# 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 Aviator."""

__all__ = ["ADDSForecastType", "ADDSMessage", "ADDSMessageCollection", "ADDSMessageExtrapolationType",
"ADDSMessageInterpolationType", "ADDSMissingMessageType", "AFPROPFuelType", "AGLMSL", "ARINC424Airport",
"ARINC424Helipad", "ARINC424Navaid", "ARINC424Runway", "ARINC424Source", "ARINC424Waypoint",
"AccelerationAdvancedAccelerationMode", "AccelerationManeuverAerodynamicPropulsionMode", "AccelerationManeuverMode",
"AccelerationMode", "AccelerationPerformanceModelOverride", "AdvancedFixedWingAerodynamicStrategy",
"AdvancedFixedWingElectricPowerplant", "AdvancedFixedWingEmpiricalJetEngine", "AdvancedFixedWingExternalAerodynamic",
"AdvancedFixedWingExternalPropulsion", "AdvancedFixedWingFourPointAerodynamic", "AdvancedFixedWingGeometry",
"AdvancedFixedWingGeometryBasic", "AdvancedFixedWingGeometryVariable", "AdvancedFixedWingPistonPowerplant",
"AdvancedFixedWingPowerplantStrategy", "AdvancedFixedWingRamjetBasic", "AdvancedFixedWingScramjetBasic",
"AdvancedFixedWingSubSuperHypersonicAerodynamic", "AdvancedFixedWingSubSuperHypersonicPropulsion",
"AdvancedFixedWingSubsonicAerodynamic", "AdvancedFixedWingSupersonicAerodynamic", "AdvancedFixedWingTool",
"AdvancedFixedWingTurbofanBasicABPowerplant", "AdvancedFixedWingTurbofanBasicABPropulsion",
"AdvancedFixedWingTurbojetBasicABPowerplant", "AdvancedFixedWingTurbojetBasicABPropulsion",
"AdvancedFixedWingTurbopropPowerplant", "AerodynamicPropulsionFlightMode", "AerodynamicPropulsionManeuverModeHelper",
"AerodynamicPropulsionSimpleMode", "AileronRollFlightPath", "AileronRollMode", "AircraftAcceleration",
"AircraftAccelerationMode", "AircraftAdvancedAccelerationModel", "AircraftAdvancedClimbModel",
"AircraftAdvancedCruiseModel", "AircraftAdvancedDescentModel", "AircraftAdvancedLandingModel",
"AircraftAdvancedTakeoffModel", "AircraftAerodynamic", "AircraftAerodynamicStrategy", "AircraftBasicAccelerationModel",
"AircraftBasicClimbModel", "AircraftBasicCruiseModel", "AircraftBasicDescentModel", "AircraftBasicFixedWingAerodynamic",
"AircraftBasicFixedWingPropulsion", "AircraftBasicLandingModel", "AircraftBasicTakeoffModel", "AircraftCategory",
"AircraftClimb", "AircraftCruise", "AircraftDescent", "AircraftExternalAerodynamic", "AircraftExternalPropulsion",
"AircraftLanding", "AircraftModel", "AircraftModels", "AircraftPropulsion", "AircraftPropulsionStrategy",
"AircraftSimpleAerodynamic", "AircraftSimplePropulsion", "AircraftTakeoff", "AircraftTerrainFollow",
"AircraftTerrainFollowModel", "AircraftVTOL", "AircraftVTOLModel", "AirportCategory", "AirspeedType",
"AltitudeConstraintManeuverMode", "AltitudeMSLAndLevelOffOptions", "AltitudeMSLOptions", "AltitudeOptions",
"AltitudeReference", "AndOr", "AngleMode", "ApproachMode", "ArcAltitudeAndDelayOptions", "ArcAltitudeOptions",
"ArcOptions", "ArcVerticalPlaneOptions", "AtmosphereModel", "AtmosphereModelBasic", "AtmosphereModelType",
"AttitudeTransitions", "AutopilotAltitudeControlMode", "AutopilotAltitudeMode", "AutopilotHorizontalPlaneMode",
"AviatorNumericalIntegrator", "AviatorPropagator", "Ballistic3DControlMode", "BasicFixedWingForwardFlightLiftHelper",
"BasicFixedWingPropulsionMode", "BasicManeuverAirspeedMode", "BasicManeuverAirspeedOptions",
"BasicManeuverAltitudeLimit", "BasicManeuverFuelFlowType", "BasicManeuverGlideSpeedControlMode",
"BasicManeuverReferenceFrame", "BasicManeuverStrategy", "BasicManeuverStrategyAileronRoll",
"BasicManeuverStrategyAirspeedPerformanceLimits", "BasicManeuverStrategyAutopilotNavigation",
"BasicManeuverStrategyAutopilotProf", "BasicManeuverStrategyBallistic3D", "BasicManeuverStrategyBarrelRoll",
"BasicManeuverStrategyBezier", "BasicManeuverStrategyCruiseProfile", "BasicManeuverStrategyFlyAOA",
"BasicManeuverStrategyGlideProfile", "BasicManeuverStrategyIntercept", "BasicManeuverStrategyLTAHover",
"BasicManeuverStrategyLoop", "BasicManeuverStrategyNavigationControlLimit", "BasicManeuverStrategyPitch3D",
"BasicManeuverStrategyPoweredCruiseMode", "BasicManeuverStrategyPull", "BasicManeuverStrategyPushPull",
"BasicManeuverStrategyRelativeBearing", "BasicManeuverStrategyRelativeCourse",
"BasicManeuverStrategyRelativeFlightPathAngle", "BasicManeuverStrategyRelativeSpeedAltitude",
"BasicManeuverStrategyRendezvous", "BasicManeuverStrategyRollingPull", "BasicManeuverStrategySimpleTurn",
"BasicManeuverStrategySmoothAcceleration", "BasicManeuverStrategySmoothTurn", "BasicManeuverStrategyStationkeeping",
"BasicManeuverStrategyStraightAhead", "BasicManeuverStrategyWeave", "BasicManeuverTargetPositionVelocity",
"BasicManeuverTargetPositionVelocityNoisyBearingRange", "BasicManeuverTargetPositionVelocityNoisySurfTarget",
"CEAFuelType", "CalculationOptions", "Catalog", "ClimbAndDescentTransitions", "ClimbSpeedType", "ClosureMode",
"ClosureValue", "Configuration", "CruiseAirspeedAndProfileOptions", "CruiseAirspeedOptions", "CruiseAirspeedProfile",
"CruiseMaxPerformanceSpeedType", "CruiseSpeed", "DAFIFHelipad", "DAFIFRunway", "DAFIFSource", "DAFIFWaypoint",
"DelayAltitudeMode", "DelayTurnDirection", "DepartureSpeedMode", "DescentSpeedType", "EnrouteAndDelayOptions",
"EnrouteOptions", "EnrouteTurnDirectionOptions", "EphemShiftRotateAltitudeMode", "EphemShiftRotateCourseMode",
"ErrorCodes", "ExtEphemFlightMode", "FlightLineProcedureType", "FlyAOALeftRight", "FlyToFlightPathAngleMode",
"FormationFlyerStopCondition", "FourPointAerodynamic", "FuelFlowType", "FuelModelKeroseneAFPROP",
"FuelModelKeroseneCEA", "FuelTankExternal", "FuelTankInternal", "HoldRefuelDumpMode", "HoldingDirection",
"HoldingEntryManeuver", "HoldingProfileMode", "HoverAltitudeMode", "HoverAltitudeOptions", "HoverHeadingMode",
"HoverMode", "IARINC424Airport", "IARINC424Item", "IAdvancedFixedWingGeometry", "IAdvancedFixedWingPowerplant",
"IAutomationStrategyFactory", "IAviatorVehicle", "IBasicFixedWingLiftHelper", "IBasicManeuverStrategy",
"ICatalogAirport", "ICatalogItem", "ICatalogNavaid", "ICatalogRunway", "ICatalogSource", "ICatalogVTOLPoint",
"ICatalogWaypoint", "IConnect", "ICruiseAirspeedAndProfileOptions", "IDAFIFItem", "IEnrouteAndDelayOptions",
"IPerformanceModel", "IProcedure", "ISite", "ISiteUnknown", "IStation", "IVerticalPlaneOptions", "InterceptMode",
"JetEngineExhaustNozzleType", "JetEngineIntakeType", "JetEngineTechnologyLevel", "JetEngineTurbineType", "JetFuelType",
"JoinExitArcMethod", "LandingApproachFixRangeMode", "LandingCruiseAirspeedAndProfileOptions", "LandingEnrouteOptions",
"LandingEnterDownwindPattern", "LandingInterceptGlideslope", "LandingStandardInstrumentApproach",
"LandingVerticalPlaneOptions", "LaunchAttitudeMode", "LaunchDynamicStateBearingReference",
"LaunchDynamicStateCoordFrame", "LevelTurns", "LineOrientation", "MinimizeSiteProcedureTimeDiff",
"MissileAdvancedAerodynamic", "MissileAerodynamic", "MissileAerodynamicStrategy", "MissileExternalAerodynamic",
"MissileExternalPropulsion", "MissileFourPointAerodynamic", "MissileModel", "MissileModels", "MissilePropulsion",
"MissilePropulsionStrategy", "MissileRamjetPropulsion", "MissileRocketPropulsion", "MissileSimpleAerodynamic",
"MissileSimplePropulsion", "MissileTurbojetPropulsion", "Mission", "NavaidCategory", "NavigationOptions",
"NavigatorTurnDirection", "PayloadStation", "PerformanceModel", "PerformanceModelOptions", "PerformanceModelOverride",
"Phase", "PhaseCollection", "PhaseOfFlight", "Pitch3DControlMode", "PointToPointMode", "Procedure", "ProcedureAirway",
"ProcedureAirwayRouter", "ProcedureArcEnroute", "ProcedureArcPointToPoint", "ProcedureAreaTargetSearch",
"ProcedureBasicManeuver", "ProcedureBasicPointToPoint", "ProcedureCollection", "ProcedureDelay", "ProcedureEnroute",
"ProcedureExtEphem", "ProcedureFastTimeOptions", "ProcedureFlightLine", "ProcedureFormationFlyer",
"ProcedureFormationRecover", "ProcedureHoldingCircular", "ProcedureHoldingFigure8", "ProcedureHoldingRacetrack",
"ProcedureHover", "ProcedureHoverTranslate", "ProcedureInFormation", "ProcedureLanding", "ProcedureLaunch",
"ProcedureLaunchDynamicState", "ProcedureLaunchWaypoint", "ProcedureParallelFlightLine", "ProcedureReferenceState",
"ProcedureSuperProcedure", "ProcedureTakeoff", "ProcedureTerrainFollow", "ProcedureTimeOptions",
"ProcedureTransitionToForwardFlight", "ProcedureTransitionToHover", "ProcedureType", "ProcedureVGTPoint",
"ProcedureVerticalLanding", "ProcedureVerticalTakeoff", "ProfileControlLimit", "PropulsionEfficiencies",
"PropulsionThrust", "PullMode", "PushPull", "RamjetMode", "ReferenceStateAttitudeMode",
"ReferenceStateForwardFlightOptions", "ReferenceStateHoverOptions", "ReferenceStateLateralAccelerationMode",
"ReferenceStateLongitudinalAccelerationMode", "ReferenceStatePerformanceMode", "ReferenceStateTakeoffLandingOptions",
"ReferenceStateWeightOnWheelsOptions", "RefuelDumpMode", "RefuelDumpProperties", "RelativeAbsoluteBearing",
"RelativeAltitudeMode", "RelativeSpeedAltitudeStopCondition", "RendezvousStopCondition", "RollLeftRight",
"RollUprightInverted", "RollingPullMode", "RotorcraftAerodynamic", "RotorcraftModel", "RotorcraftModels",
"RotorcraftPowerplantType", "RotorcraftPropulsion", "RunwayCategory", "RunwayHeadingOptions", "RunwayHighLowEnd",
"STKObjectWaypointOffsetMode", "ScramjetMode", "SearchPatternCourseMode", "Site", "SiteAirportFromCatalog",
"SiteDynamicState", "SiteEndOfPrevProcedure", "SiteNavaidFromCatalog", "SiteReferenceState",
"SiteRelativeToPrevProcedure", "SiteRelativeToSTKObject", "SiteRunway", "SiteRunwayFromCatalog", "SiteSTKAreaTarget",
"SiteSTKObjectWaypoint", "SiteSTKStaticObject", "SiteSTKVehicle", "SiteSuperProcedure", "SiteType", "SiteVTOLPoint",
"SiteVTOLPointFromCatalog", "SiteWaypoint", "SiteWaypointFromCatalog", "SmoothAccelerationLeftRight",
"SmoothAccelerationStopConditions", "SmoothTurnFlightPathAngleMode", "SmoothTurnMode", "StationCollection",
"StationkeepingStopCondition", "StraightAheadReferenceFrame", "TakeoffDeparturePoint", "TakeoffLandingSpeedMode",
"TakeoffLowTransition", "TakeoffMode", "TakeoffNormal", "TargetPositionVelocityType", "TrajectoryBlendMode",
"TransitionToHoverMode", "TurbineMode", "TurnDirection", "TurnMode", "UserRunway", "UserRunwaySource", "UserVTOLPoint",
"UserVTOLPointSource", "UserWaypoint", "UserWaypointSource", "VTOLFinalHeadingMode", "VTOLHeadingMode",
"VTOLPointCategory", "VTOLRateMode", "VTOLTransitionMode", "VTOLTranslationFinalCourseMode", "VTOLTranslationMode",
"VertLandingMode", "VerticalPlaneAndFlightPathOptions", "VerticalPlaneOptions", "WaypointCategory",
"WindAtmosphereModelSource", "WindModel", "WindModelADDS", "WindModelConstant", "WindModelType"]

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 ...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 ErrorCodes(IntEnum):
    """Error Codes."""

    OBJECT_NOT_FOUND = (((1 << 31) | (4 << 16)) | (0x200 + 1))
    """Object not found."""
    INDEX_OUT_OF_RANGE = (((1 << 31) | (4 << 16)) | (0x200 + 2))
    """Index out of range."""
    INVALID_ATTRIBUTE = (((1 << 31) | (4 << 16)) | (0x200 + 3))
    """The attribute is invalid."""
    COMMAND_FAILED = (((1 << 31) | (4 << 16)) | (0x200 + 4))
    """The command failed."""
    ERROR_INVALID_ARG = (((1 << 31) | (4 << 16)) | (0x200 + 5))
    """Invalid argument."""
    EMPTY_ARG = (((1 << 31) | (4 << 16)) | (0x200 + 6))
    """Empty argument."""
    OBJECT_NOT_REMOVED = (((1 << 31) | (4 << 16)) | (0x200 + 7))
    """Object was not removed."""
    FAILED_TO_RENAME_OBJECT = (((1 << 31) | (4 << 16)) | (0x200 + 8))
    """Error renaming object."""
    UNKNOWN_CLASS_TYPE = (((1 << 31) | (4 << 16)) | (0x200 + 9))
    """Unknown class type."""
    FAILED_TO_CREATE_OBJECT = (((1 << 31) | (4 << 16)) | (0x200 + 10))
    """Failed to create the object."""
    OBJECT_LINK_INVALID_CHOICE = (((1 << 31) | (4 << 16)) | (0x200 + 11))
    """Invalid choice for object link."""
    OBJECT_LINK_NO_CHOICES = (((1 << 31) | (4 << 16)) | (0x200 + 12))
    """No choices available."""
    READ_ONLY_ATTRIBUTE = (((1 << 31) | (4 << 16)) | (0x200 + 13))
    """Read only attribute."""
    INVALID_CSTR_LIST = (((1 << 31) | (4 << 16)) | (0x200 + 14))
    """Invalid constraint list."""
    INVALID_CONSTRAINT = (((1 << 31) | (4 << 16)) | (0x200 + 15))
    """InvalidConstraint."""
    LIST_READ_ONLY = (((1 << 31) | (4 << 16)) | (0x200 + 16))
    """List if read only."""
    LIST_INSERT_FAILED = (((1 << 31) | (4 << 16)) | (0x200 + 17))
    """Failed to insert the item into the list."""
    INVALID_LENGTH = (((1 << 31) | (4 << 16)) | (0x200 + 18))
    """Length is invalid."""
    FAILED_TO_LOAD_FILE = (((1 << 31) | (4 << 16)) | (0x200 + 19))
    """Error loading a file."""
    INVALID_OPERATION = (((1 << 31) | (4 << 16)) | (0x200 + 20))
    """Invalid operation."""
    METHOD_INVOKE_FAILED = (((1 << 31) | (4 << 16)) | (0x200 + 21))
    """Method failed."""
    DEPRECATED = (((1 << 31) | (4 << 16)) | (0x200 + 22))
    """Deprecated property or method."""

ErrorCodes.OBJECT_NOT_FOUND.__doc__ = "Object not found."
ErrorCodes.INDEX_OUT_OF_RANGE.__doc__ = "Index out of range."
ErrorCodes.INVALID_ATTRIBUTE.__doc__ = "The attribute is invalid."
ErrorCodes.COMMAND_FAILED.__doc__ = "The command failed."
ErrorCodes.ERROR_INVALID_ARG.__doc__ = "Invalid argument."
ErrorCodes.EMPTY_ARG.__doc__ = "Empty argument."
ErrorCodes.OBJECT_NOT_REMOVED.__doc__ = "Object was not removed."
ErrorCodes.FAILED_TO_RENAME_OBJECT.__doc__ = "Error renaming object."
ErrorCodes.UNKNOWN_CLASS_TYPE.__doc__ = "Unknown class type."
ErrorCodes.FAILED_TO_CREATE_OBJECT.__doc__ = "Failed to create the object."
ErrorCodes.OBJECT_LINK_INVALID_CHOICE.__doc__ = "Invalid choice for object link."
ErrorCodes.OBJECT_LINK_NO_CHOICES.__doc__ = "No choices available."
ErrorCodes.READ_ONLY_ATTRIBUTE.__doc__ = "Read only attribute."
ErrorCodes.INVALID_CSTR_LIST.__doc__ = "Invalid constraint list."
ErrorCodes.INVALID_CONSTRAINT.__doc__ = "InvalidConstraint."
ErrorCodes.LIST_READ_ONLY.__doc__ = "List if read only."
ErrorCodes.LIST_INSERT_FAILED.__doc__ = "Failed to insert the item into the list."
ErrorCodes.INVALID_LENGTH.__doc__ = "Length is invalid."
ErrorCodes.FAILED_TO_LOAD_FILE.__doc__ = "Error loading a file."
ErrorCodes.INVALID_OPERATION.__doc__ = "Invalid operation."
ErrorCodes.METHOD_INVOKE_FAILED.__doc__ = "Method failed."
ErrorCodes.DEPRECATED.__doc__ = "Deprecated property or method."

agcls.AgTypeNameMap["ErrorCodes"] = ErrorCodes

class ClosureValue(IntEnum):
    """The closure value."""

    CLOSURE_MODE = 0
    """The closure mode."""
    MAX_ANGLE = 1
    """The HOBS max angle offset."""
    ANGLE_TOL = 2
    """The HOBS angle tolerance."""

ClosureValue.CLOSURE_MODE.__doc__ = "The closure mode."
ClosureValue.MAX_ANGLE.__doc__ = "The HOBS max angle offset."
ClosureValue.ANGLE_TOL.__doc__ = "The HOBS angle tolerance."

agcls.AgTypeNameMap["ClosureValue"] = ClosureValue

class ProcedureType(IntEnum):
    """Aviator procedure types."""

    PROCEDURE_AIRWAY = 0
    """Airway procedure."""
    PROCEDURE_AIRWAY_ROUTER = 1
    """Airway Router procedure."""
    PROCEDURE_ARC_ENROUTE = 2
    """ArcEnroute procedure."""
    PROCEDURE_ARC_POINT_TO_POINT = 3
    """ArcPointToPoint procedure."""
    PROCEDURE_AREA_TARGET_SEARCH = 4
    """Area Target Search procedure."""
    PROCEDURE_BASIC_MANEUVER = 5
    """Basic Maneuver procedure."""
    PROCEDURE_BASIC_POINT_TO_POINT = 6
    """Basic Point to Point procedure."""
    PROCEDURE_DELAY = 7
    """Delay procedure."""
    PROCEDURE_ENROUTE = 8
    """Enroute procedure."""
    PROCEDURE_FLIGHT_LINE = 9
    """Flight Line procedure."""
    PROCEDURE_FORMATION_RECOVER = 10
    """Formation Recover procedure."""
    PROCEDURE_HOLDING_CIRCULAR = 11
    """Holding Circular procedure."""
    PROCEDURE_HOLDING_FIGURE8 = 12
    """Holding Figure 8 procedure."""
    PROCEDURE_HOLDING_RACETRACK = 13
    """Holding Racetrack procedure."""
    PROCEDURE_HOVER = 14
    """Hover procedure."""
    PROCEDURE_HOVER_TRANSLATE = 15
    """Hover Translate procedure."""
    PROCEDURE_IN_FORMATION = 16
    """In Formation procedure."""
    PROCEDURE_LANDING = 17
    """Landing procedure."""
    PROCEDURE_LAUNCH = 18
    """Launch procedure."""
    PROCEDURE_PARALLEL_FLIGHT_LINE = 19
    """Parallel Flight Line procedure."""
    PROCEDURE_REFERENCE_STATE = 20
    """Reference State procedure."""
    PROCEDURE_SUPER_PROCEDURE = 21
    """Super Procedure procedure."""
    PROCEDURE_TAKEOFF = 22
    """Takeoff procedure."""
    PROCEDURE_TERRAIN_FOLLOWING = 23
    """Terrain Following procedure."""
    PROCEDURE_TRANSITION_TO_FORWARD_FLIGHT = 24
    """Transition to Forward Flight procedure."""
    PROCEDURE_TRANSITION_TO_HOVER = 25
    """Transition To Hover procedure."""
    PROCEDURE_VERTICAL_LANDING = 26
    """Vertical Landing procedure."""
    PROCEDURE_VERTICAL_TAKEOFF = 27
    """Vertical Takeoff procedure."""
    PROCEDURE_VGT_POINT = 28
    """VGT Point procedure."""
    PROCEDURE_LAUNCH_DYNAMIC_STATE = 29
    """LaunchDynState procedure."""
    PROCEDURE_LAUNCH_WAYPOINT = 30
    """LaunchWaypoint procedure."""
    PROCEDURE_FORMATION_FLYER = 31
    """FormationFlyer procedure."""
    PROCEDURE_EXT_EPHEM = 32
    """ExtEphem procedure."""

ProcedureType.PROCEDURE_AIRWAY.__doc__ = "Airway procedure."
ProcedureType.PROCEDURE_AIRWAY_ROUTER.__doc__ = "Airway Router procedure."
ProcedureType.PROCEDURE_ARC_ENROUTE.__doc__ = "ArcEnroute procedure."
ProcedureType.PROCEDURE_ARC_POINT_TO_POINT.__doc__ = "ArcPointToPoint procedure."
ProcedureType.PROCEDURE_AREA_TARGET_SEARCH.__doc__ = "Area Target Search procedure."
ProcedureType.PROCEDURE_BASIC_MANEUVER.__doc__ = "Basic Maneuver procedure."
ProcedureType.PROCEDURE_BASIC_POINT_TO_POINT.__doc__ = "Basic Point to Point procedure."
ProcedureType.PROCEDURE_DELAY.__doc__ = "Delay procedure."
ProcedureType.PROCEDURE_ENROUTE.__doc__ = "Enroute procedure."
ProcedureType.PROCEDURE_FLIGHT_LINE.__doc__ = "Flight Line procedure."
ProcedureType.PROCEDURE_FORMATION_RECOVER.__doc__ = "Formation Recover procedure."
ProcedureType.PROCEDURE_HOLDING_CIRCULAR.__doc__ = "Holding Circular procedure."
ProcedureType.PROCEDURE_HOLDING_FIGURE8.__doc__ = "Holding Figure 8 procedure."
ProcedureType.PROCEDURE_HOLDING_RACETRACK.__doc__ = "Holding Racetrack procedure."
ProcedureType.PROCEDURE_HOVER.__doc__ = "Hover procedure."
ProcedureType.PROCEDURE_HOVER_TRANSLATE.__doc__ = "Hover Translate procedure."
ProcedureType.PROCEDURE_IN_FORMATION.__doc__ = "In Formation procedure."
ProcedureType.PROCEDURE_LANDING.__doc__ = "Landing procedure."
ProcedureType.PROCEDURE_LAUNCH.__doc__ = "Launch procedure."
ProcedureType.PROCEDURE_PARALLEL_FLIGHT_LINE.__doc__ = "Parallel Flight Line procedure."
ProcedureType.PROCEDURE_REFERENCE_STATE.__doc__ = "Reference State procedure."
ProcedureType.PROCEDURE_SUPER_PROCEDURE.__doc__ = "Super Procedure procedure."
ProcedureType.PROCEDURE_TAKEOFF.__doc__ = "Takeoff procedure."
ProcedureType.PROCEDURE_TERRAIN_FOLLOWING.__doc__ = "Terrain Following procedure."
ProcedureType.PROCEDURE_TRANSITION_TO_FORWARD_FLIGHT.__doc__ = "Transition to Forward Flight procedure."
ProcedureType.PROCEDURE_TRANSITION_TO_HOVER.__doc__ = "Transition To Hover procedure."
ProcedureType.PROCEDURE_VERTICAL_LANDING.__doc__ = "Vertical Landing procedure."
ProcedureType.PROCEDURE_VERTICAL_TAKEOFF.__doc__ = "Vertical Takeoff procedure."
ProcedureType.PROCEDURE_VGT_POINT.__doc__ = "VGT Point procedure."
ProcedureType.PROCEDURE_LAUNCH_DYNAMIC_STATE.__doc__ = "LaunchDynState procedure."
ProcedureType.PROCEDURE_LAUNCH_WAYPOINT.__doc__ = "LaunchWaypoint procedure."
ProcedureType.PROCEDURE_FORMATION_FLYER.__doc__ = "FormationFlyer procedure."
ProcedureType.PROCEDURE_EXT_EPHEM.__doc__ = "ExtEphem procedure."

agcls.AgTypeNameMap["ProcedureType"] = ProcedureType

class SiteType(IntEnum):
    """Aviator site types."""

    SITE_AIRPORT_FROM_CATALOG = 0
    """Airport from Catalog site."""
    SITE_END_OF_PREV_PROCEDURE = 1
    """End of Previous Procedure site."""
    SITE_NAVAID_FROM_CATALOG = 2
    """Navaid from Catalog site."""
    SITE_REFERENCE_STATE = 3
    """Reference State site."""
    SITE_RELATIVE_TO_PREV_PROCEDURE = 4
    """Relative to Previous Procedure site."""
    SITE_RELATIVE_TO_STATIONARY_STK_OBJECT = 5
    """Relative to Stationary STK Object site."""
    SITE_RUNWAY = 6
    """Runway site."""
    SITE_RUNWAY_FROM_CATALOG = 7
    """Runway from Catalog site."""
    SITE_STK_AREA_TARGET = 8
    """STK Area Target site."""
    SITE_STK_OBJECT_WAYPOINT = 9
    """STK Object Waypoint site."""
    SITE_STK_STATIC_OBJECT = 10
    """STK STatic Object site."""
    SITE_STK_VEHICLE = 11
    """STK Vehicle site."""
    SITE_SUPER_PROCEDURE = 12
    """Super Procedure site."""
    SITE_VTOL_POINT = 13
    """VTOL Point site."""
    SITE_VTOL_POINT_FROM_CATALOG = 14
    """VTOL Point from Catalog site."""
    SITE_WAYPOINT = 15
    """Waypoint site."""
    SITE_WAYPOINT_FROM_CATALOG = 16
    """Waypoint from Catalog site."""
    SITE_DYNAMIC_STATE = 17
    """DynState site."""

SiteType.SITE_AIRPORT_FROM_CATALOG.__doc__ = "Airport from Catalog site."
SiteType.SITE_END_OF_PREV_PROCEDURE.__doc__ = "End of Previous Procedure site."
SiteType.SITE_NAVAID_FROM_CATALOG.__doc__ = "Navaid from Catalog site."
SiteType.SITE_REFERENCE_STATE.__doc__ = "Reference State site."
SiteType.SITE_RELATIVE_TO_PREV_PROCEDURE.__doc__ = "Relative to Previous Procedure site."
SiteType.SITE_RELATIVE_TO_STATIONARY_STK_OBJECT.__doc__ = "Relative to Stationary STK Object site."
SiteType.SITE_RUNWAY.__doc__ = "Runway site."
SiteType.SITE_RUNWAY_FROM_CATALOG.__doc__ = "Runway from Catalog site."
SiteType.SITE_STK_AREA_TARGET.__doc__ = "STK Area Target site."
SiteType.SITE_STK_OBJECT_WAYPOINT.__doc__ = "STK Object Waypoint site."
SiteType.SITE_STK_STATIC_OBJECT.__doc__ = "STK STatic Object site."
SiteType.SITE_STK_VEHICLE.__doc__ = "STK Vehicle site."
SiteType.SITE_SUPER_PROCEDURE.__doc__ = "Super Procedure site."
SiteType.SITE_VTOL_POINT.__doc__ = "VTOL Point site."
SiteType.SITE_VTOL_POINT_FROM_CATALOG.__doc__ = "VTOL Point from Catalog site."
SiteType.SITE_WAYPOINT.__doc__ = "Waypoint site."
SiteType.SITE_WAYPOINT_FROM_CATALOG.__doc__ = "Waypoint from Catalog site."
SiteType.SITE_DYNAMIC_STATE.__doc__ = "DynState site."

agcls.AgTypeNameMap["SiteType"] = SiteType

class BasicManeuverStrategy(IntEnum):
    """Basic maneuver strategy types."""

    STRAIGHT_AHEAD = 0
    """Straight Ahead strategy."""
    WEAVE = 1
    """Weave strategy."""

BasicManeuverStrategy.STRAIGHT_AHEAD.__doc__ = "Straight Ahead strategy."
BasicManeuverStrategy.WEAVE.__doc__ = "Weave strategy."

agcls.AgTypeNameMap["BasicManeuverStrategy"] = BasicManeuverStrategy

class StraightAheadReferenceFrame(IntEnum):
    """Straight Ahead basic maneuver Reference Frame."""

    MAINTAIN_COURSE = 0
    """Maintain Course."""
    MAINTAIN_HEADING = 1
    """Maintain Heading."""
    NO_LATERAL_ACC = 2
    """No Lateral Accelerations."""
    COMPENSATE_CORIOLIS = 3
    """Compensate For Coriolis."""

StraightAheadReferenceFrame.MAINTAIN_COURSE.__doc__ = "Maintain Course."
StraightAheadReferenceFrame.MAINTAIN_HEADING.__doc__ = "Maintain Heading."
StraightAheadReferenceFrame.NO_LATERAL_ACC.__doc__ = "No Lateral Accelerations."
StraightAheadReferenceFrame.COMPENSATE_CORIOLIS.__doc__ = "Compensate For Coriolis."

agcls.AgTypeNameMap["StraightAheadReferenceFrame"] = StraightAheadReferenceFrame

class AirspeedType(IntEnum):
    """Airspeed types."""

    MACH = 0
    """Mach number."""
    EAS = 1
    """Equivalent airspeed."""
    CAS = 2
    """Calibrated airspeed."""
    TAS = 3
    """True airspeed."""

AirspeedType.MACH.__doc__ = "Mach number."
AirspeedType.EAS.__doc__ = "Equivalent airspeed."
AirspeedType.CAS.__doc__ = "Calibrated airspeed."
AirspeedType.TAS.__doc__ = "True airspeed."

agcls.AgTypeNameMap["AirspeedType"] = AirspeedType

class AerodynamicPropulsionSimpleMode(IntEnum):
    """Aircraft operating mode for basic acceleration models with aerodynamics set to Simple."""

    FIXED_WING = 0
    """Fixed wing operatiog mode."""
    HELICOPTER = 1
    """Helicopter operating mode."""

AerodynamicPropulsionSimpleMode.FIXED_WING.__doc__ = "Fixed wing operatiog mode."
AerodynamicPropulsionSimpleMode.HELICOPTER.__doc__ = "Helicopter operating mode."

agcls.AgTypeNameMap["AerodynamicPropulsionSimpleMode"] = AerodynamicPropulsionSimpleMode

class AerodynamicPropulsionFlightMode(IntEnum):
    """Flight mode for the Aero/Prop maneuver mode helper in aircraft acceleration models."""

    FLIGHT_PERFORMANCE_FORWARD_FLIGHT = 0
    """Forward Flight mode."""
    FLIGHT_PERFORMANCE_HOVER = 1
    """Hover mode."""
    FLIGHT_PERFORMANCE_TAKEOFF = 2
    """Takeoff mode."""
    FLIGHT_PERFORMANCE_LANDING = 3
    """Landing mode."""
    FLIGHT_PERFORMANCE_WEIGHT_ON_WHEELS = 4
    """Weight on wheels mode."""

AerodynamicPropulsionFlightMode.FLIGHT_PERFORMANCE_FORWARD_FLIGHT.__doc__ = "Forward Flight mode."
AerodynamicPropulsionFlightMode.FLIGHT_PERFORMANCE_HOVER.__doc__ = "Hover mode."
AerodynamicPropulsionFlightMode.FLIGHT_PERFORMANCE_TAKEOFF.__doc__ = "Takeoff mode."
AerodynamicPropulsionFlightMode.FLIGHT_PERFORMANCE_LANDING.__doc__ = "Landing mode."
AerodynamicPropulsionFlightMode.FLIGHT_PERFORMANCE_WEIGHT_ON_WHEELS.__doc__ = "Weight on wheels mode."

agcls.AgTypeNameMap["AerodynamicPropulsionFlightMode"] = AerodynamicPropulsionFlightMode

class PhaseOfFlight(IntEnum):
    """Flight mode for basic maneuver procedures."""

    FLIGHT_PHASE_TAKEOFF = 1
    """Takeoff flight mode."""
    FLIGHT_PHASE_CLIMB = 2
    """Forward flight climb flight mode."""
    FLIGHT_PHASE_CRUISE = 3
    """Forward flight - cruise flight mode."""
    FLIGHT_PHASE_DESCEND = 4
    """Forward flight descend flight mode."""
    FLIGHT_PHASE_LANDING = 5
    """Landing flight mode."""
    FLIGHT_PHASE_VTOL = 6
    """Rotary wing / hover flight mode."""

PhaseOfFlight.FLIGHT_PHASE_TAKEOFF.__doc__ = "Takeoff flight mode."
PhaseOfFlight.FLIGHT_PHASE_CLIMB.__doc__ = "Forward flight climb flight mode."
PhaseOfFlight.FLIGHT_PHASE_CRUISE.__doc__ = "Forward flight - cruise flight mode."
PhaseOfFlight.FLIGHT_PHASE_DESCEND.__doc__ = "Forward flight descend flight mode."
PhaseOfFlight.FLIGHT_PHASE_LANDING.__doc__ = "Landing flight mode."
PhaseOfFlight.FLIGHT_PHASE_VTOL.__doc__ = "Rotary wing / hover flight mode."

agcls.AgTypeNameMap["PhaseOfFlight"] = PhaseOfFlight

class CruiseSpeed(IntEnum):
    """Cruise airspeed type for the procedure."""

    MIN_AIRSPEED = 0
    """Minimum airspeed."""
    MAX_ENDURANCE_AIRSPEED = 1
    """Maximum endurance airspeed."""
    MAX_RANGE_AIRSPEED = 2
    """Maximum range airspeed."""
    OTHER_AIRSPEED = 3
    """Other airspeed."""
    MAX_AIRSPEED = 4
    """Maximum airspeed."""
    MAX_PERFORMANCE_AIRSPEED = 6
    """Maximum performance airspeed."""

CruiseSpeed.MIN_AIRSPEED.__doc__ = "Minimum airspeed."
CruiseSpeed.MAX_ENDURANCE_AIRSPEED.__doc__ = "Maximum endurance airspeed."
CruiseSpeed.MAX_RANGE_AIRSPEED.__doc__ = "Maximum range airspeed."
CruiseSpeed.OTHER_AIRSPEED.__doc__ = "Other airspeed."
CruiseSpeed.MAX_AIRSPEED.__doc__ = "Maximum airspeed."
CruiseSpeed.MAX_PERFORMANCE_AIRSPEED.__doc__ = "Maximum performance airspeed."

agcls.AgTypeNameMap["CruiseSpeed"] = CruiseSpeed

class TakeoffMode(IntEnum):
    """Takeoff procedure mode."""

    TAKEOFF_NORMAL = 0
    """Normal takeoff mode."""
    TAKEOFF_FLY_TO_DEPARTURE_POINT = 1
    """Fly to departure point takeoff mode."""
    TAKEOFF_LOW_TRANSITION = 2
    """Low transition takeoff."""

TakeoffMode.TAKEOFF_NORMAL.__doc__ = "Normal takeoff mode."
TakeoffMode.TAKEOFF_FLY_TO_DEPARTURE_POINT.__doc__ = "Fly to departure point takeoff mode."
TakeoffMode.TAKEOFF_LOW_TRANSITION.__doc__ = "Low transition takeoff."

agcls.AgTypeNameMap["TakeoffMode"] = TakeoffMode

class ApproachMode(IntEnum):
    """Landing procedure approach mode."""

    STANDARD_INSTRUMENT_APPROACH = 0
    """Standard instrument approach mode."""
    INTERCEPT_GLIDESLOPE = 1
    """Intercept Glideslope approach mode."""
    ENTER_DOWNWIND_PATTERN = 2
    """Enter downwind pattern approach mode."""

ApproachMode.STANDARD_INSTRUMENT_APPROACH.__doc__ = "Standard instrument approach mode."
ApproachMode.INTERCEPT_GLIDESLOPE.__doc__ = "Intercept Glideslope approach mode."
ApproachMode.ENTER_DOWNWIND_PATTERN.__doc__ = "Enter downwind pattern approach mode."

agcls.AgTypeNameMap["ApproachMode"] = ApproachMode

class NavigatorTurnDirection(IntEnum):
    """Turn mode for procedures with Enroute Turn Direction options."""

    NAVIGATOR_TURN_AUTO = 0
    """Automatic turn. Aviator will determine the direction of the turn."""
    NAVIGATOR_TURN_LEFT = 1
    """Left turn."""
    NAVIGATOR_TURN_RIGHT = 2
    """Right turn."""

NavigatorTurnDirection.NAVIGATOR_TURN_AUTO.__doc__ = "Automatic turn. Aviator will determine the direction of the turn."
NavigatorTurnDirection.NAVIGATOR_TURN_LEFT.__doc__ = "Left turn."
NavigatorTurnDirection.NAVIGATOR_TURN_RIGHT.__doc__ = "Right turn."

agcls.AgTypeNameMap["NavigatorTurnDirection"] = NavigatorTurnDirection

class BasicManeuverFuelFlowType(IntEnum):
    """Fuel flow type for basic maneuver procedures."""

    BASIC_MANEUVER_FUEL_FLOW_TAKEOFF = 0
    """Fuel flow defined for the current Takeoff performance model."""
    BASIC_MANEUVER_FUEL_FLOW_CRUISE = 1
    """Fuel flow defined for the current Cruise performance model."""
    BASIC_MANEUVER_FUEL_FLOW_LANDING = 2
    """Fuel flow defined for the current Landing performance model."""
    BASIC_MANEUVER_FUEL_FLOW_VTOL = 3
    """Fuel flow defined for the current VTOL performance model."""
    BASIC_MANEUVER_FUEL_FLOW_AERODYNAMIC_PROPULSION = 4
    """Fuel flow defined for the Aerodynamics and Propulsion Analysis component of the current basic acceleration performance model."""
    BASIC_MANEUVER_FUEL_FLOW_OVERRIDE = 5
    """Fuel flow defined manually."""
    BASIC_MANEUVER_FUEL_FLOW_THRUST_MODEL = 6
    """Fuel flow defined using the thrust model for this maneuver."""

BasicManeuverFuelFlowType.BASIC_MANEUVER_FUEL_FLOW_TAKEOFF.__doc__ = "Fuel flow defined for the current Takeoff performance model."
BasicManeuverFuelFlowType.BASIC_MANEUVER_FUEL_FLOW_CRUISE.__doc__ = "Fuel flow defined for the current Cruise performance model."
BasicManeuverFuelFlowType.BASIC_MANEUVER_FUEL_FLOW_LANDING.__doc__ = "Fuel flow defined for the current Landing performance model."
BasicManeuverFuelFlowType.BASIC_MANEUVER_FUEL_FLOW_VTOL.__doc__ = "Fuel flow defined for the current VTOL performance model."
BasicManeuverFuelFlowType.BASIC_MANEUVER_FUEL_FLOW_AERODYNAMIC_PROPULSION.__doc__ = "Fuel flow defined for the Aerodynamics and Propulsion Analysis component of the current basic acceleration performance model."
BasicManeuverFuelFlowType.BASIC_MANEUVER_FUEL_FLOW_OVERRIDE.__doc__ = "Fuel flow defined manually."
BasicManeuverFuelFlowType.BASIC_MANEUVER_FUEL_FLOW_THRUST_MODEL.__doc__ = "Fuel flow defined using the thrust model for this maneuver."

agcls.AgTypeNameMap["BasicManeuverFuelFlowType"] = BasicManeuverFuelFlowType

class BasicManeuverAltitudeLimit(IntEnum):
    """The type of response Aviator will have if the maneuver attempts to exceed the altitude limit."""

    BASIC_MANEUVER_ALTITUDE_LIMIT_ERROR = 0
    """Error when altitude limit exceeded."""
    BASIC_MANEUVER_ALTITUDE_LIMIT_STOP = 1
    """Stop when altitude limit exceeded."""
    BASIC_MANEUVER_ALTITUDE_LIMIT_CONTINUE = 2
    """Continue when altitude limit exceeded."""

BasicManeuverAltitudeLimit.BASIC_MANEUVER_ALTITUDE_LIMIT_ERROR.__doc__ = "Error when altitude limit exceeded."
BasicManeuverAltitudeLimit.BASIC_MANEUVER_ALTITUDE_LIMIT_STOP.__doc__ = "Stop when altitude limit exceeded."
BasicManeuverAltitudeLimit.BASIC_MANEUVER_ALTITUDE_LIMIT_CONTINUE.__doc__ = "Continue when altitude limit exceeded."

agcls.AgTypeNameMap["BasicManeuverAltitudeLimit"] = BasicManeuverAltitudeLimit

class RunwayHighLowEnd(IntEnum):
    """Runway heading that the aircraft will use."""

    HIGH_END = 0
    """High end."""
    LOW_END = 1
    """Low end."""
    HEADWIND = 2
    """Headwind."""

RunwayHighLowEnd.HIGH_END.__doc__ = "High end."
RunwayHighLowEnd.LOW_END.__doc__ = "Low end."
RunwayHighLowEnd.HEADWIND.__doc__ = "Headwind."

agcls.AgTypeNameMap["RunwayHighLowEnd"] = RunwayHighLowEnd

class BasicManeuverReferenceFrame(IntEnum):
    """Reference frame for the basic maneuver strategy."""

    EARTH_FRAME = 0
    """Earth frame."""
    WIND_FRAME = 1
    """Wind frame."""

BasicManeuverReferenceFrame.EARTH_FRAME.__doc__ = "Earth frame."
BasicManeuverReferenceFrame.WIND_FRAME.__doc__ = "Wind frame."

agcls.AgTypeNameMap["BasicManeuverReferenceFrame"] = BasicManeuverReferenceFrame

class BasicManeuverStrategyNavigationControlLimit(IntEnum):
    """Define the control limits for the aircraft during the maneuver."""

    NAVIGATION_USE_ACCELERATION_PERFORMANCE_MODEL = 0
    """Use Accel Perf Model."""
    NAVIGATION_MIN_TURN_RADIUS = 1
    """Specify min turn radius."""
    NAVIGATION_MAX_TURN_RATE = 2
    """Specify max turn rate."""
    NAVIGATION_MAX_HORIZONTAL_ACCELERATION = 3
    """Specify max horiz accel."""

BasicManeuverStrategyNavigationControlLimit.NAVIGATION_USE_ACCELERATION_PERFORMANCE_MODEL.__doc__ = "Use Accel Perf Model."
BasicManeuverStrategyNavigationControlLimit.NAVIGATION_MIN_TURN_RADIUS.__doc__ = "Specify min turn radius."
BasicManeuverStrategyNavigationControlLimit.NAVIGATION_MAX_TURN_RATE.__doc__ = "Specify max turn rate."
BasicManeuverStrategyNavigationControlLimit.NAVIGATION_MAX_HORIZONTAL_ACCELERATION.__doc__ = "Specify max horiz accel."

agcls.AgTypeNameMap["BasicManeuverStrategyNavigationControlLimit"] = BasicManeuverStrategyNavigationControlLimit

class AccelerationManeuverMode(IntEnum):
    """The mode that the aircraft will adhere to the specified acceleration parameters."""

    ACCELERATION_MANEUVER_MODE_NORMAL = 0
    """Constant value (default)."""
    ACCELERATION_MANEUVER_MODE_DENSITY_SCALE = 1
    """Scale by amtmospheric density. The aircraft will consider dynamic pressure when calculating turn radius."""
    ACCELERATION_MANEUVER_MODE_AERODYNAMIC_PROPULSION = 2
    """Aero/Prop maneuver mode."""

AccelerationManeuverMode.ACCELERATION_MANEUVER_MODE_NORMAL.__doc__ = "Constant value (default)."
AccelerationManeuverMode.ACCELERATION_MANEUVER_MODE_DENSITY_SCALE.__doc__ = "Scale by amtmospheric density. The aircraft will consider dynamic pressure when calculating turn radius."
AccelerationManeuverMode.ACCELERATION_MANEUVER_MODE_AERODYNAMIC_PROPULSION.__doc__ = "Aero/Prop maneuver mode."

agcls.AgTypeNameMap["AccelerationManeuverMode"] = AccelerationManeuverMode

class AircraftAerodynamicStrategy(IntEnum):
    """The aerodynamic strategy used to compute lift, drag, angle of attack, sideslip and intermediate / derived values."""

    AIRCRAFT_AERODYNAMIC_SIMPLE = 0
    """Simple aerodynamics."""
    AIRCRAFT_AERODYNAMIC_EXTERNAL_FILE = 1
    """External file aerodynamics."""
    AIRCRAFT_AERODYNAMIC_BASIC_FIXED_WING = 2
    """Basic fixed wing aerodynamics."""
    AIRCRAFT_AERODYNAMIC_ADVANCED_MISSILE = 3
    """Advanced missile aerodynamics."""
    AIRCRAFT_AERODYNAMIC_FOUR_POINT = 4
    """Four Point aerodynamics."""

AircraftAerodynamicStrategy.AIRCRAFT_AERODYNAMIC_SIMPLE.__doc__ = "Simple aerodynamics."
AircraftAerodynamicStrategy.AIRCRAFT_AERODYNAMIC_EXTERNAL_FILE.__doc__ = "External file aerodynamics."
AircraftAerodynamicStrategy.AIRCRAFT_AERODYNAMIC_BASIC_FIXED_WING.__doc__ = "Basic fixed wing aerodynamics."
AircraftAerodynamicStrategy.AIRCRAFT_AERODYNAMIC_ADVANCED_MISSILE.__doc__ = "Advanced missile aerodynamics."
AircraftAerodynamicStrategy.AIRCRAFT_AERODYNAMIC_FOUR_POINT.__doc__ = "Four Point aerodynamics."

agcls.AgTypeNameMap["AircraftAerodynamicStrategy"] = AircraftAerodynamicStrategy

class AircraftPropulsionStrategy(IntEnum):
    """The propulsion strategy used to compute thrust and throttle setting."""

    AIRCRAFT_PROPULSION_SIMPLE = 0
    """Simple propulsion."""
    AIRCRAFT_PROPULSION_EXTERNAL_FILE = 1
    """External file propulsion."""
    AIRCRAFT_PROPULSION_BASIC_FIXED_WING = 2
    """Basic fixed wing propulsion."""
    AIRCRAFT_PROPULSION_MISSILE_RAMJET = 3
    """Missile - Ramjet propulsion."""
    AIRCRAFT_PROPULSION_MISSILE_ROCKET = 4
    """Missile - Rocket propulsion."""
    AIRCRAFT_PROPULSION_MISSILE_TURBOJET = 5
    """Missile - Turbojet propulsion."""

AircraftPropulsionStrategy.AIRCRAFT_PROPULSION_SIMPLE.__doc__ = "Simple propulsion."
AircraftPropulsionStrategy.AIRCRAFT_PROPULSION_EXTERNAL_FILE.__doc__ = "External file propulsion."
AircraftPropulsionStrategy.AIRCRAFT_PROPULSION_BASIC_FIXED_WING.__doc__ = "Basic fixed wing propulsion."
AircraftPropulsionStrategy.AIRCRAFT_PROPULSION_MISSILE_RAMJET.__doc__ = "Missile - Ramjet propulsion."
AircraftPropulsionStrategy.AIRCRAFT_PROPULSION_MISSILE_ROCKET.__doc__ = "Missile - Rocket propulsion."
AircraftPropulsionStrategy.AIRCRAFT_PROPULSION_MISSILE_TURBOJET.__doc__ = "Missile - Turbojet propulsion."

agcls.AgTypeNameMap["AircraftPropulsionStrategy"] = AircraftPropulsionStrategy

class AGLMSL(IntEnum):
    """The altitude mode."""

    ALTITUDE_AGL = 0
    """AGl altitude. ALtitude above local terrain."""
    ALTITUDE_MSL = 1
    """MSL altitude. Altitude above sea level."""

AGLMSL.ALTITUDE_AGL.__doc__ = "AGl altitude. ALtitude above local terrain."
AGLMSL.ALTITUDE_MSL.__doc__ = "MSL altitude. Altitude above sea level."

agcls.AgTypeNameMap["AGLMSL"] = AGLMSL

class LandingApproachFixRangeMode(IntEnum):
    """The reference point on the runway for the Approach Fix Range."""

    RELATIVE_TO_RUNWAY_CENTER = 0
    """Runway center."""
    RELATIVE_TO_RUNWAY_END = 1
    """Runway end."""

LandingApproachFixRangeMode.RELATIVE_TO_RUNWAY_CENTER.__doc__ = "Runway center."
LandingApproachFixRangeMode.RELATIVE_TO_RUNWAY_END.__doc__ = "Runway end."

agcls.AgTypeNameMap["LandingApproachFixRangeMode"] = LandingApproachFixRangeMode

class AccelerationAdvancedAccelerationMode(IntEnum):
    """Acceleration mode for aircraft advanced acceleration models."""

    ACCELERATION_MODE_MAX_ACCELERATION = 0
    """Max acceleration."""
    ACCELERATION_MODE_OVERRIDE_ACCELERATION = 1
    """Manually override the acceleration."""

AccelerationAdvancedAccelerationMode.ACCELERATION_MODE_MAX_ACCELERATION.__doc__ = "Max acceleration."
AccelerationAdvancedAccelerationMode.ACCELERATION_MODE_OVERRIDE_ACCELERATION.__doc__ = "Manually override the acceleration."

agcls.AgTypeNameMap["AccelerationAdvancedAccelerationMode"] = AccelerationAdvancedAccelerationMode

class AccelerationManeuverAerodynamicPropulsionMode(IntEnum):
    """The mode used for the Aero/Prop maneuver mode helper for aircraft basic acceleration models."""

    USE_THRUST_AND_LIFT_COEFFICIENT = 0
    """Use Thrust and Lift Coefficient."""
    USE_LIFT_COEFFICIENT_ONLY = 1
    """Use Lift Coefficient only."""

AccelerationManeuverAerodynamicPropulsionMode.USE_THRUST_AND_LIFT_COEFFICIENT.__doc__ = "Use Thrust and Lift Coefficient."
AccelerationManeuverAerodynamicPropulsionMode.USE_LIFT_COEFFICIENT_ONLY.__doc__ = "Use Lift Coefficient only."

agcls.AgTypeNameMap["AccelerationManeuverAerodynamicPropulsionMode"] = AccelerationManeuverAerodynamicPropulsionMode

class BasicManeuverStrategyAirspeedPerformanceLimits(IntEnum):
    """The type of response Aviator will have if the basic maneuver attempts to exceed the airspeed limit."""

    CONSTRAIN_IF_VIOLATED = 0
    """Constrain the aircraft to not exceed the airspeed limit."""
    STOP_IF_VIOLATED = 1
    """Stop when airspeed limit exceeded.."""
    ERROR_IF_VIOLATED = 2
    """Error when airspeed limit exceeded."""
    IGNORE_IF_VIOLATED = 3
    """Ignore when airspeed limit exceeded."""

BasicManeuverStrategyAirspeedPerformanceLimits.CONSTRAIN_IF_VIOLATED.__doc__ = "Constrain the aircraft to not exceed the airspeed limit."
BasicManeuverStrategyAirspeedPerformanceLimits.STOP_IF_VIOLATED.__doc__ = "Stop when airspeed limit exceeded.."
BasicManeuverStrategyAirspeedPerformanceLimits.ERROR_IF_VIOLATED.__doc__ = "Error when airspeed limit exceeded."
BasicManeuverStrategyAirspeedPerformanceLimits.IGNORE_IF_VIOLATED.__doc__ = "Ignore when airspeed limit exceeded."

agcls.AgTypeNameMap["BasicManeuverStrategyAirspeedPerformanceLimits"] = BasicManeuverStrategyAirspeedPerformanceLimits

class BasicManeuverStrategyPoweredCruiseMode(IntEnum):
    """Powered Cruise Options."""

    GLIDE_SPECIFY_UN_POWERED_CRUISE = 0
    """The mode selected is unpowered options."""
    GLIDE_SPECIFY_THROTTLE = 1
    """The mode selected is specify throttle."""
    GLIDE_SPECIFY_THRUST_MODEL = 2
    """The mode selected is thrust model."""

BasicManeuverStrategyPoweredCruiseMode.GLIDE_SPECIFY_UN_POWERED_CRUISE.__doc__ = "The mode selected is unpowered options."
BasicManeuverStrategyPoweredCruiseMode.GLIDE_SPECIFY_THROTTLE.__doc__ = "The mode selected is specify throttle."
BasicManeuverStrategyPoweredCruiseMode.GLIDE_SPECIFY_THRUST_MODEL.__doc__ = "The mode selected is thrust model."

agcls.AgTypeNameMap["BasicManeuverStrategyPoweredCruiseMode"] = BasicManeuverStrategyPoweredCruiseMode

class TurnMode(IntEnum):
    """The mode to specify an aircraft's level turn performance for acceleration performance models."""

    TURN_MODE_TURN_G = 0
    """Turn G. The standard G force of the aircraft in a turn."""
    TURN_MODE_BANK_ANGLE = 1
    """Bank angle."""
    TURN_MODE_ACCELERATION = 2
    """Turn acceleration."""
    TURN_MODE_RADIUS = 3
    """Turn radius."""
    TURN_MODE_RATE = 4
    """Turn rate."""

TurnMode.TURN_MODE_TURN_G.__doc__ = "Turn G. The standard G force of the aircraft in a turn."
TurnMode.TURN_MODE_BANK_ANGLE.__doc__ = "Bank angle."
TurnMode.TURN_MODE_ACCELERATION.__doc__ = "Turn acceleration."
TurnMode.TURN_MODE_RADIUS.__doc__ = "Turn radius."
TurnMode.TURN_MODE_RATE.__doc__ = "Turn rate."

agcls.AgTypeNameMap["TurnMode"] = TurnMode

class PointToPointMode(IntEnum):
    """The heading or course of the aircraft at the beginning of the procedure."""

    FLY_DIRECT = 0
    """Fly direct."""
    ARRIVE_ON_COURSE_FOR_NEXT = 1
    """Arrive on course for next procedure."""
    ARRIVE_ON_COURSE = 2
    """Arrive on course."""
    INSCRIBED_TURN = 3
    """Inscribed turn."""
    ARRIVE_ON_HDG_INTO_WIND = 4
    """Arrive on heading into wind."""

PointToPointMode.FLY_DIRECT.__doc__ = "Fly direct."
PointToPointMode.ARRIVE_ON_COURSE_FOR_NEXT.__doc__ = "Arrive on course for next procedure."
PointToPointMode.ARRIVE_ON_COURSE.__doc__ = "Arrive on course."
PointToPointMode.INSCRIBED_TURN.__doc__ = "Inscribed turn."
PointToPointMode.ARRIVE_ON_HDG_INTO_WIND.__doc__ = "Arrive on heading into wind."

agcls.AgTypeNameMap["PointToPointMode"] = PointToPointMode

class AltitudeConstraintManeuverMode(IntEnum):
    """Turn mode for procedures that may require a level off maneuver."""

    LEVEL_OFF_AUTOMATIC_MANEUVER = 0
    """Automatic turn.Aviator will determine the direction of the turn."""
    LEVEL_OFF_LEFT_TURN_MANEUVER = 1
    """Left turn."""
    LEVEL_OFF_RIGHT_TURN_MANEUVER = 2
    """Right turn."""
    LEVEL_OFF_NO_MANEUVER = 3
    """No turn. A level off maneuver will not be performed."""

AltitudeConstraintManeuverMode.LEVEL_OFF_AUTOMATIC_MANEUVER.__doc__ = "Automatic turn.Aviator will determine the direction of the turn."
AltitudeConstraintManeuverMode.LEVEL_OFF_LEFT_TURN_MANEUVER.__doc__ = "Left turn."
AltitudeConstraintManeuverMode.LEVEL_OFF_RIGHT_TURN_MANEUVER.__doc__ = "Right turn."
AltitudeConstraintManeuverMode.LEVEL_OFF_NO_MANEUVER.__doc__ = "No turn. A level off maneuver will not be performed."

agcls.AgTypeNameMap["AltitudeConstraintManeuverMode"] = AltitudeConstraintManeuverMode

class WindModelType(IntEnum):
    """The wind model type."""

    CONSTANT_WIND = 0
    """Constant Wind/Speed."""
    ADDS = 1
    """NOAA ADDS Service."""
    DISABLED = 2
    """Disabled wind model."""

WindModelType.CONSTANT_WIND.__doc__ = "Constant Wind/Speed."
WindModelType.ADDS.__doc__ = "NOAA ADDS Service."
WindModelType.DISABLED.__doc__ = "Disabled wind model."

agcls.AgTypeNameMap["WindModelType"] = WindModelType

class WindAtmosphereModelSource(IntEnum):
    """The source for the wind or atmosphere model."""

    SCENARIO_MODEL = 0
    """Scenario Model."""
    MISSION_MODEL = 1
    """Mission Model."""
    PROCEDURE_MODEL = 2
    """Procedure Model."""

WindAtmosphereModelSource.SCENARIO_MODEL.__doc__ = "Scenario Model."
WindAtmosphereModelSource.MISSION_MODEL.__doc__ = "Mission Model."
WindAtmosphereModelSource.PROCEDURE_MODEL.__doc__ = "Procedure Model."

agcls.AgTypeNameMap["WindAtmosphereModelSource"] = WindAtmosphereModelSource

class ADDSMessageInterpolationType(IntEnum):
    """The interpolation method for the wind conditions."""

    INTERPOLATION_ONE_POINT = 0
    """One Point Interpolation."""
    INTERPOLATION_TWO_POINT = 1
    """Two Point Interpolation."""

ADDSMessageInterpolationType.INTERPOLATION_ONE_POINT.__doc__ = "One Point Interpolation."
ADDSMessageInterpolationType.INTERPOLATION_TWO_POINT.__doc__ = "Two Point Interpolation."

agcls.AgTypeNameMap["ADDSMessageInterpolationType"] = ADDSMessageInterpolationType

class ADDSMissingMessageType(IntEnum):
    """The wind effect to apply if there is an interval gap between messages."""

    MISSING_MESSAGE_ZERO_WIND = 0
    """Zero Wind."""
    MISSING_MESSAGE_INTERPOLATION_END_POINTS = 1
    """Interpolate End Points."""

ADDSMissingMessageType.MISSING_MESSAGE_ZERO_WIND.__doc__ = "Zero Wind."
ADDSMissingMessageType.MISSING_MESSAGE_INTERPOLATION_END_POINTS.__doc__ = "Interpolate End Points."

agcls.AgTypeNameMap["ADDSMissingMessageType"] = ADDSMissingMessageType

class ADDSMessageExtrapolationType(IntEnum):
    """The wind effect to apply if the procedure(s) extend beyond the intervals of any available messages."""

    EXTRAPOLATION_MESSAGE_ZERO_WIND = 0
    """Zero Wind."""
    EXTRAPOLATION_MESSAGE_HOLD_END_POINTS = 1
    """Hold End Point Wind."""

ADDSMessageExtrapolationType.EXTRAPOLATION_MESSAGE_ZERO_WIND.__doc__ = "Zero Wind."
ADDSMessageExtrapolationType.EXTRAPOLATION_MESSAGE_HOLD_END_POINTS.__doc__ = "Hold End Point Wind."

agcls.AgTypeNameMap["ADDSMessageExtrapolationType"] = ADDSMessageExtrapolationType

class ADDSForecastType(IntEnum):
    """The forecast type for the NOAA ADDS message."""

    HOUR_6 = 0
    """6 hour forecast."""
    HOUR_12 = 1
    """12 hour forecast."""
    HOUR_24 = 2
    """24 hour forecast."""

ADDSForecastType.HOUR_6.__doc__ = "6 hour forecast."
ADDSForecastType.HOUR_12.__doc__ = "12 hour forecast."
ADDSForecastType.HOUR_24.__doc__ = "24 hour forecast."

agcls.AgTypeNameMap["ADDSForecastType"] = ADDSForecastType

class AtmosphereModelType(IntEnum):
    """The basic atmosphere model type."""

    STANDARD1976 = 0
    """1976 U.S. Standard Atmosphere."""
    MIL_HOT = 1
    """U.S. MIL HDBK 310 - Hot."""
    MIL_COLD = 2
    """U.S. MIL HDBK 310 - Cold."""
    MIL_LOW_DENSITY = 3
    """U.S. MIL HDBK 310 - Low Density."""
    MIL_HIGH_DENSITY = 4
    """U.S. MIL HDBK 310 - High Density."""
    MIL_INTERPOLATE = 5
    """Interpolate MIL HDBK 310 Data."""

AtmosphereModelType.STANDARD1976.__doc__ = "1976 U.S. Standard Atmosphere."
AtmosphereModelType.MIL_HOT.__doc__ = "U.S. MIL HDBK 310 - Hot."
AtmosphereModelType.MIL_COLD.__doc__ = "U.S. MIL HDBK 310 - Cold."
AtmosphereModelType.MIL_LOW_DENSITY.__doc__ = "U.S. MIL HDBK 310 - Low Density."
AtmosphereModelType.MIL_HIGH_DENSITY.__doc__ = "U.S. MIL HDBK 310 - High Density."
AtmosphereModelType.MIL_INTERPOLATE.__doc__ = "Interpolate MIL HDBK 310 Data."

agcls.AgTypeNameMap["AtmosphereModelType"] = AtmosphereModelType

class SmoothTurnMode(IntEnum):
    """The basic maneuver smooth turn mode."""

    SMOOTH_TURN_LOAD_FACTOR = 0
    """Specify the load factor of the smooth turn."""
    SMOOTH_TURN_ROLL_ANGLE = 1
    """Specify the roll angle of the smooth turn."""

SmoothTurnMode.SMOOTH_TURN_LOAD_FACTOR.__doc__ = "Specify the load factor of the smooth turn."
SmoothTurnMode.SMOOTH_TURN_ROLL_ANGLE.__doc__ = "Specify the roll angle of the smooth turn."

agcls.AgTypeNameMap["SmoothTurnMode"] = SmoothTurnMode

class PerformanceModelOverride(IntEnum):
    """The performance model override mode."""

    PERFORMANCE_MODEL_VALUE = 0
    """Use the performance model value."""
    OVERRIDE = 1
    """Override the performance model value."""

PerformanceModelOverride.PERFORMANCE_MODEL_VALUE.__doc__ = "Use the performance model value."
PerformanceModelOverride.OVERRIDE.__doc__ = "Override the performance model value."

agcls.AgTypeNameMap["PerformanceModelOverride"] = PerformanceModelOverride

class BasicManeuverAirspeedMode(IntEnum):
    """The basic maneuver airspeed mode."""

    MAINTAIN_CURRENT_AIRSPEED = 0
    """Maintain the current airspeed."""
    MAINTAIN_SPECIFIED_AIRSPEED = 1
    """Maintain the specified airspeed."""
    MAINTAIN_MIN_AIRSPEED = 2
    """Maintain the minimum airspeed for the aircraft."""
    MAINTAIN_MAX_ENDURANCE_AIRSPEED = 3
    """Maintain the maximum endurance airspeed for the aircraft."""
    MAINTAIN_MAX_RANGE_AIRSPEED = 4
    """Maintain the maximum range airspeed for the aircraft."""
    MAINTAIN_MAX_AIRSPEED = 5
    """Maintain the maximum airspeed for the aircraft."""
    MAINTAIN_MAX_PERFORMANCE_AIRSPEED = 6
    """Maintain the maximum performance airspeed for the aircraft."""
    ACCELERATION_AT_G = 7
    """Accelerate at the specified rate."""
    DECELERATION_AT_G = 8
    """Decelerate at the specified rate."""
    ACCELERATION_DECELERATION_UNDER_GRAVITY = 9
    """Accel/Decel at the force of gravity (no drag, no thrust)."""
    ACCELERATION_DECELERATION_AERODYNAMIC_PROPULSION = 10
    """Accel/Decel using Aero/Propulsion with throttle setting."""
    THRUST = 11
    """Specify thrust (using drag from Aerodynamics model)."""
    INTERPOLATE_ACCELERATION_DECELERATION = 12
    """Interpolate Accelerate/Decelerate over interval."""

BasicManeuverAirspeedMode.MAINTAIN_CURRENT_AIRSPEED.__doc__ = "Maintain the current airspeed."
BasicManeuverAirspeedMode.MAINTAIN_SPECIFIED_AIRSPEED.__doc__ = "Maintain the specified airspeed."
BasicManeuverAirspeedMode.MAINTAIN_MIN_AIRSPEED.__doc__ = "Maintain the minimum airspeed for the aircraft."
BasicManeuverAirspeedMode.MAINTAIN_MAX_ENDURANCE_AIRSPEED.__doc__ = "Maintain the maximum endurance airspeed for the aircraft."
BasicManeuverAirspeedMode.MAINTAIN_MAX_RANGE_AIRSPEED.__doc__ = "Maintain the maximum range airspeed for the aircraft."
BasicManeuverAirspeedMode.MAINTAIN_MAX_AIRSPEED.__doc__ = "Maintain the maximum airspeed for the aircraft."
BasicManeuverAirspeedMode.MAINTAIN_MAX_PERFORMANCE_AIRSPEED.__doc__ = "Maintain the maximum performance airspeed for the aircraft."
BasicManeuverAirspeedMode.ACCELERATION_AT_G.__doc__ = "Accelerate at the specified rate."
BasicManeuverAirspeedMode.DECELERATION_AT_G.__doc__ = "Decelerate at the specified rate."
BasicManeuverAirspeedMode.ACCELERATION_DECELERATION_UNDER_GRAVITY.__doc__ = "Accel/Decel at the force of gravity (no drag, no thrust)."
BasicManeuverAirspeedMode.ACCELERATION_DECELERATION_AERODYNAMIC_PROPULSION.__doc__ = "Accel/Decel using Aero/Propulsion with throttle setting."
BasicManeuverAirspeedMode.THRUST.__doc__ = "Specify thrust (using drag from Aerodynamics model)."
BasicManeuverAirspeedMode.INTERPOLATE_ACCELERATION_DECELERATION.__doc__ = "Interpolate Accelerate/Decelerate over interval."

agcls.AgTypeNameMap["BasicManeuverAirspeedMode"] = BasicManeuverAirspeedMode

class AileronRollFlightPath(IntEnum):
    """The flight path option for an aileron roll strategy for a basic maneuver procedure."""

    STRAIGHT_LINE_FLIGHT_PATH = 0
    """Fly a straight line flight path."""
    ZERO_G_FLIGHT_PATH = 1
    """Fly a zero G flight path."""

AileronRollFlightPath.STRAIGHT_LINE_FLIGHT_PATH.__doc__ = "Fly a straight line flight path."
AileronRollFlightPath.ZERO_G_FLIGHT_PATH.__doc__ = "Fly a zero G flight path."

agcls.AgTypeNameMap["AileronRollFlightPath"] = AileronRollFlightPath

class RollLeftRight(IntEnum):
    """The roll direction for an aileron roll strategy for a basic maneuver procedure."""

    ROLL_LEFT = 0
    """Roll left."""
    ROLL_RIGHT = 1
    """Roll right."""

RollLeftRight.ROLL_LEFT.__doc__ = "Roll left."
RollLeftRight.ROLL_RIGHT.__doc__ = "Roll right."

agcls.AgTypeNameMap["RollLeftRight"] = RollLeftRight

class RollUprightInverted(IntEnum):
    """The orientation for an aileron roll strategy for a basic maneuver procedure."""

    ROLL_UPRIGHT = 0
    """Upright roll."""
    ROLL_INVERTED = 1
    """Inverted roll."""

RollUprightInverted.ROLL_UPRIGHT.__doc__ = "Upright roll."
RollUprightInverted.ROLL_INVERTED.__doc__ = "Inverted roll."

agcls.AgTypeNameMap["RollUprightInverted"] = RollUprightInverted

class AileronRollMode(IntEnum):
    """The roll mode aileron roll strategy for a basic maneuver procedure."""

    ROLL_TO_ANGLE = 0
    """Specify the angle to roll."""
    ROLL_TO_ORIENTATION = 1
    """Specify the orientation to roll to."""

AileronRollMode.ROLL_TO_ANGLE.__doc__ = "Specify the angle to roll."
AileronRollMode.ROLL_TO_ORIENTATION.__doc__ = "Specify the orientation to roll to."

agcls.AgTypeNameMap["AileronRollMode"] = AileronRollMode

class FlyAOALeftRight(IntEnum):
    """The roll direction for a Fly AOA strategy for a basic maneuver procedure."""

    FLY_AOA_LEFT = 0
    """Roll left."""
    FLY_AOA_RIGHT = 1
    """Roll right."""
    FLY_AOA_NO_ROLL = 2
    """No roll."""

FlyAOALeftRight.FLY_AOA_LEFT.__doc__ = "Roll left."
FlyAOALeftRight.FLY_AOA_RIGHT.__doc__ = "Roll right."
FlyAOALeftRight.FLY_AOA_NO_ROLL.__doc__ = "No roll."

agcls.AgTypeNameMap["FlyAOALeftRight"] = FlyAOALeftRight

class SmoothAccelerationLeftRight(IntEnum):
    """The roll direction for a smooth acceleration strategy for a basic maneuver procedure."""

    SMOOTH_ACCELERATION_LEFT = 0
    """Roll left."""
    SMOOTH_ACCELERATION_RIGHT = 1
    """Roll right."""
    SMOOTH_ACCELERATION_NO_ROLL = 2
    """No roll."""

SmoothAccelerationLeftRight.SMOOTH_ACCELERATION_LEFT.__doc__ = "Roll left."
SmoothAccelerationLeftRight.SMOOTH_ACCELERATION_RIGHT.__doc__ = "Roll right."
SmoothAccelerationLeftRight.SMOOTH_ACCELERATION_NO_ROLL.__doc__ = "No roll."

agcls.AgTypeNameMap["SmoothAccelerationLeftRight"] = SmoothAccelerationLeftRight

class PullMode(IntEnum):
    """The pull mode for a pull strategy of a basic maneuver procedure."""

    PULL_TO_ANGLE = 0
    """Pull to the specified angle."""
    PULL_TO_HORIZON = 1
    """Pull to the horizon plus the additional angle."""

PullMode.PULL_TO_ANGLE.__doc__ = "Pull to the specified angle."
PullMode.PULL_TO_HORIZON.__doc__ = "Pull to the horizon plus the additional angle."

agcls.AgTypeNameMap["PullMode"] = PullMode

class RollingPullMode(IntEnum):
    """The rolling pull mode for a rolling pull strategy of a basic maneuver procedure."""

    ROLL_TO_ANGLE_MODE = 0
    """Roll to the specified angle."""
    ROLL_TO_ORIENTATION_MODE = 1
    """Roll to the specified orientaiton plus additional angle."""
    PULL_TO_ANGLE_MODE = 2
    """Pull to the specified angle."""
    PULL_TO_HORIZON_MODE = 3
    """Pull to the horizon plus the additional angle."""

RollingPullMode.ROLL_TO_ANGLE_MODE.__doc__ = "Roll to the specified angle."
RollingPullMode.ROLL_TO_ORIENTATION_MODE.__doc__ = "Roll to the specified orientaiton plus additional angle."
RollingPullMode.PULL_TO_ANGLE_MODE.__doc__ = "Pull to the specified angle."
RollingPullMode.PULL_TO_HORIZON_MODE.__doc__ = "Pull to the horizon plus the additional angle."

agcls.AgTypeNameMap["RollingPullMode"] = RollingPullMode

class SmoothAccelerationStopConditions(IntEnum):
    """The rolling pull mode for a rolling pull strategy of a basic maneuver procedure."""

    ROLL_RATE_AND_LOAD_FACTOR = 0
    """Roll rate and load factor rate achieved."""
    ROLL_RATE_OR_LOAD_FACTOR = 1
    """Roll rate or load factor rate achieved."""
    SMOOTH_ACCELERATION_NORMAL_STOP_CONDITIONS = 2
    """Basic stop conditions."""

SmoothAccelerationStopConditions.ROLL_RATE_AND_LOAD_FACTOR.__doc__ = "Roll rate and load factor rate achieved."
SmoothAccelerationStopConditions.ROLL_RATE_OR_LOAD_FACTOR.__doc__ = "Roll rate or load factor rate achieved."
SmoothAccelerationStopConditions.SMOOTH_ACCELERATION_NORMAL_STOP_CONDITIONS.__doc__ = "Basic stop conditions."

agcls.AgTypeNameMap["SmoothAccelerationStopConditions"] = SmoothAccelerationStopConditions

class AutopilotHorizontalPlaneMode(IntEnum):
    """The autopilot mode for an autopilot - horizontal plane strategy of a basic maneuver procedure."""

    AUTOPILOT_ABSOLUTE_HEADING = 0
    """The absolute heading mode."""
    AUTOPILOT_ABSOLUTE_COURSE = 1
    """The absolute course mode."""
    AUTOPILOT_RELATIVE_HEADING = 2
    """The relative heading change mode."""
    AUTOPILOT_RELATIVE_COURSE = 3
    """The relative course change mode."""
    AUTOPILOT_HEADING_RATE = 4
    """The set heading rate mode."""
    AUTOPILOT_COURSE_RATE = 5
    """The set course rate  mode."""

AutopilotHorizontalPlaneMode.AUTOPILOT_ABSOLUTE_HEADING.__doc__ = "The absolute heading mode."
AutopilotHorizontalPlaneMode.AUTOPILOT_ABSOLUTE_COURSE.__doc__ = "The absolute course mode."
AutopilotHorizontalPlaneMode.AUTOPILOT_RELATIVE_HEADING.__doc__ = "The relative heading change mode."
AutopilotHorizontalPlaneMode.AUTOPILOT_RELATIVE_COURSE.__doc__ = "The relative course change mode."
AutopilotHorizontalPlaneMode.AUTOPILOT_HEADING_RATE.__doc__ = "The set heading rate mode."
AutopilotHorizontalPlaneMode.AUTOPILOT_COURSE_RATE.__doc__ = "The set course rate  mode."

agcls.AgTypeNameMap["AutopilotHorizontalPlaneMode"] = AutopilotHorizontalPlaneMode

class AngleMode(IntEnum):
    """The angle mode for a barrel roll strategy of a basic maneuver procedure."""

    RELATIVE_ANGLE = 0
    """The absolute angle option."""
    ABSOLUTE_ANGLE = 1
    """The relative angle option."""

AngleMode.RELATIVE_ANGLE.__doc__ = "The absolute angle option."
AngleMode.ABSOLUTE_ANGLE.__doc__ = "The relative angle option."

agcls.AgTypeNameMap["AngleMode"] = AngleMode

class HoverAltitudeMode(IntEnum):
    """The altitude mode for the lighter than air hover strategy of a basic maneuver procedure."""

    HOVER_HOLD_INIT_ALTITUDE = 0
    """The hold initial altitude mode."""
    HOVER_SPECIFY_ALTITUDE = 1
    """The specify altitude mode."""
    HOVER_SPECIFY_ALTITUDE_CHANGE = 2
    """The specify altitude change mode."""
    HOVER_SPECIFY_ALTITUDE_RATE = 3
    """The specify altitude rate mode."""
    HOVER_HOLD_INIT_ALTITUDE_RATE = 4
    """The hold initial altitude rate mode."""
    HOVER_PARACHUTE = 5
    """The parachute mode."""

HoverAltitudeMode.HOVER_HOLD_INIT_ALTITUDE.__doc__ = "The hold initial altitude mode."
HoverAltitudeMode.HOVER_SPECIFY_ALTITUDE.__doc__ = "The specify altitude mode."
HoverAltitudeMode.HOVER_SPECIFY_ALTITUDE_CHANGE.__doc__ = "The specify altitude change mode."
HoverAltitudeMode.HOVER_SPECIFY_ALTITUDE_RATE.__doc__ = "The specify altitude rate mode."
HoverAltitudeMode.HOVER_HOLD_INIT_ALTITUDE_RATE.__doc__ = "The hold initial altitude rate mode."
HoverAltitudeMode.HOVER_PARACHUTE.__doc__ = "The parachute mode."

agcls.AgTypeNameMap["HoverAltitudeMode"] = HoverAltitudeMode

class HoverHeadingMode(IntEnum):
    """The heading mode for the lighter than air hover strategy of a basic maneuver procedure."""

    HOVER_RELATIVE = 0
    """The relative to start heading mode."""
    HOVER_ABSOLUTE = 1
    """The absolute heading mode."""
    HOVER_INTO_WIND = 2
    """The align into wind heading mode."""
    HOVER_OPPOSITE_WIND = 3
    """The align opposite wind heading mode."""

HoverHeadingMode.HOVER_RELATIVE.__doc__ = "The relative to start heading mode."
HoverHeadingMode.HOVER_ABSOLUTE.__doc__ = "The absolute heading mode."
HoverHeadingMode.HOVER_INTO_WIND.__doc__ = "The align into wind heading mode."
HoverHeadingMode.HOVER_OPPOSITE_WIND.__doc__ = "The align opposite wind heading mode."

agcls.AgTypeNameMap["HoverHeadingMode"] = HoverHeadingMode

class AutopilotAltitudeMode(IntEnum):
    """The altitude mode for the autopilot - vertical plane strategy of a basic maneuver procedure."""

    AUTOPILOT_HOLD_INIT_ALTITUDE = 0
    """The hold initial altitude mode."""
    AUTOPILOT_SPECIFY_ALTITUDE = 1
    """The specify altitude mode."""
    AUTOPILOT_SPECIFY_ALTITUDE_CHANGE = 2
    """The specify altitude change mode."""
    AUTOPILOT_SPECIFY_ALTITUDE_RATE = 3
    """The specify altitude rate mode."""
    AUTOPILOT_HOLD_INIT_ALTITUDE_RATE = 4
    """The hold initial altitude rate mode."""
    AUTOPILOT_SPECIFY_FLIGHT_PATH_ANGLE = 5
    """The specify wind frame flight path angle mode."""
    AUTOPILOT_HOLD_INIT_FLIGHT_PATH_ANGLE = 6
    """The hold initial wind frame flight path angle mode."""
    AUTOPILOT_BALLISTIC = 7
    """The ballistic flight path mode."""

AutopilotAltitudeMode.AUTOPILOT_HOLD_INIT_ALTITUDE.__doc__ = "The hold initial altitude mode."
AutopilotAltitudeMode.AUTOPILOT_SPECIFY_ALTITUDE.__doc__ = "The specify altitude mode."
AutopilotAltitudeMode.AUTOPILOT_SPECIFY_ALTITUDE_CHANGE.__doc__ = "The specify altitude change mode."
AutopilotAltitudeMode.AUTOPILOT_SPECIFY_ALTITUDE_RATE.__doc__ = "The specify altitude rate mode."
AutopilotAltitudeMode.AUTOPILOT_HOLD_INIT_ALTITUDE_RATE.__doc__ = "The hold initial altitude rate mode."
AutopilotAltitudeMode.AUTOPILOT_SPECIFY_FLIGHT_PATH_ANGLE.__doc__ = "The specify wind frame flight path angle mode."
AutopilotAltitudeMode.AUTOPILOT_HOLD_INIT_FLIGHT_PATH_ANGLE.__doc__ = "The hold initial wind frame flight path angle mode."
AutopilotAltitudeMode.AUTOPILOT_BALLISTIC.__doc__ = "The ballistic flight path mode."

agcls.AgTypeNameMap["AutopilotAltitudeMode"] = AutopilotAltitudeMode

class AutopilotAltitudeControlMode(IntEnum):
    """The altitude control mode for the autopilot - vertical plane strategy of a basic maneuver procedure."""

    AUTOPILOT_ALTITUDE_RATE = 0
    """The control altitude rate mode."""
    AUTOPILOT_FLIGHT_PATH_ANGLE = 1
    """The control flight path angle mode."""
    AUTOPILOT_PERFORMANCE_MODELS = 2
    """The climb/descent performance models mode."""

AutopilotAltitudeControlMode.AUTOPILOT_ALTITUDE_RATE.__doc__ = "The control altitude rate mode."
AutopilotAltitudeControlMode.AUTOPILOT_FLIGHT_PATH_ANGLE.__doc__ = "The control flight path angle mode."
AutopilotAltitudeControlMode.AUTOPILOT_PERFORMANCE_MODELS.__doc__ = "The climb/descent performance models mode."

agcls.AgTypeNameMap["AutopilotAltitudeControlMode"] = AutopilotAltitudeControlMode

class ClosureMode(IntEnum):
    """The closure mode for guidance strategies of the basic maneuver procedure."""

    CLOSURE_NOT_SET = 0
    """The closure is not set. The maneuver will continue whether or not the aircraft is closing with the target."""
    CLOSURE_REQUIRED = 1
    """The closure is required."""
    HOBS = 2
    """The high off boresight mode."""

ClosureMode.CLOSURE_NOT_SET.__doc__ = "The closure is not set. The maneuver will continue whether or not the aircraft is closing with the target."
ClosureMode.CLOSURE_REQUIRED.__doc__ = "The closure is required."
ClosureMode.HOBS.__doc__ = "The high off boresight mode."

agcls.AgTypeNameMap["ClosureMode"] = ClosureMode

class InterceptMode(IntEnum):
    """The intercept mode for the intercept strategy of the basic maneuver procedure."""

    TARGET_ASPECT = 0
    """The target aspect mode. The aircraft will maintain an approach angle with the target."""
    LATERAL_SEPARATION = 1
    """The lateral separation mode. The aircraft will guide to a specific distance from the target."""

InterceptMode.TARGET_ASPECT.__doc__ = "The target aspect mode. The aircraft will maintain an approach angle with the target."
InterceptMode.LATERAL_SEPARATION.__doc__ = "The lateral separation mode. The aircraft will guide to a specific distance from the target."

agcls.AgTypeNameMap["InterceptMode"] = InterceptMode

class RendezvousStopCondition(IntEnum):
    """The stop condition options for a rendezvous formation strategy of the basic maneuver procedure."""

    STOP_NORMAL = 0
    """The basic stopping conditions will be used."""
    STOP_AFTER_TARGET_CURRENT_PROCEDURE = 1
    """Stop after the target completes the current procedure."""
    STOP_AFTER_TARGET_CURRENT_PHASE = 2
    """Stop after the target completes the current phase."""
    STOP_WHEN_TARGET_PERFORMANCE_MODE_CHANGES = 3
    """Stop when the target enters a new mode of flight."""
    STOP_WHEN_TARGET_PHASE_OF_FLIGHT_CHANGES = 4
    """Stop when the target enters a new performance phase."""

RendezvousStopCondition.STOP_NORMAL.__doc__ = "The basic stopping conditions will be used."
RendezvousStopCondition.STOP_AFTER_TARGET_CURRENT_PROCEDURE.__doc__ = "Stop after the target completes the current procedure."
RendezvousStopCondition.STOP_AFTER_TARGET_CURRENT_PHASE.__doc__ = "Stop after the target completes the current phase."
RendezvousStopCondition.STOP_WHEN_TARGET_PERFORMANCE_MODE_CHANGES.__doc__ = "Stop when the target enters a new mode of flight."
RendezvousStopCondition.STOP_WHEN_TARGET_PHASE_OF_FLIGHT_CHANGES.__doc__ = "Stop when the target enters a new performance phase."

agcls.AgTypeNameMap["RendezvousStopCondition"] = RendezvousStopCondition

class FormationFlyerStopCondition(IntEnum):
    """The stop condition options for a Formation Flyer procedure."""

    FORMATION_FLYER_STOP_AFTER_FULL_MISSION = 0
    """Stop After FullMission."""
    FORMATION_FLYER_STOP_AFTER_TIME = 1
    """Stop After Time."""
    FORMATION_FLYER_STOP_AFTER_FUEL_STATE = 2
    """Stop After FuelState."""
    FORMATION_FLYER_STOP_AFTER_DOWN_RANGE = 3
    """Stop After DownRange."""
    FORMATION_FLYER_STOP_WHEN_TARGET_PROCEDURE_CHANGES = 4
    """Stop When TargetProcedure Changes."""
    FORMATION_FLYER_STOP_WHEN_TARGET_MISSION_CHANGES = 5
    """Stop When Target Mission Changes."""
    FORMATION_FLYER_STOP_WHEN_TARGET_PHASE_OF_FLIGHT_CHANGES = 6
    """Stop When Target PhaseOfFlight Changes."""
    FORMATION_FLYER_STOP_WHEN_TARGET_PERFORMANCE_MODE_CHANGES = 7
    """Stop When Target PerfMode Changes."""

FormationFlyerStopCondition.FORMATION_FLYER_STOP_AFTER_FULL_MISSION.__doc__ = "Stop After FullMission."
FormationFlyerStopCondition.FORMATION_FLYER_STOP_AFTER_TIME.__doc__ = "Stop After Time."
FormationFlyerStopCondition.FORMATION_FLYER_STOP_AFTER_FUEL_STATE.__doc__ = "Stop After FuelState."
FormationFlyerStopCondition.FORMATION_FLYER_STOP_AFTER_DOWN_RANGE.__doc__ = "Stop After DownRange."
FormationFlyerStopCondition.FORMATION_FLYER_STOP_WHEN_TARGET_PROCEDURE_CHANGES.__doc__ = "Stop When TargetProcedure Changes."
FormationFlyerStopCondition.FORMATION_FLYER_STOP_WHEN_TARGET_MISSION_CHANGES.__doc__ = "Stop When Target Mission Changes."
FormationFlyerStopCondition.FORMATION_FLYER_STOP_WHEN_TARGET_PHASE_OF_FLIGHT_CHANGES.__doc__ = "Stop When Target PhaseOfFlight Changes."
FormationFlyerStopCondition.FORMATION_FLYER_STOP_WHEN_TARGET_PERFORMANCE_MODE_CHANGES.__doc__ = "Stop When Target PerfMode Changes."

agcls.AgTypeNameMap["FormationFlyerStopCondition"] = FormationFlyerStopCondition

class ExtEphemFlightMode(IntEnum):
    """Flight mode enums for ExtEphem."""

    EXT_EPHEM_FLIGHT_MODE_FORWARD_FLIGHT_CLIMB = 0
    """ForwardFlightClimb."""
    EXT_EPHEM_FLIGHT_MODE_FORWARD_FLIGHT_CRUISE = 1
    """ForwardFlightCruise."""
    EXT_EPHEM_FLIGHT_MODE_FORWARD_FLIGHT_DESCEND = 2
    """ForwardFlightDescend."""
    EXT_EPHEM_FLIGHT_MODE_LANDING = 3
    """Landing."""
    EXT_EPHEM_FLIGHT_MODE_LANDING_WOW = 4
    """LandingWOW."""
    EXT_EPHEM_FLIGHT_MODE_TAKEOFF = 5
    """Takeoff."""
    EXT_EPHEM_FLIGHT_MODE_TAKEOFF_WOW = 6
    """TakeoffWOW."""
    EXT_EPHEM_FLIGHT_MODE_VTOL_HOVER = 7
    """VTOLHover ."""

ExtEphemFlightMode.EXT_EPHEM_FLIGHT_MODE_FORWARD_FLIGHT_CLIMB.__doc__ = "ForwardFlightClimb."
ExtEphemFlightMode.EXT_EPHEM_FLIGHT_MODE_FORWARD_FLIGHT_CRUISE.__doc__ = "ForwardFlightCruise."
ExtEphemFlightMode.EXT_EPHEM_FLIGHT_MODE_FORWARD_FLIGHT_DESCEND.__doc__ = "ForwardFlightDescend."
ExtEphemFlightMode.EXT_EPHEM_FLIGHT_MODE_LANDING.__doc__ = "Landing."
ExtEphemFlightMode.EXT_EPHEM_FLIGHT_MODE_LANDING_WOW.__doc__ = "LandingWOW."
ExtEphemFlightMode.EXT_EPHEM_FLIGHT_MODE_TAKEOFF.__doc__ = "Takeoff."
ExtEphemFlightMode.EXT_EPHEM_FLIGHT_MODE_TAKEOFF_WOW.__doc__ = "TakeoffWOW."
ExtEphemFlightMode.EXT_EPHEM_FLIGHT_MODE_VTOL_HOVER.__doc__ = "VTOLHover ."

agcls.AgTypeNameMap["ExtEphemFlightMode"] = ExtEphemFlightMode

class AccelerationPerformanceModelOverride(IntEnum):
    """The acceleration performance model override mode."""

    ACCELERATION_PERFORMANCE_MODEL_VALUE = 0
    """Use the acceleration performance model value."""
    ACCELERATION_OVERRIDE = 1
    """Override the performance model value."""
    ACCELERATION_NO_LIMIT = 2
    """Set no limit on the acceleration."""

AccelerationPerformanceModelOverride.ACCELERATION_PERFORMANCE_MODEL_VALUE.__doc__ = "Use the acceleration performance model value."
AccelerationPerformanceModelOverride.ACCELERATION_OVERRIDE.__doc__ = "Override the performance model value."
AccelerationPerformanceModelOverride.ACCELERATION_NO_LIMIT.__doc__ = "Set no limit on the acceleration."

agcls.AgTypeNameMap["AccelerationPerformanceModelOverride"] = AccelerationPerformanceModelOverride

class StationkeepingStopCondition(IntEnum):
    """The stop condition options for a stationkeeping strategy."""

    STOP_CONDITION_NOT_SET = 0
    """The basic stopping conditions will be used."""
    STOP_AFTER_TURN_COUNT = 1
    """Stop after a specified number of turns."""
    STOP_AFTER_DURATION = 2
    """Stop after a specified duration."""
    STOP_AFTER_TIME = 3
    """Stop at the specified time."""

StationkeepingStopCondition.STOP_CONDITION_NOT_SET.__doc__ = "The basic stopping conditions will be used."
StationkeepingStopCondition.STOP_AFTER_TURN_COUNT.__doc__ = "Stop after a specified number of turns."
StationkeepingStopCondition.STOP_AFTER_DURATION.__doc__ = "Stop after a specified duration."
StationkeepingStopCondition.STOP_AFTER_TIME.__doc__ = "Stop at the specified time."

agcls.AgTypeNameMap["StationkeepingStopCondition"] = StationkeepingStopCondition

class TurnDirection(IntEnum):
    """The roll direction for an aileron roll strategy for a basic maneuver procedure."""

    TURN_LEFT = 0
    """Turn left."""
    TURN_RIGHT = 2
    """Turn right."""

TurnDirection.TURN_LEFT.__doc__ = "Turn left."
TurnDirection.TURN_RIGHT.__doc__ = "Turn right."

agcls.AgTypeNameMap["TurnDirection"] = TurnDirection

class ProfileControlLimit(IntEnum):
    """Define the control limits for a profile strategy of a basic maneuver procedure."""

    PROFILE_ACCELERATION_PERFORMANCE_MODEL = 0
    """Use Accel Perf Model."""
    PROFILE_PITCH_RATE = 1
    """Specify the pitch rate."""

ProfileControlLimit.PROFILE_ACCELERATION_PERFORMANCE_MODEL.__doc__ = "Use Accel Perf Model."
ProfileControlLimit.PROFILE_PITCH_RATE.__doc__ = "Specify the pitch rate."

agcls.AgTypeNameMap["ProfileControlLimit"] = ProfileControlLimit

class RelativeSpeedAltitudeStopCondition(IntEnum):
    """The stop condition options for a relative speed/altitude strategy."""

    RELATIVE_SPEED_ALTITUDE_STOP_NORMAL = 0
    """The basic stopping conditions will be used."""
    RELATIVE_SPEED_ALTITUDE_STOP_MIN_RANGE_FOR_EQUAL_SPEED = 1
    """Stop when the aircraft achieves the range for equal speed."""
    RELATIVE_SPEED_ALTITUDE_STOP_TRANSITION_SPEED_RANGE = 2
    """Stop when the aircraft achieves the range to transition speed."""
    RELATIVE_SPEED_ALTITUDE_STOP_AFTER_TARGET_CURRENT_PROCEDURE = 3
    """Stop after the target completes the current procedure."""
    RELATIVE_SPEED_ALTITUDE_STOP_AFTER_TARGET_CURRENT_PHASE = 4
    """Stop after the target completes the current phase."""
    RELATIVE_SPEED_ALTITUDE_STOP_WHEN_TARGET_PERFORMANCE_MODE_CHANGES = 5
    """Stop when the target enters a new mode of flight."""
    RELATIVE_SPEED_ALTITUDE_STOP_WHEN_TARGET_PHASE_OF_FLIGHT_CHANGES = 6
    """Stop when the target enters a new performance phase."""

RelativeSpeedAltitudeStopCondition.RELATIVE_SPEED_ALTITUDE_STOP_NORMAL.__doc__ = "The basic stopping conditions will be used."
RelativeSpeedAltitudeStopCondition.RELATIVE_SPEED_ALTITUDE_STOP_MIN_RANGE_FOR_EQUAL_SPEED.__doc__ = "Stop when the aircraft achieves the range for equal speed."
RelativeSpeedAltitudeStopCondition.RELATIVE_SPEED_ALTITUDE_STOP_TRANSITION_SPEED_RANGE.__doc__ = "Stop when the aircraft achieves the range to transition speed."
RelativeSpeedAltitudeStopCondition.RELATIVE_SPEED_ALTITUDE_STOP_AFTER_TARGET_CURRENT_PROCEDURE.__doc__ = "Stop after the target completes the current procedure."
RelativeSpeedAltitudeStopCondition.RELATIVE_SPEED_ALTITUDE_STOP_AFTER_TARGET_CURRENT_PHASE.__doc__ = "Stop after the target completes the current phase."
RelativeSpeedAltitudeStopCondition.RELATIVE_SPEED_ALTITUDE_STOP_WHEN_TARGET_PERFORMANCE_MODE_CHANGES.__doc__ = "Stop when the target enters a new mode of flight."
RelativeSpeedAltitudeStopCondition.RELATIVE_SPEED_ALTITUDE_STOP_WHEN_TARGET_PHASE_OF_FLIGHT_CHANGES.__doc__ = "Stop when the target enters a new performance phase."

agcls.AgTypeNameMap["RelativeSpeedAltitudeStopCondition"] = RelativeSpeedAltitudeStopCondition

class RelativeAltitudeMode(IntEnum):
    """The relative altitude mode for a relative speed/altitude strategy."""

    HOLD_OFFSET_ALTITUDE = 0
    """Maintain the specified altitude offset from the target."""
    HOLD_INIT_ALTITUDE_OFFSET = 1
    """Maintain the altitude offset at the beginning of the maneuver."""
    HOLD_ELEVATION_ANGLE = 2
    """Maintain the specified elevation angle from the target."""
    HOLD_INIT_ELEVATION_ANGLE = 3
    """Maintain the elevation angle at the beginning of the maneuver."""

RelativeAltitudeMode.HOLD_OFFSET_ALTITUDE.__doc__ = "Maintain the specified altitude offset from the target."
RelativeAltitudeMode.HOLD_INIT_ALTITUDE_OFFSET.__doc__ = "Maintain the altitude offset at the beginning of the maneuver."
RelativeAltitudeMode.HOLD_ELEVATION_ANGLE.__doc__ = "Maintain the specified elevation angle from the target."
RelativeAltitudeMode.HOLD_INIT_ELEVATION_ANGLE.__doc__ = "Maintain the elevation angle at the beginning of the maneuver."

agcls.AgTypeNameMap["RelativeAltitudeMode"] = RelativeAltitudeMode

class FlyToFlightPathAngleMode(IntEnum):
    """The flight path angle mode mode for a bezier profile strategy."""

    FLY_TO_ALTITUDE_RATE = 0
    """Fly to a specified altitude rate."""
    FLY_TO_FLIGHT_PATH_ANGLE = 1
    """Fly to a specified flight path angle."""

FlyToFlightPathAngleMode.FLY_TO_ALTITUDE_RATE.__doc__ = "Fly to a specified altitude rate."
FlyToFlightPathAngleMode.FLY_TO_FLIGHT_PATH_ANGLE.__doc__ = "Fly to a specified flight path angle."

agcls.AgTypeNameMap["FlyToFlightPathAngleMode"] = FlyToFlightPathAngleMode

class PushPull(IntEnum):
    """The option to pull up or push over for a push/pull profile strategy."""

    PULL_UP = 0
    """Pull up."""
    PUSH_OVER = 1
    """Push over."""

PushPull.PULL_UP.__doc__ = "Pull up."
PushPull.PUSH_OVER.__doc__ = "Push over."

agcls.AgTypeNameMap["PushPull"] = PushPull

class AccelerationMode(IntEnum):
    """The acceleration/decelation option for a push/pull profile strategy."""

    ACCELERATION = 0
    """Accelerate at specified G."""
    DECELERATION = 1
    """Decelerate at specified G."""
    MAINTAIN_SPEED = 2
    """Maintain the initial airspeed."""

AccelerationMode.ACCELERATION.__doc__ = "Accelerate at specified G."
AccelerationMode.DECELERATION.__doc__ = "Decelerate at specified G."
AccelerationMode.MAINTAIN_SPEED.__doc__ = "Maintain the initial airspeed."

agcls.AgTypeNameMap["AccelerationMode"] = AccelerationMode

class DelayAltitudeMode(IntEnum):
    """The altitude options for a delay procedure."""

    DELAY_LEVEL_OFF = 0
    """Use a level off maneuver to fly to the default altitude."""
    DELAY_DEFAULT_CRUISE_ALTITUDE = 1
    """The default cruise altitude."""
    DELAY_OVERRIDE = 2
    """Override the default altitude."""

DelayAltitudeMode.DELAY_LEVEL_OFF.__doc__ = "Use a level off maneuver to fly to the default altitude."
DelayAltitudeMode.DELAY_DEFAULT_CRUISE_ALTITUDE.__doc__ = "The default cruise altitude."
DelayAltitudeMode.DELAY_OVERRIDE.__doc__ = "Override the default altitude."

agcls.AgTypeNameMap["DelayAltitudeMode"] = DelayAltitudeMode

class JoinExitArcMethod(IntEnum):
    """The options to join or exit an arc."""

    JOIN_EXIT_OUTBOUND = 0
    """The aircraft begins/ends the procedure on a course away from the site."""
    JOIN_EXIT_ON = 1
    """The aircraft begins/ends the procedure at the start bearing."""
    JOIN_EXIT_INBOUND = 2
    """The aircraft begins/ends on a course towards the site."""

JoinExitArcMethod.JOIN_EXIT_OUTBOUND.__doc__ = "The aircraft begins/ends the procedure on a course away from the site."
JoinExitArcMethod.JOIN_EXIT_ON.__doc__ = "The aircraft begins/ends the procedure at the start bearing."
JoinExitArcMethod.JOIN_EXIT_INBOUND.__doc__ = "The aircraft begins/ends on a course towards the site."

agcls.AgTypeNameMap["JoinExitArcMethod"] = JoinExitArcMethod

class FlightLineProcedureType(IntEnum):
    """The procedure methodology used to calculate the flight line."""

    PROCEDURE_TYPE_ENROUTE = 0
    """An enroute procedure type."""
    PROCEDURE_TYPE_BASIC_POINT_TO_POINT = 1
    """A basic point to point procedure type."""
    PROCEDURE_TYPE_TERRAIN_FOLLOW = 2
    """A terrain follow procedure type."""

FlightLineProcedureType.PROCEDURE_TYPE_ENROUTE.__doc__ = "An enroute procedure type."
FlightLineProcedureType.PROCEDURE_TYPE_BASIC_POINT_TO_POINT.__doc__ = "A basic point to point procedure type."
FlightLineProcedureType.PROCEDURE_TYPE_TERRAIN_FOLLOW.__doc__ = "A terrain follow procedure type."

agcls.AgTypeNameMap["FlightLineProcedureType"] = FlightLineProcedureType

class TransitionToHoverMode(IntEnum):
    """The type of hover to transition to."""

    FULL_STOP = 0
    """Transition to a full stop hover."""
    TRANSLATION_ONLY = 1
    """Transition to a hover with a constant translation rate."""
    TRANSLATION_AND_ALTITUDE = 2
    """Transition to a hover with a constant translation and altitude rate."""

TransitionToHoverMode.FULL_STOP.__doc__ = "Transition to a full stop hover."
TransitionToHoverMode.TRANSLATION_ONLY.__doc__ = "Transition to a hover with a constant translation rate."
TransitionToHoverMode.TRANSLATION_AND_ALTITUDE.__doc__ = "Transition to a hover with a constant translation and altitude rate."

agcls.AgTypeNameMap["TransitionToHoverMode"] = TransitionToHoverMode

class VTOLRateMode(IntEnum):
    """The rate mode for the VTOL procedure."""

    HALT_AUTOMATIC = 0
    """The rate during the procedure will be maintained."""
    ALWAYS_STOP = 1
    """The rate will be set to zero."""

VTOLRateMode.HALT_AUTOMATIC.__doc__ = "The rate during the procedure will be maintained."
VTOLRateMode.ALWAYS_STOP.__doc__ = "The rate will be set to zero."

agcls.AgTypeNameMap["VTOLRateMode"] = VTOLRateMode

class HoldingProfileMode(IntEnum):
    """How the aircraft will perform during the holding pattern with respect to airspeed and altitude."""

    STK8_COMPATIBLE = 0
    """The aircraft will fly the pattern at the speed at which it arrived at the entry point."""
    LEVEL_OFF_CRUISE_SPEED = 1
    """The aircraft will level off and fly at the cruise speed."""
    CLIMB_DESCENT_ON_STATION = 2
    """The aircraft will climb or descend to the specified altitude."""

HoldingProfileMode.STK8_COMPATIBLE.__doc__ = "The aircraft will fly the pattern at the speed at which it arrived at the entry point."
HoldingProfileMode.LEVEL_OFF_CRUISE_SPEED.__doc__ = "The aircraft will level off and fly at the cruise speed."
HoldingProfileMode.CLIMB_DESCENT_ON_STATION.__doc__ = "The aircraft will climb or descend to the specified altitude."

agcls.AgTypeNameMap["HoldingProfileMode"] = HoldingProfileMode

class HoldingDirection(IntEnum):
    """The turn direction for the aircraft to enter the holding pattern."""

    INBOUND_LEFT_TURN = 0
    """Turn left on the way inbound to the site."""
    INBOUND_RIGHT_TURN = 1
    """Turn right on the way inbound to the site."""
    OUTBOUND_LEFT_TURN = 2
    """Turn left on the way outbound from the site."""
    OUTBOUND_RIGHT_TURN = 3
    """Turn right on the way outbound from the site."""

HoldingDirection.INBOUND_LEFT_TURN.__doc__ = "Turn left on the way inbound to the site."
HoldingDirection.INBOUND_RIGHT_TURN.__doc__ = "Turn right on the way inbound to the site."
HoldingDirection.OUTBOUND_LEFT_TURN.__doc__ = "Turn left on the way outbound from the site."
HoldingDirection.OUTBOUND_RIGHT_TURN.__doc__ = "Turn right on the way outbound from the site."

agcls.AgTypeNameMap["HoldingDirection"] = HoldingDirection

class HoldRefuelDumpMode(IntEnum):
    """Define when the aircraft will leave the holding pattern after it has completed refueling or dumping fuel."""

    FULL_NUMER_OF_TURNS = 0
    """Turn left on the way inbound to the site."""
    EXIT_AT_END_OF_TURN = 1
    """Turn right on the way inbound to the site."""
    IMMEDIATE_EXIT = 2
    """Turn left on the way outbound from the site."""

HoldRefuelDumpMode.FULL_NUMER_OF_TURNS.__doc__ = "Turn left on the way inbound to the site."
HoldRefuelDumpMode.EXIT_AT_END_OF_TURN.__doc__ = "Turn right on the way inbound to the site."
HoldRefuelDumpMode.IMMEDIATE_EXIT.__doc__ = "Turn left on the way outbound from the site."

agcls.AgTypeNameMap["HoldRefuelDumpMode"] = HoldRefuelDumpMode

class HoldingEntryManeuver(IntEnum):
    """Define how the aircraft will enter the holding pattern."""

    HOLD_ENTRY_NO_MANEUVER = 0
    """The aircraft will enter the holding pattern at the normal holding point."""
    USE_STANDARD_ENTRY_TURNS = 1
    """The aircraft will enter the holding pattern using a standard entry maneuvers defined in the FAA Instrument Flying Handbook."""
    USE_ALTERNATE_ENTRY_POINTS = 2
    """The aircraft will enter the holding pattern at an alternate entry point."""

HoldingEntryManeuver.HOLD_ENTRY_NO_MANEUVER.__doc__ = "The aircraft will enter the holding pattern at the normal holding point."
HoldingEntryManeuver.USE_STANDARD_ENTRY_TURNS.__doc__ = "The aircraft will enter the holding pattern using a standard entry maneuvers defined in the FAA Instrument Flying Handbook."
HoldingEntryManeuver.USE_ALTERNATE_ENTRY_POINTS.__doc__ = "The aircraft will enter the holding pattern at an alternate entry point."

agcls.AgTypeNameMap["HoldingEntryManeuver"] = HoldingEntryManeuver

class VTOLTransitionMode(IntEnum):
    """The mode to specify the course of the transition maneuver."""

    TRANSITION_RELATIVE_HDG = 0
    """Specify a heading relative to the previous procedure."""
    TRANSITION_ABSOLUTE_HDG = 1
    """Specify an absolute heading."""
    TRANSITION_INTO_WIND = 2
    """Transition into the wind direction."""

VTOLTransitionMode.TRANSITION_RELATIVE_HDG.__doc__ = "Specify a heading relative to the previous procedure."
VTOLTransitionMode.TRANSITION_ABSOLUTE_HDG.__doc__ = "Specify an absolute heading."
VTOLTransitionMode.TRANSITION_INTO_WIND.__doc__ = "Transition into the wind direction."

agcls.AgTypeNameMap["VTOLTransitionMode"] = VTOLTransitionMode

class VTOLFinalHeadingMode(IntEnum):
    """The mode to specify the heading at the end of the maneuver."""

    FINAL_HEADING_RELATIVE = 0
    """Specify a heading relative to the previous procedure."""
    FINAL_HEADING_ABSOLUTE = 1
    """Specify an absolute heading."""
    FINAL_HEADING_TRANSLATION_COURSE = 2
    """The aircraft have the same heading as the translation bearing."""

VTOLFinalHeadingMode.FINAL_HEADING_RELATIVE.__doc__ = "Specify a heading relative to the previous procedure."
VTOLFinalHeadingMode.FINAL_HEADING_ABSOLUTE.__doc__ = "Specify an absolute heading."
VTOLFinalHeadingMode.FINAL_HEADING_TRANSLATION_COURSE.__doc__ = "The aircraft have the same heading as the translation bearing."

agcls.AgTypeNameMap["VTOLFinalHeadingMode"] = VTOLFinalHeadingMode

class VTOLTranslationMode(IntEnum):
    """The mode to specify the translation of the VTOL maneuver."""

    SET_BEARING_AND_RANGE = 0
    """The aircraft will translate on a specific bearing and range."""
    COME_TO_STOP = 1
    """The aircraft will come to a complete stop."""
    MAINTAIN_RATE = 2
    """The aircraft will continue to translate with the same rate and direction as it began the procedure."""

VTOLTranslationMode.SET_BEARING_AND_RANGE.__doc__ = "The aircraft will translate on a specific bearing and range."
VTOLTranslationMode.COME_TO_STOP.__doc__ = "The aircraft will come to a complete stop."
VTOLTranslationMode.MAINTAIN_RATE.__doc__ = "The aircraft will continue to translate with the same rate and direction as it began the procedure."

agcls.AgTypeNameMap["VTOLTranslationMode"] = VTOLTranslationMode

class VTOLTranslationFinalCourseMode(IntEnum):
    """The mode to specify the final course of the VTOL maneuver."""

    TRANSLATE_DIRECT = 0
    """The aircraft will translate directly along the specified bearing and range."""
    BISECT_INBOUND_OUTBOUND = 1
    """The aircraft will translate along a bisecting line between the inbound and outbound course."""
    ANTICIPATE_NEXT_TRANSLATION = 2
    """The aircraft will evaluate the procedure ahead to determine the translation bearing and rate."""

VTOLTranslationFinalCourseMode.TRANSLATE_DIRECT.__doc__ = "The aircraft will translate directly along the specified bearing and range."
VTOLTranslationFinalCourseMode.BISECT_INBOUND_OUTBOUND.__doc__ = "The aircraft will translate along a bisecting line between the inbound and outbound course."
VTOLTranslationFinalCourseMode.ANTICIPATE_NEXT_TRANSLATION.__doc__ = "The aircraft will evaluate the procedure ahead to determine the translation bearing and rate."

agcls.AgTypeNameMap["VTOLTranslationFinalCourseMode"] = VTOLTranslationFinalCourseMode

class HoverMode(IntEnum):
    """The hover mode."""

    HOVER_MODE_FIXED_TIME = 0
    """Hover in place for a fixed time."""
    HOVER_MODE_MANEUVER = 1
    """Perform a hovering maneuver."""

HoverMode.HOVER_MODE_FIXED_TIME.__doc__ = "Hover in place for a fixed time."
HoverMode.HOVER_MODE_MANEUVER.__doc__ = "Perform a hovering maneuver."

agcls.AgTypeNameMap["HoverMode"] = HoverMode

class VTOLHeadingMode(IntEnum):
    """The heading mode for the hover maneuver."""

    HEADING_INDEPENDENT = 0
    """The aircraft's heading is independent of its translation."""
    HEADING_ALIGN_TRANSLATION_COURSE = 1
    """The aircraft will align its heading with the translation course."""
    HEADING_INTO_WIND = 2
    """The aircraft will set its heading into the wind."""

VTOLHeadingMode.HEADING_INDEPENDENT.__doc__ = "The aircraft's heading is independent of its translation."
VTOLHeadingMode.HEADING_ALIGN_TRANSLATION_COURSE.__doc__ = "The aircraft will align its heading with the translation course."
VTOLHeadingMode.HEADING_INTO_WIND.__doc__ = "The aircraft will set its heading into the wind."

agcls.AgTypeNameMap["VTOLHeadingMode"] = VTOLHeadingMode

class VertLandingMode(IntEnum):
    """The heading mode for a vertical landing maneuver."""

    VERT_LANDING_INDEPENDENT = 0
    """The aircraft's heading is independent of its translation."""
    VERT_LANDING_ALIGN_TRANSLATION_COURSE = 1
    """The aircraft will align its heading with the translation course."""
    VERT_LANDING_INTO_WIND = 2
    """The aircraft will set its heading into the wind."""
    VERT_LANDING_ALIGN_TRANSLATION_COURSE_OVERRIDE = 3
    """The aircraft will align its heading with the translation course  will achieve the specified heading upon arriving."""

VertLandingMode.VERT_LANDING_INDEPENDENT.__doc__ = "The aircraft's heading is independent of its translation."
VertLandingMode.VERT_LANDING_ALIGN_TRANSLATION_COURSE.__doc__ = "The aircraft will align its heading with the translation course."
VertLandingMode.VERT_LANDING_INTO_WIND.__doc__ = "The aircraft will set its heading into the wind."
VertLandingMode.VERT_LANDING_ALIGN_TRANSLATION_COURSE_OVERRIDE.__doc__ = "The aircraft will align its heading with the translation course  will achieve the specified heading upon arriving."

agcls.AgTypeNameMap["VertLandingMode"] = VertLandingMode

class LaunchAttitudeMode(IntEnum):
    """The attitude mode for the launch procedure."""

    LAUNCH_ALIGN_DIRECTION_VECTOR = 0
    """The aircraft's attitude is aligned with the specified direction vector."""
    LAUNCH_HOLD_PARENT_ATTITUDE = 1
    """The aircraft will maintain the parent vehicle's attiude at the time of launch."""
    LAUNCH_VTOL = 2
    """The aircraft launches in level flight."""

LaunchAttitudeMode.LAUNCH_ALIGN_DIRECTION_VECTOR.__doc__ = "The aircraft's attitude is aligned with the specified direction vector."
LaunchAttitudeMode.LAUNCH_HOLD_PARENT_ATTITUDE.__doc__ = "The aircraft will maintain the parent vehicle's attiude at the time of launch."
LaunchAttitudeMode.LAUNCH_VTOL.__doc__ = "The aircraft launches in level flight."

agcls.AgTypeNameMap["LaunchAttitudeMode"] = LaunchAttitudeMode

class FuelFlowType(IntEnum):
    """The fuel flow type to use for the procedure."""

    FUEL_FLOW_TAKEOFF = 0
    """Fuel flow defined for the current Takeoff performance model."""
    FUEL_FLOW_CRUISE = 1
    """Fuel flow defined for the current Cruise performance model."""
    FUEL_FLOW_LANDING = 2
    """Fuel flow defined for the current Landing performance model."""
    FUEL_FLOW_VTOL = 3
    """Fuel flow defined for the current VTOL performance model."""
    FUEL_FLOW_AERODYNAMIC_PROPULSION = 4
    """Fuel flow defined for the Aerodynamics and Propulsion Analysis component of the current basic acceleration performance model."""
    FUEL_FLOW_OVERRIDE = 5
    """Fuel flow defined manually."""

FuelFlowType.FUEL_FLOW_TAKEOFF.__doc__ = "Fuel flow defined for the current Takeoff performance model."
FuelFlowType.FUEL_FLOW_CRUISE.__doc__ = "Fuel flow defined for the current Cruise performance model."
FuelFlowType.FUEL_FLOW_LANDING.__doc__ = "Fuel flow defined for the current Landing performance model."
FuelFlowType.FUEL_FLOW_VTOL.__doc__ = "Fuel flow defined for the current VTOL performance model."
FuelFlowType.FUEL_FLOW_AERODYNAMIC_PROPULSION.__doc__ = "Fuel flow defined for the Aerodynamics and Propulsion Analysis component of the current basic acceleration performance model."
FuelFlowType.FUEL_FLOW_OVERRIDE.__doc__ = "Fuel flow defined manually."

agcls.AgTypeNameMap["FuelFlowType"] = FuelFlowType

class LineOrientation(IntEnum):
    """The orientation for a parallel flight line procedure."""

    FLIGHT_LINE_TO_LEFT = 0
    """Left of the previous flight line."""
    FLIGHT_LINE_TO_RIGHT = 1
    """Right of the previous flight line."""

LineOrientation.FLIGHT_LINE_TO_LEFT.__doc__ = "Left of the previous flight line."
LineOrientation.FLIGHT_LINE_TO_RIGHT.__doc__ = "Right of the previous flight line."

agcls.AgTypeNameMap["LineOrientation"] = LineOrientation

class RelativeAbsoluteBearing(IntEnum):
    """The options for a bearing that can be relative or absolute."""

    RELATIVE_BEARING = 0
    """A bearing relative to the previous course."""
    TRUE_BEARING = 1
    """A bearing using true north."""
    MAGNETIC_BEARING = 2
    """A bearing using magnetic north."""

RelativeAbsoluteBearing.RELATIVE_BEARING.__doc__ = "A bearing relative to the previous course."
RelativeAbsoluteBearing.TRUE_BEARING.__doc__ = "A bearing using true north."
RelativeAbsoluteBearing.MAGNETIC_BEARING.__doc__ = "A bearing using magnetic north."

agcls.AgTypeNameMap["RelativeAbsoluteBearing"] = RelativeAbsoluteBearing

class BasicFixedWingPropulsionMode(IntEnum):
    """The option to specify the thrust (jet engines) or power (propellers)."""

    SPECIFY_THRUST = 0
    """Jet - Specify net thrust."""
    SPECIFY_POWER = 1
    """Propeller - Specify net power."""

BasicFixedWingPropulsionMode.SPECIFY_THRUST.__doc__ = "Jet - Specify net thrust."
BasicFixedWingPropulsionMode.SPECIFY_POWER.__doc__ = "Propeller - Specify net power."

agcls.AgTypeNameMap["BasicFixedWingPropulsionMode"] = BasicFixedWingPropulsionMode

class ClimbSpeedType(IntEnum):
    """The mode to calculate the aircraft's airspeed while climbing for an advanced climb performance model."""

    CLIMB_SPEED_BEST_RATE = 0
    """The speed at which the aircraft's rate of climb is maximized."""
    CLIMB_SPEED_BEST_ANGLE = 1
    """The speed at which the aircraft will gain the most altitude over downrange distance."""
    CLIMB_SPEED_MIN_FUEL = 2
    """The speed at which the aircraft's fuel consumption is minimized."""
    CLIMB_SPEED_OVERRIDE = 3
    """Manually specify the speed."""

ClimbSpeedType.CLIMB_SPEED_BEST_RATE.__doc__ = "The speed at which the aircraft's rate of climb is maximized."
ClimbSpeedType.CLIMB_SPEED_BEST_ANGLE.__doc__ = "The speed at which the aircraft will gain the most altitude over downrange distance."
ClimbSpeedType.CLIMB_SPEED_MIN_FUEL.__doc__ = "The speed at which the aircraft's fuel consumption is minimized."
ClimbSpeedType.CLIMB_SPEED_OVERRIDE.__doc__ = "Manually specify the speed."

agcls.AgTypeNameMap["ClimbSpeedType"] = ClimbSpeedType

class CruiseMaxPerformanceSpeedType(IntEnum):
    """The method for defining the maximum performance airspeed of the aircraft for an advanced cruise model."""

    CORNER_SPEED = 0
    """The lowest speed at which the aircraft can generate lift while pulling maximum Gs."""
    MAX_PS_DRY_THRUST = 1
    """The maximum specific excess power without afterburning."""
    MAX_PS_AFTERBURNER = 2
    """The maximum specific excess power while afterburning."""
    MAX_SPEED_DRY_THRUST = 3
    """The maximum speed without afterburning."""
    MAX_RANGE_AFTERBURNER = 4
    """The speed which maximizes the aircraft range while afterburning."""

CruiseMaxPerformanceSpeedType.CORNER_SPEED.__doc__ = "The lowest speed at which the aircraft can generate lift while pulling maximum Gs."
CruiseMaxPerformanceSpeedType.MAX_PS_DRY_THRUST.__doc__ = "The maximum specific excess power without afterburning."
CruiseMaxPerformanceSpeedType.MAX_PS_AFTERBURNER.__doc__ = "The maximum specific excess power while afterburning."
CruiseMaxPerformanceSpeedType.MAX_SPEED_DRY_THRUST.__doc__ = "The maximum speed without afterburning."
CruiseMaxPerformanceSpeedType.MAX_RANGE_AFTERBURNER.__doc__ = "The speed which maximizes the aircraft range while afterburning."

agcls.AgTypeNameMap["CruiseMaxPerformanceSpeedType"] = CruiseMaxPerformanceSpeedType

class DescentSpeedType(IntEnum):
    """The method for calculating the aircraft's airspeed while descending."""

    DESCENT_MAX_RANGE_CRUISE = 0
    """A variable airspeed that maximizes the distance that the aircraft can fly."""
    DESCENT_MAX_GLIDE_RATIO = 1
    """The speed at which the aircraft's glide ratio is maximized."""
    DESCENT_MIN_SINK_RATE = 2
    """The speed at which the aircraft's rate of descent is minimized."""
    DESCENT_STALL_SPEED_RATIO = 3
    """A speed relative to the aircraft's stall speed.."""
    DESCENT_SPEED_OVERRIDE = 4
    """Manually define the airspeed."""

DescentSpeedType.DESCENT_MAX_RANGE_CRUISE.__doc__ = "A variable airspeed that maximizes the distance that the aircraft can fly."
DescentSpeedType.DESCENT_MAX_GLIDE_RATIO.__doc__ = "The speed at which the aircraft's glide ratio is maximized."
DescentSpeedType.DESCENT_MIN_SINK_RATE.__doc__ = "The speed at which the aircraft's rate of descent is minimized."
DescentSpeedType.DESCENT_STALL_SPEED_RATIO.__doc__ = "A speed relative to the aircraft's stall speed.."
DescentSpeedType.DESCENT_SPEED_OVERRIDE.__doc__ = "Manually define the airspeed."

agcls.AgTypeNameMap["DescentSpeedType"] = DescentSpeedType

class TakeoffLandingSpeedMode(IntEnum):
    """The method for calculating the aircraft's speed upon leaving the ground or at wheels down."""

    TAKEOFF_LANDING_STALL_SPEED_RATIO = 0
    """A multiple of the aircraft's stall speed."""
    TAKEOFF_LANDING_ANGLE_OF_ATTACK = 1
    """The speed needed to achieve lift at the specified Angle of Attack."""

TakeoffLandingSpeedMode.TAKEOFF_LANDING_STALL_SPEED_RATIO.__doc__ = "A multiple of the aircraft's stall speed."
TakeoffLandingSpeedMode.TAKEOFF_LANDING_ANGLE_OF_ATTACK.__doc__ = "The speed needed to achieve lift at the specified Angle of Attack."

agcls.AgTypeNameMap["TakeoffLandingSpeedMode"] = TakeoffLandingSpeedMode

class DepartureSpeedMode(IntEnum):
    """The method for calculating the aircraft's airspeed upon leaving the ground."""

    MAX_CLIMB_ANGLE = 0
    """The aircraft will fly at the max climb angle."""
    MAX_CLIMB_RATE = 1
    """The aircraft will fly at the max climb rate."""
    USE_CLIMB_MODEL = 2
    """The aircraft will fly at the airspeed defined in the Climb performance model."""

DepartureSpeedMode.MAX_CLIMB_ANGLE.__doc__ = "The aircraft will fly at the max climb angle."
DepartureSpeedMode.MAX_CLIMB_RATE.__doc__ = "The aircraft will fly at the max climb rate."
DepartureSpeedMode.USE_CLIMB_MODEL.__doc__ = "The aircraft will fly at the airspeed defined in the Climb performance model."

agcls.AgTypeNameMap["DepartureSpeedMode"] = DepartureSpeedMode

class AdvancedFixedWingAerodynamicStrategy(IntEnum):
    """The aerodynamic strategy for the Advanced Fixed Wing Tool."""

    EXTERNAL_AERODYNAMIC_FILE = 0
    """Define the aerodynamics using an external .aero file."""
    SUB_SUPER_HYPER_AERODYNAMIC = 1
    """Define the aerodynamics using a model derived from first principles that is valid for the full speed range of high speed aircraft."""
    SUBSONIC_AERODYNAMIC = 2
    """Define the aerodynamics for an aircraft that generally travels at subsonic speeds."""
    SUPERSONIC_AERODYNAMIC = 3
    """Define the aerodynamics for an aircraft that generally travels at supersonic speeds."""
    FOUR_POINT_AERODYNAMIC = 4
    """Define the aerodynamics for an aircraft defined at 4 different points in the flight envelope."""

AdvancedFixedWingAerodynamicStrategy.EXTERNAL_AERODYNAMIC_FILE.__doc__ = "Define the aerodynamics using an external .aero file."
AdvancedFixedWingAerodynamicStrategy.SUB_SUPER_HYPER_AERODYNAMIC.__doc__ = "Define the aerodynamics using a model derived from first principles that is valid for the full speed range of high speed aircraft."
AdvancedFixedWingAerodynamicStrategy.SUBSONIC_AERODYNAMIC.__doc__ = "Define the aerodynamics for an aircraft that generally travels at subsonic speeds."
AdvancedFixedWingAerodynamicStrategy.SUPERSONIC_AERODYNAMIC.__doc__ = "Define the aerodynamics for an aircraft that generally travels at supersonic speeds."
AdvancedFixedWingAerodynamicStrategy.FOUR_POINT_AERODYNAMIC.__doc__ = "Define the aerodynamics for an aircraft defined at 4 different points in the flight envelope."

agcls.AgTypeNameMap["AdvancedFixedWingAerodynamicStrategy"] = AdvancedFixedWingAerodynamicStrategy

class AdvancedFixedWingGeometry(IntEnum):
    """The method to define the wing geometry of an aircraft in the Advanced Fixed Wing Tool."""

    BASIC_GEOMETRY = 0
    """Define the static properties of an immovable wing."""
    VARIABLE_GEOMETRY = 1
    """Define the minimum and maximum properties of an adjustable wing."""

AdvancedFixedWingGeometry.BASIC_GEOMETRY.__doc__ = "Define the static properties of an immovable wing."
AdvancedFixedWingGeometry.VARIABLE_GEOMETRY.__doc__ = "Define the minimum and maximum properties of an adjustable wing."

agcls.AgTypeNameMap["AdvancedFixedWingGeometry"] = AdvancedFixedWingGeometry

class AdvancedFixedWingPowerplantStrategy(IntEnum):
    """The powerplant strategy for the Advanced Fixed Wing Tool."""

    ELECTRIC_POWERPLANT = 0
    """An electric engine."""
    EXTERNAL_PROPULSION_FILE = 1
    """Define the powerplant using an external .prop file."""
    PISTON_POWERPLANT = 2
    """A piston, or reciprocating, engine."""
    SUB_SUPER_HYPER_POWERPLANT = 3
    """A thermodynamic model that includes turbine, ramjet, and scramjet performance modes."""
    TURBOFAN_BASIC_AB = 4
    """A thermodynamic model of a dual-spool turbofan engine that has an afterburner."""
    TURBOFAN_HIGH_BYPASS = 5
    """An empirical model for a turbofan engine that produces significantly more fan thrust than jet thrust."""
    TURBOFAN_LOW_BYPASS = 6
    """An empirical model for a turbofan engine that produces significantly more jet thrust than fan thrust."""
    TURBOFAN_LOW_BYPASS_AFTERBURNING = 7
    """An empirical model for a turbofan engine that has an afterburner and produces significantly more jet thrust than fan thrust."""
    TURBOJET_AFTERBURNING = 8
    """An empirical model that models a turbojet engine that has an afterburner."""
    TURBOJET_BASIC_AB = 9
    """An empirical model that models a turbojet engine."""
    TURBOJET = 10
    """An empirical model that models a turbojet engine."""
    TURBOPROP = 11
    """An empirical model that models a turboprop engine."""

AdvancedFixedWingPowerplantStrategy.ELECTRIC_POWERPLANT.__doc__ = "An electric engine."
AdvancedFixedWingPowerplantStrategy.EXTERNAL_PROPULSION_FILE.__doc__ = "Define the powerplant using an external .prop file."
AdvancedFixedWingPowerplantStrategy.PISTON_POWERPLANT.__doc__ = "A piston, or reciprocating, engine."
AdvancedFixedWingPowerplantStrategy.SUB_SUPER_HYPER_POWERPLANT.__doc__ = "A thermodynamic model that includes turbine, ramjet, and scramjet performance modes."
AdvancedFixedWingPowerplantStrategy.TURBOFAN_BASIC_AB.__doc__ = "A thermodynamic model of a dual-spool turbofan engine that has an afterburner."
AdvancedFixedWingPowerplantStrategy.TURBOFAN_HIGH_BYPASS.__doc__ = "An empirical model for a turbofan engine that produces significantly more fan thrust than jet thrust."
AdvancedFixedWingPowerplantStrategy.TURBOFAN_LOW_BYPASS.__doc__ = "An empirical model for a turbofan engine that produces significantly more jet thrust than fan thrust."
AdvancedFixedWingPowerplantStrategy.TURBOFAN_LOW_BYPASS_AFTERBURNING.__doc__ = "An empirical model for a turbofan engine that has an afterburner and produces significantly more jet thrust than fan thrust."
AdvancedFixedWingPowerplantStrategy.TURBOJET_AFTERBURNING.__doc__ = "An empirical model that models a turbojet engine that has an afterburner."
AdvancedFixedWingPowerplantStrategy.TURBOJET_BASIC_AB.__doc__ = "An empirical model that models a turbojet engine."
AdvancedFixedWingPowerplantStrategy.TURBOJET.__doc__ = "An empirical model that models a turbojet engine."
AdvancedFixedWingPowerplantStrategy.TURBOPROP.__doc__ = "An empirical model that models a turboprop engine."

agcls.AgTypeNameMap["AdvancedFixedWingPowerplantStrategy"] = AdvancedFixedWingPowerplantStrategy

class MissileAerodynamicStrategy(IntEnum):
    """The aerodynamic strategy used to compute lift, drag, angle of attack, sideslip and intermediate / derived values."""

    MISSILE_AERODYNAMIC_SIMPLE = 0
    """Simple aerodynamics."""
    MISSILE_AERODYNAMIC_EXTERNAL_FILE = 1
    """External file aerodynamics."""
    MISSILE_AERODYNAMIC_ADVANCED = 2
    """Advanced missile aerodynamics."""
    MISSILE_AERODYNAMIC_FOUR_POINT = 3
    """FourPoint missile aerodynamics."""

MissileAerodynamicStrategy.MISSILE_AERODYNAMIC_SIMPLE.__doc__ = "Simple aerodynamics."
MissileAerodynamicStrategy.MISSILE_AERODYNAMIC_EXTERNAL_FILE.__doc__ = "External file aerodynamics."
MissileAerodynamicStrategy.MISSILE_AERODYNAMIC_ADVANCED.__doc__ = "Advanced missile aerodynamics."
MissileAerodynamicStrategy.MISSILE_AERODYNAMIC_FOUR_POINT.__doc__ = "FourPoint missile aerodynamics."

agcls.AgTypeNameMap["MissileAerodynamicStrategy"] = MissileAerodynamicStrategy

class MissilePropulsionStrategy(IntEnum):
    """The propulsion strategy used to compute thrust and throttle setting."""

    MISSILE_PROPULSION_SIMPLE = 0
    """Simple propulsion."""
    MISSILE_PROPULSION_EXTERNAL_FILE = 1
    """External file propulsion."""
    MISSILE_PROPULSION_RAMJET = 2
    """Ramjet propulsion."""
    MISSILE_PROPULSION_ROCKET = 3
    """Rocket propulsion."""
    MISSILE_PROPULSION_TURBOJET = 4
    """Turbojet propulsion."""

MissilePropulsionStrategy.MISSILE_PROPULSION_SIMPLE.__doc__ = "Simple propulsion."
MissilePropulsionStrategy.MISSILE_PROPULSION_EXTERNAL_FILE.__doc__ = "External file propulsion."
MissilePropulsionStrategy.MISSILE_PROPULSION_RAMJET.__doc__ = "Ramjet propulsion."
MissilePropulsionStrategy.MISSILE_PROPULSION_ROCKET.__doc__ = "Rocket propulsion."
MissilePropulsionStrategy.MISSILE_PROPULSION_TURBOJET.__doc__ = "Turbojet propulsion."

agcls.AgTypeNameMap["MissilePropulsionStrategy"] = MissilePropulsionStrategy

class RotorcraftPowerplantType(IntEnum):
    """The powerplant type for a rotorcraft."""

    ROTORCRAFT_ELECTRIC = 0
    """Electric propulsion."""
    ROTORCRAFT_TURBOSHAFT = 1
    """Turboshaft propulsion."""
    ROTORCRAFT_PISTON = 2
    """Piston propulsion."""

RotorcraftPowerplantType.ROTORCRAFT_ELECTRIC.__doc__ = "Electric propulsion."
RotorcraftPowerplantType.ROTORCRAFT_TURBOSHAFT.__doc__ = "Turboshaft propulsion."
RotorcraftPowerplantType.ROTORCRAFT_PISTON.__doc__ = "Piston propulsion."

agcls.AgTypeNameMap["RotorcraftPowerplantType"] = RotorcraftPowerplantType

class MinimizeSiteProcedureTimeDiff(IntEnum):
    """Options for minimizing the time difference between the procedure and site times."""

    MINIMIZE_TIME_DIFFERENCE_OFF = 0
    """Do not converge the procedure and site times."""
    MINIMIZE_TIME_DIFFERENCE_ALWAYS = 1
    """Always recalculate."""
    MINIMIZE_TIME_DIFFERENCE_NEXT_UPDATE = 2
    """Only recalculate when updated."""

MinimizeSiteProcedureTimeDiff.MINIMIZE_TIME_DIFFERENCE_OFF.__doc__ = "Do not converge the procedure and site times."
MinimizeSiteProcedureTimeDiff.MINIMIZE_TIME_DIFFERENCE_ALWAYS.__doc__ = "Always recalculate."
MinimizeSiteProcedureTimeDiff.MINIMIZE_TIME_DIFFERENCE_NEXT_UPDATE.__doc__ = "Only recalculate when updated."

agcls.AgTypeNameMap["MinimizeSiteProcedureTimeDiff"] = MinimizeSiteProcedureTimeDiff

class STKObjectWaypointOffsetMode(IntEnum):
    """The options to offset the site location relative to the STK Object."""

    OFFSET_NONE = 0
    """No offset."""
    OFFSET_BEARING_RANGE = 1
    """Bearing/Range (relative to North)."""
    OFFSET_VGT_POINT = 2
    """VGT Point."""
    OFFSET_RELATIVE_BEARING_RANGE = 3
    """Bearing/Reange relative to Vehicle course."""

STKObjectWaypointOffsetMode.OFFSET_NONE.__doc__ = "No offset."
STKObjectWaypointOffsetMode.OFFSET_BEARING_RANGE.__doc__ = "Bearing/Range (relative to North)."
STKObjectWaypointOffsetMode.OFFSET_VGT_POINT.__doc__ = "VGT Point."
STKObjectWaypointOffsetMode.OFFSET_RELATIVE_BEARING_RANGE.__doc__ = "Bearing/Reange relative to Vehicle course."

agcls.AgTypeNameMap["STKObjectWaypointOffsetMode"] = STKObjectWaypointOffsetMode

class SearchPatternCourseMode(IntEnum):
    """The mode to determine the course of the search pattern."""

    COURSE_MODE_LOW = 0
    """Automatically begin the search pattern within 0 - 180 degrees."""
    COURSE_MODE_HIGH = 1
    """Automatically begin the search pattern within 180 - 360 degrees."""
    COURSE_MODE_OVERRIDE = 2
    """Manually define the course of the search pattern."""

SearchPatternCourseMode.COURSE_MODE_LOW.__doc__ = "Automatically begin the search pattern within 0 - 180 degrees."
SearchPatternCourseMode.COURSE_MODE_HIGH.__doc__ = "Automatically begin the search pattern within 180 - 360 degrees."
SearchPatternCourseMode.COURSE_MODE_OVERRIDE.__doc__ = "Manually define the course of the search pattern."

agcls.AgTypeNameMap["SearchPatternCourseMode"] = SearchPatternCourseMode

class DelayTurnDirection(IntEnum):
    """Turn mode for procedures with Delay options."""

    DELAY_TURN_AUTO = 0
    """Automatic turn. Aviator will determine the direction of the turn."""
    DELAY_TURN_LEFT = 1
    """Left turn."""
    DELAY_TURN_RIGHT = 2
    """Right turn."""

DelayTurnDirection.DELAY_TURN_AUTO.__doc__ = "Automatic turn. Aviator will determine the direction of the turn."
DelayTurnDirection.DELAY_TURN_LEFT.__doc__ = "Left turn."
DelayTurnDirection.DELAY_TURN_RIGHT.__doc__ = "Right turn."

agcls.AgTypeNameMap["DelayTurnDirection"] = DelayTurnDirection

class TrajectoryBlendMode(IntEnum):
    """The interpolation mode to determine the aircraft's position and velocity."""

    BLEND_BODY_QUADRATIC = 0
    """Quadratic interpolation using the body frame."""
    BLEND_BODY_CUBIC = 1
    """Cubic interpolation using the body frame."""
    BLEND_LH_QUADRATIC = 2
    """Quadratic interpolation using the local horizontal frame."""
    BLEND_LH_CUBIC = 3
    """Cubic interpolation using the local horizontal frame."""
    BLEND_ECF_QUADRATIC = 4
    """Quadratic interpolation using the Earth-Centered Fixed frame."""
    BLEND_ECF_CUBIC = 5
    """Cubic interpolation using the Earth-Centered Fixed frame."""

TrajectoryBlendMode.BLEND_BODY_QUADRATIC.__doc__ = "Quadratic interpolation using the body frame."
TrajectoryBlendMode.BLEND_BODY_CUBIC.__doc__ = "Cubic interpolation using the body frame."
TrajectoryBlendMode.BLEND_LH_QUADRATIC.__doc__ = "Quadratic interpolation using the local horizontal frame."
TrajectoryBlendMode.BLEND_LH_CUBIC.__doc__ = "Cubic interpolation using the local horizontal frame."
TrajectoryBlendMode.BLEND_ECF_QUADRATIC.__doc__ = "Quadratic interpolation using the Earth-Centered Fixed frame."
TrajectoryBlendMode.BLEND_ECF_CUBIC.__doc__ = "Cubic interpolation using the Earth-Centered Fixed frame."

agcls.AgTypeNameMap["TrajectoryBlendMode"] = TrajectoryBlendMode

class ReferenceStatePerformanceMode(IntEnum):
    """The type of motion the aircraft is engaged in at the reference state."""

    REFERENCE_STATE_CLIMB = 0
    """Forward Flight - Climb performance mode."""
    REFERENCE_STATE_CRUISE = 1
    """Forward Flight - Cruise performance mode."""
    REFERENCE_STATE_DESCEND = 2
    """Forward Flight - Descend performance mode."""
    REFERENCE_STATE_HOVER = 3
    """Hover performance mode."""
    REFERENCE_STATE_LANDING = 4
    """Landing performance mode."""
    REFERENCE_STATE_TAKEOFF = 5
    """Takeoff performance mode."""
    REFERENCE_STATE_LANDING_ROLLOUT = 6
    """Weight On Wheels - Landing Rollout performance mode."""
    REFERENCE_STATE_TAKEOFF_RUN = 7
    """Weight On Wheels - Takeoff Run performance mode."""

ReferenceStatePerformanceMode.REFERENCE_STATE_CLIMB.__doc__ = "Forward Flight - Climb performance mode."
ReferenceStatePerformanceMode.REFERENCE_STATE_CRUISE.__doc__ = "Forward Flight - Cruise performance mode."
ReferenceStatePerformanceMode.REFERENCE_STATE_DESCEND.__doc__ = "Forward Flight - Descend performance mode."
ReferenceStatePerformanceMode.REFERENCE_STATE_HOVER.__doc__ = "Hover performance mode."
ReferenceStatePerformanceMode.REFERENCE_STATE_LANDING.__doc__ = "Landing performance mode."
ReferenceStatePerformanceMode.REFERENCE_STATE_TAKEOFF.__doc__ = "Takeoff performance mode."
ReferenceStatePerformanceMode.REFERENCE_STATE_LANDING_ROLLOUT.__doc__ = "Weight On Wheels - Landing Rollout performance mode."
ReferenceStatePerformanceMode.REFERENCE_STATE_TAKEOFF_RUN.__doc__ = "Weight On Wheels - Takeoff Run performance mode."

agcls.AgTypeNameMap["ReferenceStatePerformanceMode"] = ReferenceStatePerformanceMode

class ReferenceStateLongitudinalAccelerationMode(IntEnum):
    """The mode to specify the longitudinal acceleration of the aircraft."""

    SPECIFY_TAS_DOT = 0
    """Specify the true airspeed acceleration."""
    SPECIFY_GROUND_SPEED_DOT = 1
    """Specify the groundspeed acceleration."""

ReferenceStateLongitudinalAccelerationMode.SPECIFY_TAS_DOT.__doc__ = "Specify the true airspeed acceleration."
ReferenceStateLongitudinalAccelerationMode.SPECIFY_GROUND_SPEED_DOT.__doc__ = "Specify the groundspeed acceleration."

agcls.AgTypeNameMap["ReferenceStateLongitudinalAccelerationMode"] = ReferenceStateLongitudinalAccelerationMode

class ReferenceStateLateralAccelerationMode(IntEnum):
    """The mode to specify the lateral acceleration of the aircraft."""

    SPECIFY_HEADING_DOT = 0
    """Specify the heading rate of change."""
    SPECIFY_COURSE_DOT = 1
    """Specify the course rate of change."""

ReferenceStateLateralAccelerationMode.SPECIFY_HEADING_DOT.__doc__ = "Specify the heading rate of change."
ReferenceStateLateralAccelerationMode.SPECIFY_COURSE_DOT.__doc__ = "Specify the course rate of change."

agcls.AgTypeNameMap["ReferenceStateLateralAccelerationMode"] = ReferenceStateLateralAccelerationMode

class ReferenceStateAttitudeMode(IntEnum):
    """The mode to specify the attitude rate of change."""

    SPECIFY_PUSH_PULL_G = 0
    """Specify the push/pull G."""
    SPECIFY_PITCH_RATE = 1
    """Specify the pitch rate of change."""

ReferenceStateAttitudeMode.SPECIFY_PUSH_PULL_G.__doc__ = "Specify the push/pull G."
ReferenceStateAttitudeMode.SPECIFY_PITCH_RATE.__doc__ = "Specify the pitch rate of change."

agcls.AgTypeNameMap["ReferenceStateAttitudeMode"] = ReferenceStateAttitudeMode

class AndOr(IntEnum):
    """The option to specify AND or OR."""

    AND = 0
    """And option."""
    OR = 1
    """Or option."""

AndOr.AND.__doc__ = "And option."
AndOr.OR.__doc__ = "Or option."

agcls.AgTypeNameMap["AndOr"] = AndOr

class JetEngineTechnologyLevel(IntEnum):
    """The technology level of the jet engine."""

    IDEAL = 0
    """Ideal (perfect efficiencies)."""
    LEVEL1 = 1
    """Level 1 (1945-1965)."""
    LEVEL2 = 2
    """Level 2 (1965-1985)."""
    LEVEL3 = 3
    """Level 3 (1985-2005)."""
    LEVEL4 = 4
    """Level 4 (2005-2025)."""
    LEVEL5 = 5
    """Level 5 (2025-2045)."""

JetEngineTechnologyLevel.IDEAL.__doc__ = "Ideal (perfect efficiencies)."
JetEngineTechnologyLevel.LEVEL1.__doc__ = "Level 1 (1945-1965)."
JetEngineTechnologyLevel.LEVEL2.__doc__ = "Level 2 (1965-1985)."
JetEngineTechnologyLevel.LEVEL3.__doc__ = "Level 3 (1985-2005)."
JetEngineTechnologyLevel.LEVEL4.__doc__ = "Level 4 (2005-2025)."
JetEngineTechnologyLevel.LEVEL5.__doc__ = "Level 5 (2025-2045)."

agcls.AgTypeNameMap["JetEngineTechnologyLevel"] = JetEngineTechnologyLevel

class JetEngineIntakeType(IntEnum):
    """The intake type of the jet engine."""

    SUBSONIC_NACELLES = 0
    """Subsonic nacelles."""
    SUBSONIC_EMBEDDED = 1
    """Subsonic embedded."""
    SUPERSONIC_EMBEDDED = 2
    """Supersonic embedded."""

JetEngineIntakeType.SUBSONIC_NACELLES.__doc__ = "Subsonic nacelles."
JetEngineIntakeType.SUBSONIC_EMBEDDED.__doc__ = "Subsonic embedded."
JetEngineIntakeType.SUPERSONIC_EMBEDDED.__doc__ = "Supersonic embedded."

agcls.AgTypeNameMap["JetEngineIntakeType"] = JetEngineIntakeType

class JetEngineTurbineType(IntEnum):
    """The turbine type of the jet engine."""

    UNCOOLED = 0
    """Uncooled turbine."""
    COOLED = 1
    """Cooled turbine."""

JetEngineTurbineType.UNCOOLED.__doc__ = "Uncooled turbine."
JetEngineTurbineType.COOLED.__doc__ = "Cooled turbine."

agcls.AgTypeNameMap["JetEngineTurbineType"] = JetEngineTurbineType

class JetEngineExhaustNozzleType(IntEnum):
    """The exhaust nozzle type of the jet engine."""

    FIXED_AREA_CONVERGENT = 0
    """Fixed Area Convergent."""
    VARIABLE_AREA_CONVERGENT = 1
    """Variable Area Convergent."""
    VARIABLE_AREA_CONVERGENT_DIVERGENT = 2
    """Variable Area Convergent - Divergent."""

JetEngineExhaustNozzleType.FIXED_AREA_CONVERGENT.__doc__ = "Fixed Area Convergent."
JetEngineExhaustNozzleType.VARIABLE_AREA_CONVERGENT.__doc__ = "Variable Area Convergent."
JetEngineExhaustNozzleType.VARIABLE_AREA_CONVERGENT_DIVERGENT.__doc__ = "Variable Area Convergent - Divergent."

agcls.AgTypeNameMap["JetEngineExhaustNozzleType"] = JetEngineExhaustNozzleType

class JetFuelType(IntEnum):
    """The jet fuel type."""

    KEROSENE_AFPROP = 0
    """A kerosene fuel model based on AFPROP."""
    KEROSENE_CEA = 1
    """A kerosene fuel model based on NASA CEA."""
    HYDROGEN = 2
    """A hydrogen fuel model based on NASA CEA."""

JetFuelType.KEROSENE_AFPROP.__doc__ = "A kerosene fuel model based on AFPROP."
JetFuelType.KEROSENE_CEA.__doc__ = "A kerosene fuel model based on NASA CEA."
JetFuelType.HYDROGEN.__doc__ = "A hydrogen fuel model based on NASA CEA."

agcls.AgTypeNameMap["JetFuelType"] = JetFuelType

class AFPROPFuelType(IntEnum):
    """The AFPROP fuel type."""

    AFPROP_OVERRIDE = 0
    """Override the specific energy."""
    AFPROP_JET_A = 1
    """Jet A fuel model based on AFPROP."""
    AFPROP_JET_A1 = 2
    """Jet A-1 fuel model based on AFPROP."""
    AFPROPJP5 = 3
    """JP-5 fuel model based on AFPROP."""
    AFPROPJP7 = 4
    """JP-7 fuel model based on AFPROP."""

AFPROPFuelType.AFPROP_OVERRIDE.__doc__ = "Override the specific energy."
AFPROPFuelType.AFPROP_JET_A.__doc__ = "Jet A fuel model based on AFPROP."
AFPROPFuelType.AFPROP_JET_A1.__doc__ = "Jet A-1 fuel model based on AFPROP."
AFPROPFuelType.AFPROPJP5.__doc__ = "JP-5 fuel model based on AFPROP."
AFPROPFuelType.AFPROPJP7.__doc__ = "JP-7 fuel model based on AFPROP."

agcls.AgTypeNameMap["AFPROPFuelType"] = AFPROPFuelType

class CEAFuelType(IntEnum):
    """The CEA fuel type."""

    CEA_OVERRIDE = 0
    """Override the specific energy."""
    CEA_JET_A = 1
    """Jet A fuel model based on NASA CEA."""
    CEA_JET_A1 = 2
    """Jet A-1 fuel model based on NASA CEA."""
    CEAJP5 = 3
    """JP-5 fuel model based on NASA CEA."""
    CEAJP7 = 4
    """JP-7 fuel model based on NASA CEA."""

CEAFuelType.CEA_OVERRIDE.__doc__ = "Override the specific energy."
CEAFuelType.CEA_JET_A.__doc__ = "Jet A fuel model based on NASA CEA."
CEAFuelType.CEA_JET_A1.__doc__ = "Jet A-1 fuel model based on NASA CEA."
CEAFuelType.CEAJP5.__doc__ = "JP-5 fuel model based on NASA CEA."
CEAFuelType.CEAJP7.__doc__ = "JP-7 fuel model based on NASA CEA."

agcls.AgTypeNameMap["CEAFuelType"] = CEAFuelType

class TurbineMode(IntEnum):
    """The turbine mode for a Sub/Super/Hypersonic powerplant."""

    TURBINE_MODE_DISABLED = 0
    """Disabled turbine mode."""
    TURBINE_MODE_TURBOJET_BASIC_AB = 1
    """Turbojet - Basic w/AB (Thermodynamic model)."""
    TURBINE_MODE_TURBOFAN_BASIC_AB = 2
    """Turbofan - Basic w/AB (Thermodynamic model)."""

TurbineMode.TURBINE_MODE_DISABLED.__doc__ = "Disabled turbine mode."
TurbineMode.TURBINE_MODE_TURBOJET_BASIC_AB.__doc__ = "Turbojet - Basic w/AB (Thermodynamic model)."
TurbineMode.TURBINE_MODE_TURBOFAN_BASIC_AB.__doc__ = "Turbofan - Basic w/AB (Thermodynamic model)."

agcls.AgTypeNameMap["TurbineMode"] = TurbineMode

class RamjetMode(IntEnum):
    """The ramjet mode for a Sub/Super/Hypersonic powerplant."""

    RAMJET_MODE_DISABLED = 0
    """Disabled ramjet mode."""
    RAMJET_MODE_BASIC = 1
    """Ramjet - Basic mode."""

RamjetMode.RAMJET_MODE_DISABLED.__doc__ = "Disabled ramjet mode."
RamjetMode.RAMJET_MODE_BASIC.__doc__ = "Ramjet - Basic mode."

agcls.AgTypeNameMap["RamjetMode"] = RamjetMode

class ScramjetMode(IntEnum):
    """The scramjet mode for a Sub/Super/Hypersonic powerplant."""

    SCRAMJET_MODE_DISABLED = 0
    """Disabled scramjet mode."""
    SCRAMJET_MODE_BASIC = 1
    """Scramjet - Basic mode."""

ScramjetMode.SCRAMJET_MODE_DISABLED.__doc__ = "Disabled scramjet mode."
ScramjetMode.SCRAMJET_MODE_BASIC.__doc__ = "Scramjet - Basic mode."

agcls.AgTypeNameMap["ScramjetMode"] = ScramjetMode

class AviatorNumericalIntegrator(IntEnum):
    """The numerical integrator to be used for the procedure."""

    RUNGE_KUTTA4 = 0
    """Runge-Kutta 4th Order Fixed Time Step Integrator."""
    RUNGE_KUTTA45 = 1
    """Runge-Kutta 4th Order Adaptive Time Step Integrator."""

AviatorNumericalIntegrator.RUNGE_KUTTA4.__doc__ = "Runge-Kutta 4th Order Fixed Time Step Integrator."
AviatorNumericalIntegrator.RUNGE_KUTTA45.__doc__ = "Runge-Kutta 4th Order Adaptive Time Step Integrator."

agcls.AgTypeNameMap["AviatorNumericalIntegrator"] = AviatorNumericalIntegrator

class Ballistic3DControlMode(IntEnum):
    """The control mode used to define the ballistic 3D strategy of the basic maneuver procedure."""

    BALLISTIC_3D_COMPENSATE_FOR_WIND = 0
    """The vehicle will compensate for the wind along its ballistic trajectory."""
    BALLISTIC_3D_WIND_PUSHES_VEHICLE = 1
    """Allow the wind to affect the ballistic trajectory."""
    BALLISTIC_3D_PARACHUTE_MODE = 2
    """Model the vehicle as a parachute."""

Ballistic3DControlMode.BALLISTIC_3D_COMPENSATE_FOR_WIND.__doc__ = "The vehicle will compensate for the wind along its ballistic trajectory."
Ballistic3DControlMode.BALLISTIC_3D_WIND_PUSHES_VEHICLE.__doc__ = "Allow the wind to affect the ballistic trajectory."
Ballistic3DControlMode.BALLISTIC_3D_PARACHUTE_MODE.__doc__ = "Model the vehicle as a parachute."

agcls.AgTypeNameMap["Ballistic3DControlMode"] = Ballistic3DControlMode

class LaunchDynamicStateCoordFrame(IntEnum):
    """The coordinate frame used for a LaunchDynState procedure."""

    LAUNCH_DYNAMIC_STATE_COORD_FRAME_BODY = 0
    """The object's body frame."""
    LAUNCH_DYNAMIC_STATE_COORD_FRAME_LOCAL_HORIZONTAL = 1
    """The object's local horizontal frame."""

LaunchDynamicStateCoordFrame.LAUNCH_DYNAMIC_STATE_COORD_FRAME_BODY.__doc__ = "The object's body frame."
LaunchDynamicStateCoordFrame.LAUNCH_DYNAMIC_STATE_COORD_FRAME_LOCAL_HORIZONTAL.__doc__ = "The object's local horizontal frame."

agcls.AgTypeNameMap["LaunchDynamicStateCoordFrame"] = LaunchDynamicStateCoordFrame

class LaunchDynamicStateBearingReference(IntEnum):
    """The vector used as a bearing reference for a LaunchDynState procedure."""

    LAUNCH_DYNAMIC_STATE_BEARING_REFERENCE_VELOCITY = 0
    """The object's velocity vector."""
    LAUNCH_DYNAMIC_STATE_BEARING_REFERENCE_COORD_FRAME_X = 1
    """The X vector of the object's coordinate frame."""
    LAUNCH_DYNAMIC_STATE_BEARING_REFERENCE_NORTH = 2
    """The object's vector to North."""

LaunchDynamicStateBearingReference.LAUNCH_DYNAMIC_STATE_BEARING_REFERENCE_VELOCITY.__doc__ = "The object's velocity vector."
LaunchDynamicStateBearingReference.LAUNCH_DYNAMIC_STATE_BEARING_REFERENCE_COORD_FRAME_X.__doc__ = "The X vector of the object's coordinate frame."
LaunchDynamicStateBearingReference.LAUNCH_DYNAMIC_STATE_BEARING_REFERENCE_NORTH.__doc__ = "The object's vector to North."

agcls.AgTypeNameMap["LaunchDynamicStateBearingReference"] = LaunchDynamicStateBearingReference

class AltitudeReference(IntEnum):
    """The altitude reference."""

    ALTITUDE_REFERENCE_WGS84 = 0
    """Altitude above WGS84 ground reference."""
    ALTITUDE_REFERENCE_MSL = 1
    """Altitude above Mean Sea Level (MSL)."""
    ALTITUDE_REFERENCE_TERRAIN = 2
    """ALtitude above terrain."""

AltitudeReference.ALTITUDE_REFERENCE_WGS84.__doc__ = "Altitude above WGS84 ground reference."
AltitudeReference.ALTITUDE_REFERENCE_MSL.__doc__ = "Altitude above Mean Sea Level (MSL)."
AltitudeReference.ALTITUDE_REFERENCE_TERRAIN.__doc__ = "ALtitude above terrain."

agcls.AgTypeNameMap["AltitudeReference"] = AltitudeReference

class SmoothTurnFlightPathAngleMode(IntEnum):
    """The flight path angle mode for the Smooth Turn strategy of the Basic Maneuver procedure."""

    SMOOTH_TURN_FLIGHT_PATH_ANGLE_HOLD_INITIAL = 0
    """Hold the initial flight path angle."""
    SMOOTH_TURN_FLIGHT_PATH_ANGLE_LEVEL_OFF = 1
    """Levell off the flight path angle."""

SmoothTurnFlightPathAngleMode.SMOOTH_TURN_FLIGHT_PATH_ANGLE_HOLD_INITIAL.__doc__ = "Hold the initial flight path angle."
SmoothTurnFlightPathAngleMode.SMOOTH_TURN_FLIGHT_PATH_ANGLE_LEVEL_OFF.__doc__ = "Levell off the flight path angle."

agcls.AgTypeNameMap["SmoothTurnFlightPathAngleMode"] = SmoothTurnFlightPathAngleMode

class Pitch3DControlMode(IntEnum):
    """The control mode used to define the pitch 3D strategy of the basic maneuver procedure."""

    PITCH_3D_COMPENSATE_FOR_WIND = 0
    """The vehicle will compensate for the wind along its trajectory."""
    PITCH_3D_WIND_PUSHES_VEHICLE = 1
    """Allow the wind to affect the trajectory."""

Pitch3DControlMode.PITCH_3D_COMPENSATE_FOR_WIND.__doc__ = "The vehicle will compensate for the wind along its trajectory."
Pitch3DControlMode.PITCH_3D_WIND_PUSHES_VEHICLE.__doc__ = "Allow the wind to affect the trajectory."

agcls.AgTypeNameMap["Pitch3DControlMode"] = Pitch3DControlMode

class RefuelDumpMode(IntEnum):
    """The modes used to define procedure refuel/dump modes."""

    REFUEL_DUMP_DISABLED = 0
    """RefuelDump Disabled."""
    REFUEL_TOP_OFF = 1
    """Refuel Top Off."""
    REFUEL_TO_FUEL_STATE = 2
    """Refuel to specified fuel state."""
    REFUEL_TO_WEIGHT = 3
    """Refuel to specified weight."""
    REFUEL_QUANTITY = 4
    """Refuel specified quantity."""
    DUMP_TO_FUEL_STATE = 5
    """Dump to specified fuel state."""
    DUMP_TO_WEIGHT = 6
    """Dump to specified weight."""
    DUMP_QUANTITY = 7
    """Dump specified quantity."""

RefuelDumpMode.REFUEL_DUMP_DISABLED.__doc__ = "RefuelDump Disabled."
RefuelDumpMode.REFUEL_TOP_OFF.__doc__ = "Refuel Top Off."
RefuelDumpMode.REFUEL_TO_FUEL_STATE.__doc__ = "Refuel to specified fuel state."
RefuelDumpMode.REFUEL_TO_WEIGHT.__doc__ = "Refuel to specified weight."
RefuelDumpMode.REFUEL_QUANTITY.__doc__ = "Refuel specified quantity."
RefuelDumpMode.DUMP_TO_FUEL_STATE.__doc__ = "Dump to specified fuel state."
RefuelDumpMode.DUMP_TO_WEIGHT.__doc__ = "Dump to specified weight."
RefuelDumpMode.DUMP_QUANTITY.__doc__ = "Dump specified quantity."

agcls.AgTypeNameMap["RefuelDumpMode"] = RefuelDumpMode

class BasicManeuverGlideSpeedControlMode(IntEnum):
    """The modes used to define basic maneuver glide speed control modes."""

    GLIDE_SPEED_IMMEDIATE_CHANGE = 0
    """Immediate speed change."""
    GLIDE_SPEED_AT_ALTITUDE = 1
    """Achieve speed at altitude."""

BasicManeuverGlideSpeedControlMode.GLIDE_SPEED_IMMEDIATE_CHANGE.__doc__ = "Immediate speed change."
BasicManeuverGlideSpeedControlMode.GLIDE_SPEED_AT_ALTITUDE.__doc__ = "Achieve speed at altitude."

agcls.AgTypeNameMap["BasicManeuverGlideSpeedControlMode"] = BasicManeuverGlideSpeedControlMode

class TargetPositionVelocityType(IntEnum):
    """The target pos/vel type."""

    SURFACE_TARGET_POSITION_VELOCITY = 0
    """Noisy Surface Target PosVel."""
    BEARING_RANGE_TARGET_POSITION_VELOCITY = 1
    """Noisy Bearing Range Target PosVel."""
    DISABLED_POSITION_VELOCITY = 2
    """Disabled Target PosVel."""

TargetPositionVelocityType.SURFACE_TARGET_POSITION_VELOCITY.__doc__ = "Noisy Surface Target PosVel."
TargetPositionVelocityType.BEARING_RANGE_TARGET_POSITION_VELOCITY.__doc__ = "Noisy Bearing Range Target PosVel."
TargetPositionVelocityType.DISABLED_POSITION_VELOCITY.__doc__ = "Disabled Target PosVel."

agcls.AgTypeNameMap["TargetPositionVelocityType"] = TargetPositionVelocityType

class EphemShiftRotateAltitudeMode(IntEnum):
    """Ephem alt mode."""

    ALTITUDE_MODE_MSL = 0
    """Enumeration EphemShiftRotateAltitudeMode:eAltModeMSL."""
    ALTITUDE_MODE_WGS = 1
    """Enumeration EphemShiftRotateAltitudeMode:eAltModeWGS."""
    ALTITUDE_MODE_RELATIVE = 2
    """Enumeration EphemShiftRotateAltitudeMode:eAltModeRel."""

EphemShiftRotateAltitudeMode.ALTITUDE_MODE_MSL.__doc__ = "Enumeration EphemShiftRotateAltitudeMode:eAltModeMSL."
EphemShiftRotateAltitudeMode.ALTITUDE_MODE_WGS.__doc__ = "Enumeration EphemShiftRotateAltitudeMode:eAltModeWGS."
EphemShiftRotateAltitudeMode.ALTITUDE_MODE_RELATIVE.__doc__ = "Enumeration EphemShiftRotateAltitudeMode:eAltModeRel."

agcls.AgTypeNameMap["EphemShiftRotateAltitudeMode"] = EphemShiftRotateAltitudeMode

class EphemShiftRotateCourseMode(IntEnum):
    """Ephem course mode."""

    COURSE_MODE_TRUE = 0
    """Enumeration EphemShiftRotateCourseMode:eCourseModeTrue."""
    COURSE_MODE_MAGNITUDE = 1
    """Enumeration EphemShiftRotateCourseMode:eCourseModeMag."""
    COURSE_MODE_RELATIVE = 2
    """Enumeration EphemShiftRotateCourseMode:eCourseModeRel."""

EphemShiftRotateCourseMode.COURSE_MODE_TRUE.__doc__ = "Enumeration EphemShiftRotateCourseMode:eCourseModeTrue."
EphemShiftRotateCourseMode.COURSE_MODE_MAGNITUDE.__doc__ = "Enumeration EphemShiftRotateCourseMode:eCourseModeMag."
EphemShiftRotateCourseMode.COURSE_MODE_RELATIVE.__doc__ = "Enumeration EphemShiftRotateCourseMode:eCourseModeRel."

agcls.AgTypeNameMap["EphemShiftRotateCourseMode"] = EphemShiftRotateCourseMode


class ISite(object):
    """
    Interface to access Site options.

    Examples
    --------
    Rename a procedure and its site:
    >>> # IProcedure procedure: Procedure object
    >>> # Rename the procedure
    >>> procedure.name = "New Procedure"
    >>> # Get the site corresponding to the procedure
    >>> site = procedure.site
    >>> # Rename the site
    >>> site.name = "New Site"
    """

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_name_method_offset = 1
    _set_name_method_offset = 2
    _metadata = {
        "iid_data" : (5465348812426829484, 1980086686715111829),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type ISite."""
        initialize_from_source_object(self, source_object, ISite)
    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, ISite)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, ISite, None)

    _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 site."""
        return self._intf.get_property(ISite._metadata, ISite._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 site."""
        return self._intf.set_property(ISite._metadata, ISite._set_name_metadata, value)

    _property_names[name] = "name"


agcls.AgClassCatalog.add_catalog_entry((5465348812426829484, 1980086686715111829), ISite)
agcls.AgTypeNameMap["ISite"] = ISite

class ICatalogItem(object):
    """
    Interface used to access the options for a Catalog Item in the Aviator Catalog. Use this interface to Create, Remove, Duplicate, or Rename items in the catalog.

    Examples
    --------
    Create a new performance model for an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the acceleration type
    >>> acceleration = aviatorAircraft.acceleration
    >>> # Get the names of the current acceleration models
    >>> modelNames = acceleration.child_names
    >>> # Check how many models there are
    >>> modelCount = len(modelNames)
    >>> # Get the child types (for example AGI Basic Acceleration Model, Advanced Acceleration Model)
    >>> modelTypes = acceleration.child_types
    >>> # Create a new performance model of type "Advanced Acceleration Model"
    >>> newPerformanceModel = acceleration.add_child_of_type("Advanced Acceleration Model", "Model Name")
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()
    """

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_name_method_offset = 1
    _set_name_method_offset = 2
    _get_description_method_offset = 3
    _duplicate_method_offset = 4
    _remove_method_offset = 5
    _save_method_offset = 6
    _get_is_read_only_method_offset = 7
    _get_child_names_method_offset = 8
    _get_child_item_by_name_method_offset = 9
    _get_child_types_method_offset = 10
    _add_default_child_method_offset = 11
    _add_child_of_type_method_offset = 12
    _contains_child_item_method_offset = 13
    _metadata = {
        "iid_data" : (5458227820228317150, 3292997058202486194),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type ICatalogItem."""
        initialize_from_source_object(self, source_object, ICatalogItem)
    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, ICatalogItem)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, ICatalogItem, None)

    _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 catalog item."""
        return self._intf.get_property(ICatalogItem._metadata, ICatalogItem._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 catalog item."""
        return self._intf.set_property(ICatalogItem._metadata, ICatalogItem._set_name_metadata, value)

    _get_description_metadata = { "offset" : _get_description_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def description(self) -> str:
        """Get the description of the catalog item."""
        return self._intf.get_property(ICatalogItem._metadata, ICatalogItem._get_description_metadata)

    _duplicate_metadata = { "offset" : _duplicate_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def duplicate(self) -> "ICatalogItem":
        """Duplicates the catalog item."""
        return self._intf.invoke(ICatalogItem._metadata, ICatalogItem._duplicate_metadata, OutArg())

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def remove(self) -> None:
        """Remove the catalog item."""
        return self._intf.invoke(ICatalogItem._metadata, ICatalogItem._remove_metadata, )

    _save_metadata = { "offset" : _save_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def save(self) -> None:
        """Save the catalog item."""
        return self._intf.invoke(ICatalogItem._metadata, ICatalogItem._save_metadata, )

    _get_is_read_only_metadata = { "offset" : _get_is_read_only_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def is_read_only(self) -> bool:
        """Get whether the catalog item is read only."""
        return self._intf.get_property(ICatalogItem._metadata, ICatalogItem._get_is_read_only_metadata)

    _get_child_names_metadata = { "offset" : _get_child_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def child_names(self) -> list:
        """Get the child names of the catalog item."""
        return self._intf.get_property(ICatalogItem._metadata, ICatalogItem._get_child_names_metadata)

    _get_child_item_by_name_metadata = { "offset" : _get_child_item_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_child_item_by_name(self, child_name:str) -> "ICatalogItem":
        """Get the child of the catalog item with the given name."""
        return self._intf.invoke(ICatalogItem._metadata, ICatalogItem._get_child_item_by_name_metadata, child_name, OutArg())

    _get_child_types_metadata = { "offset" : _get_child_types_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def child_types(self) -> list:
        """Get the child types."""
        return self._intf.get_property(ICatalogItem._metadata, ICatalogItem._get_child_types_metadata)

    _add_default_child_metadata = { "offset" : _add_default_child_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add_default_child(self, child_name:str) -> "ICatalogItem":
        """Create a new child with the given name and default type."""
        return self._intf.invoke(ICatalogItem._metadata, ICatalogItem._add_default_child_metadata, child_name, OutArg())

    _add_child_of_type_metadata = { "offset" : _add_child_of_type_method_offset,
            "arg_types" : (agcom.BSTR, agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add_child_of_type(self, child_type:str, child_name:str) -> "ICatalogItem":
        """Create a new child with the given name and specified type."""
        return self._intf.invoke(ICatalogItem._metadata, ICatalogItem._add_child_of_type_metadata, child_type, child_name, OutArg())

    _contains_child_item_metadata = { "offset" : _contains_child_item_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.VariantBoolArg,) }
    def contains_child_item(self, child_item:str) -> bool:
        """Get whether the catalog item is contains the given child item."""
        return self._intf.invoke(ICatalogItem._metadata, ICatalogItem._contains_child_item_metadata, child_item, OutArg())

    _property_names[name] = "name"
    _property_names[description] = "description"
    _property_names[is_read_only] = "is_read_only"
    _property_names[child_names] = "child_names"
    _property_names[child_types] = "child_types"


agcls.AgClassCatalog.add_catalog_entry((5458227820228317150, 3292997058202486194), ICatalogItem)
agcls.AgTypeNameMap["ICatalogItem"] = ICatalogItem

class IBasicManeuverStrategy(object):
    """Interface used to access options for a Basic Maneuver Strategy."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (4744335311711001158, 10362982119561193112),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IBasicManeuverStrategy."""
        initialize_from_source_object(self, source_object, IBasicManeuverStrategy)
    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, IBasicManeuverStrategy)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IBasicManeuverStrategy, None)



agcls.AgClassCatalog.add_catalog_entry((4744335311711001158, 10362982119561193112), IBasicManeuverStrategy)
agcls.AgTypeNameMap["IBasicManeuverStrategy"] = IBasicManeuverStrategy

class IAviatorVehicle(object):
    """Interface for a vehicle in Aviator."""

    _num_methods = 1
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_as_catalog_item_method_offset = 1
    _metadata = {
        "iid_data" : (5343444076281023740, 16945725846674352552),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IAviatorVehicle."""
        initialize_from_source_object(self, source_object, IAviatorVehicle)
    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, IAviatorVehicle)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IAviatorVehicle, None)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(IAviatorVehicle._metadata, IAviatorVehicle._get_as_catalog_item_metadata, OutArg())



agcls.AgClassCatalog.add_catalog_entry((5343444076281023740, 16945725846674352552), IAviatorVehicle)
agcls.AgTypeNameMap["IAviatorVehicle"] = IAviatorVehicle

class IARINC424Item(object):
    """Interface used to access the options for an ARINC424 Item found in the Aviator catalog."""

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_as_catalog_item_method_offset = 1
    _get_value_method_offset = 2
    _get_all_fields_method_offset = 3
    _get_all_fields_and_values_method_offset = 4
    _copy_site_method_offset = 5
    _metadata = {
        "iid_data" : (5321250993774161200, 8939444136967404965),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IARINC424Item."""
        initialize_from_source_object(self, source_object, IARINC424Item)
    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, IARINC424Item)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IARINC424Item, None)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(IARINC424Item._metadata, IARINC424Item._get_as_catalog_item_metadata, OutArg())

    _get_value_metadata = { "offset" : _get_value_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.VariantArg,) }
    def get_value(self, field_name:str) -> typing.Any:
        """Get the value of the field with the given name."""
        return self._intf.invoke(IARINC424Item._metadata, IARINC424Item._get_value_metadata, field_name, OutArg())

    _get_all_fields_metadata = { "offset" : _get_all_fields_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    def get_all_fields(self) -> list:
        """Get all the field names."""
        return self._intf.invoke(IARINC424Item._metadata, IARINC424Item._get_all_fields_metadata, OutArg())

    _get_all_fields_and_values_metadata = { "offset" : _get_all_fields_and_values_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    def get_all_fields_and_values(self) -> list:
        """Get all the field names along with the corresponding value."""
        return self._intf.invoke(IARINC424Item._metadata, IARINC424Item._get_all_fields_and_values_metadata, OutArg())

    _copy_site_metadata = { "offset" : _copy_site_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def copy_site(self) -> None:
        """Copy the site to the clipboard."""
        return self._intf.invoke(IARINC424Item._metadata, IARINC424Item._copy_site_metadata, )



agcls.AgClassCatalog.add_catalog_entry((5321250993774161200, 8939444136967404965), IARINC424Item)
agcls.AgTypeNameMap["IARINC424Item"] = IARINC424Item

class IStation(object):
    """Interface used to access a station for an Aviator aircraft."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5722385785492826861, 3941921955448583610),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IStation."""
        initialize_from_source_object(self, source_object, IStation)
    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, IStation)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IStation, None)



agcls.AgClassCatalog.add_catalog_entry((5722385785492826861, 3941921955448583610), IStation)
agcls.AgTypeNameMap["IStation"] = IStation

class ICatalogSource(object):
    """Interface used to access options for a source in the Aviator Catalog. Examples of sources include User Aircraft Models, ARINC424runways, User Runways, etc."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_child_names_method_offset = 1
    _contains_method_offset = 2
    _remove_child_method_offset = 3
    _save_method_offset = 4
    _metadata = {
        "iid_data" : (5049762571904518511, 12921546796455048600),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type ICatalogSource."""
        initialize_from_source_object(self, source_object, ICatalogSource)
    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, ICatalogSource)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, ICatalogSource, None)

    _get_child_names_metadata = { "offset" : _get_child_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def child_names(self) -> list:
        """Return the child names."""
        return self._intf.get_property(ICatalogSource._metadata, ICatalogSource._get_child_names_metadata)

    _contains_metadata = { "offset" : _contains_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.VariantBoolArg,) }
    def contains(self, aircraft_name:str) -> bool:
        """Check whether the catalog source contains the catalog item with the given name."""
        return self._intf.invoke(ICatalogSource._metadata, ICatalogSource._contains_metadata, aircraft_name, OutArg())

    _remove_child_metadata = { "offset" : _remove_child_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def remove_child(self, child_name:str) -> None:
        """Remove the child with the given name."""
        return self._intf.invoke(ICatalogSource._metadata, ICatalogSource._remove_child_metadata, child_name)

    _save_metadata = { "offset" : _save_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def save(self) -> None:
        """Save the catalog item."""
        return self._intf.invoke(ICatalogSource._metadata, ICatalogSource._save_metadata, )

    _property_names[child_names] = "child_names"


agcls.AgClassCatalog.add_catalog_entry((5049762571904518511, 12921546796455048600), ICatalogSource)
agcls.AgTypeNameMap["ICatalogSource"] = ICatalogSource

class IBasicFixedWingLiftHelper(object):
    """Interface used to access Lift Coefficient Helper in the Basic Fixed Wing Aerodynamics interface for the Basic Acceleration Model of an aircraft."""

    _num_methods = 0
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _metadata = {
        "iid_data" : (4688474907311176393, 2468997903478744199),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IBasicFixedWingLiftHelper."""
        initialize_from_source_object(self, source_object, IBasicFixedWingLiftHelper)
    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, IBasicFixedWingLiftHelper)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IBasicFixedWingLiftHelper, None)



agcls.AgClassCatalog.add_catalog_entry((4688474907311176393, 2468997903478744199), IBasicFixedWingLiftHelper)
agcls.AgTypeNameMap["IBasicFixedWingLiftHelper"] = IBasicFixedWingLiftHelper

class ICatalogRunway(object):
    """Interface used to access a runway in the Aviator catalog."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5582374247106176888, 13141122444054183846),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type ICatalogRunway."""
        initialize_from_source_object(self, source_object, ICatalogRunway)
    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, ICatalogRunway)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, ICatalogRunway, None)



agcls.AgClassCatalog.add_catalog_entry((5582374247106176888, 13141122444054183846), ICatalogRunway)
agcls.AgTypeNameMap["ICatalogRunway"] = ICatalogRunway

class ICatalogAirport(object):
    """Interface used to access a airport in the Aviator catalog."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5517232244535054220, 17256594794181634488),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type ICatalogAirport."""
        initialize_from_source_object(self, source_object, ICatalogAirport)
    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, ICatalogAirport)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, ICatalogAirport, None)



agcls.AgClassCatalog.add_catalog_entry((5517232244535054220, 17256594794181634488), ICatalogAirport)
agcls.AgTypeNameMap["ICatalogAirport"] = ICatalogAirport

class ICatalogNavaid(object):
    """Interface used to access a navaid in the Aviator catalog."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5313582233894378368, 56929069166080155),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type ICatalogNavaid."""
        initialize_from_source_object(self, source_object, ICatalogNavaid)
    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, ICatalogNavaid)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, ICatalogNavaid, None)



agcls.AgClassCatalog.add_catalog_entry((5313582233894378368, 56929069166080155), ICatalogNavaid)
agcls.AgTypeNameMap["ICatalogNavaid"] = ICatalogNavaid

class ICatalogVTOLPoint(object):
    """Interface used to access a VTOL Point in the Aviator catalog."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5738919117285590368, 14261233550328315012),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type ICatalogVTOLPoint."""
        initialize_from_source_object(self, source_object, ICatalogVTOLPoint)
    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, ICatalogVTOLPoint)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, ICatalogVTOLPoint, None)



agcls.AgClassCatalog.add_catalog_entry((5738919117285590368, 14261233550328315012), ICatalogVTOLPoint)
agcls.AgTypeNameMap["ICatalogVTOLPoint"] = ICatalogVTOLPoint

class ICatalogWaypoint(object):
    """Interface used to access a waypoint in the Aviator catalog."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5532823826035277770, 17986873366649893022),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type ICatalogWaypoint."""
        initialize_from_source_object(self, source_object, ICatalogWaypoint)
    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, ICatalogWaypoint)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, ICatalogWaypoint, None)



agcls.AgClassCatalog.add_catalog_entry((5532823826035277770, 17986873366649893022), ICatalogWaypoint)
agcls.AgTypeNameMap["ICatalogWaypoint"] = ICatalogWaypoint

class IARINC424Airport(object):
    """Do not use this interface, as it is deprecated. Use IARINC424Item instead."""

    _num_methods = 1
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_as_catalog_item_method_offset = 1
    _metadata = {
        "iid_data" : (4806586137712321246, 15546437888766560677),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IARINC424Airport."""
        initialize_from_source_object(self, source_object, IARINC424Airport)
    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, IARINC424Airport)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IARINC424Airport, None)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(IARINC424Airport._metadata, IARINC424Airport._get_as_catalog_item_metadata, OutArg())



agcls.AgClassCatalog.add_catalog_entry((4806586137712321246, 15546437888766560677), IARINC424Airport)
agcls.AgTypeNameMap["IARINC424Airport"] = IARINC424Airport

class IDAFIFItem(object):
    """Interface used to access the options for an DAFIF Item found in the Aviator catalog."""

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_value_method_offset = 1
    _get_all_fields_method_offset = 2
    _get_all_fields_and_values_method_offset = 3
    _copy_site_method_offset = 4
    _get_as_catalog_item_method_offset = 5
    _metadata = {
        "iid_data" : (5172829076274399625, 12291090328348071297),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IDAFIFItem."""
        initialize_from_source_object(self, source_object, IDAFIFItem)
    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, IDAFIFItem)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IDAFIFItem, None)

    _get_value_metadata = { "offset" : _get_value_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.VariantArg,) }
    def get_value(self, field_name:str) -> typing.Any:
        """Get the value of the field with the given name."""
        return self._intf.invoke(IDAFIFItem._metadata, IDAFIFItem._get_value_metadata, field_name, OutArg())

    _get_all_fields_metadata = { "offset" : _get_all_fields_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    def get_all_fields(self) -> list:
        """Get all the field names."""
        return self._intf.invoke(IDAFIFItem._metadata, IDAFIFItem._get_all_fields_metadata, OutArg())

    _get_all_fields_and_values_metadata = { "offset" : _get_all_fields_and_values_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    def get_all_fields_and_values(self) -> list:
        """Get all the field names along with the corresponding value."""
        return self._intf.invoke(IDAFIFItem._metadata, IDAFIFItem._get_all_fields_and_values_metadata, OutArg())

    _copy_site_metadata = { "offset" : _copy_site_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def copy_site(self) -> None:
        """Copy the site to the clipboard."""
        return self._intf.invoke(IDAFIFItem._metadata, IDAFIFItem._copy_site_metadata, )

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(IDAFIFItem._metadata, IDAFIFItem._get_as_catalog_item_metadata, OutArg())



agcls.AgClassCatalog.add_catalog_entry((5172829076274399625, 12291090328348071297), IDAFIFItem)
agcls.AgTypeNameMap["IDAFIFItem"] = IDAFIFItem

class IVerticalPlaneOptions(object):
    """Interface used to access the Vertical Plane options for an Aviator procedure."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_min_enroute_flight_path_angle_method_offset = 1
    _set_min_enroute_flight_path_angle_method_offset = 2
    _get_max_enroute_flight_path_angle_method_offset = 3
    _set_max_enroute_flight_path_angle_method_offset = 4
    _get_max_vert_plane_radius_factor_method_offset = 5
    _set_max_vert_plane_radius_factor_method_offset = 6
    _metadata = {
        "iid_data" : (5520552088906406195, 394820396869463446),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IVerticalPlaneOptions."""
        initialize_from_source_object(self, source_object, IVerticalPlaneOptions)
    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, IVerticalPlaneOptions)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IVerticalPlaneOptions, None)

    _get_min_enroute_flight_path_angle_metadata = { "offset" : _get_min_enroute_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def min_enroute_flight_path_angle(self) -> typing.Any:
        """Get or set the minimum pitch angle of the flight path during enroute segments of the procedure."""
        return self._intf.get_property(IVerticalPlaneOptions._metadata, IVerticalPlaneOptions._get_min_enroute_flight_path_angle_metadata)

    _set_min_enroute_flight_path_angle_metadata = { "offset" : _set_min_enroute_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @min_enroute_flight_path_angle.setter
    def min_enroute_flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the minimum pitch angle of the flight path during enroute segments of the procedure."""
        return self._intf.set_property(IVerticalPlaneOptions._metadata, IVerticalPlaneOptions._set_min_enroute_flight_path_angle_metadata, value)

    _get_max_enroute_flight_path_angle_metadata = { "offset" : _get_max_enroute_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_enroute_flight_path_angle(self) -> typing.Any:
        """Get or set the maximum pitch angle of the flight path during enroute segments of the procedure."""
        return self._intf.get_property(IVerticalPlaneOptions._metadata, IVerticalPlaneOptions._get_max_enroute_flight_path_angle_metadata)

    _set_max_enroute_flight_path_angle_metadata = { "offset" : _set_max_enroute_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_enroute_flight_path_angle.setter
    def max_enroute_flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the maximum pitch angle of the flight path during enroute segments of the procedure."""
        return self._intf.set_property(IVerticalPlaneOptions._metadata, IVerticalPlaneOptions._set_max_enroute_flight_path_angle_metadata, value)

    _get_max_vert_plane_radius_factor_metadata = { "offset" : _get_max_vert_plane_radius_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_vert_plane_radius_factor(self) -> float:
        """Get or set the maximum amount the radius of vertical curve will be increased to minimize the flight path angle required to complete it."""
        return self._intf.get_property(IVerticalPlaneOptions._metadata, IVerticalPlaneOptions._get_max_vert_plane_radius_factor_metadata)

    _set_max_vert_plane_radius_factor_metadata = { "offset" : _set_max_vert_plane_radius_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_vert_plane_radius_factor.setter
    def max_vert_plane_radius_factor(self, value:float) -> None:
        """Get or set the maximum amount the radius of vertical curve will be increased to minimize the flight path angle required to complete it."""
        return self._intf.set_property(IVerticalPlaneOptions._metadata, IVerticalPlaneOptions._set_max_vert_plane_radius_factor_metadata, value)

    _property_names[min_enroute_flight_path_angle] = "min_enroute_flight_path_angle"
    _property_names[max_enroute_flight_path_angle] = "max_enroute_flight_path_angle"
    _property_names[max_vert_plane_radius_factor] = "max_vert_plane_radius_factor"


agcls.AgClassCatalog.add_catalog_entry((5520552088906406195, 394820396869463446), IVerticalPlaneOptions)
agcls.AgTypeNameMap["IVerticalPlaneOptions"] = IVerticalPlaneOptions

class IEnrouteAndDelayOptions(object):
    """Interface used to access the Enroute options for an Aviator procedure."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_delay_enroute_climb_descents_method_offset = 1
    _set_delay_enroute_climb_descents_method_offset = 2
    _get_use_max_speed_turns_method_offset = 3
    _set_use_max_speed_turns_method_offset = 4
    _get_max_turn_radius_factor_method_offset = 5
    _set_max_turn_radius_factor_method_offset = 6
    _metadata = {
        "iid_data" : (5068556317467918075, 1237280450976607145),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IEnrouteAndDelayOptions."""
        initialize_from_source_object(self, source_object, IEnrouteAndDelayOptions)
    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, IEnrouteAndDelayOptions)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IEnrouteAndDelayOptions, None)

    _get_delay_enroute_climb_descents_metadata = { "offset" : _get_delay_enroute_climb_descents_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def delay_enroute_climb_descents(self) -> bool:
        """Opt whether to delay the enroute climb or descent."""
        return self._intf.get_property(IEnrouteAndDelayOptions._metadata, IEnrouteAndDelayOptions._get_delay_enroute_climb_descents_metadata)

    _set_delay_enroute_climb_descents_metadata = { "offset" : _set_delay_enroute_climb_descents_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @delay_enroute_climb_descents.setter
    def delay_enroute_climb_descents(self, value:bool) -> None:
        """Opt whether to delay the enroute climb or descent."""
        return self._intf.set_property(IEnrouteAndDelayOptions._metadata, IEnrouteAndDelayOptions._set_delay_enroute_climb_descents_metadata, value)

    _get_use_max_speed_turns_metadata = { "offset" : _get_use_max_speed_turns_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_max_speed_turns(self) -> bool:
        """Opt whether to use the max speed turns."""
        return self._intf.get_property(IEnrouteAndDelayOptions._metadata, IEnrouteAndDelayOptions._get_use_max_speed_turns_metadata)

    _set_use_max_speed_turns_metadata = { "offset" : _set_use_max_speed_turns_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_max_speed_turns.setter
    def use_max_speed_turns(self, value:bool) -> None:
        """Opt whether to use the max speed turns."""
        return self._intf.set_property(IEnrouteAndDelayOptions._metadata, IEnrouteAndDelayOptions._set_use_max_speed_turns_metadata, value)

    _get_max_turn_radius_factor_metadata = { "offset" : _get_max_turn_radius_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_turn_radius_factor(self) -> float:
        """Get or set the maximum turn radius factor."""
        return self._intf.get_property(IEnrouteAndDelayOptions._metadata, IEnrouteAndDelayOptions._get_max_turn_radius_factor_metadata)

    _set_max_turn_radius_factor_metadata = { "offset" : _set_max_turn_radius_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_turn_radius_factor.setter
    def max_turn_radius_factor(self, value:float) -> None:
        """Get or set the maximum turn radius factor."""
        return self._intf.set_property(IEnrouteAndDelayOptions._metadata, IEnrouteAndDelayOptions._set_max_turn_radius_factor_metadata, value)

    _property_names[delay_enroute_climb_descents] = "delay_enroute_climb_descents"
    _property_names[use_max_speed_turns] = "use_max_speed_turns"
    _property_names[max_turn_radius_factor] = "max_turn_radius_factor"


agcls.AgClassCatalog.add_catalog_entry((5068556317467918075, 1237280450976607145), IEnrouteAndDelayOptions)
agcls.AgTypeNameMap["IEnrouteAndDelayOptions"] = IEnrouteAndDelayOptions

class ICruiseAirspeedAndProfileOptions(object):
    """Interface used to access the cruise airspeed options that also include a profile field."""

    _num_methods = 7
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_cruise_speed_type_method_offset = 1
    _set_cruise_speed_type_method_offset = 2
    _get_other_airspeed_type_method_offset = 3
    _get_other_airspeed_method_offset = 4
    _set_other_airspeed_method_offset = 5
    _get_fly_cruise_airspeed_profile_method_offset = 6
    _set_fly_cruise_airspeed_profile_method_offset = 7
    _metadata = {
        "iid_data" : (5050149451706347699, 5240254480125122223),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type ICruiseAirspeedAndProfileOptions."""
        initialize_from_source_object(self, source_object, ICruiseAirspeedAndProfileOptions)
    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, ICruiseAirspeedAndProfileOptions)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, ICruiseAirspeedAndProfileOptions, None)

    _get_cruise_speed_type_metadata = { "offset" : _get_cruise_speed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CruiseSpeed),) }
    @property
    def cruise_speed_type(self) -> "CruiseSpeed":
        """Get or set the method for determining the aircraft's airspeed."""
        return self._intf.get_property(ICruiseAirspeedAndProfileOptions._metadata, ICruiseAirspeedAndProfileOptions._get_cruise_speed_type_metadata)

    _set_cruise_speed_type_metadata = { "offset" : _set_cruise_speed_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CruiseSpeed),) }
    @cruise_speed_type.setter
    def cruise_speed_type(self, value:"CruiseSpeed") -> None:
        """Get or set the method for determining the aircraft's airspeed."""
        return self._intf.set_property(ICruiseAirspeedAndProfileOptions._metadata, ICruiseAirspeedAndProfileOptions._set_cruise_speed_type_metadata, value)

    _get_other_airspeed_type_metadata = { "offset" : _get_other_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def other_airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type for the other airspeed option."""
        return self._intf.get_property(ICruiseAirspeedAndProfileOptions._metadata, ICruiseAirspeedAndProfileOptions._get_other_airspeed_type_metadata)

    _get_other_airspeed_metadata = { "offset" : _get_other_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def other_airspeed(self) -> float:
        """Get the airspeed for the other airspeed option."""
        return self._intf.get_property(ICruiseAirspeedAndProfileOptions._metadata, ICruiseAirspeedAndProfileOptions._get_other_airspeed_metadata)

    _set_other_airspeed_metadata = { "offset" : _set_other_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_other_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the cruise airspeed. This option is only enabled if the cruise speed type is set to other."""
        return self._intf.invoke(ICruiseAirspeedAndProfileOptions._metadata, ICruiseAirspeedAndProfileOptions._set_other_airspeed_metadata, airspeed_type, airspeed)

    _get_fly_cruise_airspeed_profile_metadata = { "offset" : _get_fly_cruise_airspeed_profile_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def fly_cruise_airspeed_profile(self) -> bool:
        """Opt whether the aircraft immediately adopts the selected cruise airspeed or gradually begins accelerating/decelerating in the previous procedure."""
        return self._intf.get_property(ICruiseAirspeedAndProfileOptions._metadata, ICruiseAirspeedAndProfileOptions._get_fly_cruise_airspeed_profile_metadata)

    _set_fly_cruise_airspeed_profile_metadata = { "offset" : _set_fly_cruise_airspeed_profile_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @fly_cruise_airspeed_profile.setter
    def fly_cruise_airspeed_profile(self, value:bool) -> None:
        """Opt whether the aircraft immediately adopts the selected cruise airspeed or gradually begins accelerating/decelerating in the previous procedure."""
        return self._intf.set_property(ICruiseAirspeedAndProfileOptions._metadata, ICruiseAirspeedAndProfileOptions._set_fly_cruise_airspeed_profile_metadata, value)

    _property_names[cruise_speed_type] = "cruise_speed_type"
    _property_names[other_airspeed_type] = "other_airspeed_type"
    _property_names[other_airspeed] = "other_airspeed"
    _property_names[fly_cruise_airspeed_profile] = "fly_cruise_airspeed_profile"


agcls.AgClassCatalog.add_catalog_entry((5050149451706347699, 5240254480125122223), ICruiseAirspeedAndProfileOptions)
agcls.AgTypeNameMap["ICruiseAirspeedAndProfileOptions"] = ICruiseAirspeedAndProfileOptions

class IAutomationStrategyFactory(object):
    """Interface used to send connect commands to Aviator objects."""

    _num_methods = 1
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _construct_strategy_method_offset = 1
    _metadata = {
        "iid_data" : (5748143157570064853, 17141228144581304450),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IAutomationStrategyFactory."""
        initialize_from_source_object(self, source_object, IAutomationStrategyFactory)
    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, IAutomationStrategyFactory)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IAutomationStrategyFactory, None)

    _construct_strategy_metadata = { "offset" : _construct_strategy_method_offset,
            "arg_types" : (agcom.PVOID, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceInArg("IUnknown"), agmarshall.InterfaceOutArg,) }
    def construct_strategy(self, obj:"IUnknown") -> "IBasicManeuverStrategy":
        """Construct the strategy."""
        return self._intf.invoke(IAutomationStrategyFactory._metadata, IAutomationStrategyFactory._construct_strategy_metadata, obj, OutArg())



agcls.AgClassCatalog.add_catalog_entry((5748143157570064853, 17141228144581304450), IAutomationStrategyFactory)
agcls.AgTypeNameMap["IAutomationStrategyFactory"] = IAutomationStrategyFactory

class IConnect(object):
    """Interface used to send connect commands to Aviator objects."""

    _num_methods = 1
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _execute_command_method_offset = 1
    _metadata = {
        "iid_data" : (5321476311283717631, 17088119313231705791),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IConnect."""
        initialize_from_source_object(self, source_object, IConnect)
    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, IConnect)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IConnect, None)

    _execute_command_metadata = { "offset" : _execute_command_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def execute_command(self, command:str) -> typing.Any:
        """Send a connect command to an Aviator object."""
        return self._intf.invoke(IConnect._metadata, IConnect._execute_command_metadata, command, OutArg())



agcls.AgClassCatalog.add_catalog_entry((5321476311283717631, 17088119313231705791), IConnect)
agcls.AgTypeNameMap["IConnect"] = IConnect

class IProcedure(object):
    """
    Interface used to access the options for a procedure. Use this interface to get the Site and Get the time options for the current procedure.

    Examples
    --------
    Configure the wind and atmosphere for a procedure:
    >>> # IProcedure procedure: Procedure object
    >>> # Get the wind model for the procedure
    >>> windModel = procedure.wind_model
    >>> # Use the procedure model
    >>> windModel.wind_model_source = WindAtmosphereModelSource.PROCEDURE_MODEL
    >>> # Let's use constant wind
    >>> windModel.wind_model_type = WindModelType.CONSTANT_WIND
    >>> # Get the constant wind model options
    >>> constantWind = windModel.mode_as_constant
    >>> # Set the wind bearing
    >>> constantWind.wind_bearing = 30
    >>> # Set the wind speed
    >>> constantWind.wind_speed = 5
    >>>
    >>> # Get the atmosphere model used for the procedure
    >>> atmosphere = procedure.atmosphere_model
    >>> # Let's use the procedure model
    >>> atmosphere.atmosphere_model_source = WindAtmosphereModelSource.PROCEDURE_MODEL
    >>> # Get the basic atmosphere options
    >>> basicAtmosphere = atmosphere.mode_as_basic
    >>> # Use standard 1976 atmosphere
    >>> basicAtmosphere.basic_model_type = AtmosphereModelType.STANDARD1976

    Configure a procedure's time options:
    >>> # IProcedure procedure: Procedure object
    >>> # Get the time in epoch seconds
    >>> root.units_preferences.set_current_unit("DateFormat", "EpSec")
    >>> # Get the time options
    >>> timeOptions = procedure.time_options
    >>> # Get the start time
    >>> startTime = timeOptions.start_time
    >>> # Set the procedure to interrupt after 15 seconds
    >>> timeOptions.set_interrupt_time(15)

    Rename a procedure and its site:
    >>> # IProcedure procedure: Procedure object
    >>> # Rename the procedure
    >>> procedure.name = "New Procedure"
    >>> # Get the site corresponding to the procedure
    >>> site = procedure.site
    >>> # Rename the site
    >>> site.name = "New Site"
    """

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_name_method_offset = 1
    _set_name_method_offset = 2
    _get_site_method_offset = 3
    _get_time_options_method_offset = 4
    _get_wind_model_method_offset = 5
    _get_atmosphere_model_method_offset = 6
    _get_calculation_options_method_offset = 7
    _get_refuel_dump_is_supported_method_offset = 8
    _get_refuel_dump_properties_method_offset = 9
    _get_fast_time_options_method_offset = 10
    _metadata = {
        "iid_data" : (5354902126736355035, 15840099138053069727),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IProcedure."""
        initialize_from_source_object(self, source_object, IProcedure)
    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, IProcedure)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IProcedure, None)

    _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 procedure."""
        return self._intf.get_property(IProcedure._metadata, IProcedure._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 procedure."""
        return self._intf.set_property(IProcedure._metadata, IProcedure._set_name_metadata, value)

    _get_site_metadata = { "offset" : _get_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def site(self) -> "ISite":
        """Get the site of the current procedure."""
        return self._intf.get_property(IProcedure._metadata, IProcedure._get_site_metadata)

    _get_time_options_metadata = { "offset" : _get_time_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def time_options(self) -> "ProcedureTimeOptions":
        """Get the time options for the current procedure."""
        return self._intf.get_property(IProcedure._metadata, IProcedure._get_time_options_metadata)

    _get_wind_model_metadata = { "offset" : _get_wind_model_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def wind_model(self) -> "WindModel":
        """Get the wind model for the current procedure."""
        return self._intf.get_property(IProcedure._metadata, IProcedure._get_wind_model_metadata)

    _get_atmosphere_model_metadata = { "offset" : _get_atmosphere_model_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def atmosphere_model(self) -> "AtmosphereModel":
        """Get the mission atmosphere model."""
        return self._intf.get_property(IProcedure._metadata, IProcedure._get_atmosphere_model_metadata)

    _get_calculation_options_metadata = { "offset" : _get_calculation_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def calculation_options(self) -> "CalculationOptions":
        """Get the calculation options for the current procedure."""
        return self._intf.get_property(IProcedure._metadata, IProcedure._get_calculation_options_metadata)

    _get_refuel_dump_is_supported_metadata = { "offset" : _get_refuel_dump_is_supported_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def refuel_dump_is_supported(self) -> bool:
        """Refuel/dump is supported for the current procedure."""
        return self._intf.get_property(IProcedure._metadata, IProcedure._get_refuel_dump_is_supported_metadata)

    _get_refuel_dump_properties_metadata = { "offset" : _get_refuel_dump_properties_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def refuel_dump_properties(self) -> "RefuelDumpProperties":
        """Get the refuel/dump properties for the current procedure."""
        return self._intf.get_property(IProcedure._metadata, IProcedure._get_refuel_dump_properties_metadata)

    _get_fast_time_options_metadata = { "offset" : _get_fast_time_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def fast_time_options(self) -> "ProcedureFastTimeOptions":
        """Get the fast time options (without validation or constraints) for the current procedure."""
        return self._intf.get_property(IProcedure._metadata, IProcedure._get_fast_time_options_metadata)

    _property_names[name] = "name"
    _property_names[site] = "site"
    _property_names[time_options] = "time_options"
    _property_names[wind_model] = "wind_model"
    _property_names[atmosphere_model] = "atmosphere_model"
    _property_names[calculation_options] = "calculation_options"
    _property_names[refuel_dump_is_supported] = "refuel_dump_is_supported"
    _property_names[refuel_dump_properties] = "refuel_dump_properties"
    _property_names[fast_time_options] = "fast_time_options"


agcls.AgClassCatalog.add_catalog_entry((5354902126736355035, 15840099138053069727), IProcedure)
agcls.AgTypeNameMap["IProcedure"] = IProcedure

class IPerformanceModel(object):
    """
    Interface for a performance model of an Aviator vehicle.

    Examples
    --------
    Create a new performance model for an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the acceleration type
    >>> acceleration = aviatorAircraft.acceleration
    >>> # Get the names of the current acceleration models
    >>> modelNames = acceleration.child_names
    >>> # Check how many models there are
    >>> modelCount = len(modelNames)
    >>> # Get the child types (for example AGI Basic Acceleration Model, Advanced Acceleration Model)
    >>> modelTypes = acceleration.child_types
    >>> # Create a new performance model of type "Advanced Acceleration Model"
    >>> newPerformanceModel = acceleration.add_child_of_type("Advanced Acceleration Model", "Model Name")
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()
    """

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (4722239720283002114, 10874464253498804653),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IPerformanceModel."""
        initialize_from_source_object(self, source_object, IPerformanceModel)
    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, IPerformanceModel)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IPerformanceModel, None)



agcls.AgClassCatalog.add_catalog_entry((4722239720283002114, 10874464253498804653), IPerformanceModel)
agcls.AgTypeNameMap["IPerformanceModel"] = IPerformanceModel

class IAdvancedFixedWingGeometry(object):
    """Interface used to access the options for the wing geometry in the advanced fixed wing tool."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (4940865896231186286, 11578475062663105194),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IAdvancedFixedWingGeometry."""
        initialize_from_source_object(self, source_object, IAdvancedFixedWingGeometry)
    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, IAdvancedFixedWingGeometry)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IAdvancedFixedWingGeometry, None)



agcls.AgClassCatalog.add_catalog_entry((4940865896231186286, 11578475062663105194), IAdvancedFixedWingGeometry)
agcls.AgTypeNameMap["IAdvancedFixedWingGeometry"] = IAdvancedFixedWingGeometry

class IAdvancedFixedWingPowerplant(object):
    """Interface for a powerplant strategy in the advanced fixed wing tool."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (5713896957878092641, 17244840932805749889),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type IAdvancedFixedWingPowerplant."""
        initialize_from_source_object(self, source_object, IAdvancedFixedWingPowerplant)
    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, IAdvancedFixedWingPowerplant)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, IAdvancedFixedWingPowerplant, None)



agcls.AgClassCatalog.add_catalog_entry((5713896957878092641, 17244840932805749889), IAdvancedFixedWingPowerplant)
agcls.AgTypeNameMap["IAdvancedFixedWingPowerplant"] = IAdvancedFixedWingPowerplant

class ISiteUnknown(object):
    """Interface of an unknown site."""

    _num_methods = 0
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _metadata = {
        "iid_data" : (4927199749278391215, 245580461777180035),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def __init__(self, source_object=None):
        """Construct an object of type ISiteUnknown."""
        initialize_from_source_object(self, source_object, ISiteUnknown)
    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, ISiteUnknown)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_interface_attribute(self, attrname, value, ISiteUnknown, None)



agcls.AgClassCatalog.add_catalog_entry((4927199749278391215, 245580461777180035), ISiteUnknown)
agcls.AgTypeNameMap["ISiteUnknown"] = ISiteUnknown



class SiteWaypoint(ISite, SupportsDeleteCallback):
    """Interface used to access the options for a waypoint site."""

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_latitude_method_offset = 1
    _set_latitude_method_offset = 2
    _get_longitude_method_offset = 3
    _set_longitude_method_offset = 4
    _get_as_site_method_offset = 5
    _metadata = {
        "iid_data" : (5613574524731284566, 17207683338010306734),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteWaypoint)

    _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 waypoint latitude."""
        return self._intf.get_property(SiteWaypoint._metadata, SiteWaypoint._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:
        """Get or set the waypoint latitude."""
        return self._intf.set_property(SiteWaypoint._metadata, SiteWaypoint._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 waypoint longitude."""
        return self._intf.get_property(SiteWaypoint._metadata, SiteWaypoint._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:
        """Get or set the waypoint longitude."""
        return self._intf.set_property(SiteWaypoint._metadata, SiteWaypoint._set_longitude_metadata, value)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteWaypoint._metadata, SiteWaypoint._get_as_site_metadata, OutArg())

    _property_names[latitude] = "latitude"
    _property_names[longitude] = "longitude"

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

agcls.AgClassCatalog.add_catalog_entry((5108603041944758707, 10578588674234114712), SiteWaypoint)
agcls.AgTypeNameMap["SiteWaypoint"] = SiteWaypoint

class SiteEndOfPrevProcedure(ISite, SupportsDeleteCallback):
    """Interface used to access the options for an End of Previous Procedure site type."""

    _num_methods = 1
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_as_site_method_offset = 1
    _metadata = {
        "iid_data" : (5004093185145679190, 7313314850458100887),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteEndOfPrevProcedure)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteEndOfPrevProcedure._metadata, SiteEndOfPrevProcedure._get_as_site_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((5621720374100682259, 1489086470013473170), SiteEndOfPrevProcedure)
agcls.AgTypeNameMap["SiteEndOfPrevProcedure"] = SiteEndOfPrevProcedure

class SiteVTOLPoint(ISite, SupportsDeleteCallback):
    """Interface used to access the options for a VTOL Point site."""

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._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_altitude_reference_method_offset = 7
    _set_altitude_reference_method_offset = 8
    _get_as_site_method_offset = 9
    _metadata = {
        "iid_data" : (5600278003038443155, 12434436858381676162),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteVTOLPoint)

    _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 VTOL Point latitude."""
        return self._intf.get_property(SiteVTOLPoint._metadata, SiteVTOLPoint._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:
        """Get or set the VTOL Point latitude."""
        return self._intf.set_property(SiteVTOLPoint._metadata, SiteVTOLPoint._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 VTOL Point longitude."""
        return self._intf.get_property(SiteVTOLPoint._metadata, SiteVTOLPoint._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:
        """Get or set the VTOL Point longitude."""
        return self._intf.set_property(SiteVTOLPoint._metadata, SiteVTOLPoint._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 for the site."""
        return self._intf.get_property(SiteVTOLPoint._metadata, SiteVTOLPoint._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:
        """Get or set the altitude for the site."""
        return self._intf.set_property(SiteVTOLPoint._metadata, SiteVTOLPoint._set_altitude_metadata, value)

    _get_altitude_reference_metadata = { "offset" : _get_altitude_reference_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AGLMSL),) }
    @property
    def altitude_reference(self) -> "AGLMSL":
        """Get or set the altitude reference."""
        return self._intf.get_property(SiteVTOLPoint._metadata, SiteVTOLPoint._get_altitude_reference_metadata)

    _set_altitude_reference_metadata = { "offset" : _set_altitude_reference_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AGLMSL),) }
    @altitude_reference.setter
    def altitude_reference(self, value:"AGLMSL") -> None:
        """Get or set the altitude reference."""
        return self._intf.set_property(SiteVTOLPoint._metadata, SiteVTOLPoint._set_altitude_reference_metadata, value)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteVTOLPoint._metadata, SiteVTOLPoint._get_as_site_metadata, OutArg())

    _property_names[latitude] = "latitude"
    _property_names[longitude] = "longitude"
    _property_names[altitude] = "altitude"
    _property_names[altitude_reference] = "altitude_reference"

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

agcls.AgClassCatalog.add_catalog_entry((4843052394715389444, 16917492219472377009), SiteVTOLPoint)
agcls.AgTypeNameMap["SiteVTOLPoint"] = SiteVTOLPoint

class SiteReferenceState(ISite, SupportsDeleteCallback):
    """Interface used to access the options for a Reference State site."""

    _num_methods = 1
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_as_site_method_offset = 1
    _metadata = {
        "iid_data" : (5183490168050866731, 113889888384022661),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteReferenceState)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteReferenceState._metadata, SiteReferenceState._get_as_site_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((5669257357524304127, 16224037961252013460), SiteReferenceState)
agcls.AgTypeNameMap["SiteReferenceState"] = SiteReferenceState

class SiteSTKVehicle(ISite, SupportsDeleteCallback):
    """Interface used to access the options for a STK Vehicle site."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_object_name_method_offset = 1
    _set_object_name_method_offset = 2
    _get_valid_object_names_method_offset = 3
    _get_as_site_method_offset = 4
    _metadata = {
        "iid_data" : (5253646862927661627, 14251339590362269831),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteSTKVehicle)

    _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 object name to link to."""
        return self._intf.get_property(SiteSTKVehicle._metadata, SiteSTKVehicle._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:
        """Get or set the object name to link to."""
        return self._intf.set_property(SiteSTKVehicle._metadata, SiteSTKVehicle._set_object_name_metadata, value)

    _get_valid_object_names_metadata = { "offset" : _get_valid_object_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def valid_object_names(self) -> list:
        """Return the valid object names."""
        return self._intf.get_property(SiteSTKVehicle._metadata, SiteSTKVehicle._get_valid_object_names_metadata)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteSTKVehicle._metadata, SiteSTKVehicle._get_as_site_metadata, OutArg())

    _property_names[object_name] = "object_name"
    _property_names[valid_object_names] = "valid_object_names"

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

agcls.AgClassCatalog.add_catalog_entry((5597757840433509036, 13479290176329506690), SiteSTKVehicle)
agcls.AgTypeNameMap["SiteSTKVehicle"] = SiteSTKVehicle

class SiteSuperProcedure(ISite, SupportsDeleteCallback):
    """Interface used to access the options for a Super Procedure site."""

    _num_methods = 1
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_as_site_method_offset = 1
    _metadata = {
        "iid_data" : (5571997691972875262, 2757918785063417476),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteSuperProcedure)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteSuperProcedure._metadata, SiteSuperProcedure._get_as_site_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((5371976027007327351, 12208188571124011188), SiteSuperProcedure)
agcls.AgTypeNameMap["SiteSuperProcedure"] = SiteSuperProcedure

class SiteRelativeToPrevProcedure(ISite, SupportsDeleteCallback):
    """Interface used to access the options for a Relative to Previous Procedure site."""

    _num_methods = 7
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_bearing_mode_method_offset = 1
    _set_bearing_mode_method_offset = 2
    _get_bearing_method_offset = 3
    _set_bearing_method_offset = 4
    _get_range_method_offset = 5
    _set_range_method_offset = 6
    _get_as_site_method_offset = 7
    _metadata = {
        "iid_data" : (5759285823815417596, 3125305812269783207),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteRelativeToPrevProcedure)

    _get_bearing_mode_metadata = { "offset" : _get_bearing_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RelativeAbsoluteBearing),) }
    @property
    def bearing_mode(self) -> "RelativeAbsoluteBearing":
        """Get or set the bearing reference."""
        return self._intf.get_property(SiteRelativeToPrevProcedure._metadata, SiteRelativeToPrevProcedure._get_bearing_mode_metadata)

    _set_bearing_mode_metadata = { "offset" : _set_bearing_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(RelativeAbsoluteBearing),) }
    @bearing_mode.setter
    def bearing_mode(self, value:"RelativeAbsoluteBearing") -> None:
        """Get or set the bearing reference."""
        return self._intf.set_property(SiteRelativeToPrevProcedure._metadata, SiteRelativeToPrevProcedure._set_bearing_mode_metadata, value)

    _get_bearing_metadata = { "offset" : _get_bearing_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def bearing(self) -> typing.Any:
        """Get or set the bearing to define the site."""
        return self._intf.get_property(SiteRelativeToPrevProcedure._metadata, SiteRelativeToPrevProcedure._get_bearing_metadata)

    _set_bearing_metadata = { "offset" : _set_bearing_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @bearing.setter
    def bearing(self, value:typing.Any) -> None:
        """Get or set the bearing to define the site."""
        return self._intf.set_property(SiteRelativeToPrevProcedure._metadata, SiteRelativeToPrevProcedure._set_bearing_metadata, value)

    _get_range_metadata = { "offset" : _get_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def range(self) -> float:
        """Get or set the range from the previous procedure."""
        return self._intf.get_property(SiteRelativeToPrevProcedure._metadata, SiteRelativeToPrevProcedure._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:
        """Get or set the range from the previous procedure."""
        return self._intf.set_property(SiteRelativeToPrevProcedure._metadata, SiteRelativeToPrevProcedure._set_range_metadata, value)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteRelativeToPrevProcedure._metadata, SiteRelativeToPrevProcedure._get_as_site_metadata, OutArg())

    _property_names[bearing_mode] = "bearing_mode"
    _property_names[bearing] = "bearing"
    _property_names[range] = "range"

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

agcls.AgClassCatalog.add_catalog_entry((4958528407379756360, 17186724269580697779), SiteRelativeToPrevProcedure)
agcls.AgTypeNameMap["SiteRelativeToPrevProcedure"] = SiteRelativeToPrevProcedure

class SiteSTKObjectWaypoint(ISite, SupportsDeleteCallback):
    """Interface used to access the options for a STK Object Waypoint site."""

    _num_methods = 20
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_object_name_method_offset = 1
    _set_object_name_method_offset = 2
    _get_valid_object_names_method_offset = 3
    _get_min_time_method_offset = 4
    _get_waypoint_time_method_offset = 5
    _set_waypoint_time_method_offset = 6
    _get_minimize_site_procedure_time_diff_method_offset = 7
    _set_minimize_site_procedure_time_diff_method_offset = 8
    _get_max_time_method_offset = 9
    _get_offset_mode_method_offset = 10
    _set_offset_mode_method_offset = 11
    _get_bearing_method_offset = 12
    _set_bearing_method_offset = 13
    _get_use_magnetic_bearing_method_offset = 14
    _set_use_magnetic_bearing_method_offset = 15
    _get_range_method_offset = 16
    _set_range_method_offset = 17
    _get_vgt_point_method_offset = 18
    _set_vgt_point_method_offset = 19
    _get_as_site_method_offset = 20
    _metadata = {
        "iid_data" : (4734056756504829268, 17555142127045754021),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteSTKObjectWaypoint)

    _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 object name to link to."""
        return self._intf.get_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._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:
        """Get or set the object name to link to."""
        return self._intf.set_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._set_object_name_metadata, value)

    _get_valid_object_names_metadata = { "offset" : _get_valid_object_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def valid_object_names(self) -> list:
        """Return the valid object names."""
        return self._intf.get_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._get_valid_object_names_metadata)

    _get_min_time_metadata = { "offset" : _get_min_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def min_time(self) -> typing.Any:
        """Get the earliest time that the object is available as a site."""
        return self._intf.get_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._get_min_time_metadata)

    _get_waypoint_time_metadata = { "offset" : _get_waypoint_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def waypoint_time(self) -> typing.Any:
        """Get or set the time at which the object's position will be used as a waypoint."""
        return self._intf.get_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._get_waypoint_time_metadata)

    _set_waypoint_time_metadata = { "offset" : _set_waypoint_time_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @waypoint_time.setter
    def waypoint_time(self, value:typing.Any) -> None:
        """Get or set the time at which the object's position will be used as a waypoint."""
        return self._intf.set_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._set_waypoint_time_metadata, value)

    _get_minimize_site_procedure_time_diff_metadata = { "offset" : _get_minimize_site_procedure_time_diff_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(MinimizeSiteProcedureTimeDiff),) }
    @property
    def minimize_site_procedure_time_diff(self) -> "MinimizeSiteProcedureTimeDiff":
        """Get or set the mode to minimize the time difference between the procedure and site times."""
        return self._intf.get_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._get_minimize_site_procedure_time_diff_metadata)

    _set_minimize_site_procedure_time_diff_metadata = { "offset" : _set_minimize_site_procedure_time_diff_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(MinimizeSiteProcedureTimeDiff),) }
    @minimize_site_procedure_time_diff.setter
    def minimize_site_procedure_time_diff(self, value:"MinimizeSiteProcedureTimeDiff") -> None:
        """Get or set the mode to minimize the time difference between the procedure and site times."""
        return self._intf.set_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._set_minimize_site_procedure_time_diff_metadata, value)

    _get_max_time_metadata = { "offset" : _get_max_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_time(self) -> typing.Any:
        """Get the latest time that the object is available as a site."""
        return self._intf.get_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._get_max_time_metadata)

    _get_offset_mode_metadata = { "offset" : _get_offset_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(STKObjectWaypointOffsetMode),) }
    @property
    def offset_mode(self) -> "STKObjectWaypointOffsetMode":
        """Get or set the mode to offset the site location relative from the STK Object."""
        return self._intf.get_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._get_offset_mode_metadata)

    _set_offset_mode_metadata = { "offset" : _set_offset_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(STKObjectWaypointOffsetMode),) }
    @offset_mode.setter
    def offset_mode(self, value:"STKObjectWaypointOffsetMode") -> None:
        """Get or set the mode to offset the site location relative from the STK Object."""
        return self._intf.set_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._set_offset_mode_metadata, value)

    _get_bearing_metadata = { "offset" : _get_bearing_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def bearing(self) -> typing.Any:
        """Get or set the bearing offset of the site location relative to the object's position."""
        return self._intf.get_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._get_bearing_metadata)

    _set_bearing_metadata = { "offset" : _set_bearing_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @bearing.setter
    def bearing(self, value:typing.Any) -> None:
        """Get or set the bearing offset of the site location relative to the object's position."""
        return self._intf.set_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._set_bearing_metadata, value)

    _get_use_magnetic_bearing_metadata = { "offset" : _get_use_magnetic_bearing_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_magnetic_bearing(self) -> bool:
        """Get or set the option to use a magnetic heading for the bearing."""
        return self._intf.get_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._get_use_magnetic_bearing_metadata)

    _set_use_magnetic_bearing_metadata = { "offset" : _set_use_magnetic_bearing_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_magnetic_bearing.setter
    def use_magnetic_bearing(self, value:bool) -> None:
        """Get or set the option to use a magnetic heading for the bearing."""
        return self._intf.set_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._set_use_magnetic_bearing_metadata, value)

    _get_range_metadata = { "offset" : _get_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def range(self) -> float:
        """Get or set the range offset of the site location relative to the object's position."""
        return self._intf.get_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._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:
        """Get or set the range offset of the site location relative to the object's position."""
        return self._intf.set_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._set_range_metadata, value)

    _get_vgt_point_metadata = { "offset" : _get_vgt_point_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def vgt_point(self) -> str:
        """Get or set the reference VGT Point."""
        return self._intf.get_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._get_vgt_point_metadata)

    _set_vgt_point_metadata = { "offset" : _set_vgt_point_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @vgt_point.setter
    def vgt_point(self, value:str) -> None:
        """Get or set the reference VGT Point."""
        return self._intf.set_property(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._set_vgt_point_metadata, value)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteSTKObjectWaypoint._metadata, SiteSTKObjectWaypoint._get_as_site_metadata, OutArg())

    _property_names[object_name] = "object_name"
    _property_names[valid_object_names] = "valid_object_names"
    _property_names[min_time] = "min_time"
    _property_names[waypoint_time] = "waypoint_time"
    _property_names[minimize_site_procedure_time_diff] = "minimize_site_procedure_time_diff"
    _property_names[max_time] = "max_time"
    _property_names[offset_mode] = "offset_mode"
    _property_names[bearing] = "bearing"
    _property_names[use_magnetic_bearing] = "use_magnetic_bearing"
    _property_names[range] = "range"
    _property_names[vgt_point] = "vgt_point"

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

agcls.AgClassCatalog.add_catalog_entry((4708768213832241837, 15242180819678770347), SiteSTKObjectWaypoint)
agcls.AgTypeNameMap["SiteSTKObjectWaypoint"] = SiteSTKObjectWaypoint

class SiteSTKStaticObject(ISite, SupportsDeleteCallback):
    """Interface used to access the options for a STK Static Object site."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_object_name_method_offset = 1
    _set_object_name_method_offset = 2
    _get_valid_object_names_method_offset = 3
    _get_as_site_method_offset = 4
    _metadata = {
        "iid_data" : (5314851912555770583, 18348917179993581711),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteSTKStaticObject)

    _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 object name to link to."""
        return self._intf.get_property(SiteSTKStaticObject._metadata, SiteSTKStaticObject._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:
        """Get or set the object name to link to."""
        return self._intf.set_property(SiteSTKStaticObject._metadata, SiteSTKStaticObject._set_object_name_metadata, value)

    _get_valid_object_names_metadata = { "offset" : _get_valid_object_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def valid_object_names(self) -> list:
        """Return the valid object names."""
        return self._intf.get_property(SiteSTKStaticObject._metadata, SiteSTKStaticObject._get_valid_object_names_metadata)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteSTKStaticObject._metadata, SiteSTKStaticObject._get_as_site_metadata, OutArg())

    _property_names[object_name] = "object_name"
    _property_names[valid_object_names] = "valid_object_names"

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

agcls.AgClassCatalog.add_catalog_entry((5632434088179407466, 7029154613056126903), SiteSTKStaticObject)
agcls.AgTypeNameMap["SiteSTKStaticObject"] = SiteSTKStaticObject

class SiteRelativeToSTKObject(ISite, SupportsDeleteCallback):
    """Interface used to access the options for a Relative to Stationary STK Object site."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_object_name_method_offset = 1
    _set_object_name_method_offset = 2
    _get_valid_object_names_method_offset = 3
    _get_bearing_method_offset = 4
    _set_bearing_method_offset = 5
    _get_use_magnetic_bearing_method_offset = 6
    _set_use_magnetic_bearing_method_offset = 7
    _get_range_method_offset = 8
    _set_range_method_offset = 9
    _get_as_site_method_offset = 10
    _metadata = {
        "iid_data" : (5151549297227299121, 9177416622143414688),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteRelativeToSTKObject)

    _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 object name to link to."""
        return self._intf.get_property(SiteRelativeToSTKObject._metadata, SiteRelativeToSTKObject._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:
        """Get or set the object name to link to."""
        return self._intf.set_property(SiteRelativeToSTKObject._metadata, SiteRelativeToSTKObject._set_object_name_metadata, value)

    _get_valid_object_names_metadata = { "offset" : _get_valid_object_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def valid_object_names(self) -> list:
        """Return the valid object names."""
        return self._intf.get_property(SiteRelativeToSTKObject._metadata, SiteRelativeToSTKObject._get_valid_object_names_metadata)

    _get_bearing_metadata = { "offset" : _get_bearing_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def bearing(self) -> typing.Any:
        """Get or set the bearing from the STK object."""
        return self._intf.get_property(SiteRelativeToSTKObject._metadata, SiteRelativeToSTKObject._get_bearing_metadata)

    _set_bearing_metadata = { "offset" : _set_bearing_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @bearing.setter
    def bearing(self, value:typing.Any) -> None:
        """Get or set the bearing from the STK object."""
        return self._intf.set_property(SiteRelativeToSTKObject._metadata, SiteRelativeToSTKObject._set_bearing_metadata, value)

    _get_use_magnetic_bearing_metadata = { "offset" : _get_use_magnetic_bearing_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_magnetic_bearing(self) -> bool:
        """Get or set the option to use a magnetic bearing."""
        return self._intf.get_property(SiteRelativeToSTKObject._metadata, SiteRelativeToSTKObject._get_use_magnetic_bearing_metadata)

    _set_use_magnetic_bearing_metadata = { "offset" : _set_use_magnetic_bearing_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_magnetic_bearing.setter
    def use_magnetic_bearing(self, value:bool) -> None:
        """Get or set the option to use a magnetic bearing."""
        return self._intf.set_property(SiteRelativeToSTKObject._metadata, SiteRelativeToSTKObject._set_use_magnetic_bearing_metadata, value)

    _get_range_metadata = { "offset" : _get_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def range(self) -> float:
        """Get or set the range from the STK object."""
        return self._intf.get_property(SiteRelativeToSTKObject._metadata, SiteRelativeToSTKObject._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:
        """Get or set the range from the STK object."""
        return self._intf.set_property(SiteRelativeToSTKObject._metadata, SiteRelativeToSTKObject._set_range_metadata, value)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteRelativeToSTKObject._metadata, SiteRelativeToSTKObject._get_as_site_metadata, OutArg())

    _property_names[object_name] = "object_name"
    _property_names[valid_object_names] = "valid_object_names"
    _property_names[bearing] = "bearing"
    _property_names[use_magnetic_bearing] = "use_magnetic_bearing"
    _property_names[range] = "range"

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

agcls.AgClassCatalog.add_catalog_entry((5732220974452340660, 18011894982964506785), SiteRelativeToSTKObject)
agcls.AgTypeNameMap["SiteRelativeToSTKObject"] = SiteRelativeToSTKObject

class SiteSTKAreaTarget(ISite, SupportsDeleteCallback):
    """Interface used to access the options for a STK Area Target site."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_object_name_method_offset = 1
    _set_object_name_method_offset = 2
    _get_valid_object_names_method_offset = 3
    _get_as_site_method_offset = 4
    _metadata = {
        "iid_data" : (4695342907041492328, 2553066883356031928),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteSTKAreaTarget)

    _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 object name to link to."""
        return self._intf.get_property(SiteSTKAreaTarget._metadata, SiteSTKAreaTarget._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:
        """Get or set the object name to link to."""
        return self._intf.set_property(SiteSTKAreaTarget._metadata, SiteSTKAreaTarget._set_object_name_metadata, value)

    _get_valid_object_names_metadata = { "offset" : _get_valid_object_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def valid_object_names(self) -> list:
        """Return the valid object names."""
        return self._intf.get_property(SiteSTKAreaTarget._metadata, SiteSTKAreaTarget._get_valid_object_names_metadata)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteSTKAreaTarget._metadata, SiteSTKAreaTarget._get_as_site_metadata, OutArg())

    _property_names[object_name] = "object_name"
    _property_names[valid_object_names] = "valid_object_names"

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

agcls.AgClassCatalog.add_catalog_entry((4643775838845076022, 17375698151001436338), SiteSTKAreaTarget)
agcls.AgTypeNameMap["SiteSTKAreaTarget"] = SiteSTKAreaTarget

class SiteRunway(ISite, SupportsDeleteCallback):
    """
    Interface used to access the options for a Runway site type.

    Examples
    --------
    Configure a runway site:
    >>> # SiteRunway runway: Runway object
    >>> # Set the latitude, longitude, and altitude
    >>> runway.latitude = 41
    >>> runway.longitude = 77
    >>> runway.altitude = 5
    >>>
    >>> # Set the altitude reference
    >>> runway.altitude_reference = AGLMSL.ALTITUDE_MSL
    >>>
    >>> # Set the heading
    >>> runway.high_end_heading = 195
    >>> # Opt to use true heading
    >>> runway.is_magnetic = False
    >>>
    >>> # Set the length of the runway
    >>> runway.length = 5
    >>>
    >>> # Rename the runway
    >>> runway.name = "New User Runway"
    >>> # Add the runway to the catalog to use it for next time
    >>> runway.add_to_catalog(1)

    Configure a runway site from a runway in the Aviator catalog:
    >>> # SiteRunway runway: Runway object
    >>> # Catalog catalog: Aviator catalog object
    >>> # Get the source of user runways
    >>> userRunways = catalog.runway_category.user_runways
    >>> # Check that the runway exists in the catalog
    >>> if userRunways.contains("New User Runway") is True:
    >>>     # If so, get the user runway with the given name
    >>>     runwayFromCatalog = userRunways.get_user_runway("New User Runway")
    >>>     # Copy the parameters of that runway
    >>>     runway.copy_from_catalog(runwayFromCatalog)
    """

    _num_methods = 19
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_method_offset = 1
    _set_altitude_method_offset = 2
    _get_latitude_method_offset = 3
    _set_latitude_method_offset = 4
    _get_longitude_method_offset = 5
    _set_longitude_method_offset = 6
    _get_length_method_offset = 7
    _set_length_method_offset = 8
    _get_altitude_reference_method_offset = 9
    _set_altitude_reference_method_offset = 10
    _get_low_end_heading_method_offset = 11
    _set_low_end_heading_method_offset = 12
    _get_high_end_heading_method_offset = 13
    _set_high_end_heading_method_offset = 14
    _get_is_magnetic_method_offset = 15
    _set_is_magnetic_method_offset = 16
    _add_to_catalog_method_offset = 17
    _copy_from_catalog_method_offset = 18
    _get_as_site_method_offset = 19
    _metadata = {
        "iid_data" : (5308502759604380100, 9664305760779056786),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteRunway)

    _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 runway altitude."""
        return self._intf.get_property(SiteRunway._metadata, SiteRunway._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:
        """Get or set the runway altitude."""
        return self._intf.set_property(SiteRunway._metadata, SiteRunway._set_altitude_metadata, value)

    _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 runway latitude."""
        return self._intf.get_property(SiteRunway._metadata, SiteRunway._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:
        """Get or set the runway latitude."""
        return self._intf.set_property(SiteRunway._metadata, SiteRunway._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 runway longitude."""
        return self._intf.get_property(SiteRunway._metadata, SiteRunway._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:
        """Get or set the runway longitude."""
        return self._intf.set_property(SiteRunway._metadata, SiteRunway._set_longitude_metadata, value)

    _get_length_metadata = { "offset" : _get_length_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def length(self) -> float:
        """Get or set the length of the runway."""
        return self._intf.get_property(SiteRunway._metadata, SiteRunway._get_length_metadata)

    _set_length_metadata = { "offset" : _set_length_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @length.setter
    def length(self, value:float) -> None:
        """Get or set the length of the runway."""
        return self._intf.set_property(SiteRunway._metadata, SiteRunway._set_length_metadata, value)

    _get_altitude_reference_metadata = { "offset" : _get_altitude_reference_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AGLMSL),) }
    @property
    def altitude_reference(self) -> "AGLMSL":
        """Get or set the altitude reference for the runway."""
        return self._intf.get_property(SiteRunway._metadata, SiteRunway._get_altitude_reference_metadata)

    _set_altitude_reference_metadata = { "offset" : _set_altitude_reference_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AGLMSL),) }
    @altitude_reference.setter
    def altitude_reference(self, value:"AGLMSL") -> None:
        """Get or set the altitude reference for the runway."""
        return self._intf.set_property(SiteRunway._metadata, SiteRunway._set_altitude_reference_metadata, value)

    _get_low_end_heading_metadata = { "offset" : _get_low_end_heading_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def low_end_heading(self) -> typing.Any:
        """Get or set the low end heading of the runway."""
        return self._intf.get_property(SiteRunway._metadata, SiteRunway._get_low_end_heading_metadata)

    _set_low_end_heading_metadata = { "offset" : _set_low_end_heading_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @low_end_heading.setter
    def low_end_heading(self, value:typing.Any) -> None:
        """Get or set the low end heading of the runway."""
        return self._intf.set_property(SiteRunway._metadata, SiteRunway._set_low_end_heading_metadata, value)

    _get_high_end_heading_metadata = { "offset" : _get_high_end_heading_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def high_end_heading(self) -> typing.Any:
        """Get or set the high end heading of the runway."""
        return self._intf.get_property(SiteRunway._metadata, SiteRunway._get_high_end_heading_metadata)

    _set_high_end_heading_metadata = { "offset" : _set_high_end_heading_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @high_end_heading.setter
    def high_end_heading(self, value:typing.Any) -> None:
        """Get or set the high end heading of the runway."""
        return self._intf.set_property(SiteRunway._metadata, SiteRunway._set_high_end_heading_metadata, value)

    _get_is_magnetic_metadata = { "offset" : _get_is_magnetic_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def is_magnetic(self) -> bool:
        """Opt whether to use a magnetic heading for the runway heading."""
        return self._intf.get_property(SiteRunway._metadata, SiteRunway._get_is_magnetic_metadata)

    _set_is_magnetic_metadata = { "offset" : _set_is_magnetic_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @is_magnetic.setter
    def is_magnetic(self, value:bool) -> None:
        """Opt whether to use a magnetic heading for the runway heading."""
        return self._intf.set_property(SiteRunway._metadata, SiteRunway._set_is_magnetic_metadata, value)

    _add_to_catalog_metadata = { "offset" : _add_to_catalog_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    def add_to_catalog(self, overwrite:bool) -> None:
        """Add the runway to the catalog."""
        return self._intf.invoke(SiteRunway._metadata, SiteRunway._add_to_catalog_metadata, overwrite)

    _copy_from_catalog_metadata = { "offset" : _copy_from_catalog_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("ICatalogRunway"),) }
    def copy_from_catalog(self, runway:"ICatalogRunway") -> None:
        """Copy the information from the runway stored in the catalog."""
        return self._intf.invoke(SiteRunway._metadata, SiteRunway._copy_from_catalog_metadata, runway)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteRunway._metadata, SiteRunway._get_as_site_metadata, OutArg())

    _property_names[altitude] = "altitude"
    _property_names[latitude] = "latitude"
    _property_names[longitude] = "longitude"
    _property_names[length] = "length"
    _property_names[altitude_reference] = "altitude_reference"
    _property_names[low_end_heading] = "low_end_heading"
    _property_names[high_end_heading] = "high_end_heading"
    _property_names[is_magnetic] = "is_magnetic"

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

agcls.AgClassCatalog.add_catalog_entry((5138752020114409457, 17128394562080548993), SiteRunway)
agcls.AgTypeNameMap["SiteRunway"] = SiteRunway

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

agcls.AgClassCatalog.add_catalog_entry((4930703979729104237, 439084692498343612), Site)
agcls.AgTypeNameMap["Site"] = Site

class ProcedureLanding(IProcedure, SupportsDeleteCallback):
    """
    Interface used to access the options for a landing procedure.

    Examples
    --------
    Add and configure a landing procedure:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add a landing procedure
    >>> landing = procedures.add(SiteType.SITE_RUNWAY, ProcedureType.PROCEDURE_LANDING)
    >>>
    >>> # Get the runway heading options
    >>> headingOptions = landing.runway_heading_options
    >>> # Land from the low end
    >>> headingOptions.runway_mode = RunwayHighLowEnd.LOW_END
    >>>
    >>> # Use a standard instrument approach
    >>> landing.approach_mode = ApproachMode.STANDARD_INSTRUMENT_APPROACH
    >>> # Get the options for a standard instrument approach
    >>> sia = landing.mode_as_standard_instrument_approach
    >>> # Change the approach altitude
    >>> sia.approach_altitude = 1000
    >>> # Change the glideslope
    >>> sia.glideslope = 4
    >>> # Offset the runway altitude
    >>> sia.runway_altitude_offset = 10
    >>> # Use the terrain as an altitude reference for the runway
    >>> sia.use_runway_terrain = True
    """

    _num_methods = 11
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_mode_as_standard_instrument_approach_method_offset = 1
    _get_mode_as_intercept_glideslope_method_offset = 2
    _get_mode_as_enter_downwind_pattern_method_offset = 3
    _get_runway_heading_options_method_offset = 4
    _get_enroute_cruise_airspeed_options_method_offset = 5
    _get_enroute_turn_direction_options_method_offset = 6
    _get_enroute_options_method_offset = 7
    _get_vertical_plane_options_method_offset = 8
    _get_approach_mode_method_offset = 9
    _set_approach_mode_method_offset = 10
    _get_as_procedure_method_offset = 11
    _metadata = {
        "iid_data" : (5173821936820820516, 1444667070054508934),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureLanding)

    _get_mode_as_standard_instrument_approach_metadata = { "offset" : _get_mode_as_standard_instrument_approach_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_standard_instrument_approach(self) -> "LandingStandardInstrumentApproach":
        """Get the interface for a standard instrument approach landing."""
        return self._intf.get_property(ProcedureLanding._metadata, ProcedureLanding._get_mode_as_standard_instrument_approach_metadata)

    _get_mode_as_intercept_glideslope_metadata = { "offset" : _get_mode_as_intercept_glideslope_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_intercept_glideslope(self) -> "LandingInterceptGlideslope":
        """Get the interface for an intercept glideslope landing."""
        return self._intf.get_property(ProcedureLanding._metadata, ProcedureLanding._get_mode_as_intercept_glideslope_metadata)

    _get_mode_as_enter_downwind_pattern_metadata = { "offset" : _get_mode_as_enter_downwind_pattern_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_enter_downwind_pattern(self) -> "LandingEnterDownwindPattern":
        """Get the interface for a downwind pattern landing."""
        return self._intf.get_property(ProcedureLanding._metadata, ProcedureLanding._get_mode_as_enter_downwind_pattern_metadata)

    _get_runway_heading_options_metadata = { "offset" : _get_runway_heading_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def runway_heading_options(self) -> "RunwayHeadingOptions":
        """Get the runway heading options."""
        return self._intf.get_property(ProcedureLanding._metadata, ProcedureLanding._get_runway_heading_options_metadata)

    _get_enroute_cruise_airspeed_options_metadata = { "offset" : _get_enroute_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_cruise_airspeed_options(self) -> "ICruiseAirspeedAndProfileOptions":
        """Get the enroute cruise airspeed options."""
        return self._intf.get_property(ProcedureLanding._metadata, ProcedureLanding._get_enroute_cruise_airspeed_options_metadata)

    _get_enroute_turn_direction_options_metadata = { "offset" : _get_enroute_turn_direction_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_turn_direction_options(self) -> "EnrouteTurnDirectionOptions":
        """Get the enroute turn direction options."""
        return self._intf.get_property(ProcedureLanding._metadata, ProcedureLanding._get_enroute_turn_direction_options_metadata)

    _get_enroute_options_metadata = { "offset" : _get_enroute_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_options(self) -> "IEnrouteAndDelayOptions":
        """Get the enroute options."""
        return self._intf.get_property(ProcedureLanding._metadata, ProcedureLanding._get_enroute_options_metadata)

    _get_vertical_plane_options_metadata = { "offset" : _get_vertical_plane_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def vertical_plane_options(self) -> "IVerticalPlaneOptions":
        """Get the vertical plane options."""
        return self._intf.get_property(ProcedureLanding._metadata, ProcedureLanding._get_vertical_plane_options_metadata)

    _get_approach_mode_metadata = { "offset" : _get_approach_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ApproachMode),) }
    @property
    def approach_mode(self) -> "ApproachMode":
        """Get or set the type of landing the aircraft will perform."""
        return self._intf.get_property(ProcedureLanding._metadata, ProcedureLanding._get_approach_mode_metadata)

    _set_approach_mode_metadata = { "offset" : _set_approach_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ApproachMode),) }
    @approach_mode.setter
    def approach_mode(self, value:"ApproachMode") -> None:
        """Get or set the type of landing the aircraft will perform."""
        return self._intf.set_property(ProcedureLanding._metadata, ProcedureLanding._set_approach_mode_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureLanding._metadata, ProcedureLanding._get_as_procedure_metadata, OutArg())

    _property_names[mode_as_standard_instrument_approach] = "mode_as_standard_instrument_approach"
    _property_names[mode_as_intercept_glideslope] = "mode_as_intercept_glideslope"
    _property_names[mode_as_enter_downwind_pattern] = "mode_as_enter_downwind_pattern"
    _property_names[runway_heading_options] = "runway_heading_options"
    _property_names[enroute_cruise_airspeed_options] = "enroute_cruise_airspeed_options"
    _property_names[enroute_turn_direction_options] = "enroute_turn_direction_options"
    _property_names[enroute_options] = "enroute_options"
    _property_names[vertical_plane_options] = "vertical_plane_options"
    _property_names[approach_mode] = "approach_mode"

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

agcls.AgClassCatalog.add_catalog_entry((5217645111817093152, 16954556210728333749), ProcedureLanding)
agcls.AgTypeNameMap["ProcedureLanding"] = ProcedureLanding

class ProcedureEnroute(IProcedure, SupportsDeleteCallback):
    """
    Interface used to access the options for an enroute procedure.

    Examples
    --------
    Add and configure an en-route procedure:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add an enroute procedure with a site type of End of Previous Procedure
    >>> enroute = procedures.add_at_index(1, SiteType.SITE_END_OF_PREV_PROCEDURE, ProcedureType.PROCEDURE_ENROUTE)
    >>> # Get the altitude options
    >>> altitudeOptions = enroute.altitude_msl_options
    >>> # To specify an altitude, turn off the option to use the default cruise altitude
    >>> altitudeOptions.use_default_cruise_altitude = False
    >>> # Set the altitude
    >>> altitudeOptions.msl_altitude = 10000
    >>>
    >>> # Get the navigation options
    >>> navigationOptions = enroute.navigation_options
    >>> # Set the route to arrive on a specified course
    >>> navigationOptions.navigation_mode = PointToPointMode.ARRIVE_ON_COURSE
    >>> # Set the course
    >>> navigationOptions.arrive_on_course = 30
    >>> # Use a magnetic heading
    >>> navigationOptions.use_magnetic_heading = True
    >>>
    >>> # Get the navigation options
    >>> airspeedOptions = enroute.enroute_cruise_airspeed_options
    >>> # Fly at max speed
    >>> airspeedOptions.cruise_speed_type = CruiseSpeed.MAX_AIRSPEED
    >>> # To specify an airspeed to fly at, set the speed type to other airspeed
    >>> airspeedOptions.cruise_speed_type = CruiseSpeed.OTHER_AIRSPEED
    >>> # Then set the airspeed and airspeed type
    >>> airspeedOptions.set_other_airspeed(AirspeedType.TAS, 200)
    """

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_msl_options_method_offset = 1
    _get_navigation_options_method_offset = 2
    _get_enroute_options_method_offset = 3
    _get_enroute_cruise_airspeed_options_method_offset = 4
    _get_as_procedure_method_offset = 5
    _metadata = {
        "iid_data" : (5434799576980412844, 10892687876198075050),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureEnroute)

    _get_altitude_msl_options_metadata = { "offset" : _get_altitude_msl_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def altitude_msl_options(self) -> "AltitudeMSLAndLevelOffOptions":
        """Get the altitude MSL options."""
        return self._intf.get_property(ProcedureEnroute._metadata, ProcedureEnroute._get_altitude_msl_options_metadata)

    _get_navigation_options_metadata = { "offset" : _get_navigation_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def navigation_options(self) -> "NavigationOptions":
        """Get the navigation options."""
        return self._intf.get_property(ProcedureEnroute._metadata, ProcedureEnroute._get_navigation_options_metadata)

    _get_enroute_options_metadata = { "offset" : _get_enroute_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_options(self) -> "IEnrouteAndDelayOptions":
        """Get the enroute options."""
        return self._intf.get_property(ProcedureEnroute._metadata, ProcedureEnroute._get_enroute_options_metadata)

    _get_enroute_cruise_airspeed_options_metadata = { "offset" : _get_enroute_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the enroute cruise airspeed options."""
        return self._intf.get_property(ProcedureEnroute._metadata, ProcedureEnroute._get_enroute_cruise_airspeed_options_metadata)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureEnroute._metadata, ProcedureEnroute._get_as_procedure_metadata, OutArg())

    _property_names[altitude_msl_options] = "altitude_msl_options"
    _property_names[navigation_options] = "navigation_options"
    _property_names[enroute_options] = "enroute_options"
    _property_names[enroute_cruise_airspeed_options] = "enroute_cruise_airspeed_options"

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

agcls.AgClassCatalog.add_catalog_entry((5519935132979626266, 10381875481096635325), ProcedureEnroute)
agcls.AgTypeNameMap["ProcedureEnroute"] = ProcedureEnroute

class ProcedureExtEphem(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for an ExtEphem procedure."""

    _num_methods = 29
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _set_ephemeris_file_method_offset = 1
    _get_ephemeris_file_method_offset = 2
    _get_ephemeris_file_duration_method_offset = 3
    _set_use_start_duration_method_offset = 4
    _get_use_start_duration_method_offset = 5
    _set_start_time_method_offset = 6
    _get_start_time_method_offset = 7
    _set_duration_method_offset = 8
    _get_duration_method_offset = 9
    _get_flight_mode_method_offset = 10
    _set_flight_mode_method_offset = 11
    _get_as_procedure_method_offset = 12
    _set_use_shift_rotate_method_offset = 13
    _get_use_shift_rotate_method_offset = 14
    _get_shift_time_method_offset = 15
    _set_shift_time_method_offset = 16
    _get_latitude_method_offset = 17
    _set_latitude_method_offset = 18
    _get_longitude_method_offset = 19
    _set_longitude_method_offset = 20
    _get_altitude_method_offset = 21
    _set_altitude_method_offset = 22
    _get_course_method_offset = 23
    _set_course_method_offset = 24
    _get_course_mode_method_offset = 25
    _set_course_mode_method_offset = 26
    _get_altitude_mode_method_offset = 27
    _set_altitude_mode_method_offset = 28
    _shift_rotate_set_method_offset = 29
    _metadata = {
        "iid_data" : (4706318164488420241, 10859321374984907949),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureExtEphem)

    _get_ephemeris_file_metadata = { "offset" : _get_ephemeris_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def ephemeris_file(self) -> str:
        """Get the ephemeris filename."""
        return self._intf.get_property(ProcedureExtEphem._metadata, ProcedureExtEphem._get_ephemeris_file_metadata)

    _set_ephemeris_file_metadata = { "offset" : _set_ephemeris_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @ephemeris_file.setter
    def ephemeris_file(self, value:str) -> None:
        """Set the ephemeris filename."""
        return self._intf.set_property(ProcedureExtEphem._metadata, ProcedureExtEphem._set_ephemeris_file_metadata, value)

    _get_ephemeris_file_duration_metadata = { "offset" : _get_ephemeris_file_duration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def ephemeris_file_duration(self) -> float:
        """Get the ephemeris file duration."""
        return self._intf.get_property(ProcedureExtEphem._metadata, ProcedureExtEphem._get_ephemeris_file_duration_metadata)

    _get_use_start_duration_metadata = { "offset" : _get_use_start_duration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_start_duration(self) -> bool:
        """Get whether to use Start and Duration."""
        return self._intf.get_property(ProcedureExtEphem._metadata, ProcedureExtEphem._get_use_start_duration_metadata)

    _set_use_start_duration_metadata = { "offset" : _set_use_start_duration_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_start_duration.setter
    def use_start_duration(self, use_sd:bool) -> None:
        """Set whether to use Start and Duration."""
        return self._intf.set_property(ProcedureExtEphem._metadata, ProcedureExtEphem._set_use_start_duration_metadata, use_sd)

    _get_start_time_metadata = { "offset" : _get_start_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def start_time(self) -> float:
        """Get the start time."""
        return self._intf.get_property(ProcedureExtEphem._metadata, ProcedureExtEphem._get_start_time_metadata)

    _set_start_time_metadata = { "offset" : _set_start_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @start_time.setter
    def start_time(self, start:float) -> None:
        """Set the start time."""
        return self._intf.set_property(ProcedureExtEphem._metadata, ProcedureExtEphem._set_start_time_metadata, start)

    _get_duration_metadata = { "offset" : _get_duration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def duration(self) -> float:
        """Get the duration."""
        return self._intf.get_property(ProcedureExtEphem._metadata, ProcedureExtEphem._get_duration_metadata)

    _set_duration_metadata = { "offset" : _set_duration_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @duration.setter
    def duration(self, start:float) -> None:
        """Set the duration."""
        return self._intf.set_property(ProcedureExtEphem._metadata, ProcedureExtEphem._set_duration_metadata, start)

    _get_flight_mode_metadata = { "offset" : _get_flight_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ExtEphemFlightMode),) }
    @property
    def flight_mode(self) -> "ExtEphemFlightMode":
        """Get the flight mode."""
        return self._intf.get_property(ProcedureExtEphem._metadata, ProcedureExtEphem._get_flight_mode_metadata)

    _set_flight_mode_metadata = { "offset" : _set_flight_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ExtEphemFlightMode),) }
    @flight_mode.setter
    def flight_mode(self, mode:"ExtEphemFlightMode") -> None:
        """Set the flight mode."""
        return self._intf.set_property(ProcedureExtEphem._metadata, ProcedureExtEphem._set_flight_mode_metadata, mode)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureExtEphem._metadata, ProcedureExtEphem._get_as_procedure_metadata, OutArg())

    _get_use_shift_rotate_metadata = { "offset" : _get_use_shift_rotate_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_shift_rotate(self) -> bool:
        """Get whether to use Shift/Rotate."""
        return self._intf.get_property(ProcedureExtEphem._metadata, ProcedureExtEphem._get_use_shift_rotate_metadata)

    _set_use_shift_rotate_metadata = { "offset" : _set_use_shift_rotate_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_shift_rotate.setter
    def use_shift_rotate(self, use_sd:bool) -> None:
        """Set whether to use Shift/Rotate."""
        return self._intf.set_property(ProcedureExtEphem._metadata, ProcedureExtEphem._set_use_shift_rotate_metadata, use_sd)

    _get_shift_time_metadata = { "offset" : _get_shift_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def shift_time(self) -> float:
        """Get the shift time."""
        return self._intf.get_property(ProcedureExtEphem._metadata, ProcedureExtEphem._get_shift_time_metadata)

    _set_shift_time_metadata = { "offset" : _set_shift_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @shift_time.setter
    def shift_time(self, value:float) -> None:
        """Set the shift time."""
        return self._intf.set_property(ProcedureExtEphem._metadata, ProcedureExtEphem._set_shift_time_metadata, value)

    _get_latitude_metadata = { "offset" : _get_latitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def latitude(self) -> float:
        """Get the waypoint latitude."""
        return self._intf.get_property(ProcedureExtEphem._metadata, ProcedureExtEphem._get_latitude_metadata)

    _set_latitude_metadata = { "offset" : _set_latitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @latitude.setter
    def latitude(self, value:float) -> None:
        """Set the waypoint latitude."""
        return self._intf.set_property(ProcedureExtEphem._metadata, ProcedureExtEphem._set_latitude_metadata, value)

    _get_longitude_metadata = { "offset" : _get_longitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def longitude(self) -> float:
        """Get the waypoint longitude."""
        return self._intf.get_property(ProcedureExtEphem._metadata, ProcedureExtEphem._get_longitude_metadata)

    _set_longitude_metadata = { "offset" : _set_longitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @longitude.setter
    def longitude(self, value:float) -> None:
        """Set the waypoint longitude."""
        return self._intf.set_property(ProcedureExtEphem._metadata, ProcedureExtEphem._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 the altitude."""
        return self._intf.get_property(ProcedureExtEphem._metadata, ProcedureExtEphem._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:
        """Set the altitude."""
        return self._intf.set_property(ProcedureExtEphem._metadata, ProcedureExtEphem._set_altitude_metadata, value)

    _get_course_metadata = { "offset" : _get_course_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def course(self) -> float:
        """Get the course."""
        return self._intf.get_property(ProcedureExtEphem._metadata, ProcedureExtEphem._get_course_metadata)

    _set_course_metadata = { "offset" : _set_course_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @course.setter
    def course(self, value:float) -> None:
        """Set the course."""
        return self._intf.set_property(ProcedureExtEphem._metadata, ProcedureExtEphem._set_course_metadata, value)

    _get_course_mode_metadata = { "offset" : _get_course_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(EphemShiftRotateCourseMode),) }
    @property
    def course_mode(self) -> "EphemShiftRotateCourseMode":
        """Get the course mode."""
        return self._intf.get_property(ProcedureExtEphem._metadata, ProcedureExtEphem._get_course_mode_metadata)

    _set_course_mode_metadata = { "offset" : _set_course_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(EphemShiftRotateCourseMode),) }
    @course_mode.setter
    def course_mode(self, altmode:"EphemShiftRotateCourseMode") -> None:
        """Set the course mode."""
        return self._intf.set_property(ProcedureExtEphem._metadata, ProcedureExtEphem._set_course_mode_metadata, altmode)

    _get_altitude_mode_metadata = { "offset" : _get_altitude_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(EphemShiftRotateAltitudeMode),) }
    @property
    def altitude_mode(self) -> "EphemShiftRotateAltitudeMode":
        """Get the alt mode."""
        return self._intf.get_property(ProcedureExtEphem._metadata, ProcedureExtEphem._get_altitude_mode_metadata)

    _set_altitude_mode_metadata = { "offset" : _set_altitude_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(EphemShiftRotateAltitudeMode),) }
    @altitude_mode.setter
    def altitude_mode(self, altmode:"EphemShiftRotateAltitudeMode") -> None:
        """Set the alt mode."""
        return self._intf.set_property(ProcedureExtEphem._metadata, ProcedureExtEphem._set_altitude_mode_metadata, altmode)

    _shift_rotate_set_metadata = { "offset" : _shift_rotate_set_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def shift_rotate_set(self) -> None:
        """Shift rotate set values."""
        return self._intf.invoke(ProcedureExtEphem._metadata, ProcedureExtEphem._shift_rotate_set_metadata, )

    _property_names[ephemeris_file] = "ephemeris_file"
    _property_names[ephemeris_file_duration] = "ephemeris_file_duration"
    _property_names[use_start_duration] = "use_start_duration"
    _property_names[start_time] = "start_time"
    _property_names[duration] = "duration"
    _property_names[flight_mode] = "flight_mode"
    _property_names[use_shift_rotate] = "use_shift_rotate"
    _property_names[shift_time] = "shift_time"
    _property_names[latitude] = "latitude"
    _property_names[longitude] = "longitude"
    _property_names[altitude] = "altitude"
    _property_names[course] = "course"
    _property_names[course_mode] = "course_mode"
    _property_names[altitude_mode] = "altitude_mode"

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

agcls.AgClassCatalog.add_catalog_entry((5229605635028001773, 1223198393308242336), ProcedureExtEphem)
agcls.AgTypeNameMap["ProcedureExtEphem"] = ProcedureExtEphem

class ProcedureFormationFlyer(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for an enroute procedure."""

    _num_methods = 19
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_min_time_step_method_offset = 1
    _set_min_time_step_method_offset = 2
    _get_max_time_step_method_offset = 3
    _set_max_time_step_method_offset = 4
    _get_cross_range_close_rate_method_offset = 5
    _set_cross_range_close_rate_method_offset = 6
    _get_initial_close_max_speed_advantage_method_offset = 7
    _set_initial_close_max_speed_advantage_method_offset = 8
    _get_stop_condition_method_offset = 9
    _set_stop_condition_method_offset = 10
    _get_stop_time_method_offset = 11
    _set_stop_time_method_offset = 12
    _get_stop_down_range_method_offset = 13
    _set_stop_down_range_method_offset = 14
    _get_stop_fuel_state_method_offset = 15
    _set_stop_fuel_state_method_offset = 16
    _get_as_procedure_method_offset = 17
    _set_stop_on_hover_method_offset = 18
    _get_stop_on_hover_method_offset = 19
    _metadata = {
        "iid_data" : (4637041047160961161, 14166705763825796783),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureFormationFlyer)

    _get_min_time_step_metadata = { "offset" : _get_min_time_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_time_step(self) -> float:
        """Get Min time Step."""
        return self._intf.get_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._get_min_time_step_metadata)

    _set_min_time_step_metadata = { "offset" : _set_min_time_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_time_step.setter
    def min_time_step(self, value:float) -> None:
        """Set Min time Step."""
        return self._intf.set_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._set_min_time_step_metadata, value)

    _get_max_time_step_metadata = { "offset" : _get_max_time_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_time_step(self) -> float:
        """Get Max time Step."""
        return self._intf.get_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._get_max_time_step_metadata)

    _set_max_time_step_metadata = { "offset" : _set_max_time_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_time_step.setter
    def max_time_step(self, value:float) -> None:
        """Set Max time Step."""
        return self._intf.set_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._set_max_time_step_metadata, value)

    _get_cross_range_close_rate_metadata = { "offset" : _get_cross_range_close_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cross_range_close_rate(self) -> float:
        """Get Cross Range close rate."""
        return self._intf.get_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._get_cross_range_close_rate_metadata)

    _set_cross_range_close_rate_metadata = { "offset" : _set_cross_range_close_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cross_range_close_rate.setter
    def cross_range_close_rate(self, value:float) -> None:
        """Set Cross Range close rate."""
        return self._intf.set_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._set_cross_range_close_rate_metadata, value)

    _get_initial_close_max_speed_advantage_metadata = { "offset" : _get_initial_close_max_speed_advantage_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def initial_close_max_speed_advantage(self) -> float:
        """Get Initial Close Max Speed Advantage."""
        return self._intf.get_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._get_initial_close_max_speed_advantage_metadata)

    _set_initial_close_max_speed_advantage_metadata = { "offset" : _set_initial_close_max_speed_advantage_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @initial_close_max_speed_advantage.setter
    def initial_close_max_speed_advantage(self, value:float) -> None:
        """Set Initial Close Max Speed Advantage."""
        return self._intf.set_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._set_initial_close_max_speed_advantage_metadata, value)

    _get_stop_condition_metadata = { "offset" : _get_stop_condition_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(FormationFlyerStopCondition),) }
    @property
    def stop_condition(self) -> "FormationFlyerStopCondition":
        """Get Stop condition."""
        return self._intf.get_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._get_stop_condition_metadata)

    _set_stop_condition_metadata = { "offset" : _set_stop_condition_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(FormationFlyerStopCondition),) }
    @stop_condition.setter
    def stop_condition(self, value:"FormationFlyerStopCondition") -> None:
        """Set Stop condition."""
        return self._intf.set_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._set_stop_condition_metadata, value)

    _get_stop_time_metadata = { "offset" : _get_stop_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stop_time(self) -> float:
        """Get stop time."""
        return self._intf.get_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._get_stop_time_metadata)

    _set_stop_time_metadata = { "offset" : _set_stop_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @stop_time.setter
    def stop_time(self, value:float) -> None:
        """Set stop time."""
        return self._intf.set_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._set_stop_time_metadata, value)

    _get_stop_down_range_metadata = { "offset" : _get_stop_down_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stop_down_range(self) -> float:
        """Get stop downrange."""
        return self._intf.get_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._get_stop_down_range_metadata)

    _set_stop_down_range_metadata = { "offset" : _set_stop_down_range_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @stop_down_range.setter
    def stop_down_range(self, value:float) -> None:
        """Set stop downrange."""
        return self._intf.set_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._set_stop_down_range_metadata, value)

    _get_stop_fuel_state_metadata = { "offset" : _get_stop_fuel_state_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stop_fuel_state(self) -> float:
        """Get stop fuel state."""
        return self._intf.get_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._get_stop_fuel_state_metadata)

    _set_stop_fuel_state_metadata = { "offset" : _set_stop_fuel_state_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @stop_fuel_state.setter
    def stop_fuel_state(self, value:float) -> None:
        """Set stop fuel state."""
        return self._intf.set_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._set_stop_fuel_state_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._get_as_procedure_metadata, OutArg())

    _get_stop_on_hover_metadata = { "offset" : _get_stop_on_hover_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def stop_on_hover(self) -> bool:
        """Get Stop on hover mode."""
        return self._intf.get_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._get_stop_on_hover_metadata)

    _set_stop_on_hover_metadata = { "offset" : _set_stop_on_hover_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @stop_on_hover.setter
    def stop_on_hover(self, stop_on_hover:bool) -> None:
        """Set Stop on hover mode."""
        return self._intf.set_property(ProcedureFormationFlyer._metadata, ProcedureFormationFlyer._set_stop_on_hover_metadata, stop_on_hover)

    _property_names[min_time_step] = "min_time_step"
    _property_names[max_time_step] = "max_time_step"
    _property_names[cross_range_close_rate] = "cross_range_close_rate"
    _property_names[initial_close_max_speed_advantage] = "initial_close_max_speed_advantage"
    _property_names[stop_condition] = "stop_condition"
    _property_names[stop_time] = "stop_time"
    _property_names[stop_down_range] = "stop_down_range"
    _property_names[stop_fuel_state] = "stop_fuel_state"
    _property_names[stop_on_hover] = "stop_on_hover"

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

agcls.AgClassCatalog.add_catalog_entry((5626350792346175468, 8231896308722198688), ProcedureFormationFlyer)
agcls.AgTypeNameMap["ProcedureFormationFlyer"] = ProcedureFormationFlyer

class ProcedureBasicPointToPoint(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a basic point to point procedure."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_options_method_offset = 1
    _get_navigation_options_method_offset = 2
    _get_enroute_options_method_offset = 3
    _get_enroute_cruise_airspeed_options_method_offset = 4
    _get_vertical_plane_options_method_offset = 5
    _get_as_procedure_method_offset = 6
    _metadata = {
        "iid_data" : (5190483266878387264, 613211873364248510),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureBasicPointToPoint)

    _get_altitude_options_metadata = { "offset" : _get_altitude_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def altitude_options(self) -> "AltitudeOptions":
        """Get the altitude options."""
        return self._intf.get_property(ProcedureBasicPointToPoint._metadata, ProcedureBasicPointToPoint._get_altitude_options_metadata)

    _get_navigation_options_metadata = { "offset" : _get_navigation_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def navigation_options(self) -> "NavigationOptions":
        """Get the navigation options."""
        return self._intf.get_property(ProcedureBasicPointToPoint._metadata, ProcedureBasicPointToPoint._get_navigation_options_metadata)

    _get_enroute_options_metadata = { "offset" : _get_enroute_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_options(self) -> "EnrouteOptions":
        """Get the enroute options."""
        return self._intf.get_property(ProcedureBasicPointToPoint._metadata, ProcedureBasicPointToPoint._get_enroute_options_metadata)

    _get_enroute_cruise_airspeed_options_metadata = { "offset" : _get_enroute_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_cruise_airspeed_options(self) -> "ICruiseAirspeedAndProfileOptions":
        """Get the enroute cruise airspeed options."""
        return self._intf.get_property(ProcedureBasicPointToPoint._metadata, ProcedureBasicPointToPoint._get_enroute_cruise_airspeed_options_metadata)

    _get_vertical_plane_options_metadata = { "offset" : _get_vertical_plane_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def vertical_plane_options(self) -> "VerticalPlaneAndFlightPathOptions":
        """Get the vertical plane options."""
        return self._intf.get_property(ProcedureBasicPointToPoint._metadata, ProcedureBasicPointToPoint._get_vertical_plane_options_metadata)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureBasicPointToPoint._metadata, ProcedureBasicPointToPoint._get_as_procedure_metadata, OutArg())

    _property_names[altitude_options] = "altitude_options"
    _property_names[navigation_options] = "navigation_options"
    _property_names[enroute_options] = "enroute_options"
    _property_names[enroute_cruise_airspeed_options] = "enroute_cruise_airspeed_options"
    _property_names[vertical_plane_options] = "vertical_plane_options"

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

agcls.AgClassCatalog.add_catalog_entry((4658651044347023593, 13646940327219296687), ProcedureBasicPointToPoint)
agcls.AgTypeNameMap["ProcedureBasicPointToPoint"] = ProcedureBasicPointToPoint

class ProcedureArcEnroute(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for an arc enroute procedure."""

    _num_methods = 7
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_options_method_offset = 1
    _get_arc_options_method_offset = 2
    _get_arc_cruise_airspeed_options_method_offset = 3
    _get_enroute_options_method_offset = 4
    _get_enroute_cruise_airspeed_options_method_offset = 5
    _get_enroute_turn_direction_options_method_offset = 6
    _get_as_procedure_method_offset = 7
    _metadata = {
        "iid_data" : (5178802862750644614, 11742865424791326105),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureArcEnroute)

    _get_altitude_options_metadata = { "offset" : _get_altitude_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def altitude_options(self) -> "ArcAltitudeAndDelayOptions":
        """Get the altitude options."""
        return self._intf.get_property(ProcedureArcEnroute._metadata, ProcedureArcEnroute._get_altitude_options_metadata)

    _get_arc_options_metadata = { "offset" : _get_arc_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def arc_options(self) -> "ArcOptions":
        """Get the arc options."""
        return self._intf.get_property(ProcedureArcEnroute._metadata, ProcedureArcEnroute._get_arc_options_metadata)

    _get_arc_cruise_airspeed_options_metadata = { "offset" : _get_arc_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def arc_cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the arc cruise airspeed options."""
        return self._intf.get_property(ProcedureArcEnroute._metadata, ProcedureArcEnroute._get_arc_cruise_airspeed_options_metadata)

    _get_enroute_options_metadata = { "offset" : _get_enroute_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_options(self) -> "IEnrouteAndDelayOptions":
        """Get the enroute options."""
        return self._intf.get_property(ProcedureArcEnroute._metadata, ProcedureArcEnroute._get_enroute_options_metadata)

    _get_enroute_cruise_airspeed_options_metadata = { "offset" : _get_enroute_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the enroute cruise airspeed options."""
        return self._intf.get_property(ProcedureArcEnroute._metadata, ProcedureArcEnroute._get_enroute_cruise_airspeed_options_metadata)

    _get_enroute_turn_direction_options_metadata = { "offset" : _get_enroute_turn_direction_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_turn_direction_options(self) -> "EnrouteTurnDirectionOptions":
        """Get the enroute turn direction options."""
        return self._intf.get_property(ProcedureArcEnroute._metadata, ProcedureArcEnroute._get_enroute_turn_direction_options_metadata)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureArcEnroute._metadata, ProcedureArcEnroute._get_as_procedure_metadata, OutArg())

    _property_names[altitude_options] = "altitude_options"
    _property_names[arc_options] = "arc_options"
    _property_names[arc_cruise_airspeed_options] = "arc_cruise_airspeed_options"
    _property_names[enroute_options] = "enroute_options"
    _property_names[enroute_cruise_airspeed_options] = "enroute_cruise_airspeed_options"
    _property_names[enroute_turn_direction_options] = "enroute_turn_direction_options"

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

agcls.AgClassCatalog.add_catalog_entry((5255200399109307333, 13934917253357422254), ProcedureArcEnroute)
agcls.AgTypeNameMap["ProcedureArcEnroute"] = ProcedureArcEnroute

class ProcedureArcPointToPoint(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for an arc point to point procedure."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_options_method_offset = 1
    _get_arc_options_method_offset = 2
    _get_arc_cruise_airspeed_options_method_offset = 3
    _get_enroute_options_method_offset = 4
    _get_enroute_cruise_airspeed_options_method_offset = 5
    _get_enroute_turn_direction_options_method_offset = 6
    _get_fly_cruise_airspeed_profile_method_offset = 7
    _set_fly_cruise_airspeed_profile_method_offset = 8
    _get_vertical_plane_options_method_offset = 9
    _get_as_procedure_method_offset = 10
    _metadata = {
        "iid_data" : (4627887812079693651, 17276351109473528244),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureArcPointToPoint)

    _get_altitude_options_metadata = { "offset" : _get_altitude_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def altitude_options(self) -> "ArcAltitudeOptions":
        """Get the altitude options."""
        return self._intf.get_property(ProcedureArcPointToPoint._metadata, ProcedureArcPointToPoint._get_altitude_options_metadata)

    _get_arc_options_metadata = { "offset" : _get_arc_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def arc_options(self) -> "ArcOptions":
        """Get the arc options."""
        return self._intf.get_property(ProcedureArcPointToPoint._metadata, ProcedureArcPointToPoint._get_arc_options_metadata)

    _get_arc_cruise_airspeed_options_metadata = { "offset" : _get_arc_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def arc_cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the arc cruise airspeed options."""
        return self._intf.get_property(ProcedureArcPointToPoint._metadata, ProcedureArcPointToPoint._get_arc_cruise_airspeed_options_metadata)

    _get_enroute_options_metadata = { "offset" : _get_enroute_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_options(self) -> "EnrouteOptions":
        """Get the enroute options."""
        return self._intf.get_property(ProcedureArcPointToPoint._metadata, ProcedureArcPointToPoint._get_enroute_options_metadata)

    _get_enroute_cruise_airspeed_options_metadata = { "offset" : _get_enroute_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the enroute cruise airspeed options."""
        return self._intf.get_property(ProcedureArcPointToPoint._metadata, ProcedureArcPointToPoint._get_enroute_cruise_airspeed_options_metadata)

    _get_enroute_turn_direction_options_metadata = { "offset" : _get_enroute_turn_direction_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_turn_direction_options(self) -> "EnrouteTurnDirectionOptions":
        """Get the enroute turn direction options."""
        return self._intf.get_property(ProcedureArcPointToPoint._metadata, ProcedureArcPointToPoint._get_enroute_turn_direction_options_metadata)

    _get_fly_cruise_airspeed_profile_metadata = { "offset" : _get_fly_cruise_airspeed_profile_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def fly_cruise_airspeed_profile(self) -> bool:
        """Opt whether the aircraft immediately adopts the selected cruise airspeed or gradually begins accelerating/decelerating in the previous procedure."""
        return self._intf.get_property(ProcedureArcPointToPoint._metadata, ProcedureArcPointToPoint._get_fly_cruise_airspeed_profile_metadata)

    _set_fly_cruise_airspeed_profile_metadata = { "offset" : _set_fly_cruise_airspeed_profile_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @fly_cruise_airspeed_profile.setter
    def fly_cruise_airspeed_profile(self, value:bool) -> None:
        """Opt whether the aircraft immediately adopts the selected cruise airspeed or gradually begins accelerating/decelerating in the previous procedure."""
        return self._intf.set_property(ProcedureArcPointToPoint._metadata, ProcedureArcPointToPoint._set_fly_cruise_airspeed_profile_metadata, value)

    _get_vertical_plane_options_metadata = { "offset" : _get_vertical_plane_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def vertical_plane_options(self) -> "ArcVerticalPlaneOptions":
        """Get the vertical plane options."""
        return self._intf.get_property(ProcedureArcPointToPoint._metadata, ProcedureArcPointToPoint._get_vertical_plane_options_metadata)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureArcPointToPoint._metadata, ProcedureArcPointToPoint._get_as_procedure_metadata, OutArg())

    _property_names[altitude_options] = "altitude_options"
    _property_names[arc_options] = "arc_options"
    _property_names[arc_cruise_airspeed_options] = "arc_cruise_airspeed_options"
    _property_names[enroute_options] = "enroute_options"
    _property_names[enroute_cruise_airspeed_options] = "enroute_cruise_airspeed_options"
    _property_names[enroute_turn_direction_options] = "enroute_turn_direction_options"
    _property_names[fly_cruise_airspeed_profile] = "fly_cruise_airspeed_profile"
    _property_names[vertical_plane_options] = "vertical_plane_options"

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

agcls.AgClassCatalog.add_catalog_entry((4700081710069607543, 13277755077444961177), ProcedureArcPointToPoint)
agcls.AgTypeNameMap["ProcedureArcPointToPoint"] = ProcedureArcPointToPoint

class ProcedureFlightLine(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a flight line procedure."""

    _num_methods = 20
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_options_method_offset = 1
    _get_fly_cruise_airspeed_profile_method_offset = 2
    _set_fly_cruise_airspeed_profile_method_offset = 3
    _get_flight_line_airspeed_options_method_offset = 4
    _get_enroute_options_method_offset = 5
    _get_enroute_turn_direction_options_method_offset = 6
    _get_enroute_cruise_airspeed_options_method_offset = 7
    _get_procedure_type_method_offset = 8
    _set_procedure_type_method_offset = 9
    _get_outbound_course_method_offset = 10
    _set_outbound_course_method_offset = 11
    _get_use_magnetic_heading_method_offset = 12
    _set_use_magnetic_heading_method_offset = 13
    _get_leg_length_method_offset = 14
    _set_leg_length_method_offset = 15
    _get_must_level_off_method_offset = 16
    _set_must_level_off_method_offset = 17
    _get_level_off_mode_method_offset = 18
    _set_level_off_mode_method_offset = 19
    _get_as_procedure_method_offset = 20
    _metadata = {
        "iid_data" : (5641659199997018566, 6013725867356615561),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureFlightLine)

    _get_altitude_options_metadata = { "offset" : _get_altitude_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def altitude_options(self) -> "AltitudeOptions":
        """Get the altitude options."""
        return self._intf.get_property(ProcedureFlightLine._metadata, ProcedureFlightLine._get_altitude_options_metadata)

    _get_fly_cruise_airspeed_profile_metadata = { "offset" : _get_fly_cruise_airspeed_profile_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def fly_cruise_airspeed_profile(self) -> bool:
        """Opt whether the aircraft immediately adopts the selected cruise airspeed or gradually begins accelerating/decelerating in the previous procedure."""
        return self._intf.get_property(ProcedureFlightLine._metadata, ProcedureFlightLine._get_fly_cruise_airspeed_profile_metadata)

    _set_fly_cruise_airspeed_profile_metadata = { "offset" : _set_fly_cruise_airspeed_profile_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @fly_cruise_airspeed_profile.setter
    def fly_cruise_airspeed_profile(self, value:bool) -> None:
        """Opt whether the aircraft immediately adopts the selected cruise airspeed or gradually begins accelerating/decelerating in the previous procedure."""
        return self._intf.set_property(ProcedureFlightLine._metadata, ProcedureFlightLine._set_fly_cruise_airspeed_profile_metadata, value)

    _get_flight_line_airspeed_options_metadata = { "offset" : _get_flight_line_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def flight_line_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the flight line airspeed options."""
        return self._intf.get_property(ProcedureFlightLine._metadata, ProcedureFlightLine._get_flight_line_airspeed_options_metadata)

    _get_enroute_options_metadata = { "offset" : _get_enroute_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_options(self) -> "EnrouteOptions":
        """Get the enroute options."""
        return self._intf.get_property(ProcedureFlightLine._metadata, ProcedureFlightLine._get_enroute_options_metadata)

    _get_enroute_turn_direction_options_metadata = { "offset" : _get_enroute_turn_direction_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_turn_direction_options(self) -> "EnrouteTurnDirectionOptions":
        """Get the enroute turn direction options."""
        return self._intf.get_property(ProcedureFlightLine._metadata, ProcedureFlightLine._get_enroute_turn_direction_options_metadata)

    _get_enroute_cruise_airspeed_options_metadata = { "offset" : _get_enroute_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the enroute cruise airspeed options."""
        return self._intf.get_property(ProcedureFlightLine._metadata, ProcedureFlightLine._get_enroute_cruise_airspeed_options_metadata)

    _get_procedure_type_metadata = { "offset" : _get_procedure_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(FlightLineProcedureType),) }
    @property
    def procedure_type(self) -> "FlightLineProcedureType":
        """Get or set the procedure methodology used to calculate the flight line."""
        return self._intf.get_property(ProcedureFlightLine._metadata, ProcedureFlightLine._get_procedure_type_metadata)

    _set_procedure_type_metadata = { "offset" : _set_procedure_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(FlightLineProcedureType),) }
    @procedure_type.setter
    def procedure_type(self, value:"FlightLineProcedureType") -> None:
        """Get or set the procedure methodology used to calculate the flight line."""
        return self._intf.set_property(ProcedureFlightLine._metadata, ProcedureFlightLine._set_procedure_type_metadata, value)

    _get_outbound_course_metadata = { "offset" : _get_outbound_course_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def outbound_course(self) -> typing.Any:
        """Get or set the outbound course."""
        return self._intf.get_property(ProcedureFlightLine._metadata, ProcedureFlightLine._get_outbound_course_metadata)

    _set_outbound_course_metadata = { "offset" : _set_outbound_course_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @outbound_course.setter
    def outbound_course(self, value:typing.Any) -> None:
        """Get or set the outbound course."""
        return self._intf.set_property(ProcedureFlightLine._metadata, ProcedureFlightLine._set_outbound_course_metadata, value)

    _get_use_magnetic_heading_metadata = { "offset" : _get_use_magnetic_heading_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_magnetic_heading(self) -> bool:
        """Get or set the option to use a magnetic heading."""
        return self._intf.get_property(ProcedureFlightLine._metadata, ProcedureFlightLine._get_use_magnetic_heading_metadata)

    _set_use_magnetic_heading_metadata = { "offset" : _set_use_magnetic_heading_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_magnetic_heading.setter
    def use_magnetic_heading(self, value:bool) -> None:
        """Get or set the option to use a magnetic heading."""
        return self._intf.set_property(ProcedureFlightLine._metadata, ProcedureFlightLine._set_use_magnetic_heading_metadata, value)

    _get_leg_length_metadata = { "offset" : _get_leg_length_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def leg_length(self) -> float:
        """Get or set the length of the flight line."""
        return self._intf.get_property(ProcedureFlightLine._metadata, ProcedureFlightLine._get_leg_length_metadata)

    _set_leg_length_metadata = { "offset" : _set_leg_length_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @leg_length.setter
    def leg_length(self, value:float) -> None:
        """Get or set the length of the flight line."""
        return self._intf.set_property(ProcedureFlightLine._metadata, ProcedureFlightLine._set_leg_length_metadata, value)

    _get_must_level_off_metadata = { "offset" : _get_must_level_off_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def must_level_off(self) -> bool:
        """Opt whether the procedure must level off."""
        return self._intf.get_property(ProcedureFlightLine._metadata, ProcedureFlightLine._get_must_level_off_metadata)

    _set_must_level_off_metadata = { "offset" : _set_must_level_off_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @must_level_off.setter
    def must_level_off(self, value:bool) -> None:
        """Opt whether the procedure must level off."""
        return self._intf.set_property(ProcedureFlightLine._metadata, ProcedureFlightLine._set_must_level_off_metadata, value)

    _get_level_off_mode_metadata = { "offset" : _get_level_off_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AltitudeConstraintManeuverMode),) }
    @property
    def level_off_mode(self) -> "AltitudeConstraintManeuverMode":
        """Get or set the level off mode. This is only used when the must level off option is on."""
        return self._intf.get_property(ProcedureFlightLine._metadata, ProcedureFlightLine._get_level_off_mode_metadata)

    _set_level_off_mode_metadata = { "offset" : _set_level_off_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AltitudeConstraintManeuverMode),) }
    @level_off_mode.setter
    def level_off_mode(self, value:"AltitudeConstraintManeuverMode") -> None:
        """Get or set the level off mode. This is only used when the must level off option is on."""
        return self._intf.set_property(ProcedureFlightLine._metadata, ProcedureFlightLine._set_level_off_mode_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureFlightLine._metadata, ProcedureFlightLine._get_as_procedure_metadata, OutArg())

    _property_names[altitude_options] = "altitude_options"
    _property_names[fly_cruise_airspeed_profile] = "fly_cruise_airspeed_profile"
    _property_names[flight_line_airspeed_options] = "flight_line_airspeed_options"
    _property_names[enroute_options] = "enroute_options"
    _property_names[enroute_turn_direction_options] = "enroute_turn_direction_options"
    _property_names[enroute_cruise_airspeed_options] = "enroute_cruise_airspeed_options"
    _property_names[procedure_type] = "procedure_type"
    _property_names[outbound_course] = "outbound_course"
    _property_names[use_magnetic_heading] = "use_magnetic_heading"
    _property_names[leg_length] = "leg_length"
    _property_names[must_level_off] = "must_level_off"
    _property_names[level_off_mode] = "level_off_mode"

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

agcls.AgClassCatalog.add_catalog_entry((5232752425516520970, 13442831997956569777), ProcedureFlightLine)
agcls.AgTypeNameMap["ProcedureFlightLine"] = ProcedureFlightLine

class ProcedureDelay(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a delay procedure."""

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_mode_method_offset = 1
    _set_altitude_mode_method_offset = 2
    _get_altitude_method_offset = 3
    _set_altitude_method_offset = 4
    _get_cruise_airspeed_options_method_offset = 5
    _get_turn_direction_method_offset = 6
    _set_turn_direction_method_offset = 7
    _get_turn_radius_factor_method_offset = 8
    _set_turn_radius_factor_method_offset = 9
    _metadata = {
        "iid_data" : (5716195463449211488, 12706362011475005615),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureDelay)

    _get_altitude_mode_metadata = { "offset" : _get_altitude_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DelayAltitudeMode),) }
    @property
    def altitude_mode(self) -> "DelayAltitudeMode":
        """Get or set the mode for handling the altitude of the aircraft."""
        return self._intf.get_property(ProcedureDelay._metadata, ProcedureDelay._get_altitude_mode_metadata)

    _set_altitude_mode_metadata = { "offset" : _set_altitude_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DelayAltitudeMode),) }
    @altitude_mode.setter
    def altitude_mode(self, value:"DelayAltitudeMode") -> None:
        """Get or set the mode for handling the altitude of the aircraft."""
        return self._intf.set_property(ProcedureDelay._metadata, ProcedureDelay._set_altitude_mode_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 requested altitude of the procedure."""
        return self._intf.get_property(ProcedureDelay._metadata, ProcedureDelay._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:
        """Get or set the requested altitude of the procedure."""
        return self._intf.set_property(ProcedureDelay._metadata, ProcedureDelay._set_altitude_metadata, value)

    _get_cruise_airspeed_options_metadata = { "offset" : _get_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the interface for the cruise airspeed options."""
        return self._intf.get_property(ProcedureDelay._metadata, ProcedureDelay._get_cruise_airspeed_options_metadata)

    _get_turn_direction_metadata = { "offset" : _get_turn_direction_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(NavigatorTurnDirection),) }
    @property
    def turn_direction(self) -> "NavigatorTurnDirection":
        """Get or set the turn direction of the procedure."""
        return self._intf.get_property(ProcedureDelay._metadata, ProcedureDelay._get_turn_direction_metadata)

    _set_turn_direction_metadata = { "offset" : _set_turn_direction_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(NavigatorTurnDirection),) }
    @turn_direction.setter
    def turn_direction(self, value:"NavigatorTurnDirection") -> None:
        """Get or set the turn direction of the procedure."""
        return self._intf.set_property(ProcedureDelay._metadata, ProcedureDelay._set_turn_direction_metadata, value)

    _get_turn_radius_factor_metadata = { "offset" : _get_turn_radius_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def turn_radius_factor(self) -> float:
        """Get or set the turn radius factor."""
        return self._intf.get_property(ProcedureDelay._metadata, ProcedureDelay._get_turn_radius_factor_metadata)

    _set_turn_radius_factor_metadata = { "offset" : _set_turn_radius_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @turn_radius_factor.setter
    def turn_radius_factor(self, value:float) -> None:
        """Get or set the turn radius factor."""
        return self._intf.set_property(ProcedureDelay._metadata, ProcedureDelay._set_turn_radius_factor_metadata, value)

    _property_names[altitude_mode] = "altitude_mode"
    _property_names[altitude] = "altitude"
    _property_names[cruise_airspeed_options] = "cruise_airspeed_options"
    _property_names[turn_direction] = "turn_direction"
    _property_names[turn_radius_factor] = "turn_radius_factor"

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

agcls.AgClassCatalog.add_catalog_entry((5704318683765486662, 710367158900072076), ProcedureDelay)
agcls.AgTypeNameMap["ProcedureDelay"] = ProcedureDelay

class ProcedureTakeoff(IProcedure, SupportsDeleteCallback):
    """
    Interface used to access the options for a takeoff procedure.

    Examples
    --------
    Add a takeoff procedure from a runway:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add a takeoff procedure with a runway as a site
    >>> takeoff = procedures.add(SiteType.SITE_RUNWAY, ProcedureType.PROCEDURE_TAKEOFF)
    >>>
    >>> # Get the runway heading options
    >>> headingOptions = takeoff.runway_heading_options
    >>> # Opt to use the headwind runway
    >>> headingOptions.runway_mode = RunwayHighLowEnd.HEADWIND
    >>>
    >>> # Set the takeoff mode and get that interface
    >>> takeoff.takeoff_mode = TakeoffMode.TAKEOFF_NORMAL
    >>> takeoffNormal = takeoff.mode_as_normal
    >>>
    >>> # Set the takeoff climb angle
    >>> takeoffNormal.takeoff_climb_angle = 5
    >>> # Set the departure altitude above the runway
    >>> takeoffNormal.departure_altitude = 600
    >>> # Set the altitude offset for the runway
    >>> takeoffNormal.runway_altitude_offset = 10
    >>> # Use terrain for the runway's altitude
    >>> takeoffNormal.use_runway_terrain = True
    """

    _num_methods = 7
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_runway_heading_options_method_offset = 1
    _get_mode_as_normal_method_offset = 2
    _get_mode_as_departure_point_method_offset = 3
    _get_mode_as_low_transition_method_offset = 4
    _get_takeoff_mode_method_offset = 5
    _set_takeoff_mode_method_offset = 6
    _get_as_procedure_method_offset = 7
    _metadata = {
        "iid_data" : (4746749933092015974, 13227298329395480749),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureTakeoff)

    _get_runway_heading_options_metadata = { "offset" : _get_runway_heading_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def runway_heading_options(self) -> "RunwayHeadingOptions":
        """Get the runway heading options."""
        return self._intf.get_property(ProcedureTakeoff._metadata, ProcedureTakeoff._get_runway_heading_options_metadata)

    _get_mode_as_normal_metadata = { "offset" : _get_mode_as_normal_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_normal(self) -> "TakeoffNormal":
        """Get the interface for a normal takeoff."""
        return self._intf.get_property(ProcedureTakeoff._metadata, ProcedureTakeoff._get_mode_as_normal_metadata)

    _get_mode_as_departure_point_metadata = { "offset" : _get_mode_as_departure_point_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_departure_point(self) -> "TakeoffDeparturePoint":
        """Get the interface for a departure point takeoff."""
        return self._intf.get_property(ProcedureTakeoff._metadata, ProcedureTakeoff._get_mode_as_departure_point_metadata)

    _get_mode_as_low_transition_metadata = { "offset" : _get_mode_as_low_transition_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_low_transition(self) -> "TakeoffLowTransition":
        """Get the interface for a low transition takeoff."""
        return self._intf.get_property(ProcedureTakeoff._metadata, ProcedureTakeoff._get_mode_as_low_transition_metadata)

    _get_takeoff_mode_metadata = { "offset" : _get_takeoff_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(TakeoffMode),) }
    @property
    def takeoff_mode(self) -> "TakeoffMode":
        """Get or set the type of takeoff the aircraft will perform."""
        return self._intf.get_property(ProcedureTakeoff._metadata, ProcedureTakeoff._get_takeoff_mode_metadata)

    _set_takeoff_mode_metadata = { "offset" : _set_takeoff_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(TakeoffMode),) }
    @takeoff_mode.setter
    def takeoff_mode(self, value:"TakeoffMode") -> None:
        """Get or set the type of takeoff the aircraft will perform."""
        return self._intf.set_property(ProcedureTakeoff._metadata, ProcedureTakeoff._set_takeoff_mode_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureTakeoff._metadata, ProcedureTakeoff._get_as_procedure_metadata, OutArg())

    _property_names[runway_heading_options] = "runway_heading_options"
    _property_names[mode_as_normal] = "mode_as_normal"
    _property_names[mode_as_departure_point] = "mode_as_departure_point"
    _property_names[mode_as_low_transition] = "mode_as_low_transition"
    _property_names[takeoff_mode] = "takeoff_mode"

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

agcls.AgClassCatalog.add_catalog_entry((4622436812587213547, 17163227853363219857), ProcedureTakeoff)
agcls.AgTypeNameMap["ProcedureTakeoff"] = ProcedureTakeoff

class ProcedureCollection(SupportsDeleteCallback):
    """
    Interface used to access the collection of procedures for a given phase in a mission. Use this interface to Get, Add, or Remove a procedure.

    Examples
    --------
    Add a takeoff procedure from a runway:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add a takeoff procedure with a runway as a site
    >>> takeoff = procedures.add(SiteType.SITE_RUNWAY, ProcedureType.PROCEDURE_TAKEOFF)
    >>>
    >>> # Get the runway heading options
    >>> headingOptions = takeoff.runway_heading_options
    >>> # Opt to use the headwind runway
    >>> headingOptions.runway_mode = RunwayHighLowEnd.HEADWIND
    >>>
    >>> # Set the takeoff mode and get that interface
    >>> takeoff.takeoff_mode = TakeoffMode.TAKEOFF_NORMAL
    >>> takeoffNormal = takeoff.mode_as_normal
    >>>
    >>> # Set the takeoff climb angle
    >>> takeoffNormal.takeoff_climb_angle = 5
    >>> # Set the departure altitude above the runway
    >>> takeoffNormal.departure_altitude = 600
    >>> # Set the altitude offset for the runway
    >>> takeoffNormal.runway_altitude_offset = 10
    >>> # Use terrain for the runway's altitude
    >>> takeoffNormal.use_runway_terrain = True

    Add and configure a landing procedure:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add a landing procedure
    >>> landing = procedures.add(SiteType.SITE_RUNWAY, ProcedureType.PROCEDURE_LANDING)
    >>>
    >>> # Get the runway heading options
    >>> headingOptions = landing.runway_heading_options
    >>> # Land from the low end
    >>> headingOptions.runway_mode = RunwayHighLowEnd.LOW_END
    >>>
    >>> # Use a standard instrument approach
    >>> landing.approach_mode = ApproachMode.STANDARD_INSTRUMENT_APPROACH
    >>> # Get the options for a standard instrument approach
    >>> sia = landing.mode_as_standard_instrument_approach
    >>> # Change the approach altitude
    >>> sia.approach_altitude = 1000
    >>> # Change the glideslope
    >>> sia.glideslope = 4
    >>> # Offset the runway altitude
    >>> sia.runway_altitude_offset = 10
    >>> # Use the terrain as an altitude reference for the runway
    >>> sia.use_runway_terrain = True

    Add and configure an en-route procedure:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add an enroute procedure with a site type of End of Previous Procedure
    >>> enroute = procedures.add_at_index(1, SiteType.SITE_END_OF_PREV_PROCEDURE, ProcedureType.PROCEDURE_ENROUTE)
    >>> # Get the altitude options
    >>> altitudeOptions = enroute.altitude_msl_options
    >>> # To specify an altitude, turn off the option to use the default cruise altitude
    >>> altitudeOptions.use_default_cruise_altitude = False
    >>> # Set the altitude
    >>> altitudeOptions.msl_altitude = 10000
    >>>
    >>> # Get the navigation options
    >>> navigationOptions = enroute.navigation_options
    >>> # Set the route to arrive on a specified course
    >>> navigationOptions.navigation_mode = PointToPointMode.ARRIVE_ON_COURSE
    >>> # Set the course
    >>> navigationOptions.arrive_on_course = 30
    >>> # Use a magnetic heading
    >>> navigationOptions.use_magnetic_heading = True
    >>>
    >>> # Get the navigation options
    >>> airspeedOptions = enroute.enroute_cruise_airspeed_options
    >>> # Fly at max speed
    >>> airspeedOptions.cruise_speed_type = CruiseSpeed.MAX_AIRSPEED
    >>> # To specify an airspeed to fly at, set the speed type to other airspeed
    >>> airspeedOptions.cruise_speed_type = CruiseSpeed.OTHER_AIRSPEED
    >>> # Then set the airspeed and airspeed type
    >>> airspeedOptions.set_other_airspeed(AirspeedType.TAS, 200)

    Add and configure a basic maneuver procedure:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add a basic maneuver procedure
    >>> basicManeuver = procedures.add(SiteType.SITE_END_OF_PREV_PROCEDURE, ProcedureType.PROCEDURE_BASIC_MANEUVER)
    >>>
    >>> # Set the navigation to use a Straight Ahead strategy
    >>> basicManeuver.navigation_strategy_type = "Straight Ahead"
    >>> # Get the options for the straight ahead strategy
    >>> straightAhead = basicManeuver.navigation
    >>> # Opt to maintain course (as opposed to maintain heading)
    >>> straightAhead.reference_frame = StraightAheadReferenceFrame.MAINTAIN_COURSE
    >>>
    >>> # Set the profile to use a Autopilot - Vertical Plane strategy
    >>> basicManeuver.profile_strategy_type = "Autopilot - Vertical Plane"
    >>> # Get the options for the profile strategy
    >>> autopilot = basicManeuver.profile
    >>> # Opt to maintain the initial altitude
    >>> autopilot.altitude_mode = AutopilotAltitudeMode.AUTOPILOT_HOLD_INIT_ALTITUDE
    >>> airspeedOptions = autopilot.airspeed_options
    >>> # Opt to maintain a specified airspeed
    >>> airspeedOptions.airspeed_mode = BasicManeuverAirspeedMode.MAINTAIN_SPECIFIED_AIRSPEED
    >>> # Specify the airspeed
    >>> airspeedOptions.specified_airspeed = 250
    >>>
    >>> # Configure the options on the Attitude / Performance / Fuel page
    >>> basicManeuver.flight_mode = PhaseOfFlight.FLIGHT_PHASE_CRUISE
    >>> # Override the fuel flow
    >>> basicManeuver.fuel_flow_type = BasicManeuverFuelFlowType.BASIC_MANEUVER_FUEL_FLOW_OVERRIDE
    >>> basicManeuver.override_fuel_flow_value = 1000
    >>>
    >>> # Set the basic stopping conditions
    >>> basicManeuver.use_max_downrange = True
    >>> basicManeuver.max_downrange = 10
    >>> basicManeuver.use_stop_fuel_state = False
    >>> basicManeuver.use_max_time_of_flight = False

    Add and remove procedures:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # AviatorPropagator propagator: Aviator Propagator object
    >>> # Add a takeoff procedure with a runway as a site. This will add the procedure
    >>> takeoff = procedures.add(SiteType.SITE_RUNWAY, ProcedureType.PROCEDURE_TAKEOFF)
    >>> # Add a procedure at a given index (starting from 0)
    >>> enroute = procedures.add_at_index(1, SiteType.SITE_END_OF_PREV_PROCEDURE, ProcedureType.PROCEDURE_ENROUTE)
    >>>
    >>> # Make sure to propagate the mission to calculate the route
    >>> propagator.propagate()
    >>> # Get the mission
    >>> mission = propagator.aviator_mission
    >>> # Check to see if the mission is valid (must first be propagated)
    >>> isValid = mission.is_valid
    >>>
    >>> # Get the number of procedures
    >>> procedureCount = procedures.count
    >>> # Remove the procedure at the given index
    >>> procedures.remove_at_index(1)
    >>> # Remove the given procedure
    >>> procedures.remove(takeoff)
    >>>
    >>> # Propagate the mission
    >>> propagator.propagate()
    """

    _num_methods = 9
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _get_count_method_offset = 1
    _item_method_offset = 2
    _get__new_enum_method_offset = 3
    _add_method_offset = 4
    _add_at_index_method_offset = 5
    _remove_method_offset = 6
    _remove_at_index_method_offset = 7
    _enable_auto_propagate_method_offset = 8
    _disable_auto_propagate_method_offset = 9
    _metadata = {
        "iid_data" : (4672125039402126824, 4866911027730476462),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureCollection)
    def __iter__(self):
        """Create an iterator for the ProcedureCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "IProcedure":
        """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

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

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "IProcedure":
        """Given an index, returns an element in the collection."""
        return self._intf.invoke(ProcedureCollection._metadata, ProcedureCollection._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:
        """Return an enumerator that can iterate through the collection."""
        return self._intf.get_property(ProcedureCollection._metadata, ProcedureCollection._get__new_enum_metadata)

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (agcom.LONG, agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.EnumArg(SiteType), agmarshall.EnumArg(ProcedureType), agmarshall.InterfaceOutArg,) }
    def add(self, site_type:"SiteType", procedure_type:"ProcedureType") -> "IProcedure":
        """Add a procedure with the specified site at the end of the current phase."""
        return self._intf.invoke(ProcedureCollection._metadata, ProcedureCollection._add_metadata, site_type, procedure_type, OutArg())

    _add_at_index_metadata = { "offset" : _add_at_index_method_offset,
            "arg_types" : (agcom.LONG, agcom.LONG, agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.EnumArg(SiteType), agmarshall.EnumArg(ProcedureType), agmarshall.InterfaceOutArg,) }
    def add_at_index(self, index:int, site_type:"SiteType", procedure_type:"ProcedureType") -> "IProcedure":
        """Add a procedure with the specified site at the given index."""
        return self._intf.invoke(ProcedureCollection._metadata, ProcedureCollection._add_at_index_metadata, index, site_type, procedure_type, OutArg())

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("IProcedure"),) }
    def remove(self, procedure:"IProcedure") -> None:
        """Remove given procedure."""
        return self._intf.invoke(ProcedureCollection._metadata, ProcedureCollection._remove_metadata, procedure)

    _remove_at_index_metadata = { "offset" : _remove_at_index_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    def remove_at_index(self, index:int) -> None:
        """Remove procedure at the given index."""
        return self._intf.invoke(ProcedureCollection._metadata, ProcedureCollection._remove_at_index_metadata, index)

    _enable_auto_propagate_metadata = { "offset" : _enable_auto_propagate_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def enable_auto_propagate(self) -> None:
        """Enable automatically propagating the mission. Aviator will automatically propagate before adding a procedure, ensuring a valid initial state for the new procedure."""
        return self._intf.invoke(ProcedureCollection._metadata, ProcedureCollection._enable_auto_propagate_metadata, )

    _disable_auto_propagate_metadata = { "offset" : _disable_auto_propagate_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def disable_auto_propagate(self) -> None:
        """Disable automatically propagating the mission. Use with caution. Aviator will not automatically propagate before adding new procedures."""
        return self._intf.invoke(ProcedureCollection._metadata, ProcedureCollection._disable_auto_propagate_metadata, )

    __getitem__ = item


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

    def __init__(self, source_object=None):
        """Construct an object of type ProcedureCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProcedureCollection)
    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, ProcedureCollection, [ProcedureCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5616253919542791990, 16838747785619043462), ProcedureCollection)
agcls.AgTypeNameMap["ProcedureCollection"] = ProcedureCollection

class Phase(SupportsDeleteCallback):
    """
    Interface used to access the phase options for a mission.

    Examples
    --------
    Configure the performance models to be used in the phase:
    >>> # Phase phase: Phase object
    >>> # Get the acceleration performance model used for the current phase
    >>> acceleration = phase.get_performance_model_by_type("Acceleration")
    >>> # Check if it is linked to the catalog
    >>> isLinkedToCatalog = acceleration.is_linked_to_catalog
    >>> # Use the performance model in the catalog named "Built-In Model"
    >>> acceleration.link_to_catalog("Built-In Model")
    >>>
    >>> # Get the VTOL performance model
    >>> vtol = phase.get_performance_model_by_type("VTOL")
    >>> # Create a new vtol model of type AGI VTOL Model. Note that this new model does not exist in the catalog and only exists in the phase.
    >>> vtol.create_new("AGI VTOL Model")
    >>> # Rename the performance model
    >>> vtol.rename("Temporary VTOL Model")

    Add a new phase and use the same performance models as the first phase:
    >>> # PhaseCollection phases: Phase Collection object
    >>> # Add a new phase at the end of the mission
    >>> newPhase = phases.add()
    >>> # Rename the phase
    >>> newPhase.name = "New Phase"
    >>> # Copy the performance models from the first phase and paste it to the new phase
    >>> phases[0].copy_performance_models()
    >>> newPhase.paste_performance_models()
    """

    _num_methods = 7
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_procedures_method_offset = 1
    _get_name_method_offset = 2
    _set_name_method_offset = 3
    _get_performance_model_by_type_method_offset = 4
    _set_default_performance_models_method_offset = 5
    _copy_performance_models_method_offset = 6
    _paste_performance_models_method_offset = 7
    _metadata = {
        "iid_data" : (5065421894605992373, 7712798079751778479),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, Phase)

    _get_procedures_metadata = { "offset" : _get_procedures_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def procedures(self) -> "ProcedureCollection":
        """Return the procedure collection."""
        return self._intf.get_property(Phase._metadata, Phase._get_procedures_metadata)

    _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 phase."""
        return self._intf.get_property(Phase._metadata, Phase._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 phase."""
        return self._intf.set_property(Phase._metadata, Phase._set_name_metadata, value)

    _get_performance_model_by_type_metadata = { "offset" : _get_performance_model_by_type_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_performance_model_by_type(self, type:str) -> "PerformanceModelOptions":
        """Get the active performance model for the given category type."""
        return self._intf.invoke(Phase._metadata, Phase._get_performance_model_by_type_metadata, type, OutArg())

    _set_default_performance_models_metadata = { "offset" : _set_default_performance_models_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def set_default_performance_models(self) -> None:
        """Set the phase to use the default performance models of the aircraft."""
        return self._intf.invoke(Phase._metadata, Phase._set_default_performance_models_metadata, )

    _copy_performance_models_metadata = { "offset" : _copy_performance_models_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def copy_performance_models(self) -> None:
        """Create a copy of the active performance models for the current phase."""
        return self._intf.invoke(Phase._metadata, Phase._copy_performance_models_metadata, )

    _paste_performance_models_metadata = { "offset" : _paste_performance_models_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def paste_performance_models(self) -> None:
        """Paste the performance models."""
        return self._intf.invoke(Phase._metadata, Phase._paste_performance_models_metadata, )

    _property_names[procedures] = "procedures"
    _property_names[name] = "name"

    def __init__(self, source_object=None):
        """Construct an object of type Phase."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, Phase)
    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, Phase, [Phase, ])

agcls.AgClassCatalog.add_catalog_entry((5327259017682921546, 13780760074728122774), Phase)
agcls.AgTypeNameMap["Phase"] = Phase

class PhaseCollection(SupportsDeleteCallback):
    """
    Interface used to access the collection of phases for a mission.

    Examples
    --------
    Add a new phase and use the same performance models as the first phase:
    >>> # PhaseCollection phases: Phase Collection object
    >>> # Add a new phase at the end of the mission
    >>> newPhase = phases.add()
    >>> # Rename the phase
    >>> newPhase.name = "New Phase"
    >>> # Copy the performance models from the first phase and paste it to the new phase
    >>> phases[0].copy_performance_models()
    >>> newPhase.paste_performance_models()
    """

    _num_methods = 7
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _get_count_method_offset = 1
    _item_method_offset = 2
    _get__new_enum_method_offset = 3
    _add_method_offset = 4
    _add_at_index_method_offset = 5
    _remove_method_offset = 6
    _remove_at_index_method_offset = 7
    _metadata = {
        "iid_data" : (5253053724572556766, 10071354963761500314),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, PhaseCollection)
    def __iter__(self):
        """Create an iterator for the PhaseCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "Phase":
        """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

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

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "Phase":
        """Given an index, returns an element in the collection."""
        return self._intf.invoke(PhaseCollection._metadata, PhaseCollection._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:
        """Return an enumerator that can iterate through the collection."""
        return self._intf.get_property(PhaseCollection._metadata, PhaseCollection._get__new_enum_metadata)

    _add_metadata = { "offset" : _add_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def add(self) -> "Phase":
        """Add a phase at the end of the mission."""
        return self._intf.invoke(PhaseCollection._metadata, PhaseCollection._add_metadata, OutArg())

    _add_at_index_metadata = { "offset" : _add_at_index_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def add_at_index(self, index:int) -> "Phase":
        """Add a phase at the given index."""
        return self._intf.invoke(PhaseCollection._metadata, PhaseCollection._add_at_index_metadata, index, OutArg())

    _remove_metadata = { "offset" : _remove_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("Phase"),) }
    def remove(self, phase:"Phase") -> None:
        """Remove given phase."""
        return self._intf.invoke(PhaseCollection._metadata, PhaseCollection._remove_metadata, phase)

    _remove_at_index_metadata = { "offset" : _remove_at_index_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    def remove_at_index(self, index:int) -> None:
        """Remove phase at the given index."""
        return self._intf.invoke(PhaseCollection._metadata, PhaseCollection._remove_at_index_metadata, index)

    __getitem__ = item


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

    def __init__(self, source_object=None):
        """Construct an object of type PhaseCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, PhaseCollection)
    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, PhaseCollection, [PhaseCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5426301579413729339, 2385420409047666822), PhaseCollection)
agcls.AgTypeNameMap["PhaseCollection"] = PhaseCollection

class Mission(SupportsDeleteCallback):
    """
    Interface for the mission of an aircraft using the Aviator propagator.

    Examples
    --------
    Set the Configuration used for the Mission:
    >>> # Mission mission: Aviator Mission object
    >>> # Get the configuration used for the mission
    >>> configuration = mission.configuration
    >>> # Set the max landing weight
    >>> configuration.max_landing_weight = 300000
    >>> # Set the empty weight
    >>> configuration.empty_weight = 210000
    >>> # Update the center of gravity of the aircraft when empty
    >>> configuration.set_empty_cg(2, 0, 1)
    >>>
    >>> # Get the stations
    >>> stations = configuration.get_stations()
    >>> # Check if there is an internal fuel station
    >>> if stations.contains_station("Internal Fuel") is True:
    >>>     # Get the fuel tank
    >>>     fuelTank = stations.get_internal_fuel_tank_by_name("Internal Fuel")
    >>>     # Set the capacity of the fuel tank
    >>>     fuelTank.capacity = 175000
    >>>     # Set the initial state of the fuel tank
    >>>     fuelTank.initial_fuel_state = 125000
    >>>
    >>> # Add a new payload station
    >>> newPayload = stations.add_payload_station()
    >>> # Set the position of the payload station
    >>> newPayload.set_position(0, 2, 0)
    >>> # Add an external fuel tank
    >>> externalTank = newPayload.add_external_fuel_tank()
    >>> # Set the empty weight of the tank
    >>> externalTank.empty_weight = 2000

    Set the aircraft used for the mission to an aircraft found in the Aviator catalog:
    >>> # AviatorPropagator propagator: Aviator Propagator object
    >>> # Get the Aviator catalog
    >>> catalog = propagator.aviator_catalog
    >>> # Get the aircraft category
    >>> category = catalog.aircraft_category
    >>> # Get the user aircraft models
    >>> aircraftModels = category.aircraft_models
    >>> # Get the basic fighter
    >>> fighter = aircraftModels.get_aircraft("Basic Fighter")
    >>> # Get the mission
    >>> mission = propagator.aviator_mission
    >>> # Set the vehicle used for the mission
    >>> mission.vehicle = fighter

    Configure the weather and atmosphere of the Mission:
    >>> # Mission mission: Aviator Mission object
    >>> # Get the wind model used for the mission
    >>> windModel = mission.wind_model
    >>> # Let's use the mission model
    >>> windModel.wind_model_source = WindAtmosphereModelSource.MISSION_MODEL
    >>> # Let's use constant wind
    >>> windModel.wind_model_type = WindModelType.CONSTANT_WIND
    >>> # Get the constant wind model options
    >>> constantWind = windModel.mode_as_constant
    >>> # Set the wind bearing
    >>> constantWind.wind_bearing = 30
    >>> # Set the wind speed
    >>> constantWind.wind_speed = 5
    >>>
    >>> # Get the atmosphere model used for the mission
    >>> atmosphere = mission.atmosphere_model
    >>> # Let's use the mission model
    >>> atmosphere.atmosphere_model_source = WindAtmosphereModelSource.MISSION_MODEL
    >>> # Get the basic atmosphere options
    >>> basicAtmosphere = atmosphere.mode_as_basic
    >>> # Use standard 1976 atmosphere
    >>> basicAtmosphere.basic_model_type = AtmosphereModelType.STANDARD1976
    >>> # Opt to override the values
    >>> basicAtmosphere.use_non_standard_atmosphere = True
    >>> # Override the temperature
    >>> basicAtmosphere.temperature = 290

    Add and remove procedures:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # AviatorPropagator propagator: Aviator Propagator object
    >>> # Add a takeoff procedure with a runway as a site. This will add the procedure
    >>> takeoff = procedures.add(SiteType.SITE_RUNWAY, ProcedureType.PROCEDURE_TAKEOFF)
    >>> # Add a procedure at a given index (starting from 0)
    >>> enroute = procedures.add_at_index(1, SiteType.SITE_END_OF_PREV_PROCEDURE, ProcedureType.PROCEDURE_ENROUTE)
    >>>
    >>> # Make sure to propagate the mission to calculate the route
    >>> propagator.propagate()
    >>> # Get the mission
    >>> mission = propagator.aviator_mission
    >>> # Check to see if the mission is valid (must first be propagated)
    >>> isValid = mission.is_valid
    >>>
    >>> # Get the number of procedures
    >>> procedureCount = procedures.count
    >>> # Remove the procedure at the given index
    >>> procedures.remove_at_index(1)
    >>> # Remove the given procedure
    >>> procedures.remove(takeoff)
    >>>
    >>> # Propagate the mission
    >>> propagator.propagate()
    """

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_phases_method_offset = 1
    _get_vehicle_method_offset = 2
    _set_vehicle_method_offset = 3
    _get_configuration_method_offset = 4
    _get_wind_model_method_offset = 5
    _get_atmosphere_model_method_offset = 6
    _get_is_valid_method_offset = 7
    _get_first_invalid_procedure_method_offset = 8
    _metadata = {
        "iid_data" : (5166308313264454994, 7736963905921891476),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, Mission)

    _get_phases_metadata = { "offset" : _get_phases_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def phases(self) -> "PhaseCollection":
        """Get the mission phases."""
        return self._intf.get_property(Mission._metadata, Mission._get_phases_metadata)

    _get_vehicle_metadata = { "offset" : _get_vehicle_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def vehicle(self) -> "IAviatorVehicle":
        """Get or set the vehicle used in the mission."""
        return self._intf.get_property(Mission._metadata, Mission._get_vehicle_metadata)

    _set_vehicle_metadata = { "offset" : _set_vehicle_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("IAviatorVehicle"),) }
    @vehicle.setter
    def vehicle(self, aviator_vehicle:"IAviatorVehicle") -> None:
        """Get or set the vehicle used in the mission."""
        return self._intf.set_property(Mission._metadata, Mission._set_vehicle_metadata, aviator_vehicle)

    _get_configuration_metadata = { "offset" : _get_configuration_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def configuration(self) -> "Configuration":
        """Get the aircraft's configuration for the mission."""
        return self._intf.get_property(Mission._metadata, Mission._get_configuration_metadata)

    _get_wind_model_metadata = { "offset" : _get_wind_model_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def wind_model(self) -> "WindModel":
        """Get the mission wind model."""
        return self._intf.get_property(Mission._metadata, Mission._get_wind_model_metadata)

    _get_atmosphere_model_metadata = { "offset" : _get_atmosphere_model_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def atmosphere_model(self) -> "AtmosphereModel":
        """Get the mission atmosphere model."""
        return self._intf.get_property(Mission._metadata, Mission._get_atmosphere_model_metadata)

    _get_is_valid_metadata = { "offset" : _get_is_valid_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def is_valid(self) -> bool:
        """Check whether the mission is valid. Calling this property will propagate the mission."""
        return self._intf.get_property(Mission._metadata, Mission._get_is_valid_metadata)

    _get_first_invalid_procedure_metadata = { "offset" : _get_first_invalid_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_first_invalid_procedure(self) -> "IProcedure":
        """Get the first invalid procedure in the mission. Calling this method will propagate the mission."""
        return self._intf.invoke(Mission._metadata, Mission._get_first_invalid_procedure_metadata, OutArg())

    _property_names[phases] = "phases"
    _property_names[vehicle] = "vehicle"
    _property_names[configuration] = "configuration"
    _property_names[wind_model] = "wind_model"
    _property_names[atmosphere_model] = "atmosphere_model"
    _property_names[is_valid] = "is_valid"

    def __init__(self, source_object=None):
        """Construct an object of type Mission."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, Mission)
    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, Mission, [Mission, ])

agcls.AgClassCatalog.add_catalog_entry((5084660225869613847, 3815698403988913814), Mission)
agcls.AgTypeNameMap["Mission"] = Mission

class AviatorPropagator(SupportsDeleteCallback):
    """
    Interface used to access the Aviator interface for an aircraft. Use this interface to get the mission or Aviator catalog.

    Examples
    --------
    Configure the Aviator propagator:
    >>> # Aircraft aircraft: Aircraft object
    >>> # Set to Propagator to Aviator
    >>> aircraft.set_route_type(PropagatorType.AVIATOR)
    >>> # Get the aircraft's route
    >>> aircraftRoute = aircraft.route
    >>> # Get the Aviator propagator
    >>> propagator = aircraftRoute.aviator_propagator
    >>> # Get the Aviator mission
    >>> mission = propagator.aviator_mission
    >>> # Get the list of phases from the mission
    >>> phases = mission.phases
    >>> # Get the list of procedures from the first phase
    >>> procedures = phases[0].procedures
    >>> # Propagate the route
    >>> propagator.propagate()
    """

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_aviator_mission_method_offset = 1
    _propagate_method_offset = 2
    _get_auto_recalculate_method_offset = 3
    _set_auto_recalculate_method_offset = 4
    _get_aviator_catalog_method_offset = 5
    _metadata = {
        "iid_data" : (5661397388601039162, 10681986619092325766),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AviatorPropagator)

    _get_aviator_mission_metadata = { "offset" : _get_aviator_mission_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def aviator_mission(self) -> "Mission":
        """Get the Aviator mission."""
        return self._intf.get_property(AviatorPropagator._metadata, AviatorPropagator._get_aviator_mission_metadata)

    _propagate_metadata = { "offset" : _propagate_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def propagate(self) -> None:
        """Apply All Change."""
        return self._intf.invoke(AviatorPropagator._metadata, AviatorPropagator._propagate_metadata, )

    _get_auto_recalculate_metadata = { "offset" : _get_auto_recalculate_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def auto_recalculate(self) -> bool:
        """Opt whether to have the propagator auto recalculate."""
        return self._intf.get_property(AviatorPropagator._metadata, AviatorPropagator._get_auto_recalculate_metadata)

    _set_auto_recalculate_metadata = { "offset" : _set_auto_recalculate_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @auto_recalculate.setter
    def auto_recalculate(self, auto_recalc:bool) -> None:
        """Opt whether to have the propagator auto recalculate."""
        return self._intf.set_property(AviatorPropagator._metadata, AviatorPropagator._set_auto_recalculate_metadata, auto_recalc)

    _get_aviator_catalog_metadata = { "offset" : _get_aviator_catalog_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def aviator_catalog(self) -> "Catalog":
        """Get the Aviator catalog."""
        return self._intf.get_property(AviatorPropagator._metadata, AviatorPropagator._get_aviator_catalog_metadata)

    _property_names[aviator_mission] = "aviator_mission"
    _property_names[auto_recalculate] = "auto_recalculate"
    _property_names[aviator_catalog] = "aviator_catalog"

    def __init__(self, source_object=None):
        """Construct an object of type AviatorPropagator."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AviatorPropagator)
    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, AviatorPropagator, [AviatorPropagator, ])

agcls.AgClassCatalog.add_catalog_entry((4966342315327056185, 8021477894575781281), AviatorPropagator)
agcls.AgTypeNameMap["AviatorPropagator"] = AviatorPropagator

class ProcedureBasicManeuver(IProcedure, SupportsDeleteCallback):
    """
    Interface used to access the options for a Basic Maneuver procedure.

    Examples
    --------
    Add and configure a basic maneuver procedure:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add a basic maneuver procedure
    >>> basicManeuver = procedures.add(SiteType.SITE_END_OF_PREV_PROCEDURE, ProcedureType.PROCEDURE_BASIC_MANEUVER)
    >>>
    >>> # Set the navigation to use a Straight Ahead strategy
    >>> basicManeuver.navigation_strategy_type = "Straight Ahead"
    >>> # Get the options for the straight ahead strategy
    >>> straightAhead = basicManeuver.navigation
    >>> # Opt to maintain course (as opposed to maintain heading)
    >>> straightAhead.reference_frame = StraightAheadReferenceFrame.MAINTAIN_COURSE
    >>>
    >>> # Set the profile to use a Autopilot - Vertical Plane strategy
    >>> basicManeuver.profile_strategy_type = "Autopilot - Vertical Plane"
    >>> # Get the options for the profile strategy
    >>> autopilot = basicManeuver.profile
    >>> # Opt to maintain the initial altitude
    >>> autopilot.altitude_mode = AutopilotAltitudeMode.AUTOPILOT_HOLD_INIT_ALTITUDE
    >>> airspeedOptions = autopilot.airspeed_options
    >>> # Opt to maintain a specified airspeed
    >>> airspeedOptions.airspeed_mode = BasicManeuverAirspeedMode.MAINTAIN_SPECIFIED_AIRSPEED
    >>> # Specify the airspeed
    >>> airspeedOptions.specified_airspeed = 250
    >>>
    >>> # Configure the options on the Attitude / Performance / Fuel page
    >>> basicManeuver.flight_mode = PhaseOfFlight.FLIGHT_PHASE_CRUISE
    >>> # Override the fuel flow
    >>> basicManeuver.fuel_flow_type = BasicManeuverFuelFlowType.BASIC_MANEUVER_FUEL_FLOW_OVERRIDE
    >>> basicManeuver.override_fuel_flow_value = 1000
    >>>
    >>> # Set the basic stopping conditions
    >>> basicManeuver.use_max_downrange = True
    >>> basicManeuver.max_downrange = 10
    >>> basicManeuver.use_stop_fuel_state = False
    >>> basicManeuver.use_max_time_of_flight = False
    """

    _num_methods = 37
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_max_time_of_flight_method_offset = 1
    _set_max_time_of_flight_method_offset = 2
    _get_use_max_time_of_flight_method_offset = 3
    _set_use_max_time_of_flight_method_offset = 4
    _get_stop_fuel_state_method_offset = 5
    _set_stop_fuel_state_method_offset = 6
    _get_use_stop_fuel_state_method_offset = 7
    _set_use_stop_fuel_state_method_offset = 8
    _get_max_downrange_method_offset = 9
    _set_max_downrange_method_offset = 10
    _get_use_max_downrange_method_offset = 11
    _set_use_max_downrange_method_offset = 12
    _get_altitude_limit_mode_method_offset = 13
    _set_altitude_limit_mode_method_offset = 14
    _get_terrain_impact_mode_method_offset = 15
    _set_terrain_impact_mode_method_offset = 16
    _get_terrain_impact_time_offset_method_offset = 17
    _set_terrain_impact_time_offset_method_offset = 18
    _get_navigation_strategy_type_method_offset = 19
    _set_navigation_strategy_type_method_offset = 20
    _get_navigation_method_offset = 21
    _get_profile_strategy_type_method_offset = 22
    _set_profile_strategy_type_method_offset = 23
    _get_profile_method_offset = 24
    _get_flight_mode_method_offset = 25
    _set_flight_mode_method_offset = 26
    _get_fuel_flow_type_method_offset = 27
    _set_fuel_flow_type_method_offset = 28
    _get_override_fuel_flow_value_method_offset = 29
    _set_override_fuel_flow_value_method_offset = 30
    _get_scale_fuel_flow_method_offset = 31
    _set_scale_fuel_flow_method_offset = 32
    _get_attitude_blend_time_method_offset = 33
    _set_attitude_blend_time_method_offset = 34
    _get_control_time_constant_method_offset = 35
    _set_control_time_constant_method_offset = 36
    _get_as_procedure_method_offset = 37
    _metadata = {
        "iid_data" : (4946730629668897604, 11088550870477238442),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureBasicManeuver)

    _get_max_time_of_flight_metadata = { "offset" : _get_max_time_of_flight_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_time_of_flight(self) -> typing.Any:
        """Get the max time of flight."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_max_time_of_flight_metadata)

    _set_max_time_of_flight_metadata = { "offset" : _set_max_time_of_flight_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_time_of_flight.setter
    def max_time_of_flight(self, value:typing.Any) -> None:
        """Set the max time of flight."""
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_max_time_of_flight_metadata, value)

    _get_use_max_time_of_flight_metadata = { "offset" : _get_use_max_time_of_flight_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_max_time_of_flight(self) -> bool:
        """Get whether to use max time of flight."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_use_max_time_of_flight_metadata)

    _set_use_max_time_of_flight_metadata = { "offset" : _set_use_max_time_of_flight_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_max_time_of_flight.setter
    def use_max_time_of_flight(self, value:bool) -> None:
        """Set whether to use max time of flight."""
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_use_max_time_of_flight_metadata, value)

    _get_stop_fuel_state_metadata = { "offset" : _get_stop_fuel_state_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stop_fuel_state(self) -> float:
        """Get the stop fuel state value."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_stop_fuel_state_metadata)

    _set_stop_fuel_state_metadata = { "offset" : _set_stop_fuel_state_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @stop_fuel_state.setter
    def stop_fuel_state(self, value:float) -> None:
        """Set the stop fuel state value."""
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_stop_fuel_state_metadata, value)

    _get_use_stop_fuel_state_metadata = { "offset" : _get_use_stop_fuel_state_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_stop_fuel_state(self) -> bool:
        """Get whether to use stop fuel state."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_use_stop_fuel_state_metadata)

    _set_use_stop_fuel_state_metadata = { "offset" : _set_use_stop_fuel_state_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_stop_fuel_state.setter
    def use_stop_fuel_state(self, value:bool) -> None:
        """Set whether to use stop fuel state."""
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_use_stop_fuel_state_metadata, value)

    _get_max_downrange_metadata = { "offset" : _get_max_downrange_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_downrange(self) -> float:
        """Get the max down range."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_max_downrange_metadata)

    _set_max_downrange_metadata = { "offset" : _set_max_downrange_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_downrange.setter
    def max_downrange(self, value:float) -> None:
        """Set the max down range."""
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_max_downrange_metadata, value)

    _get_use_max_downrange_metadata = { "offset" : _get_use_max_downrange_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_max_downrange(self) -> bool:
        """Get whether to use max down range."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_use_max_downrange_metadata)

    _set_use_max_downrange_metadata = { "offset" : _set_use_max_downrange_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_max_downrange.setter
    def use_max_downrange(self, value:bool) -> None:
        """Set whether to use max down range."""
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_use_max_downrange_metadata, value)

    _get_altitude_limit_mode_metadata = { "offset" : _get_altitude_limit_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverAltitudeLimit),) }
    @property
    def altitude_limit_mode(self) -> "BasicManeuverAltitudeLimit":
        """Get the altitude limit mode."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_altitude_limit_mode_metadata)

    _set_altitude_limit_mode_metadata = { "offset" : _set_altitude_limit_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverAltitudeLimit),) }
    @altitude_limit_mode.setter
    def altitude_limit_mode(self, value:"BasicManeuverAltitudeLimit") -> None:
        """Set the altitude limit mode."""
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_altitude_limit_mode_metadata, value)

    _get_terrain_impact_mode_metadata = { "offset" : _get_terrain_impact_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverAltitudeLimit),) }
    @property
    def terrain_impact_mode(self) -> "BasicManeuverAltitudeLimit":
        """Get the terrain impact mode."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_terrain_impact_mode_metadata)

    _set_terrain_impact_mode_metadata = { "offset" : _set_terrain_impact_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverAltitudeLimit),) }
    @terrain_impact_mode.setter
    def terrain_impact_mode(self, value:"BasicManeuverAltitudeLimit") -> None:
        """Set the terrain impact mode."""
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_terrain_impact_mode_metadata, value)

    _get_terrain_impact_time_offset_metadata = { "offset" : _get_terrain_impact_time_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def terrain_impact_time_offset(self) -> float:
        """Get the terrain impact time offset."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_terrain_impact_time_offset_metadata)

    _set_terrain_impact_time_offset_metadata = { "offset" : _set_terrain_impact_time_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @terrain_impact_time_offset.setter
    def terrain_impact_time_offset(self, value:float) -> None:
        """Set the terrain impact time offset."""
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_terrain_impact_time_offset_metadata, value)

    _get_navigation_strategy_type_metadata = { "offset" : _get_navigation_strategy_type_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def navigation_strategy_type(self) -> str:
        """Get the navigation strategy type."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_navigation_strategy_type_metadata)

    _set_navigation_strategy_type_metadata = { "offset" : _set_navigation_strategy_type_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @navigation_strategy_type.setter
    def navigation_strategy_type(self, value:str) -> None:
        """Set the navigation strategy type."""
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_navigation_strategy_type_metadata, value)

    _get_navigation_metadata = { "offset" : _get_navigation_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def navigation(self) -> "IBasicManeuverStrategy":
        """Get the interface for the navigation strategy."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_navigation_metadata)

    _get_profile_strategy_type_metadata = { "offset" : _get_profile_strategy_type_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def profile_strategy_type(self) -> str:
        """Get the profile strategy type."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_profile_strategy_type_metadata)

    _set_profile_strategy_type_metadata = { "offset" : _set_profile_strategy_type_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @profile_strategy_type.setter
    def profile_strategy_type(self, value:str) -> None:
        """Set the profile strategy type."""
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_profile_strategy_type_metadata, value)

    _get_profile_metadata = { "offset" : _get_profile_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def profile(self) -> "IBasicManeuverStrategy":
        """Get the interface for the profile strategy."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_profile_metadata)

    _get_flight_mode_metadata = { "offset" : _get_flight_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PhaseOfFlight),) }
    @property
    def flight_mode(self) -> "PhaseOfFlight":
        """Get or set the type of performance model  that the aircraft will use to fly the maneuver."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_flight_mode_metadata)

    _set_flight_mode_metadata = { "offset" : _set_flight_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PhaseOfFlight),) }
    @flight_mode.setter
    def flight_mode(self, value:"PhaseOfFlight") -> None:
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_flight_mode_metadata, value)

    _get_fuel_flow_type_metadata = { "offset" : _get_fuel_flow_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverFuelFlowType),) }
    @property
    def fuel_flow_type(self) -> "BasicManeuverFuelFlowType":
        """Get or set the source used to calculate the fuel flow for the maneuver."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_fuel_flow_type_metadata)

    _set_fuel_flow_type_metadata = { "offset" : _set_fuel_flow_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverFuelFlowType),) }
    @fuel_flow_type.setter
    def fuel_flow_type(self, value:"BasicManeuverFuelFlowType") -> None:
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_fuel_flow_type_metadata, value)

    _get_override_fuel_flow_value_metadata = { "offset" : _get_override_fuel_flow_value_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def override_fuel_flow_value(self) -> float:
        """Get or set the value used for the Override Fuel Flow type. The fuel flow type must be set to Override to access this value."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_override_fuel_flow_value_metadata)

    _set_override_fuel_flow_value_metadata = { "offset" : _set_override_fuel_flow_value_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @override_fuel_flow_value.setter
    def override_fuel_flow_value(self, value:float) -> None:
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_override_fuel_flow_value_metadata, value)

    _get_scale_fuel_flow_metadata = { "offset" : _get_scale_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def scale_fuel_flow(self) -> bool:
        """Opt whether to scale the fuel flow based on the aircraft's actual attitude."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_scale_fuel_flow_metadata)

    _set_scale_fuel_flow_metadata = { "offset" : _set_scale_fuel_flow_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @scale_fuel_flow.setter
    def scale_fuel_flow(self, value:bool) -> None:
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_scale_fuel_flow_metadata, value)

    _get_attitude_blend_time_metadata = { "offset" : _get_attitude_blend_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def attitude_blend_time(self) -> float:
        """Get or set the amount of time that the aircraft will spend transitioning from the attitude of the previous maneuver to the attitude at the beginning of the current maneuver."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_attitude_blend_time_metadata)

    _set_attitude_blend_time_metadata = { "offset" : _set_attitude_blend_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @attitude_blend_time.setter
    def attitude_blend_time(self, value:float) -> None:
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_attitude_blend_time_metadata, value)

    _get_control_time_constant_metadata = { "offset" : _get_control_time_constant_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def control_time_constant(self) -> float:
        """A smoothing constant for the performance of control surfaces."""
        return self._intf.get_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_control_time_constant_metadata)

    _set_control_time_constant_metadata = { "offset" : _set_control_time_constant_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @control_time_constant.setter
    def control_time_constant(self, value:float) -> None:
        return self._intf.set_property(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._set_control_time_constant_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureBasicManeuver._metadata, ProcedureBasicManeuver._get_as_procedure_metadata, OutArg())

    _property_names[max_time_of_flight] = "max_time_of_flight"
    _property_names[use_max_time_of_flight] = "use_max_time_of_flight"
    _property_names[stop_fuel_state] = "stop_fuel_state"
    _property_names[use_stop_fuel_state] = "use_stop_fuel_state"
    _property_names[max_downrange] = "max_downrange"
    _property_names[use_max_downrange] = "use_max_downrange"
    _property_names[altitude_limit_mode] = "altitude_limit_mode"
    _property_names[terrain_impact_mode] = "terrain_impact_mode"
    _property_names[terrain_impact_time_offset] = "terrain_impact_time_offset"
    _property_names[navigation_strategy_type] = "navigation_strategy_type"
    _property_names[navigation] = "navigation"
    _property_names[profile_strategy_type] = "profile_strategy_type"
    _property_names[profile] = "profile"
    _property_names[flight_mode] = "flight_mode"
    _property_names[fuel_flow_type] = "fuel_flow_type"
    _property_names[override_fuel_flow_value] = "override_fuel_flow_value"
    _property_names[scale_fuel_flow] = "scale_fuel_flow"
    _property_names[attitude_blend_time] = "attitude_blend_time"
    _property_names[control_time_constant] = "control_time_constant"

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

agcls.AgClassCatalog.add_catalog_entry((5438306318378493224, 5970325316227680169), ProcedureBasicManeuver)
agcls.AgTypeNameMap["ProcedureBasicManeuver"] = ProcedureBasicManeuver

class BasicManeuverStrategyWeave(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a weave strategy of a basic maneuver procedure."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_heading_change_method_offset = 1
    _set_heading_change_method_offset = 2
    _get_max_num_cycles_method_offset = 3
    _set_max_num_cycles_method_offset = 4
    _get_max_distance_method_offset = 5
    _set_max_distance_method_offset = 6
    _get_control_limit_mode_method_offset = 7
    _get_control_limit_turn_radius_method_offset = 8
    _get_control_limit_turn_rate_method_offset = 9
    _get_control_limit_horizontal_acceleration_method_offset = 10
    _set_control_limit_method_offset = 11
    _get_compensate_for_coriolis_acceleration_method_offset = 12
    _set_compensate_for_coriolis_acceleration_method_offset = 13
    _metadata = {
        "iid_data" : (5498161033082324708, 15050332780891237523),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyWeave)

    _get_heading_change_metadata = { "offset" : _get_heading_change_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def heading_change(self) -> typing.Any:
        """Get or set the direction in which the aircraft will begin the weave pattern."""
        return self._intf.get_property(BasicManeuverStrategyWeave._metadata, BasicManeuverStrategyWeave._get_heading_change_metadata)

    _set_heading_change_metadata = { "offset" : _set_heading_change_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @heading_change.setter
    def heading_change(self, value:typing.Any) -> None:
        return self._intf.set_property(BasicManeuverStrategyWeave._metadata, BasicManeuverStrategyWeave._set_heading_change_metadata, value)

    _get_max_num_cycles_metadata = { "offset" : _get_max_num_cycles_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_num_cycles(self) -> float:
        """Get or set the number of times the aircraft will fly the pattern."""
        return self._intf.get_property(BasicManeuverStrategyWeave._metadata, BasicManeuverStrategyWeave._get_max_num_cycles_metadata)

    _set_max_num_cycles_metadata = { "offset" : _set_max_num_cycles_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_num_cycles.setter
    def max_num_cycles(self, value:float) -> None:
        return self._intf.set_property(BasicManeuverStrategyWeave._metadata, BasicManeuverStrategyWeave._set_max_num_cycles_metadata, value)

    _get_max_distance_metadata = { "offset" : _get_max_distance_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_distance(self) -> float:
        """Get or set the maximum ground distance the aircraft will travel while performing the weave cyces."""
        return self._intf.get_property(BasicManeuverStrategyWeave._metadata, BasicManeuverStrategyWeave._get_max_distance_metadata)

    _set_max_distance_metadata = { "offset" : _set_max_distance_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_distance.setter
    def max_distance(self, value:float) -> None:
        return self._intf.set_property(BasicManeuverStrategyWeave._metadata, BasicManeuverStrategyWeave._set_max_distance_metadata, value)

    _get_control_limit_mode_metadata = { "offset" : _get_control_limit_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyNavigationControlLimit),) }
    @property
    def control_limit_mode(self) -> "BasicManeuverStrategyNavigationControlLimit":
        """Get the method to define the control limits of the aircraft during the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyWeave._metadata, BasicManeuverStrategyWeave._get_control_limit_mode_metadata)

    _get_control_limit_turn_radius_metadata = { "offset" : _get_control_limit_turn_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def control_limit_turn_radius(self) -> float:
        """Get the specified turn radius for a control limit mode of specify min turn radius."""
        return self._intf.get_property(BasicManeuverStrategyWeave._metadata, BasicManeuverStrategyWeave._get_control_limit_turn_radius_metadata)

    _get_control_limit_turn_rate_metadata = { "offset" : _get_control_limit_turn_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def control_limit_turn_rate(self) -> typing.Any:
        """Get the specified turn rate for a control limit mode of specify max turn rate."""
        return self._intf.get_property(BasicManeuverStrategyWeave._metadata, BasicManeuverStrategyWeave._get_control_limit_turn_rate_metadata)

    _get_control_limit_horizontal_acceleration_metadata = { "offset" : _get_control_limit_horizontal_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def control_limit_horizontal_acceleration(self) -> float:
        """Get the specified horizontal acceleration for a control limit mode of specify max horiz accel."""
        return self._intf.get_property(BasicManeuverStrategyWeave._metadata, BasicManeuverStrategyWeave._get_control_limit_horizontal_acceleration_metadata)

    _set_control_limit_metadata = { "offset" : _set_control_limit_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyNavigationControlLimit), agmarshall.DoubleArg,) }
    def set_control_limit(self, control_limit_mode:"BasicManeuverStrategyNavigationControlLimit", control_limit_value:float) -> None:
        """Set the method and corresponding value to define the control limits of the aircraft during the maneuver."""
        return self._intf.invoke(BasicManeuverStrategyWeave._metadata, BasicManeuverStrategyWeave._set_control_limit_metadata, control_limit_mode, control_limit_value)

    _get_compensate_for_coriolis_acceleration_metadata = { "offset" : _get_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def compensate_for_coriolis_acceleration(self) -> bool:
        """Get or set the option to compensate for the acceleration due to the Coriolis effect."""
        return self._intf.get_property(BasicManeuverStrategyWeave._metadata, BasicManeuverStrategyWeave._get_compensate_for_coriolis_acceleration_metadata)

    _set_compensate_for_coriolis_acceleration_metadata = { "offset" : _set_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @compensate_for_coriolis_acceleration.setter
    def compensate_for_coriolis_acceleration(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyWeave._metadata, BasicManeuverStrategyWeave._set_compensate_for_coriolis_acceleration_metadata, value)

    _property_names[heading_change] = "heading_change"
    _property_names[max_num_cycles] = "max_num_cycles"
    _property_names[max_distance] = "max_distance"
    _property_names[control_limit_mode] = "control_limit_mode"
    _property_names[control_limit_turn_radius] = "control_limit_turn_radius"
    _property_names[control_limit_turn_rate] = "control_limit_turn_rate"
    _property_names[control_limit_horizontal_acceleration] = "control_limit_horizontal_acceleration"
    _property_names[compensate_for_coriolis_acceleration] = "compensate_for_coriolis_acceleration"

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

agcls.AgClassCatalog.add_catalog_entry((4741432811209582740, 17876430357664068016), BasicManeuverStrategyWeave)
agcls.AgTypeNameMap["BasicManeuverStrategyWeave"] = BasicManeuverStrategyWeave

class ProcedureTimeOptions(SupportsDeleteCallback):
    """
    Interface used to access the time options for the current procedure. Use this interface to set an Interrupt Time or Fixed Duration for a procedure.

    Examples
    --------
    Configure a procedure's time options:
    >>> # IProcedure procedure: Procedure object
    >>> # Get the time in epoch seconds
    >>> root.units_preferences.set_current_unit("DateFormat", "EpSec")
    >>> # Get the time options
    >>> timeOptions = procedure.time_options
    >>> # Get the start time
    >>> startTime = timeOptions.start_time
    >>> # Set the procedure to interrupt after 15 seconds
    >>> timeOptions.set_interrupt_time(15)
    """

    _num_methods = 15
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_start_time_enabled_method_offset = 1
    _get_use_start_time_method_offset = 2
    _set_use_start_time_method_offset = 3
    _get_start_time_method_offset = 4
    _set_start_time_method_offset = 5
    _get_interrupt_time_enabled_method_offset = 6
    _get_use_interrupt_time_method_offset = 7
    _set_use_interrupt_time_method_offset = 8
    _get_interrupt_time_method_offset = 9
    _set_interrupt_time_method_offset = 10
    _get_stop_time_enabled_method_offset = 11
    _get_use_stop_time_method_offset = 12
    _set_use_stop_time_method_offset = 13
    _get_stop_time_method_offset = 14
    _set_stop_time_method_offset = 15
    _metadata = {
        "iid_data" : (5431356329456530164, 11282614112339302277),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureTimeOptions)

    _get_start_time_enabled_metadata = { "offset" : _get_start_time_enabled_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def start_time_enabled(self) -> bool:
        """Check to see if the start time is enabled for this procedure."""
        return self._intf.get_property(ProcedureTimeOptions._metadata, ProcedureTimeOptions._get_start_time_enabled_metadata)

    _get_use_start_time_metadata = { "offset" : _get_use_start_time_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_start_time(self) -> bool:
        """Opt whether to set a start time for the procedure."""
        return self._intf.get_property(ProcedureTimeOptions._metadata, ProcedureTimeOptions._get_use_start_time_metadata)

    _set_use_start_time_metadata = { "offset" : _set_use_start_time_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_start_time.setter
    def use_start_time(self, value:bool) -> None:
        """Opt whether to set a start time for the procedure."""
        return self._intf.set_property(ProcedureTimeOptions._metadata, ProcedureTimeOptions._set_use_start_time_metadata, value)

    _get_start_time_metadata = { "offset" : _get_start_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def start_time(self) -> typing.Any:
        """Start time for the procedure."""
        return self._intf.get_property(ProcedureTimeOptions._metadata, ProcedureTimeOptions._get_start_time_metadata)

    _set_start_time_metadata = { "offset" : _set_start_time_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def set_start_time(self, time:typing.Any) -> None:
        """Set the start time for the procedure."""
        return self._intf.invoke(ProcedureTimeOptions._metadata, ProcedureTimeOptions._set_start_time_metadata, time)

    _get_interrupt_time_enabled_metadata = { "offset" : _get_interrupt_time_enabled_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def interrupt_time_enabled(self) -> bool:
        """Check to see if the interrupt time is enabled for this procedure."""
        return self._intf.get_property(ProcedureTimeOptions._metadata, ProcedureTimeOptions._get_interrupt_time_enabled_metadata)

    _get_use_interrupt_time_metadata = { "offset" : _get_use_interrupt_time_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_interrupt_time(self) -> bool:
        """Opt whether to set an interrupt time for the procedure."""
        return self._intf.get_property(ProcedureTimeOptions._metadata, ProcedureTimeOptions._get_use_interrupt_time_metadata)

    _set_use_interrupt_time_metadata = { "offset" : _set_use_interrupt_time_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_interrupt_time.setter
    def use_interrupt_time(self, value:bool) -> None:
        """Opt whether to set an interrupt time for the procedure."""
        return self._intf.set_property(ProcedureTimeOptions._metadata, ProcedureTimeOptions._set_use_interrupt_time_metadata, value)

    _get_interrupt_time_metadata = { "offset" : _get_interrupt_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def interrupt_time(self) -> typing.Any:
        """Interrupt time for the procedure."""
        return self._intf.get_property(ProcedureTimeOptions._metadata, ProcedureTimeOptions._get_interrupt_time_metadata)

    _set_interrupt_time_metadata = { "offset" : _set_interrupt_time_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def set_interrupt_time(self, time:typing.Any) -> None:
        """Set the interrupt time for the procedure."""
        return self._intf.invoke(ProcedureTimeOptions._metadata, ProcedureTimeOptions._set_interrupt_time_metadata, time)

    _get_stop_time_enabled_metadata = { "offset" : _get_stop_time_enabled_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def stop_time_enabled(self) -> bool:
        """Check to see if the stop time is enabled for this procedure."""
        return self._intf.get_property(ProcedureTimeOptions._metadata, ProcedureTimeOptions._get_stop_time_enabled_metadata)

    _get_use_stop_time_metadata = { "offset" : _get_use_stop_time_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_stop_time(self) -> bool:
        """Opt whether to set a stop  time for the procedure."""
        return self._intf.get_property(ProcedureTimeOptions._metadata, ProcedureTimeOptions._get_use_stop_time_metadata)

    _set_use_stop_time_metadata = { "offset" : _set_use_stop_time_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_stop_time.setter
    def use_stop_time(self, value:bool) -> None:
        """Opt whether to set a stop time for the procedure."""
        return self._intf.set_property(ProcedureTimeOptions._metadata, ProcedureTimeOptions._set_use_stop_time_metadata, value)

    _get_stop_time_metadata = { "offset" : _get_stop_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def stop_time(self) -> typing.Any:
        """Stop time for the procedure."""
        return self._intf.get_property(ProcedureTimeOptions._metadata, ProcedureTimeOptions._get_stop_time_metadata)

    _set_stop_time_metadata = { "offset" : _set_stop_time_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def set_stop_time(self, time:typing.Any) -> None:
        """Set the stop time for the procedure."""
        return self._intf.invoke(ProcedureTimeOptions._metadata, ProcedureTimeOptions._set_stop_time_metadata, time)

    _property_names[start_time_enabled] = "start_time_enabled"
    _property_names[use_start_time] = "use_start_time"
    _property_names[start_time] = "start_time"
    _property_names[interrupt_time_enabled] = "interrupt_time_enabled"
    _property_names[use_interrupt_time] = "use_interrupt_time"
    _property_names[interrupt_time] = "interrupt_time"
    _property_names[stop_time_enabled] = "stop_time_enabled"
    _property_names[use_stop_time] = "use_stop_time"
    _property_names[stop_time] = "stop_time"

    def __init__(self, source_object=None):
        """Construct an object of type ProcedureTimeOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProcedureTimeOptions)
    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, ProcedureTimeOptions, [ProcedureTimeOptions, ])

agcls.AgClassCatalog.add_catalog_entry((4806824256453033598, 10159111947367507632), ProcedureTimeOptions)
agcls.AgTypeNameMap["ProcedureTimeOptions"] = ProcedureTimeOptions

class CalculationOptions(SupportsDeleteCallback):
    """Interface used to access the calculation options for a procedure or phase."""

    _num_methods = 14
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_max_relative_motion_factor_method_offset = 1
    _set_max_relative_motion_factor_method_offset = 2
    _get_state_cache_time_interval_method_offset = 3
    _set_state_cache_time_interval_method_offset = 4
    _get_time_resolution_method_offset = 5
    _set_time_resolution_method_offset = 6
    _get_max_iterations_method_offset = 7
    _set_max_iterations_method_offset = 8
    _get_max_bad_steps_method_offset = 9
    _set_max_bad_steps_method_offset = 10
    _get_integrator_type_method_offset = 11
    _set_integrator_type_method_offset = 12
    _get_integrator_type_string_method_offset = 13
    _set_integrator_type_string_method_offset = 14
    _metadata = {
        "iid_data" : (4930309390064999262, 5777468632786382513),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CalculationOptions)

    _get_max_relative_motion_factor_metadata = { "offset" : _get_max_relative_motion_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_relative_motion_factor(self) -> float:
        """Get or set the maximum motion allowed between sampling points."""
        return self._intf.get_property(CalculationOptions._metadata, CalculationOptions._get_max_relative_motion_factor_metadata)

    _set_max_relative_motion_factor_metadata = { "offset" : _set_max_relative_motion_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_relative_motion_factor.setter
    def max_relative_motion_factor(self, value:float) -> None:
        """Get or set the maximum motion allowed between sampling points."""
        return self._intf.set_property(CalculationOptions._metadata, CalculationOptions._set_max_relative_motion_factor_metadata, value)

    _get_state_cache_time_interval_metadata = { "offset" : _get_state_cache_time_interval_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def state_cache_time_interval(self) -> float:
        """Get or set the time interval used to store the state information."""
        return self._intf.get_property(CalculationOptions._metadata, CalculationOptions._get_state_cache_time_interval_metadata)

    _set_state_cache_time_interval_metadata = { "offset" : _set_state_cache_time_interval_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @state_cache_time_interval.setter
    def state_cache_time_interval(self, value:float) -> None:
        """Get or set the time interval used to store the state information."""
        return self._intf.set_property(CalculationOptions._metadata, CalculationOptions._set_state_cache_time_interval_metadata, value)

    _get_time_resolution_metadata = { "offset" : _get_time_resolution_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def time_resolution(self) -> float:
        """Get or set the tolerance for resolving time calculations."""
        return self._intf.get_property(CalculationOptions._metadata, CalculationOptions._get_time_resolution_metadata)

    _set_time_resolution_metadata = { "offset" : _set_time_resolution_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @time_resolution.setter
    def time_resolution(self, value:float) -> None:
        """Get or set the tolerance for resolving time calculations."""
        return self._intf.set_property(CalculationOptions._metadata, CalculationOptions._set_time_resolution_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 per time step Aviator will attempt."""
        return self._intf.get_property(CalculationOptions._metadata, CalculationOptions._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:
        """Get or set the maximum number of iterations per time step Aviator will attempt."""
        return self._intf.set_property(CalculationOptions._metadata, CalculationOptions._set_max_iterations_metadata, value)

    _get_max_bad_steps_metadata = { "offset" : _get_max_bad_steps_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_bad_steps(self) -> int:
        """Get or set the maximum number of bad steps Aviator will allow before ceasing calculation."""
        return self._intf.get_property(CalculationOptions._metadata, CalculationOptions._get_max_bad_steps_metadata)

    _set_max_bad_steps_metadata = { "offset" : _set_max_bad_steps_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_bad_steps.setter
    def max_bad_steps(self, value:int) -> None:
        """Get or set the maximum number of bad steps Aviator will allow before ceasing calculation."""
        return self._intf.set_property(CalculationOptions._metadata, CalculationOptions._set_max_bad_steps_metadata, value)

    _get_integrator_type_metadata = { "offset" : _get_integrator_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AviatorNumericalIntegrator),) }
    @property
    def integrator_type(self) -> "AviatorNumericalIntegrator":
        """Get or set the integrator type."""
        return self._intf.get_property(CalculationOptions._metadata, CalculationOptions._get_integrator_type_metadata)

    _set_integrator_type_metadata = { "offset" : _set_integrator_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AviatorNumericalIntegrator),) }
    @integrator_type.setter
    def integrator_type(self, value:"AviatorNumericalIntegrator") -> None:
        """Get or set the integrator type."""
        return self._intf.set_property(CalculationOptions._metadata, CalculationOptions._set_integrator_type_metadata, value)

    _get_integrator_type_string_metadata = { "offset" : _get_integrator_type_string_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def integrator_type_string(self) -> str:
        """Get or set the integrator type as a string value. Use this for custom integrators."""
        return self._intf.get_property(CalculationOptions._metadata, CalculationOptions._get_integrator_type_string_metadata)

    _set_integrator_type_string_metadata = { "offset" : _set_integrator_type_string_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @integrator_type_string.setter
    def integrator_type_string(self, value:str) -> None:
        """Get or set the integrator type as a string value. Use this for custom integrators."""
        return self._intf.set_property(CalculationOptions._metadata, CalculationOptions._set_integrator_type_string_metadata, value)

    _property_names[max_relative_motion_factor] = "max_relative_motion_factor"
    _property_names[state_cache_time_interval] = "state_cache_time_interval"
    _property_names[time_resolution] = "time_resolution"
    _property_names[max_iterations] = "max_iterations"
    _property_names[max_bad_steps] = "max_bad_steps"
    _property_names[integrator_type] = "integrator_type"
    _property_names[integrator_type_string] = "integrator_type_string"

    def __init__(self, source_object=None):
        """Construct an object of type CalculationOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CalculationOptions)
    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, CalculationOptions, [CalculationOptions, ])

agcls.AgClassCatalog.add_catalog_entry((5747373335486459111, 3684632747864185757), CalculationOptions)
agcls.AgTypeNameMap["CalculationOptions"] = CalculationOptions

class AircraftCategory(SupportsDeleteCallback):
    """
    Interface used to access the Aircraft Category in the Aviator Catalog.

    Examples
    --------
    Set the aircraft used for the mission to an aircraft found in the Aviator catalog:
    >>> # AviatorPropagator propagator: Aviator Propagator object
    >>> # Get the Aviator catalog
    >>> catalog = propagator.aviator_catalog
    >>> # Get the aircraft category
    >>> category = catalog.aircraft_category
    >>> # Get the user aircraft models
    >>> aircraftModels = category.aircraft_models
    >>> # Get the basic fighter
    >>> fighter = aircraftModels.get_aircraft("Basic Fighter")
    >>> # Get the mission
    >>> mission = propagator.aviator_mission
    >>> # Set the vehicle used for the mission
    >>> mission.vehicle = fighter
    """

    _num_methods = 3
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _get_aircraft_models_method_offset = 1
    _get_missile_models_method_offset = 2
    _get_rotorcraft_models_method_offset = 3
    _metadata = {
        "iid_data" : (5393766329145449059, 6703502100005194163),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftCategory)

    _get_aircraft_models_metadata = { "offset" : _get_aircraft_models_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def aircraft_models(self) -> "AircraftModels":
        """Get the user aircraft models."""
        return self._intf.get_property(AircraftCategory._metadata, AircraftCategory._get_aircraft_models_metadata)

    _get_missile_models_metadata = { "offset" : _get_missile_models_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def missile_models(self) -> "MissileModels":
        """Get the user missile models."""
        return self._intf.get_property(AircraftCategory._metadata, AircraftCategory._get_missile_models_metadata)

    _get_rotorcraft_models_metadata = { "offset" : _get_rotorcraft_models_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def rotorcraft_models(self) -> "RotorcraftModels":
        """Get the user rotorcraft models."""
        return self._intf.get_property(AircraftCategory._metadata, AircraftCategory._get_rotorcraft_models_metadata)

    _property_names[aircraft_models] = "aircraft_models"
    _property_names[missile_models] = "missile_models"
    _property_names[rotorcraft_models] = "rotorcraft_models"

    def __init__(self, source_object=None):
        """Construct an object of type AircraftCategory."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AircraftCategory)
    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, AircraftCategory, [AircraftCategory, ])

agcls.AgClassCatalog.add_catalog_entry((5038526480345777203, 17565896557184368030), AircraftCategory)
agcls.AgTypeNameMap["AircraftCategory"] = AircraftCategory

class Catalog(SupportsDeleteCallback):
    """
    Interface used to access the Aviator catalog.

    Examples
    --------
    Set the aircraft used for the mission to an aircraft found in the Aviator catalog:
    >>> # AviatorPropagator propagator: Aviator Propagator object
    >>> # Get the Aviator catalog
    >>> catalog = propagator.aviator_catalog
    >>> # Get the aircraft category
    >>> category = catalog.aircraft_category
    >>> # Get the user aircraft models
    >>> aircraftModels = category.aircraft_models
    >>> # Get the basic fighter
    >>> fighter = aircraftModels.get_aircraft("Basic Fighter")
    >>> # Get the mission
    >>> mission = propagator.aviator_mission
    >>> # Set the vehicle used for the mission
    >>> mission.vehicle = fighter

    Configure a runway site from a runway in the Aviator catalog:
    >>> # SiteRunway runway: Runway object
    >>> # Catalog catalog: Aviator catalog object
    >>> # Get the source of user runways
    >>> userRunways = catalog.runway_category.user_runways
    >>> # Check that the runway exists in the catalog
    >>> if userRunways.contains("New User Runway") is True:
    >>>     # If so, get the user runway with the given name
    >>>     runwayFromCatalog = userRunways.get_user_runway("New User Runway")
    >>>     # Copy the parameters of that runway
    >>>     runway.copy_from_catalog(runwayFromCatalog)
    """

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_aircraft_category_method_offset = 1
    _get_runway_category_method_offset = 2
    _get_airport_category_method_offset = 3
    _get_navaid_category_method_offset = 4
    _get_vtol_point_category_method_offset = 5
    _get_waypoint_category_method_offset = 6
    _metadata = {
        "iid_data" : (4867560862593147186, 13685186326758395068),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, Catalog)

    _get_aircraft_category_metadata = { "offset" : _get_aircraft_category_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def aircraft_category(self) -> "AircraftCategory":
        """Get the aircraft category."""
        return self._intf.get_property(Catalog._metadata, Catalog._get_aircraft_category_metadata)

    _get_runway_category_metadata = { "offset" : _get_runway_category_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def runway_category(self) -> "RunwayCategory":
        """Get the runway category."""
        return self._intf.get_property(Catalog._metadata, Catalog._get_runway_category_metadata)

    _get_airport_category_metadata = { "offset" : _get_airport_category_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def airport_category(self) -> "AirportCategory":
        """Get the airport category."""
        return self._intf.get_property(Catalog._metadata, Catalog._get_airport_category_metadata)

    _get_navaid_category_metadata = { "offset" : _get_navaid_category_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def navaid_category(self) -> "NavaidCategory":
        """Get the navaid category."""
        return self._intf.get_property(Catalog._metadata, Catalog._get_navaid_category_metadata)

    _get_vtol_point_category_metadata = { "offset" : _get_vtol_point_category_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def vtol_point_category(self) -> "VTOLPointCategory":
        """Get the vtol point category."""
        return self._intf.get_property(Catalog._metadata, Catalog._get_vtol_point_category_metadata)

    _get_waypoint_category_metadata = { "offset" : _get_waypoint_category_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def waypoint_category(self) -> "WaypointCategory":
        """Get the waypoint category."""
        return self._intf.get_property(Catalog._metadata, Catalog._get_waypoint_category_metadata)

    _property_names[aircraft_category] = "aircraft_category"
    _property_names[runway_category] = "runway_category"
    _property_names[airport_category] = "airport_category"
    _property_names[navaid_category] = "navaid_category"
    _property_names[vtol_point_category] = "vtol_point_category"
    _property_names[waypoint_category] = "waypoint_category"

    def __init__(self, source_object=None):
        """Construct an object of type Catalog."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, Catalog)
    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, Catalog, [Catalog, ])

agcls.AgClassCatalog.add_catalog_entry((4907045706268839733, 1198668682488985004), Catalog)
agcls.AgTypeNameMap["Catalog"] = Catalog

class AircraftModel(IAviatorVehicle, ICatalogItem, SupportsDeleteCallback):
    """
    Interface used to access the aircraft options in the Aviator catalog.

    Examples
    --------
    Configure the Advanced Fixed Wing Tool and set the aircraft to use the resulting performance models:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the advanced fixed wing tool
    >>> advFixedWingTool = aviatorAircraft.advanced_fixed_wing_tool
    >>> # Set the basic geometry
    >>> advFixedWingTool.wing_area = 300
    >>> advFixedWingTool.flaps_area = 50
    >>> advFixedWingTool.speedbrakes_area = 10
    >>> # Set the structural and human factor limits
    >>> advFixedWingTool.max_altitude = 65000
    >>> advFixedWingTool.max_mach = 0.98
    >>> advFixedWingTool.max_eas = 460
    >>> advFixedWingTool.min_load_factor = -2.5
    >>> advFixedWingTool.max_load_factor = 4.5
    >>>
    >>> # Opt to enforce the max temperature limit
    >>> advFixedWingTool.use_max_temperature_limit = True
    >>> advFixedWingTool.max_temperature = 900
    >>>
    >>> # Use a subsonic aerodynamic strategy
    >>> advFixedWingTool.aerodynamic_strategy = AdvancedFixedWingAerodynamicStrategy.SUBSONIC_AERODYNAMIC
    >>> # Cache the aerodynamic data to improve calculation speed
    >>> advFixedWingTool.cache_aerodynamic_data = True
    >>> # Use a high bypass turbofan
    >>> advFixedWingTool.powerplant_strategy = AdvancedFixedWingPowerplantStrategy.TURBOFAN_HIGH_BYPASS
    >>> # Cache the fuel flow data to improve calculation speed
    >>> advFixedWingTool.cache_fuel_flow = True
    >>>
    >>> # Create the corresponding performance models that reference the advanced fixed wing tool
    >>> # Specify the name, whether to override any existing models with the same name, and whether to set the new models as the default performance models
    >>> advFixedWingTool.create_all_performance_models("AdvancedModels", True, True)
    >>>
    >>> # Save the changes in the catalog
    >>> aviatorAircraft.save()

    Set the aircraft used for the mission to an aircraft found in the Aviator catalog:
    >>> # AviatorPropagator propagator: Aviator Propagator object
    >>> # Get the Aviator catalog
    >>> catalog = propagator.aviator_catalog
    >>> # Get the aircraft category
    >>> category = catalog.aircraft_category
    >>> # Get the user aircraft models
    >>> aircraftModels = category.aircraft_models
    >>> # Get the basic fighter
    >>> fighter = aircraftModels.get_aircraft("Basic Fighter")
    >>> # Get the mission
    >>> mission = propagator.aviator_mission
    >>> # Set the vehicle used for the mission
    >>> mission.vehicle = fighter

    Create a new performance model for an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the acceleration type
    >>> acceleration = aviatorAircraft.acceleration
    >>> # Get the names of the current acceleration models
    >>> modelNames = acceleration.child_names
    >>> # Check how many models there are
    >>> modelCount = len(modelNames)
    >>> # Get the child types (for example AGI Basic Acceleration Model, Advanced Acceleration Model)
    >>> modelTypes = acceleration.child_types
    >>> # Create a new performance model of type "Advanced Acceleration Model"
    >>> newPerformanceModel = acceleration.add_child_of_type("Advanced Acceleration Model", "Model Name")
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()

    Configure the basic cruise performance model of an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the cruise type
    >>> cruise = aviatorAircraft.cruise
    >>> # Get the build in performance model
    >>> basicCruiseModel = cruise.get_built_in_model()
    >>>
    >>> # Set the ceiling altitude
    >>> basicCruiseModel.ceiling_altitude = 50000
    >>> # Set the default cruise altitude
    >>> basicCruiseModel.default_cruise_altitude = 10000
    >>> # Set the airspeed type
    >>> basicCruiseModel.airspeed_type = AirspeedType.TAS
    >>> # Opt to not use the fuel flow calculated by the aero/prop model and instead specify the values
    >>> basicCruiseModel.use_aerodynamic_propulsion_fuel = False
    >>>
    >>> # Set the various airspeeds and fuel flows
    >>> basicCruiseModel.min_airspeed = 110
    >>> basicCruiseModel.min_airspeed_fuel_flow = 10000
    >>>
    >>> basicCruiseModel.max_endurance_airspeed = 135
    >>> basicCruiseModel.max_endurance_fuel_flow = 8000
    >>>
    >>> basicCruiseModel.max_airspeed = 570
    >>> basicCruiseModel.max_airspeed_fuel_flow = 30000
    >>>
    >>> basicCruiseModel.max_range_airspeed = 140
    >>> basicCruiseModel.max_range_fuel_flow = 9000
    >>>
    >>> basicCruiseModel.max_performance_airspeed = 150
    >>> basicCruiseModel.max_performance_airspeed_fuel_flow = 12000
    >>>
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()

    Configure the basic acceleration performance model of an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the acceleration type
    >>> acceleration = aviatorAircraft.acceleration
    >>> # Get the build in performance model
    >>> basicAccModel = acceleration.get_built_in_model()
    >>>
    >>> # Get the level turns options
    >>> levelTurns = basicAccModel.level_turns
    >>> # Set a max bank angle of 25
    >>> levelTurns.set_level_turn(TurnMode.TURN_MODE_BANK_ANGLE, 25)
    >>> # Get the climb and descent transition options
    >>> climbAndDescent = basicAccModel.climb_and_descent_transitions
    >>> # Set the max pull up G to 1
    >>> climbAndDescent.max_pull_up_g = 1.2
    >>> # Get the attitude transition options
    >>> attitudeTransitions = basicAccModel.attitude_transitions
    >>> # Set the max roll rate to 25
    >>> attitudeTransitions.roll_rate = 25
    >>>
    >>> # Get the aerodynamics
    >>> aero = basicAccModel.aerodynamics
    >>> # Use simple aerodynamics
    >>> aero.aerodynamic_strategy = AircraftAerodynamicStrategy.AIRCRAFT_AERODYNAMIC_SIMPLE
    >>> # Get the options for the simple aerodynamics and set some parameters
    >>> simpleAero = aero.mode_as_simple
    >>> simpleAero.s_reference = 5
    >>> simpleAero.cl_max = 3.1
    >>> simpleAero.cd = 0.05
    >>>
    >>> # Get the propulsion
    >>> prop = basicAccModel.propulsion
    >>> # Use simple propulsion
    >>> prop.propulsion_strategy = AircraftPropulsionStrategy.AIRCRAFT_PROPULSION_SIMPLE
    >>> # Get the simple propulsion options and set some parameters
    >>> simpleProp = prop.mode_as_simple
    >>> simpleProp.max_thrust_acceleration = 0.6
    >>> simpleProp.min_thrust_deceleration = 0.4
    >>> simpleProp.set_density_scaling(True, 0.02)
    >>>
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()
    """

    _num_methods = 12
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_performance_model_types_method_offset = 1
    _get_acceleration_method_offset = 2
    _get_climb_method_offset = 3
    _get_cruise_method_offset = 4
    _get_descent_method_offset = 5
    _get_landing_method_offset = 6
    _get_takeoff_method_offset = 7
    _get_default_configuration_method_offset = 8
    _get_advanced_fixed_wing_tool_method_offset = 9
    _get_as_catalog_item_method_offset = 10
    _get_vtol_method_offset = 11
    _get_terrain_follow_method_offset = 12
    _metadata = {
        "iid_data" : (4972221985443648774, 11607092758271299260),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftModel)

    _get_performance_model_types_metadata = { "offset" : _get_performance_model_types_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def performance_model_types(self) -> list:
        """Get the types of performance models."""
        return self._intf.get_property(AircraftModel._metadata, AircraftModel._get_performance_model_types_metadata)

    _get_acceleration_metadata = { "offset" : _get_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def acceleration(self) -> "AircraftAcceleration":
        """Get the acceleration interface."""
        return self._intf.get_property(AircraftModel._metadata, AircraftModel._get_acceleration_metadata)

    _get_climb_metadata = { "offset" : _get_climb_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def climb(self) -> "AircraftClimb":
        """Get the climb interface."""
        return self._intf.get_property(AircraftModel._metadata, AircraftModel._get_climb_metadata)

    _get_cruise_metadata = { "offset" : _get_cruise_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def cruise(self) -> "AircraftCruise":
        """Get the cruise interface."""
        return self._intf.get_property(AircraftModel._metadata, AircraftModel._get_cruise_metadata)

    _get_descent_metadata = { "offset" : _get_descent_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def descent(self) -> "AircraftDescent":
        """Get the descent interface."""
        return self._intf.get_property(AircraftModel._metadata, AircraftModel._get_descent_metadata)

    _get_landing_metadata = { "offset" : _get_landing_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def landing(self) -> "AircraftLanding":
        """Get the landing interface."""
        return self._intf.get_property(AircraftModel._metadata, AircraftModel._get_landing_metadata)

    _get_takeoff_metadata = { "offset" : _get_takeoff_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def takeoff(self) -> "AircraftTakeoff":
        """Get the takeoff interface."""
        return self._intf.get_property(AircraftModel._metadata, AircraftModel._get_takeoff_metadata)

    _get_default_configuration_metadata = { "offset" : _get_default_configuration_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def default_configuration(self) -> "Configuration":
        """Get the aircraft's default configuration as saved in the catalog."""
        return self._intf.get_property(AircraftModel._metadata, AircraftModel._get_default_configuration_metadata)

    _get_advanced_fixed_wing_tool_metadata = { "offset" : _get_advanced_fixed_wing_tool_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def advanced_fixed_wing_tool(self) -> "AdvancedFixedWingTool":
        """Get the Advanced Fixed Wing Tool for the aircraft."""
        return self._intf.get_property(AircraftModel._metadata, AircraftModel._get_advanced_fixed_wing_tool_metadata)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftModel._metadata, AircraftModel._get_as_catalog_item_metadata, OutArg())

    _get_vtol_metadata = { "offset" : _get_vtol_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def vtol(self) -> "AircraftVTOL":
        """Get the VTOL interface."""
        return self._intf.get_property(AircraftModel._metadata, AircraftModel._get_vtol_metadata)

    _get_terrain_follow_metadata = { "offset" : _get_terrain_follow_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def terrain_follow(self) -> "AircraftTerrainFollow":
        """Get the TerrainFollow interface."""
        return self._intf.get_property(AircraftModel._metadata, AircraftModel._get_terrain_follow_metadata)

    _property_names[performance_model_types] = "performance_model_types"
    _property_names[acceleration] = "acceleration"
    _property_names[climb] = "climb"
    _property_names[cruise] = "cruise"
    _property_names[descent] = "descent"
    _property_names[landing] = "landing"
    _property_names[takeoff] = "takeoff"
    _property_names[default_configuration] = "default_configuration"
    _property_names[advanced_fixed_wing_tool] = "advanced_fixed_wing_tool"
    _property_names[vtol] = "vtol"
    _property_names[terrain_follow] = "terrain_follow"

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

agcls.AgClassCatalog.add_catalog_entry((5272649341851046442, 10204808036967213963), AircraftModel)
agcls.AgTypeNameMap["AircraftModel"] = AircraftModel

class MissileModel(IAviatorVehicle, ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the missile options in the Aviator catalog."""

    _num_methods = 47
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_max_load_factor_method_offset = 1
    _set_max_load_factor_method_offset = 2
    _get_maneuver_mode_method_offset = 3
    _set_maneuver_mode_method_offset = 4
    _get_maneuver_mode_helper_method_offset = 5
    _get_attitude_transitions_method_offset = 6
    _get_ignore_flight_path_angle_for_climb_descent_transitions_method_offset = 7
    _set_ignore_flight_path_angle_for_climb_descent_transitions_method_offset = 8
    _get_climb_airspeed_method_offset = 9
    _get_climb_airspeed_type_method_offset = 10
    _set_climb_airspeed_method_offset = 11
    _get_climb_max_flight_path_angle_method_offset = 12
    _set_climb_max_flight_path_angle_method_offset = 13
    _get_climb_min_flight_path_angle_method_offset = 14
    _set_climb_min_flight_path_angle_method_offset = 15
    _get_climb_fail_on_insufficient_performance_method_offset = 16
    _set_climb_fail_on_insufficient_performance_method_offset = 17
    _get_cruise_max_airspeed_method_offset = 18
    _get_cruise_max_airspeed_type_method_offset = 19
    _set_cruise_max_airspeed_method_offset = 20
    _get_cruise_default_altitude_method_offset = 21
    _set_cruise_default_altitude_method_offset = 22
    _get_descent_airspeed_method_offset = 23
    _get_descent_airspeed_type_method_offset = 24
    _set_descent_airspeed_method_offset = 25
    _get_descent_max_flight_path_angle_method_offset = 26
    _set_descent_max_flight_path_angle_method_offset = 27
    _get_descent_min_flight_path_angle_method_offset = 28
    _set_descent_min_flight_path_angle_method_offset = 29
    _get_descent_fail_on_insufficient_performance_method_offset = 30
    _set_descent_fail_on_insufficient_performance_method_offset = 31
    _get_use_total_temp_limit_method_offset = 32
    _set_use_total_temp_limit_method_offset = 33
    _get_total_temp_limit_method_offset = 34
    _set_total_temp_limit_method_offset = 35
    _get_use_mach_limit_method_offset = 36
    _set_use_mach_limit_method_offset = 37
    _get_mach_limit_method_offset = 38
    _set_mach_limit_method_offset = 39
    _get_use_eas_limit_method_offset = 40
    _set_use_eas_limit_method_offset = 41
    _get_eas_limit_method_offset = 42
    _set_eas_limit_method_offset = 43
    _get_default_configuration_method_offset = 44
    _get_aerodynamics_method_offset = 45
    _get_propulsion_method_offset = 46
    _get_as_catalog_item_method_offset = 47
    _metadata = {
        "iid_data" : (5036037641348746326, 5450613477693494170),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MissileModel)

    _get_max_load_factor_metadata = { "offset" : _get_max_load_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_load_factor(self) -> float:
        """Get or set the maximum load factor that the missile can withstand while maneuvering."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_max_load_factor_metadata)

    _set_max_load_factor_metadata = { "offset" : _set_max_load_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_load_factor.setter
    def max_load_factor(self, value:float) -> None:
        """Get or set the maximum load factor that the missile can withstand while maneuvering."""
        return self._intf.set_property(MissileModel._metadata, MissileModel._set_max_load_factor_metadata, value)

    _get_maneuver_mode_metadata = { "offset" : _get_maneuver_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AccelerationManeuverMode),) }
    @property
    def maneuver_mode(self) -> "AccelerationManeuverMode":
        """Get or set the mode that the missile will adhere to the specified load factor. Scale by atmospheric density will cause the missile to consider dynamic pressure when calculating turn radius."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_maneuver_mode_metadata)

    _set_maneuver_mode_metadata = { "offset" : _set_maneuver_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AccelerationManeuverMode),) }
    @maneuver_mode.setter
    def maneuver_mode(self, value:"AccelerationManeuverMode") -> None:
        """Get or set the mode that the missile will adhere to the specified load factor. Scale by atmospheric density will cause the missile to consider dynamic pressure when calculating turn radius."""
        return self._intf.set_property(MissileModel._metadata, MissileModel._set_maneuver_mode_metadata, value)

    _get_maneuver_mode_helper_metadata = { "offset" : _get_maneuver_mode_helper_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def maneuver_mode_helper(self) -> "AerodynamicPropulsionManeuverModeHelper":
        """Get the interface for the Aero/Prop Maneuver Mode helper. The maneuver mode must be set to Aero/Prop to access this interface."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_maneuver_mode_helper_metadata)

    _get_attitude_transitions_metadata = { "offset" : _get_attitude_transitions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def attitude_transitions(self) -> "AttitudeTransitions":
        """Get the attitude transitions interface."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_attitude_transitions_metadata)

    _get_ignore_flight_path_angle_for_climb_descent_transitions_metadata = { "offset" : _get_ignore_flight_path_angle_for_climb_descent_transitions_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def ignore_flight_path_angle_for_climb_descent_transitions(self) -> bool:
        """Opt whether to ignore the flight path angle limits for climb and descent transitions."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_ignore_flight_path_angle_for_climb_descent_transitions_metadata)

    _set_ignore_flight_path_angle_for_climb_descent_transitions_metadata = { "offset" : _set_ignore_flight_path_angle_for_climb_descent_transitions_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @ignore_flight_path_angle_for_climb_descent_transitions.setter
    def ignore_flight_path_angle_for_climb_descent_transitions(self, value:bool) -> None:
        """Opt whether to ignore the flight path angle limits for climb and descent transitions."""
        return self._intf.set_property(MissileModel._metadata, MissileModel._set_ignore_flight_path_angle_for_climb_descent_transitions_metadata, value)

    _get_climb_airspeed_metadata = { "offset" : _get_climb_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def climb_airspeed(self) -> float:
        """Get the standard airspeed of the missile while climbing."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_climb_airspeed_metadata)

    _get_climb_airspeed_type_metadata = { "offset" : _get_climb_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def climb_airspeed_type(self) -> "AirspeedType":
        """Get the climb airspeed type."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_climb_airspeed_type_metadata)

    _set_climb_airspeed_metadata = { "offset" : _set_climb_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_climb_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the missile's climb airspeed and airspeed type."""
        return self._intf.invoke(MissileModel._metadata, MissileModel._set_climb_airspeed_metadata, airspeed_type, airspeed)

    _get_climb_max_flight_path_angle_metadata = { "offset" : _get_climb_max_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def climb_max_flight_path_angle(self) -> typing.Any:
        """Get or set the maximum flight path angle of the missile's flight path while climbing."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_climb_max_flight_path_angle_metadata)

    _set_climb_max_flight_path_angle_metadata = { "offset" : _set_climb_max_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @climb_max_flight_path_angle.setter
    def climb_max_flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the maximum flight path angle of the missile's flight path while climbing."""
        return self._intf.set_property(MissileModel._metadata, MissileModel._set_climb_max_flight_path_angle_metadata, value)

    _get_climb_min_flight_path_angle_metadata = { "offset" : _get_climb_min_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def climb_min_flight_path_angle(self) -> typing.Any:
        """Get or set the minimum flight path angle of the missile's flight path while climbing."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_climb_min_flight_path_angle_metadata)

    _set_climb_min_flight_path_angle_metadata = { "offset" : _set_climb_min_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @climb_min_flight_path_angle.setter
    def climb_min_flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the minimum flight path angle of the missile's flight path while climbing."""
        return self._intf.set_property(MissileModel._metadata, MissileModel._set_climb_min_flight_path_angle_metadata, value)

    _get_climb_fail_on_insufficient_performance_metadata = { "offset" : _get_climb_fail_on_insufficient_performance_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def climb_fail_on_insufficient_performance(self) -> bool:
        """Opt whether to fail while climbing if there is insufficient specific excess power."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_climb_fail_on_insufficient_performance_metadata)

    _set_climb_fail_on_insufficient_performance_metadata = { "offset" : _set_climb_fail_on_insufficient_performance_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @climb_fail_on_insufficient_performance.setter
    def climb_fail_on_insufficient_performance(self, value:bool) -> None:
        """Opt whether to fail while climbing if there is insufficient specific excess power."""
        return self._intf.set_property(MissileModel._metadata, MissileModel._set_climb_fail_on_insufficient_performance_metadata, value)

    _get_cruise_max_airspeed_metadata = { "offset" : _get_cruise_max_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cruise_max_airspeed(self) -> float:
        """Get the maximum airspeed of the missile while cruising."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_cruise_max_airspeed_metadata)

    _get_cruise_max_airspeed_type_metadata = { "offset" : _get_cruise_max_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def cruise_max_airspeed_type(self) -> "AirspeedType":
        """Get the cruise airspeed type."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_cruise_max_airspeed_type_metadata)

    _set_cruise_max_airspeed_metadata = { "offset" : _set_cruise_max_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_cruise_max_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the missile's max cruise airspeed and airspeed type."""
        return self._intf.invoke(MissileModel._metadata, MissileModel._set_cruise_max_airspeed_metadata, airspeed_type, airspeed)

    _get_cruise_default_altitude_metadata = { "offset" : _get_cruise_default_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cruise_default_altitude(self) -> float:
        """Get or set the missile's default cruising altitude."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_cruise_default_altitude_metadata)

    _set_cruise_default_altitude_metadata = { "offset" : _set_cruise_default_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cruise_default_altitude.setter
    def cruise_default_altitude(self, value:float) -> None:
        """Get or set the missile's default cruising altitude."""
        return self._intf.set_property(MissileModel._metadata, MissileModel._set_cruise_default_altitude_metadata, value)

    _get_descent_airspeed_metadata = { "offset" : _get_descent_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def descent_airspeed(self) -> float:
        """Get the standard airspeed of the missile while descending."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_descent_airspeed_metadata)

    _get_descent_airspeed_type_metadata = { "offset" : _get_descent_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def descent_airspeed_type(self) -> "AirspeedType":
        """Get the descent airspeed type."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_descent_airspeed_type_metadata)

    _set_descent_airspeed_metadata = { "offset" : _set_descent_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_descent_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the missile's descent airspeed and airspeed type."""
        return self._intf.invoke(MissileModel._metadata, MissileModel._set_descent_airspeed_metadata, airspeed_type, airspeed)

    _get_descent_max_flight_path_angle_metadata = { "offset" : _get_descent_max_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def descent_max_flight_path_angle(self) -> typing.Any:
        """Get or set the maximum flight path angle of the missile's flight path while descending."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_descent_max_flight_path_angle_metadata)

    _set_descent_max_flight_path_angle_metadata = { "offset" : _set_descent_max_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @descent_max_flight_path_angle.setter
    def descent_max_flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the maximum flight path angle of the missile's flight path while descending."""
        return self._intf.set_property(MissileModel._metadata, MissileModel._set_descent_max_flight_path_angle_metadata, value)

    _get_descent_min_flight_path_angle_metadata = { "offset" : _get_descent_min_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def descent_min_flight_path_angle(self) -> typing.Any:
        """Get or set the minimum flight path angle of the missile's flight path while descending."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_descent_min_flight_path_angle_metadata)

    _set_descent_min_flight_path_angle_metadata = { "offset" : _set_descent_min_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @descent_min_flight_path_angle.setter
    def descent_min_flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the minimum flight path angle of the missile's flight path while descending."""
        return self._intf.set_property(MissileModel._metadata, MissileModel._set_descent_min_flight_path_angle_metadata, value)

    _get_descent_fail_on_insufficient_performance_metadata = { "offset" : _get_descent_fail_on_insufficient_performance_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def descent_fail_on_insufficient_performance(self) -> bool:
        """Opt whether to fail while descending if there is insufficient specific excess power."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_descent_fail_on_insufficient_performance_metadata)

    _set_descent_fail_on_insufficient_performance_metadata = { "offset" : _set_descent_fail_on_insufficient_performance_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @descent_fail_on_insufficient_performance.setter
    def descent_fail_on_insufficient_performance(self, value:bool) -> None:
        """Opt whether to fail while descending if there is insufficient specific excess power."""
        return self._intf.set_property(MissileModel._metadata, MissileModel._set_descent_fail_on_insufficient_performance_metadata, value)

    _get_use_total_temp_limit_metadata = { "offset" : _get_use_total_temp_limit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_total_temp_limit(self) -> bool:
        """Opt whether to limit the speed of the missile so the specified temperature is not exceeded."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_use_total_temp_limit_metadata)

    _set_use_total_temp_limit_metadata = { "offset" : _set_use_total_temp_limit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_total_temp_limit.setter
    def use_total_temp_limit(self, value:bool) -> None:
        """Opt whether to limit the speed of the missile so the specified temperature is not exceeded."""
        return self._intf.set_property(MissileModel._metadata, MissileModel._set_use_total_temp_limit_metadata, value)

    _get_total_temp_limit_metadata = { "offset" : _get_total_temp_limit_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def total_temp_limit(self) -> float:
        """Get or set the maximum total temperature limit of the missile."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_total_temp_limit_metadata)

    _set_total_temp_limit_metadata = { "offset" : _set_total_temp_limit_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @total_temp_limit.setter
    def total_temp_limit(self, value:float) -> None:
        """Get or set the maximum total temperature limit of the missile."""
        return self._intf.set_property(MissileModel._metadata, MissileModel._set_total_temp_limit_metadata, value)

    _get_use_mach_limit_metadata = { "offset" : _get_use_mach_limit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_mach_limit(self) -> bool:
        """Opt whether to limit the speed of the missile so the specified mach number is not exceeded."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_use_mach_limit_metadata)

    _set_use_mach_limit_metadata = { "offset" : _set_use_mach_limit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_mach_limit.setter
    def use_mach_limit(self, value:bool) -> None:
        """Opt whether to limit the speed of the missile so the specified mach number is not exceeded."""
        return self._intf.set_property(MissileModel._metadata, MissileModel._set_use_mach_limit_metadata, value)

    _get_mach_limit_metadata = { "offset" : _get_mach_limit_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mach_limit(self) -> float:
        """Get or set the maximum allowable mach number."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_mach_limit_metadata)

    _set_mach_limit_metadata = { "offset" : _set_mach_limit_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mach_limit.setter
    def mach_limit(self, value:float) -> None:
        """Get or set the maximum allowable mach number."""
        return self._intf.set_property(MissileModel._metadata, MissileModel._set_mach_limit_metadata, value)

    _get_use_eas_limit_metadata = { "offset" : _get_use_eas_limit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_eas_limit(self) -> bool:
        """Opt whether to limit the speed of the missile so the specified Equivalent Airspeed is not exceeded."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_use_eas_limit_metadata)

    _set_use_eas_limit_metadata = { "offset" : _set_use_eas_limit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_eas_limit.setter
    def use_eas_limit(self, value:bool) -> None:
        """Opt whether to limit the speed of the missile so the specified Equivalent Airspeed is not exceeded."""
        return self._intf.set_property(MissileModel._metadata, MissileModel._set_use_eas_limit_metadata, value)

    _get_eas_limit_metadata = { "offset" : _get_eas_limit_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def eas_limit(self) -> float:
        """Get or set the maximum allowable Equivalent Airspeed."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_eas_limit_metadata)

    _set_eas_limit_metadata = { "offset" : _set_eas_limit_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @eas_limit.setter
    def eas_limit(self, value:float) -> None:
        """Get or set the maximum allowable Equivalent Airspeed."""
        return self._intf.set_property(MissileModel._metadata, MissileModel._set_eas_limit_metadata, value)

    _get_default_configuration_metadata = { "offset" : _get_default_configuration_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def default_configuration(self) -> "Configuration":
        """Get the aircraft's default configuration as saved in the catalog."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_default_configuration_metadata)

    _get_aerodynamics_metadata = { "offset" : _get_aerodynamics_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def aerodynamics(self) -> "MissileAerodynamic":
        """Get the aerodynamics interface."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_aerodynamics_metadata)

    _get_propulsion_metadata = { "offset" : _get_propulsion_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def propulsion(self) -> "MissilePropulsion":
        """Get the propulsion interface."""
        return self._intf.get_property(MissileModel._metadata, MissileModel._get_propulsion_metadata)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(MissileModel._metadata, MissileModel._get_as_catalog_item_metadata, OutArg())

    _property_names[max_load_factor] = "max_load_factor"
    _property_names[maneuver_mode] = "maneuver_mode"
    _property_names[maneuver_mode_helper] = "maneuver_mode_helper"
    _property_names[attitude_transitions] = "attitude_transitions"
    _property_names[ignore_flight_path_angle_for_climb_descent_transitions] = "ignore_flight_path_angle_for_climb_descent_transitions"
    _property_names[climb_airspeed] = "climb_airspeed"
    _property_names[climb_airspeed_type] = "climb_airspeed_type"
    _property_names[climb_max_flight_path_angle] = "climb_max_flight_path_angle"
    _property_names[climb_min_flight_path_angle] = "climb_min_flight_path_angle"
    _property_names[climb_fail_on_insufficient_performance] = "climb_fail_on_insufficient_performance"
    _property_names[cruise_max_airspeed] = "cruise_max_airspeed"
    _property_names[cruise_max_airspeed_type] = "cruise_max_airspeed_type"
    _property_names[cruise_default_altitude] = "cruise_default_altitude"
    _property_names[descent_airspeed] = "descent_airspeed"
    _property_names[descent_airspeed_type] = "descent_airspeed_type"
    _property_names[descent_max_flight_path_angle] = "descent_max_flight_path_angle"
    _property_names[descent_min_flight_path_angle] = "descent_min_flight_path_angle"
    _property_names[descent_fail_on_insufficient_performance] = "descent_fail_on_insufficient_performance"
    _property_names[use_total_temp_limit] = "use_total_temp_limit"
    _property_names[total_temp_limit] = "total_temp_limit"
    _property_names[use_mach_limit] = "use_mach_limit"
    _property_names[mach_limit] = "mach_limit"
    _property_names[use_eas_limit] = "use_eas_limit"
    _property_names[eas_limit] = "eas_limit"
    _property_names[default_configuration] = "default_configuration"
    _property_names[aerodynamics] = "aerodynamics"
    _property_names[propulsion] = "propulsion"

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

agcls.AgClassCatalog.add_catalog_entry((5537525572496185256, 6677635249753434025), MissileModel)
agcls.AgTypeNameMap["MissileModel"] = MissileModel

class RotorcraftModel(IAviatorVehicle, ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the rotorcraft options in the Aviator catalog."""

    _num_methods = 44
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_max_altitude_method_offset = 1
    _set_max_altitude_method_offset = 2
    _get_default_cruise_altitude_method_offset = 3
    _set_default_cruise_altitude_method_offset = 4
    _get_descent_rate_factor_method_offset = 5
    _set_descent_rate_factor_method_offset = 6
    _get_max_climb_angle_method_offset = 7
    _set_max_climb_angle_method_offset = 8
    _get_climb_at_cruise_airspeed_method_offset = 9
    _set_climb_at_cruise_airspeed_method_offset = 10
    _get_max_descent_angle_method_offset = 11
    _set_max_descent_angle_method_offset = 12
    _get_min_descent_rate_method_offset = 13
    _set_min_descent_rate_method_offset = 14
    _get_max_load_factor_method_offset = 15
    _set_max_load_factor_method_offset = 16
    _get_roll_rate_method_offset = 17
    _set_roll_rate_method_offset = 18
    _get_pitch_rate_method_offset = 19
    _set_pitch_rate_method_offset = 20
    _get_yaw_rate_method_offset = 21
    _set_yaw_rate_method_offset = 22
    _get_yaw_rate_dot_method_offset = 23
    _set_yaw_rate_dot_method_offset = 24
    _get_max_transition_pitch_angle_method_offset = 25
    _set_max_transition_pitch_angle_method_offset = 26
    _get_tf_max_flight_path_angle_method_offset = 27
    _set_tf_max_flight_path_angle_method_offset = 28
    _get_tf_terrain_window_method_offset = 29
    _set_tf_terrain_window_method_offset = 30
    _get_compute_delta_altitude_method_offset = 31
    _set_compute_delta_altitude_method_offset = 32
    _get_max_safe_airspeed_method_offset = 33
    _get_max_safe_airspeed_type_method_offset = 34
    _set_max_safe_airspeed_method_offset = 35
    _get_max_safe_translation_speed_method_offset = 36
    _get_max_safe_translation_speed_type_method_offset = 37
    _set_max_safe_translation_speed_method_offset = 38
    _get_ignore_flight_path_angle_for_climb_descent_transitions_method_offset = 39
    _set_ignore_flight_path_angle_for_climb_descent_transitions_method_offset = 40
    _get_default_configuration_method_offset = 41
    _get_aerodynamics_method_offset = 42
    _get_propulsion_method_offset = 43
    _get_as_catalog_item_method_offset = 44
    _metadata = {
        "iid_data" : (5082120676369899385, 4325334539633823629),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, RotorcraftModel)

    _get_max_altitude_metadata = { "offset" : _get_max_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_altitude(self) -> float:
        """Get or set the maximum altitude at which the rotorcraft is capable of operating."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_max_altitude_metadata)

    _set_max_altitude_metadata = { "offset" : _set_max_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_altitude.setter
    def max_altitude(self, value:float) -> None:
        """Get or set the maximum altitude at which the rotorcraft is capable of operating."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_max_altitude_metadata, value)

    _get_default_cruise_altitude_metadata = { "offset" : _get_default_cruise_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def default_cruise_altitude(self) -> float:
        """Get or set the rotorcraft's default cruising altitude."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_default_cruise_altitude_metadata)

    _set_default_cruise_altitude_metadata = { "offset" : _set_default_cruise_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @default_cruise_altitude.setter
    def default_cruise_altitude(self, value:float) -> None:
        """Get or set the rotorcraft's default cruising altitude."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_default_cruise_altitude_metadata, value)

    _get_descent_rate_factor_metadata = { "offset" : _get_descent_rate_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def descent_rate_factor(self) -> float:
        """Get or set the descent rate of the rotorcraft as a factor multiplied by the altitude change rate calculated at zero throttle."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_descent_rate_factor_metadata)

    _set_descent_rate_factor_metadata = { "offset" : _set_descent_rate_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @descent_rate_factor.setter
    def descent_rate_factor(self, value:float) -> None:
        """Get or set the descent rate of the rotorcraft as a factor multiplied by the altitude change rate calculated at zero throttle."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_descent_rate_factor_metadata, value)

    _get_max_climb_angle_metadata = { "offset" : _get_max_climb_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_climb_angle(self) -> typing.Any:
        """Get or set the maximum pitch angle of the rotorcraft's flight path while climbing."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_max_climb_angle_metadata)

    _set_max_climb_angle_metadata = { "offset" : _set_max_climb_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_climb_angle.setter
    def max_climb_angle(self, value:typing.Any) -> None:
        """Get or set the maximum pitch angle of the rotorcraft's flight path while climbing."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_max_climb_angle_metadata, value)

    _get_climb_at_cruise_airspeed_metadata = { "offset" : _get_climb_at_cruise_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def climb_at_cruise_airspeed(self) -> bool:
        """Select to define the climbing airspeed of the rotorcraft using the cruise airspeed of the current procedure."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_climb_at_cruise_airspeed_metadata)

    _set_climb_at_cruise_airspeed_metadata = { "offset" : _set_climb_at_cruise_airspeed_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @climb_at_cruise_airspeed.setter
    def climb_at_cruise_airspeed(self, value:bool) -> None:
        """Select to define the climbing airspeed of the rotorcraft using the cruise airspeed of the current procedure."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_climb_at_cruise_airspeed_metadata, value)

    _get_max_descent_angle_metadata = { "offset" : _get_max_descent_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_descent_angle(self) -> typing.Any:
        """Get or set the maximum pitch angle of the rotorcraft's flight path while descending."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_max_descent_angle_metadata)

    _set_max_descent_angle_metadata = { "offset" : _set_max_descent_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_descent_angle.setter
    def max_descent_angle(self, value:typing.Any) -> None:
        """Get or set the maximum pitch angle of the rotorcraft's flight path while descending."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_max_descent_angle_metadata, value)

    _get_min_descent_rate_metadata = { "offset" : _get_min_descent_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_descent_rate(self) -> float:
        """Get or set the minimum rate at which the aircraft will descend once established in a steady descent."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_min_descent_rate_metadata)

    _set_min_descent_rate_metadata = { "offset" : _set_min_descent_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_descent_rate.setter
    def min_descent_rate(self, value:float) -> None:
        """Get or set the minimum rate at which the aircraft will descend once established in a steady descent."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_min_descent_rate_metadata, value)

    _get_max_load_factor_metadata = { "offset" : _get_max_load_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_load_factor(self) -> float:
        """Get or set the maximum load factor that the aircraft can bear while maneuvering in formation."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_max_load_factor_metadata)

    _set_max_load_factor_metadata = { "offset" : _set_max_load_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_load_factor.setter
    def max_load_factor(self, value:float) -> None:
        """Get or set the maximum load factor that the aircraft can bear while maneuvering in formation."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_max_load_factor_metadata, value)

    _get_roll_rate_metadata = { "offset" : _get_roll_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def roll_rate(self) -> typing.Any:
        """Get or set the standard roll rate of the rotorcraft in a turn."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_roll_rate_metadata)

    _set_roll_rate_metadata = { "offset" : _set_roll_rate_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @roll_rate.setter
    def roll_rate(self, value:typing.Any) -> None:
        """Get or set the standard roll rate of the rotorcraft in a turn."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_roll_rate_metadata, value)

    _get_pitch_rate_metadata = { "offset" : _get_pitch_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def pitch_rate(self) -> typing.Any:
        """Get or set the pitch rate when transitioning between attitude modes or procedures."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_pitch_rate_metadata)

    _set_pitch_rate_metadata = { "offset" : _set_pitch_rate_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @pitch_rate.setter
    def pitch_rate(self, value:typing.Any) -> None:
        """Get or set the pitch rate when transitioning between attitude modes or procedures."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_pitch_rate_metadata, value)

    _get_yaw_rate_metadata = { "offset" : _get_yaw_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def yaw_rate(self) -> typing.Any:
        """Get or set the yaw rate when transitioning between attitude modes."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_yaw_rate_metadata)

    _set_yaw_rate_metadata = { "offset" : _set_yaw_rate_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @yaw_rate.setter
    def yaw_rate(self, value:typing.Any) -> None:
        """Get or set the yaw rate when transitioning between attitude modes."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_yaw_rate_metadata, value)

    _get_yaw_rate_dot_metadata = { "offset" : _get_yaw_rate_dot_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def yaw_rate_dot(self) -> typing.Any:
        """Get or set the rate of change of the yaw rate."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_yaw_rate_dot_metadata)

    _set_yaw_rate_dot_metadata = { "offset" : _set_yaw_rate_dot_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @yaw_rate_dot.setter
    def yaw_rate_dot(self, value:typing.Any) -> None:
        """Get or set the rate of change of the yaw rate."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_yaw_rate_dot_metadata, value)

    _get_max_transition_pitch_angle_metadata = { "offset" : _get_max_transition_pitch_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_transition_pitch_angle(self) -> typing.Any:
        """Get or set the maximum pitch angle of the flight path when transitioning between forward flight and hovering."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_max_transition_pitch_angle_metadata)

    _set_max_transition_pitch_angle_metadata = { "offset" : _set_max_transition_pitch_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_transition_pitch_angle.setter
    def max_transition_pitch_angle(self, value:typing.Any) -> None:
        """Get or set the maximum pitch angle of the flight path when transitioning between forward flight and hovering."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_max_transition_pitch_angle_metadata, value)

    _get_tf_max_flight_path_angle_metadata = { "offset" : _get_tf_max_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def tf_max_flight_path_angle(self) -> typing.Any:
        """Get or set the maximum pitch angle of the flight path when the rotorcraft is engaged in terrain following flight."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_tf_max_flight_path_angle_metadata)

    _set_tf_max_flight_path_angle_metadata = { "offset" : _set_tf_max_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @tf_max_flight_path_angle.setter
    def tf_max_flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the maximum pitch angle of the flight path when the rotorcraft is engaged in terrain following flight."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_tf_max_flight_path_angle_metadata, value)

    _get_tf_terrain_window_metadata = { "offset" : _get_tf_terrain_window_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tf_terrain_window(self) -> float:
        """Get or set the time interval over which terrain points are sampled when the rotorcraft is engaged in terrain following flight."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_tf_terrain_window_metadata)

    _set_tf_terrain_window_metadata = { "offset" : _set_tf_terrain_window_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tf_terrain_window.setter
    def tf_terrain_window(self, value:float) -> None:
        """Get or set the time interval over which terrain points are sampled when the rotorcraft is engaged in terrain following flight."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_tf_terrain_window_metadata, value)

    _get_compute_delta_altitude_metadata = { "offset" : _get_compute_delta_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def compute_delta_altitude(self) -> float:
        """Get or set the maximum change in altitude in a computed segment before the data is sampled again."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_compute_delta_altitude_metadata)

    _set_compute_delta_altitude_metadata = { "offset" : _set_compute_delta_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @compute_delta_altitude.setter
    def compute_delta_altitude(self, value:float) -> None:
        """Get or set the maximum change in altitude in a computed segment before the data is sampled again."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_compute_delta_altitude_metadata, value)

    _get_max_safe_airspeed_metadata = { "offset" : _get_max_safe_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_safe_airspeed(self) -> float:
        """Get the maximum cruising airspeed of the rotorcraft."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_max_safe_airspeed_metadata)

    _get_max_safe_airspeed_type_metadata = { "offset" : _get_max_safe_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def max_safe_airspeed_type(self) -> "AirspeedType":
        """Get the maximum safe airspeed type."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_max_safe_airspeed_type_metadata)

    _set_max_safe_airspeed_metadata = { "offset" : _set_max_safe_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_max_safe_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the maximum safe airspeed and airspeed type."""
        return self._intf.invoke(RotorcraftModel._metadata, RotorcraftModel._set_max_safe_airspeed_metadata, airspeed_type, airspeed)

    _get_max_safe_translation_speed_metadata = { "offset" : _get_max_safe_translation_speed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_safe_translation_speed(self) -> float:
        """Get the maximum translation speed of the rotorcraft."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_max_safe_translation_speed_metadata)

    _get_max_safe_translation_speed_type_metadata = { "offset" : _get_max_safe_translation_speed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def max_safe_translation_speed_type(self) -> "AirspeedType":
        """Get the maximum safe translation speed type."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_max_safe_translation_speed_type_metadata)

    _set_max_safe_translation_speed_metadata = { "offset" : _set_max_safe_translation_speed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_max_safe_translation_speed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the maximum safe translation airspeed and airspeed type."""
        return self._intf.invoke(RotorcraftModel._metadata, RotorcraftModel._set_max_safe_translation_speed_metadata, airspeed_type, airspeed)

    _get_ignore_flight_path_angle_for_climb_descent_transitions_metadata = { "offset" : _get_ignore_flight_path_angle_for_climb_descent_transitions_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def ignore_flight_path_angle_for_climb_descent_transitions(self) -> bool:
        """Opt to ignore load factor limits when pushing over or pulling up."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_ignore_flight_path_angle_for_climb_descent_transitions_metadata)

    _set_ignore_flight_path_angle_for_climb_descent_transitions_metadata = { "offset" : _set_ignore_flight_path_angle_for_climb_descent_transitions_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @ignore_flight_path_angle_for_climb_descent_transitions.setter
    def ignore_flight_path_angle_for_climb_descent_transitions(self, value:bool) -> None:
        """Opt to ignore load factor limits when pushing over or pulling up."""
        return self._intf.set_property(RotorcraftModel._metadata, RotorcraftModel._set_ignore_flight_path_angle_for_climb_descent_transitions_metadata, value)

    _get_default_configuration_metadata = { "offset" : _get_default_configuration_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def default_configuration(self) -> "Configuration":
        """Get the aircraft's default configuration as saved in the catalog."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_default_configuration_metadata)

    _get_aerodynamics_metadata = { "offset" : _get_aerodynamics_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def aerodynamics(self) -> "RotorcraftAerodynamic":
        """Get the aerodynamics interface."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_aerodynamics_metadata)

    _get_propulsion_metadata = { "offset" : _get_propulsion_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def propulsion(self) -> "RotorcraftPropulsion":
        """Get the propulsion interface."""
        return self._intf.get_property(RotorcraftModel._metadata, RotorcraftModel._get_propulsion_metadata)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(RotorcraftModel._metadata, RotorcraftModel._get_as_catalog_item_metadata, OutArg())

    _property_names[max_altitude] = "max_altitude"
    _property_names[default_cruise_altitude] = "default_cruise_altitude"
    _property_names[descent_rate_factor] = "descent_rate_factor"
    _property_names[max_climb_angle] = "max_climb_angle"
    _property_names[climb_at_cruise_airspeed] = "climb_at_cruise_airspeed"
    _property_names[max_descent_angle] = "max_descent_angle"
    _property_names[min_descent_rate] = "min_descent_rate"
    _property_names[max_load_factor] = "max_load_factor"
    _property_names[roll_rate] = "roll_rate"
    _property_names[pitch_rate] = "pitch_rate"
    _property_names[yaw_rate] = "yaw_rate"
    _property_names[yaw_rate_dot] = "yaw_rate_dot"
    _property_names[max_transition_pitch_angle] = "max_transition_pitch_angle"
    _property_names[tf_max_flight_path_angle] = "tf_max_flight_path_angle"
    _property_names[tf_terrain_window] = "tf_terrain_window"
    _property_names[compute_delta_altitude] = "compute_delta_altitude"
    _property_names[max_safe_airspeed] = "max_safe_airspeed"
    _property_names[max_safe_airspeed_type] = "max_safe_airspeed_type"
    _property_names[max_safe_translation_speed] = "max_safe_translation_speed"
    _property_names[max_safe_translation_speed_type] = "max_safe_translation_speed_type"
    _property_names[ignore_flight_path_angle_for_climb_descent_transitions] = "ignore_flight_path_angle_for_climb_descent_transitions"
    _property_names[default_configuration] = "default_configuration"
    _property_names[aerodynamics] = "aerodynamics"
    _property_names[propulsion] = "propulsion"

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

agcls.AgClassCatalog.add_catalog_entry((5132696765661705826, 14502770979691808656), RotorcraftModel)
agcls.AgTypeNameMap["RotorcraftModel"] = RotorcraftModel

class RotorcraftAerodynamic(SupportsDeleteCallback):
    """Interface used to access the aerodynamics options for a rotorcraft."""

    _num_methods = 22
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_rotor_count_method_offset = 1
    _set_rotor_count_method_offset = 2
    _get_rotor_diameter_method_offset = 3
    _set_rotor_diameter_method_offset = 4
    _get_blades_per_rotor_method_offset = 5
    _set_blades_per_rotor_method_offset = 6
    _get_blade_chord_method_offset = 7
    _set_blade_chord_method_offset = 8
    _get_rotor_tip_mach_method_offset = 9
    _set_rotor_tip_mach_method_offset = 10
    _get_fuselage_flat_plate_area_method_offset = 11
    _set_fuselage_flat_plate_area_method_offset = 12
    _get_tail_rotor_offset_method_offset = 13
    _set_tail_rotor_offset_method_offset = 14
    _get_tail_rotor_diameter_method_offset = 15
    _set_tail_rotor_diameter_method_offset = 16
    _get_blade_profile_drag_cd0_method_offset = 17
    _set_blade_profile_drag_cd0_method_offset = 18
    _get_blade_profile_drag_k_method_offset = 19
    _set_blade_profile_drag_k_method_offset = 20
    _get_induced_power_correction_factor_method_offset = 21
    _set_induced_power_correction_factor_method_offset = 22
    _metadata = {
        "iid_data" : (5318240503192117773, 12951249891304096688),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, RotorcraftAerodynamic)

    _get_rotor_count_metadata = { "offset" : _get_rotor_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def rotor_count(self) -> int:
        """Get or set the number of rotors."""
        return self._intf.get_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._get_rotor_count_metadata)

    _set_rotor_count_metadata = { "offset" : _set_rotor_count_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @rotor_count.setter
    def rotor_count(self, value:int) -> None:
        """Get or set the number of rotors."""
        return self._intf.set_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._set_rotor_count_metadata, value)

    _get_rotor_diameter_metadata = { "offset" : _get_rotor_diameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def rotor_diameter(self) -> float:
        """Get or set the diameter of the rotor."""
        return self._intf.get_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._get_rotor_diameter_metadata)

    _set_rotor_diameter_metadata = { "offset" : _set_rotor_diameter_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @rotor_diameter.setter
    def rotor_diameter(self, value:float) -> None:
        """Get or set the diameter of the rotor."""
        return self._intf.set_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._set_rotor_diameter_metadata, value)

    _get_blades_per_rotor_metadata = { "offset" : _get_blades_per_rotor_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def blades_per_rotor(self) -> int:
        """Get or set the number of blades on each rotor."""
        return self._intf.get_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._get_blades_per_rotor_metadata)

    _set_blades_per_rotor_metadata = { "offset" : _set_blades_per_rotor_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @blades_per_rotor.setter
    def blades_per_rotor(self, value:int) -> None:
        """Get or set the number of blades on each rotor."""
        return self._intf.set_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._set_blades_per_rotor_metadata, value)

    _get_blade_chord_metadata = { "offset" : _get_blade_chord_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def blade_chord(self) -> float:
        """Get or set the chord length of the blade."""
        return self._intf.get_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._get_blade_chord_metadata)

    _set_blade_chord_metadata = { "offset" : _set_blade_chord_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @blade_chord.setter
    def blade_chord(self, value:float) -> None:
        """Get or set the chord length of the blade."""
        return self._intf.set_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._set_blade_chord_metadata, value)

    _get_rotor_tip_mach_metadata = { "offset" : _get_rotor_tip_mach_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def rotor_tip_mach(self) -> float:
        """Get or set the Mach number of the advancing blade tip."""
        return self._intf.get_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._get_rotor_tip_mach_metadata)

    _set_rotor_tip_mach_metadata = { "offset" : _set_rotor_tip_mach_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @rotor_tip_mach.setter
    def rotor_tip_mach(self, value:float) -> None:
        """Get or set the Mach number of the advancing blade tip."""
        return self._intf.set_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._set_rotor_tip_mach_metadata, value)

    _get_fuselage_flat_plate_area_metadata = { "offset" : _get_fuselage_flat_plate_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fuselage_flat_plate_area(self) -> float:
        """Get or set the flat plate area for the fuselage."""
        return self._intf.get_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._get_fuselage_flat_plate_area_metadata)

    _set_fuselage_flat_plate_area_metadata = { "offset" : _set_fuselage_flat_plate_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fuselage_flat_plate_area.setter
    def fuselage_flat_plate_area(self, value:float) -> None:
        """Get or set the flat plate area for the fuselage."""
        return self._intf.set_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._set_fuselage_flat_plate_area_metadata, value)

    _get_tail_rotor_offset_metadata = { "offset" : _get_tail_rotor_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tail_rotor_offset(self) -> float:
        """Get or set the offset of the tail rotor."""
        return self._intf.get_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._get_tail_rotor_offset_metadata)

    _set_tail_rotor_offset_metadata = { "offset" : _set_tail_rotor_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tail_rotor_offset.setter
    def tail_rotor_offset(self, value:float) -> None:
        """Get or set the offset of the tail rotor."""
        return self._intf.set_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._set_tail_rotor_offset_metadata, value)

    _get_tail_rotor_diameter_metadata = { "offset" : _get_tail_rotor_diameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tail_rotor_diameter(self) -> float:
        """Get or set the diameter of the tail rotor."""
        return self._intf.get_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._get_tail_rotor_diameter_metadata)

    _set_tail_rotor_diameter_metadata = { "offset" : _set_tail_rotor_diameter_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tail_rotor_diameter.setter
    def tail_rotor_diameter(self, value:float) -> None:
        """Get or set the diameter of the tail rotor."""
        return self._intf.set_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._set_tail_rotor_diameter_metadata, value)

    _get_blade_profile_drag_cd0_metadata = { "offset" : _get_blade_profile_drag_cd0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def blade_profile_drag_cd0(self) -> float:
        """Get or set the drag coefficient when the rotor disc does not generate any lift."""
        return self._intf.get_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._get_blade_profile_drag_cd0_metadata)

    _set_blade_profile_drag_cd0_metadata = { "offset" : _set_blade_profile_drag_cd0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @blade_profile_drag_cd0.setter
    def blade_profile_drag_cd0(self, value:float) -> None:
        """Get or set the drag coefficient when the rotor disc does not generate any lift."""
        return self._intf.set_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._set_blade_profile_drag_cd0_metadata, value)

    _get_blade_profile_drag_k_metadata = { "offset" : _get_blade_profile_drag_k_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def blade_profile_drag_k(self) -> float:
        """Get or set the induced drag coefficient, which accounts for how lift generation impacts drag."""
        return self._intf.get_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._get_blade_profile_drag_k_metadata)

    _set_blade_profile_drag_k_metadata = { "offset" : _set_blade_profile_drag_k_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @blade_profile_drag_k.setter
    def blade_profile_drag_k(self, value:float) -> None:
        """Get or set the induced drag coefficient, which accounts for how lift generation impacts drag."""
        return self._intf.set_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._set_blade_profile_drag_k_metadata, value)

    _get_induced_power_correction_factor_metadata = { "offset" : _get_induced_power_correction_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def induced_power_correction_factor(self) -> float:
        """Get or set the slop factor that accounts for losses."""
        return self._intf.get_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._get_induced_power_correction_factor_metadata)

    _set_induced_power_correction_factor_metadata = { "offset" : _set_induced_power_correction_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @induced_power_correction_factor.setter
    def induced_power_correction_factor(self, value:float) -> None:
        """Get or set the slop factor that accounts for losses."""
        return self._intf.set_property(RotorcraftAerodynamic._metadata, RotorcraftAerodynamic._set_induced_power_correction_factor_metadata, value)

    _property_names[rotor_count] = "rotor_count"
    _property_names[rotor_diameter] = "rotor_diameter"
    _property_names[blades_per_rotor] = "blades_per_rotor"
    _property_names[blade_chord] = "blade_chord"
    _property_names[rotor_tip_mach] = "rotor_tip_mach"
    _property_names[fuselage_flat_plate_area] = "fuselage_flat_plate_area"
    _property_names[tail_rotor_offset] = "tail_rotor_offset"
    _property_names[tail_rotor_diameter] = "tail_rotor_diameter"
    _property_names[blade_profile_drag_cd0] = "blade_profile_drag_cd0"
    _property_names[blade_profile_drag_k] = "blade_profile_drag_k"
    _property_names[induced_power_correction_factor] = "induced_power_correction_factor"

    def __init__(self, source_object=None):
        """Construct an object of type RotorcraftAerodynamic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, RotorcraftAerodynamic)
    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, RotorcraftAerodynamic, [RotorcraftAerodynamic, ])

agcls.AgClassCatalog.add_catalog_entry((5254408426110746023, 3824899600395506365), RotorcraftAerodynamic)
agcls.AgTypeNameMap["RotorcraftAerodynamic"] = RotorcraftAerodynamic

class RotorcraftPropulsion(SupportsDeleteCallback):
    """Interface used to access the Propulsion options for a rotorcraft."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_powerplant_type_method_offset = 1
    _set_powerplant_type_method_offset = 2
    _get_max_sl_power_method_offset = 3
    _set_max_sl_power_method_offset = 4
    _get_max_sl_fuel_flow_method_offset = 5
    _set_max_sl_fuel_flow_method_offset = 6
    _metadata = {
        "iid_data" : (5259623472655829368, 12428325399528728501),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, RotorcraftPropulsion)

    _get_powerplant_type_metadata = { "offset" : _get_powerplant_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RotorcraftPowerplantType),) }
    @property
    def powerplant_type(self) -> "RotorcraftPowerplantType":
        """Get or set the rotorcraft's powerplant type."""
        return self._intf.get_property(RotorcraftPropulsion._metadata, RotorcraftPropulsion._get_powerplant_type_metadata)

    _set_powerplant_type_metadata = { "offset" : _set_powerplant_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(RotorcraftPowerplantType),) }
    @powerplant_type.setter
    def powerplant_type(self, value:"RotorcraftPowerplantType") -> None:
        """Get or set the rotorcraft's powerplant type."""
        return self._intf.set_property(RotorcraftPropulsion._metadata, RotorcraftPropulsion._set_powerplant_type_metadata, value)

    _get_max_sl_power_metadata = { "offset" : _get_max_sl_power_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_sl_power(self) -> float:
        """Get or set the maximum power at sea level."""
        return self._intf.get_property(RotorcraftPropulsion._metadata, RotorcraftPropulsion._get_max_sl_power_metadata)

    _set_max_sl_power_metadata = { "offset" : _set_max_sl_power_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_sl_power.setter
    def max_sl_power(self, value:float) -> None:
        """Get or set the maximum power at sea level."""
        return self._intf.set_property(RotorcraftPropulsion._metadata, RotorcraftPropulsion._set_max_sl_power_metadata, value)

    _get_max_sl_fuel_flow_metadata = { "offset" : _get_max_sl_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_sl_fuel_flow(self) -> float:
        """Get or set the maximum fuel flow at sea level."""
        return self._intf.get_property(RotorcraftPropulsion._metadata, RotorcraftPropulsion._get_max_sl_fuel_flow_metadata)

    _set_max_sl_fuel_flow_metadata = { "offset" : _set_max_sl_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_sl_fuel_flow.setter
    def max_sl_fuel_flow(self, value:float) -> None:
        """Get or set the maximum fuel flow at sea level."""
        return self._intf.set_property(RotorcraftPropulsion._metadata, RotorcraftPropulsion._set_max_sl_fuel_flow_metadata, value)

    _property_names[powerplant_type] = "powerplant_type"
    _property_names[max_sl_power] = "max_sl_power"
    _property_names[max_sl_fuel_flow] = "max_sl_fuel_flow"

    def __init__(self, source_object=None):
        """Construct an object of type RotorcraftPropulsion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, RotorcraftPropulsion)
    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, RotorcraftPropulsion, [RotorcraftPropulsion, ])

agcls.AgClassCatalog.add_catalog_entry((5760757719442343448, 132377700848243866), RotorcraftPropulsion)
agcls.AgTypeNameMap["RotorcraftPropulsion"] = RotorcraftPropulsion

class AircraftAcceleration(ICatalogItem, SupportsDeleteCallback):
    """
    Interface used to access the acceleration options for an aircraft in the Aviator catalog.

    Examples
    --------
    Create a new performance model for an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the acceleration type
    >>> acceleration = aviatorAircraft.acceleration
    >>> # Get the names of the current acceleration models
    >>> modelNames = acceleration.child_names
    >>> # Check how many models there are
    >>> modelCount = len(modelNames)
    >>> # Get the child types (for example AGI Basic Acceleration Model, Advanced Acceleration Model)
    >>> modelTypes = acceleration.child_types
    >>> # Create a new performance model of type "Advanced Acceleration Model"
    >>> newPerformanceModel = acceleration.add_child_of_type("Advanced Acceleration Model", "Model Name")
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()

    Configure the basic acceleration performance model of an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the acceleration type
    >>> acceleration = aviatorAircraft.acceleration
    >>> # Get the build in performance model
    >>> basicAccModel = acceleration.get_built_in_model()
    >>>
    >>> # Get the level turns options
    >>> levelTurns = basicAccModel.level_turns
    >>> # Set a max bank angle of 25
    >>> levelTurns.set_level_turn(TurnMode.TURN_MODE_BANK_ANGLE, 25)
    >>> # Get the climb and descent transition options
    >>> climbAndDescent = basicAccModel.climb_and_descent_transitions
    >>> # Set the max pull up G to 1
    >>> climbAndDescent.max_pull_up_g = 1.2
    >>> # Get the attitude transition options
    >>> attitudeTransitions = basicAccModel.attitude_transitions
    >>> # Set the max roll rate to 25
    >>> attitudeTransitions.roll_rate = 25
    >>>
    >>> # Get the aerodynamics
    >>> aero = basicAccModel.aerodynamics
    >>> # Use simple aerodynamics
    >>> aero.aerodynamic_strategy = AircraftAerodynamicStrategy.AIRCRAFT_AERODYNAMIC_SIMPLE
    >>> # Get the options for the simple aerodynamics and set some parameters
    >>> simpleAero = aero.mode_as_simple
    >>> simpleAero.s_reference = 5
    >>> simpleAero.cl_max = 3.1
    >>> simpleAero.cd = 0.05
    >>>
    >>> # Get the propulsion
    >>> prop = basicAccModel.propulsion
    >>> # Use simple propulsion
    >>> prop.propulsion_strategy = AircraftPropulsionStrategy.AIRCRAFT_PROPULSION_SIMPLE
    >>> # Get the simple propulsion options and set some parameters
    >>> simpleProp = prop.mode_as_simple
    >>> simpleProp.max_thrust_acceleration = 0.6
    >>> simpleProp.min_thrust_deceleration = 0.4
    >>> simpleProp.set_density_scaling(True, 0.02)
    >>>
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()
    """

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_built_in_model_method_offset = 1
    _get_basic_acceleration_by_name_method_offset = 2
    _get_advanced_acceleration_by_name_method_offset = 3
    _get_as_catalog_item_method_offset = 4
    _metadata = {
        "iid_data" : (5381104812027548008, 3758078246891655319),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftAcceleration)

    _get_built_in_model_metadata = { "offset" : _get_built_in_model_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_built_in_model(self) -> "AircraftBasicAccelerationModel":
        """Get the built-in model."""
        return self._intf.invoke(AircraftAcceleration._metadata, AircraftAcceleration._get_built_in_model_metadata, OutArg())

    _get_basic_acceleration_by_name_metadata = { "offset" : _get_basic_acceleration_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_basic_acceleration_by_name(self, name:str) -> "AircraftBasicAccelerationModel":
        """Get the basic acceleration model with the given name."""
        return self._intf.invoke(AircraftAcceleration._metadata, AircraftAcceleration._get_basic_acceleration_by_name_metadata, name, OutArg())

    _get_advanced_acceleration_by_name_metadata = { "offset" : _get_advanced_acceleration_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_advanced_acceleration_by_name(self, name:str) -> "AircraftAdvancedAccelerationModel":
        """Get the advanced acceleration model with the given name."""
        return self._intf.invoke(AircraftAcceleration._metadata, AircraftAcceleration._get_advanced_acceleration_by_name_metadata, name, OutArg())

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftAcceleration._metadata, AircraftAcceleration._get_as_catalog_item_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((5513893073497569268, 18062891268736021946), AircraftAcceleration)
agcls.AgTypeNameMap["AircraftAcceleration"] = AircraftAcceleration

class AircraftBasicAccelerationModel(IPerformanceModel, ICatalogItem, SupportsDeleteCallback):
    """
    Interface used to access the basic acceleration model options for an acceleration model of an aircraft in the Aviator catalog.

    Examples
    --------
    Configure the basic acceleration performance model of an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the acceleration type
    >>> acceleration = aviatorAircraft.acceleration
    >>> # Get the build in performance model
    >>> basicAccModel = acceleration.get_built_in_model()
    >>>
    >>> # Get the level turns options
    >>> levelTurns = basicAccModel.level_turns
    >>> # Set a max bank angle of 25
    >>> levelTurns.set_level_turn(TurnMode.TURN_MODE_BANK_ANGLE, 25)
    >>> # Get the climb and descent transition options
    >>> climbAndDescent = basicAccModel.climb_and_descent_transitions
    >>> # Set the max pull up G to 1
    >>> climbAndDescent.max_pull_up_g = 1.2
    >>> # Get the attitude transition options
    >>> attitudeTransitions = basicAccModel.attitude_transitions
    >>> # Set the max roll rate to 25
    >>> attitudeTransitions.roll_rate = 25
    >>>
    >>> # Get the aerodynamics
    >>> aero = basicAccModel.aerodynamics
    >>> # Use simple aerodynamics
    >>> aero.aerodynamic_strategy = AircraftAerodynamicStrategy.AIRCRAFT_AERODYNAMIC_SIMPLE
    >>> # Get the options for the simple aerodynamics and set some parameters
    >>> simpleAero = aero.mode_as_simple
    >>> simpleAero.s_reference = 5
    >>> simpleAero.cl_max = 3.1
    >>> simpleAero.cd = 0.05
    >>>
    >>> # Get the propulsion
    >>> prop = basicAccModel.propulsion
    >>> # Use simple propulsion
    >>> prop.propulsion_strategy = AircraftPropulsionStrategy.AIRCRAFT_PROPULSION_SIMPLE
    >>> # Get the simple propulsion options and set some parameters
    >>> simpleProp = prop.mode_as_simple
    >>> simpleProp.max_thrust_acceleration = 0.6
    >>> simpleProp.min_thrust_deceleration = 0.4
    >>> simpleProp.set_density_scaling(True, 0.02)
    >>>
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()
    """

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_level_turns_method_offset = 1
    _get_attitude_transitions_method_offset = 2
    _get_climb_and_descent_transitions_method_offset = 3
    _get_aerodynamics_method_offset = 4
    _get_propulsion_method_offset = 5
    _get_as_catalog_item_method_offset = 6
    _metadata = {
        "iid_data" : (4918589609424149010, 10824534501852204216),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftBasicAccelerationModel)

    _get_level_turns_metadata = { "offset" : _get_level_turns_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def level_turns(self) -> "LevelTurns":
        """Get the level turns interface."""
        return self._intf.get_property(AircraftBasicAccelerationModel._metadata, AircraftBasicAccelerationModel._get_level_turns_metadata)

    _get_attitude_transitions_metadata = { "offset" : _get_attitude_transitions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def attitude_transitions(self) -> "AttitudeTransitions":
        """Get the attitude transitions interface."""
        return self._intf.get_property(AircraftBasicAccelerationModel._metadata, AircraftBasicAccelerationModel._get_attitude_transitions_metadata)

    _get_climb_and_descent_transitions_metadata = { "offset" : _get_climb_and_descent_transitions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def climb_and_descent_transitions(self) -> "ClimbAndDescentTransitions":
        """Get the climb and descent transitions interface."""
        return self._intf.get_property(AircraftBasicAccelerationModel._metadata, AircraftBasicAccelerationModel._get_climb_and_descent_transitions_metadata)

    _get_aerodynamics_metadata = { "offset" : _get_aerodynamics_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def aerodynamics(self) -> "AircraftAerodynamic":
        """Get the aerodynamics interface."""
        return self._intf.get_property(AircraftBasicAccelerationModel._metadata, AircraftBasicAccelerationModel._get_aerodynamics_metadata)

    _get_propulsion_metadata = { "offset" : _get_propulsion_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def propulsion(self) -> "AircraftPropulsion":
        """Get the propulsion interface."""
        return self._intf.get_property(AircraftBasicAccelerationModel._metadata, AircraftBasicAccelerationModel._get_propulsion_metadata)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftBasicAccelerationModel._metadata, AircraftBasicAccelerationModel._get_as_catalog_item_metadata, OutArg())

    _property_names[level_turns] = "level_turns"
    _property_names[attitude_transitions] = "attitude_transitions"
    _property_names[climb_and_descent_transitions] = "climb_and_descent_transitions"
    _property_names[aerodynamics] = "aerodynamics"
    _property_names[propulsion] = "propulsion"

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

agcls.AgClassCatalog.add_catalog_entry((5233981690568010157, 10284429996961284255), AircraftBasicAccelerationModel)
agcls.AgTypeNameMap["AircraftBasicAccelerationModel"] = AircraftBasicAccelerationModel

class AircraftClimb(ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the climb options for an aircraft in the Aviator catalog."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_built_in_model_method_offset = 1
    _get_basic_climb_by_name_method_offset = 2
    _get_advanced_climb_by_name_method_offset = 3
    _get_as_catalog_item_method_offset = 4
    _metadata = {
        "iid_data" : (5263267494218211610, 12329219289477949313),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftClimb)

    _get_built_in_model_metadata = { "offset" : _get_built_in_model_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_built_in_model(self) -> "AircraftBasicClimbModel":
        """Get the built-in model."""
        return self._intf.invoke(AircraftClimb._metadata, AircraftClimb._get_built_in_model_metadata, OutArg())

    _get_basic_climb_by_name_metadata = { "offset" : _get_basic_climb_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_basic_climb_by_name(self, name:str) -> "AircraftBasicClimbModel":
        """Get the basic climb model with the given name."""
        return self._intf.invoke(AircraftClimb._metadata, AircraftClimb._get_basic_climb_by_name_metadata, name, OutArg())

    _get_advanced_climb_by_name_metadata = { "offset" : _get_advanced_climb_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_advanced_climb_by_name(self, name:str) -> "AircraftAdvancedClimbModel":
        """Get the advanced climb model with the given name."""
        return self._intf.invoke(AircraftClimb._metadata, AircraftClimb._get_advanced_climb_by_name_metadata, name, OutArg())

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftClimb._metadata, AircraftClimb._get_as_catalog_item_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((5617790646698935986, 14996628473608278423), AircraftClimb)
agcls.AgTypeNameMap["AircraftClimb"] = AircraftClimb

class AircraftCruise(ICatalogItem, SupportsDeleteCallback):
    """
    Interface used to access the cruise options for an aircraft in the Aviator catalog.

    Examples
    --------
    Configure the basic cruise performance model of an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the cruise type
    >>> cruise = aviatorAircraft.cruise
    >>> # Get the build in performance model
    >>> basicCruiseModel = cruise.get_built_in_model()
    >>>
    >>> # Set the ceiling altitude
    >>> basicCruiseModel.ceiling_altitude = 50000
    >>> # Set the default cruise altitude
    >>> basicCruiseModel.default_cruise_altitude = 10000
    >>> # Set the airspeed type
    >>> basicCruiseModel.airspeed_type = AirspeedType.TAS
    >>> # Opt to not use the fuel flow calculated by the aero/prop model and instead specify the values
    >>> basicCruiseModel.use_aerodynamic_propulsion_fuel = False
    >>>
    >>> # Set the various airspeeds and fuel flows
    >>> basicCruiseModel.min_airspeed = 110
    >>> basicCruiseModel.min_airspeed_fuel_flow = 10000
    >>>
    >>> basicCruiseModel.max_endurance_airspeed = 135
    >>> basicCruiseModel.max_endurance_fuel_flow = 8000
    >>>
    >>> basicCruiseModel.max_airspeed = 570
    >>> basicCruiseModel.max_airspeed_fuel_flow = 30000
    >>>
    >>> basicCruiseModel.max_range_airspeed = 140
    >>> basicCruiseModel.max_range_fuel_flow = 9000
    >>>
    >>> basicCruiseModel.max_performance_airspeed = 150
    >>> basicCruiseModel.max_performance_airspeed_fuel_flow = 12000
    >>>
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()
    """

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_built_in_model_method_offset = 1
    _get_basic_cruise_by_name_method_offset = 2
    _get_advanced_cruise_by_name_method_offset = 3
    _get_as_catalog_item_method_offset = 4
    _metadata = {
        "iid_data" : (5128623341727715783, 9002706155677001097),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftCruise)

    _get_built_in_model_metadata = { "offset" : _get_built_in_model_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_built_in_model(self) -> "AircraftBasicCruiseModel":
        """Get the built-in model."""
        return self._intf.invoke(AircraftCruise._metadata, AircraftCruise._get_built_in_model_metadata, OutArg())

    _get_basic_cruise_by_name_metadata = { "offset" : _get_basic_cruise_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_basic_cruise_by_name(self, name:str) -> "AircraftBasicCruiseModel":
        """Get the basic cruise model with the given name."""
        return self._intf.invoke(AircraftCruise._metadata, AircraftCruise._get_basic_cruise_by_name_metadata, name, OutArg())

    _get_advanced_cruise_by_name_metadata = { "offset" : _get_advanced_cruise_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_advanced_cruise_by_name(self, name:str) -> "AircraftAdvancedCruiseModel":
        """Get the advanced cruise model with the given name."""
        return self._intf.invoke(AircraftCruise._metadata, AircraftCruise._get_advanced_cruise_by_name_metadata, name, OutArg())

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftCruise._metadata, AircraftCruise._get_as_catalog_item_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((4952713164558545716, 391472350963315864), AircraftCruise)
agcls.AgTypeNameMap["AircraftCruise"] = AircraftCruise

class AircraftDescent(ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the descent options for an aircraft in the Aviator catalog."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_built_in_model_method_offset = 1
    _get_basic_descent_by_name_method_offset = 2
    _get_advanced_descent_by_name_method_offset = 3
    _get_as_catalog_item_method_offset = 4
    _metadata = {
        "iid_data" : (5297052565690495579, 8482664394541642129),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftDescent)

    _get_built_in_model_metadata = { "offset" : _get_built_in_model_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_built_in_model(self) -> "AircraftBasicDescentModel":
        """Get the built-in model."""
        return self._intf.invoke(AircraftDescent._metadata, AircraftDescent._get_built_in_model_metadata, OutArg())

    _get_basic_descent_by_name_metadata = { "offset" : _get_basic_descent_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_basic_descent_by_name(self, name:str) -> "AircraftBasicDescentModel":
        """Get the basic descent model with the given name."""
        return self._intf.invoke(AircraftDescent._metadata, AircraftDescent._get_basic_descent_by_name_metadata, name, OutArg())

    _get_advanced_descent_by_name_metadata = { "offset" : _get_advanced_descent_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_advanced_descent_by_name(self, name:str) -> "AircraftAdvancedDescentModel":
        """Get the advanced descent model with the given name."""
        return self._intf.invoke(AircraftDescent._metadata, AircraftDescent._get_advanced_descent_by_name_metadata, name, OutArg())

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftDescent._metadata, AircraftDescent._get_as_catalog_item_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((5218114732559411329, 18271609367029705879), AircraftDescent)
agcls.AgTypeNameMap["AircraftDescent"] = AircraftDescent

class AircraftLanding(ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the landing options for an aircraft in the Aviator catalog."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_built_in_model_method_offset = 1
    _get_basic_landing_by_name_method_offset = 2
    _get_advanced_landing_by_name_method_offset = 3
    _get_as_catalog_item_method_offset = 4
    _metadata = {
        "iid_data" : (4810761550589613477, 16758738712672605105),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftLanding)

    _get_built_in_model_metadata = { "offset" : _get_built_in_model_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_built_in_model(self) -> "AircraftBasicLandingModel":
        """Get the built-in model."""
        return self._intf.invoke(AircraftLanding._metadata, AircraftLanding._get_built_in_model_metadata, OutArg())

    _get_basic_landing_by_name_metadata = { "offset" : _get_basic_landing_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_basic_landing_by_name(self, name:str) -> "AircraftBasicLandingModel":
        """Get the basic Landing model with the given name."""
        return self._intf.invoke(AircraftLanding._metadata, AircraftLanding._get_basic_landing_by_name_metadata, name, OutArg())

    _get_advanced_landing_by_name_metadata = { "offset" : _get_advanced_landing_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_advanced_landing_by_name(self, name:str) -> "AircraftAdvancedLandingModel":
        """Get the advanced Landing model with the given name."""
        return self._intf.invoke(AircraftLanding._metadata, AircraftLanding._get_advanced_landing_by_name_metadata, name, OutArg())

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftLanding._metadata, AircraftLanding._get_as_catalog_item_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((4740693708489443339, 736458658073889207), AircraftLanding)
agcls.AgTypeNameMap["AircraftLanding"] = AircraftLanding

class AircraftTakeoff(ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the takeoff options for an aircraft in the Aviator catalog."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_built_in_model_method_offset = 1
    _get_basic_takeoff_by_name_method_offset = 2
    _get_advanced_takeoff_by_name_method_offset = 3
    _get_as_catalog_item_method_offset = 4
    _metadata = {
        "iid_data" : (5694947358439793555, 17623821908663075205),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftTakeoff)

    _get_built_in_model_metadata = { "offset" : _get_built_in_model_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_built_in_model(self) -> "AircraftBasicTakeoffModel":
        """Get the built-in model."""
        return self._intf.invoke(AircraftTakeoff._metadata, AircraftTakeoff._get_built_in_model_metadata, OutArg())

    _get_basic_takeoff_by_name_metadata = { "offset" : _get_basic_takeoff_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_basic_takeoff_by_name(self, name:str) -> "AircraftBasicTakeoffModel":
        """Get the basic Takeoff model with the given name."""
        return self._intf.invoke(AircraftTakeoff._metadata, AircraftTakeoff._get_basic_takeoff_by_name_metadata, name, OutArg())

    _get_advanced_takeoff_by_name_metadata = { "offset" : _get_advanced_takeoff_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_advanced_takeoff_by_name(self, name:str) -> "AircraftAdvancedTakeoffModel":
        """Get the advanced Takeoff model with the given name."""
        return self._intf.invoke(AircraftTakeoff._metadata, AircraftTakeoff._get_advanced_takeoff_by_name_metadata, name, OutArg())

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftTakeoff._metadata, AircraftTakeoff._get_as_catalog_item_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((5587969153310880849, 14792461406398889898), AircraftTakeoff)
agcls.AgTypeNameMap["AircraftTakeoff"] = AircraftTakeoff

class AircraftBasicClimbModel(IPerformanceModel, ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the basic climb model options for a climb model of an aircraft in the Aviator catalog."""

    _num_methods = 18
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_ceiling_altitude_method_offset = 1
    _set_ceiling_altitude_method_offset = 2
    _get_airspeed_method_offset = 3
    _get_airspeed_type_method_offset = 4
    _set_airspeed_method_offset = 5
    _get_altitude_rate_method_offset = 6
    _set_altitude_rate_method_offset = 7
    _get_use_aerodynamic_propulsion_fuel_method_offset = 8
    _set_use_aerodynamic_propulsion_fuel_method_offset = 9
    _get_scale_fuel_flow_by_non_std_density_method_offset = 10
    _set_scale_fuel_flow_by_non_std_density_method_offset = 11
    _get_fuel_flow_method_offset = 12
    _set_fuel_flow_method_offset = 13
    _get_enable_relative_airspeed_tolerance_method_offset = 14
    _set_enable_relative_airspeed_tolerance_method_offset = 15
    _get_relative_airspeed_tolerance_method_offset = 16
    _set_relative_airspeed_tolerance_method_offset = 17
    _get_as_catalog_item_method_offset = 18
    _metadata = {
        "iid_data" : (4965986558778284076, 16667235744495728830),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftBasicClimbModel)

    _get_ceiling_altitude_metadata = { "offset" : _get_ceiling_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def ceiling_altitude(self) -> float:
        """Get or set the ceiling altitude."""
        return self._intf.get_property(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._get_ceiling_altitude_metadata)

    _set_ceiling_altitude_metadata = { "offset" : _set_ceiling_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @ceiling_altitude.setter
    def ceiling_altitude(self, value:float) -> None:
        """Get or set the ceiling altitude."""
        return self._intf.set_property(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._set_ceiling_altitude_metadata, value)

    _get_airspeed_metadata = { "offset" : _get_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def airspeed(self) -> float:
        """Get the airsepeed."""
        return self._intf.get_property(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._get_airspeed_metadata)

    _get_airspeed_type_metadata = { "offset" : _get_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type."""
        return self._intf.get_property(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._get_airspeed_type_metadata)

    _set_airspeed_metadata = { "offset" : _set_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the airspeed type and value."""
        return self._intf.invoke(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._set_airspeed_metadata, airspeed_type, airspeed)

    _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 altitude rate."""
        return self._intf.get_property(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._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:
        """Get or set the altitude rate."""
        return self._intf.set_property(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._set_altitude_rate_metadata, value)

    _get_use_aerodynamic_propulsion_fuel_metadata = { "offset" : _get_use_aerodynamic_propulsion_fuel_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_aerodynamic_propulsion_fuel(self) -> bool:
        """Get or set whether to use Aero/Propulsion fuel flow."""
        return self._intf.get_property(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._get_use_aerodynamic_propulsion_fuel_metadata)

    _set_use_aerodynamic_propulsion_fuel_metadata = { "offset" : _set_use_aerodynamic_propulsion_fuel_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_aerodynamic_propulsion_fuel.setter
    def use_aerodynamic_propulsion_fuel(self, value:bool) -> None:
        """Get or set whether to use Aero/Propulsion fuel flow."""
        return self._intf.set_property(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._set_use_aerodynamic_propulsion_fuel_metadata, value)

    _get_scale_fuel_flow_by_non_std_density_metadata = { "offset" : _get_scale_fuel_flow_by_non_std_density_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def scale_fuel_flow_by_non_std_density(self) -> bool:
        """Get or set whether to scale fuel flow by non std density."""
        return self._intf.get_property(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._get_scale_fuel_flow_by_non_std_density_metadata)

    _set_scale_fuel_flow_by_non_std_density_metadata = { "offset" : _set_scale_fuel_flow_by_non_std_density_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @scale_fuel_flow_by_non_std_density.setter
    def scale_fuel_flow_by_non_std_density(self, value:bool) -> None:
        """Get or set whether to scale fuel flow by non std density."""
        return self._intf.set_property(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._set_scale_fuel_flow_by_non_std_density_metadata, value)

    _get_fuel_flow_metadata = { "offset" : _get_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fuel_flow(self) -> float:
        """Get or set the Sea Level Fuel Flow."""
        return self._intf.get_property(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._get_fuel_flow_metadata)

    _set_fuel_flow_metadata = { "offset" : _set_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fuel_flow.setter
    def fuel_flow(self, value:float) -> None:
        """Get or set the Sea Level Fuel Flow."""
        return self._intf.set_property(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._set_fuel_flow_metadata, value)

    _get_enable_relative_airspeed_tolerance_metadata = { "offset" : _get_enable_relative_airspeed_tolerance_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_relative_airspeed_tolerance(self) -> bool:
        """Get or set whether to enable relative airspeed tolerance."""
        return self._intf.get_property(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._get_enable_relative_airspeed_tolerance_metadata)

    _set_enable_relative_airspeed_tolerance_metadata = { "offset" : _set_enable_relative_airspeed_tolerance_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_relative_airspeed_tolerance.setter
    def enable_relative_airspeed_tolerance(self, value:bool) -> None:
        """Get or set whether to enable relative airspeed tolerance."""
        return self._intf.set_property(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._set_enable_relative_airspeed_tolerance_metadata, value)

    _get_relative_airspeed_tolerance_metadata = { "offset" : _get_relative_airspeed_tolerance_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def relative_airspeed_tolerance(self) -> float:
        """Get or set the relative airspeed tolerance."""
        return self._intf.get_property(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._get_relative_airspeed_tolerance_metadata)

    _set_relative_airspeed_tolerance_metadata = { "offset" : _set_relative_airspeed_tolerance_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @relative_airspeed_tolerance.setter
    def relative_airspeed_tolerance(self, value:float) -> None:
        """Get or set the relative airspeed tolerance."""
        return self._intf.set_property(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._set_relative_airspeed_tolerance_metadata, value)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftBasicClimbModel._metadata, AircraftBasicClimbModel._get_as_catalog_item_metadata, OutArg())

    _property_names[ceiling_altitude] = "ceiling_altitude"
    _property_names[airspeed] = "airspeed"
    _property_names[airspeed_type] = "airspeed_type"
    _property_names[altitude_rate] = "altitude_rate"
    _property_names[use_aerodynamic_propulsion_fuel] = "use_aerodynamic_propulsion_fuel"
    _property_names[scale_fuel_flow_by_non_std_density] = "scale_fuel_flow_by_non_std_density"
    _property_names[fuel_flow] = "fuel_flow"
    _property_names[enable_relative_airspeed_tolerance] = "enable_relative_airspeed_tolerance"
    _property_names[relative_airspeed_tolerance] = "relative_airspeed_tolerance"

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

agcls.AgClassCatalog.add_catalog_entry((5488216727438286377, 10220011439221355917), AircraftBasicClimbModel)
agcls.AgTypeNameMap["AircraftBasicClimbModel"] = AircraftBasicClimbModel

class AircraftAdvancedClimbModel(IPerformanceModel, ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the advanced climb model options for a climb model of an aircraft in the Aviator catalog."""

    _num_methods = 21
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_climb_speed_type_method_offset = 1
    _set_climb_speed_type_method_offset = 2
    _get_climb_override_airspeed_type_method_offset = 3
    _get_climb_override_airspeed_method_offset = 4
    _set_climb_override_airspeed_method_offset = 5
    _get_use_afterburner_method_offset = 6
    _set_use_afterburner_method_offset = 7
    _get_use_airspeed_limit_method_offset = 8
    _set_use_airspeed_limit_method_offset = 9
    _get_altitude_limit_method_offset = 10
    _set_altitude_limit_method_offset = 11
    _get_airspeed_limit_type_method_offset = 12
    _get_airspeed_limit_method_offset = 13
    _set_airspeed_limit_method_offset = 14
    _get_use_flight_path_angle_limit_method_offset = 15
    _set_use_flight_path_angle_limit_method_offset = 16
    _get_flight_path_angle_method_offset = 17
    _set_flight_path_angle_method_offset = 18
    _get_compute_delta_altitude_method_offset = 19
    _set_compute_delta_altitude_method_offset = 20
    _get_as_catalog_item_method_offset = 21
    _metadata = {
        "iid_data" : (5543563085120883607, 6217179742438742698),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftAdvancedClimbModel)

    _get_climb_speed_type_metadata = { "offset" : _get_climb_speed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ClimbSpeedType),) }
    @property
    def climb_speed_type(self) -> "ClimbSpeedType":
        """Get or set the mode to calculate the aircraft's airspeed while climbing."""
        return self._intf.get_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._get_climb_speed_type_metadata)

    _set_climb_speed_type_metadata = { "offset" : _set_climb_speed_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ClimbSpeedType),) }
    @climb_speed_type.setter
    def climb_speed_type(self, value:"ClimbSpeedType") -> None:
        """Get or set the mode to calculate the aircraft's airspeed while climbing."""
        return self._intf.set_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._set_climb_speed_type_metadata, value)

    _get_climb_override_airspeed_type_metadata = { "offset" : _get_climb_override_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def climb_override_airspeed_type(self) -> "AirspeedType":
        """Get the override airspeed type."""
        return self._intf.get_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._get_climb_override_airspeed_type_metadata)

    _get_climb_override_airspeed_metadata = { "offset" : _get_climb_override_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def climb_override_airspeed(self) -> float:
        """Get the override airsepeed."""
        return self._intf.get_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._get_climb_override_airspeed_metadata)

    _set_climb_override_airspeed_metadata = { "offset" : _set_climb_override_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_climb_override_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the override airspeed and airspeed type."""
        return self._intf.invoke(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._set_climb_override_airspeed_metadata, airspeed_type, airspeed)

    _get_use_afterburner_metadata = { "offset" : _get_use_afterburner_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_afterburner(self) -> bool:
        """Opt to use the engine's afterburner when climbing if available."""
        return self._intf.get_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._get_use_afterburner_metadata)

    _set_use_afterburner_metadata = { "offset" : _set_use_afterburner_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_afterburner.setter
    def use_afterburner(self, value:bool) -> None:
        """Opt to use the engine's afterburner when climbing if available."""
        return self._intf.set_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._set_use_afterburner_metadata, value)

    _get_use_airspeed_limit_metadata = { "offset" : _get_use_airspeed_limit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_airspeed_limit(self) -> bool:
        """Opt to limit the airspeed below a specified altitude."""
        return self._intf.get_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._get_use_airspeed_limit_metadata)

    _set_use_airspeed_limit_metadata = { "offset" : _set_use_airspeed_limit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_airspeed_limit.setter
    def use_airspeed_limit(self, value:bool) -> None:
        """Opt to limit the airspeed below a specified altitude."""
        return self._intf.set_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._set_use_airspeed_limit_metadata, value)

    _get_altitude_limit_metadata = { "offset" : _get_altitude_limit_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude_limit(self) -> float:
        """Get or set the altitude threshold, below which the airspeed limit will be applied."""
        return self._intf.get_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._get_altitude_limit_metadata)

    _set_altitude_limit_metadata = { "offset" : _set_altitude_limit_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude_limit.setter
    def altitude_limit(self, value:float) -> None:
        """Get or set the altitude threshold, below which the airspeed limit will be applied."""
        return self._intf.set_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._set_altitude_limit_metadata, value)

    _get_airspeed_limit_type_metadata = { "offset" : _get_airspeed_limit_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_limit_type(self) -> "AirspeedType":
        """Get the airspeed limit type."""
        return self._intf.get_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._get_airspeed_limit_type_metadata)

    _get_airspeed_limit_metadata = { "offset" : _get_airspeed_limit_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def airspeed_limit(self) -> float:
        """Get the airsepeed limit below the altitude threshold."""
        return self._intf.get_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._get_airspeed_limit_metadata)

    _set_airspeed_limit_metadata = { "offset" : _set_airspeed_limit_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_airspeed_limit(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the airspeed limit and airspeed type below the altitude threshold."""
        return self._intf.invoke(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._set_airspeed_limit_metadata, airspeed_type, airspeed)

    _get_use_flight_path_angle_limit_metadata = { "offset" : _get_use_flight_path_angle_limit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_flight_path_angle_limit(self) -> bool:
        """Opt to limit the flight path angle."""
        return self._intf.get_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._get_use_flight_path_angle_limit_metadata)

    _set_use_flight_path_angle_limit_metadata = { "offset" : _set_use_flight_path_angle_limit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_flight_path_angle_limit.setter
    def use_flight_path_angle_limit(self, value:bool) -> None:
        """Opt to limit the flight path angle."""
        return self._intf.set_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._set_use_flight_path_angle_limit_metadata, value)

    _get_flight_path_angle_metadata = { "offset" : _get_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def flight_path_angle(self) -> typing.Any:
        """Get the flight path angle limit."""
        return self._intf.get_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._get_flight_path_angle_metadata)

    _set_flight_path_angle_metadata = { "offset" : _set_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def set_flight_path_angle(self, angle:typing.Any) -> None:
        """Enable the flight path angle limit an set the flight path angle value."""
        return self._intf.invoke(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._set_flight_path_angle_metadata, angle)

    _get_compute_delta_altitude_metadata = { "offset" : _get_compute_delta_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def compute_delta_altitude(self) -> float:
        """Get or set the maximum change in altitude in a computed segment before the data is sampled again."""
        return self._intf.get_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._get_compute_delta_altitude_metadata)

    _set_compute_delta_altitude_metadata = { "offset" : _set_compute_delta_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @compute_delta_altitude.setter
    def compute_delta_altitude(self, value:float) -> None:
        """Get or set the maximum change in altitude in a computed segment before the data is sampled again."""
        return self._intf.set_property(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._set_compute_delta_altitude_metadata, value)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftAdvancedClimbModel._metadata, AircraftAdvancedClimbModel._get_as_catalog_item_metadata, OutArg())

    _property_names[climb_speed_type] = "climb_speed_type"
    _property_names[climb_override_airspeed_type] = "climb_override_airspeed_type"
    _property_names[climb_override_airspeed] = "climb_override_airspeed"
    _property_names[use_afterburner] = "use_afterburner"
    _property_names[use_airspeed_limit] = "use_airspeed_limit"
    _property_names[altitude_limit] = "altitude_limit"
    _property_names[airspeed_limit_type] = "airspeed_limit_type"
    _property_names[airspeed_limit] = "airspeed_limit"
    _property_names[use_flight_path_angle_limit] = "use_flight_path_angle_limit"
    _property_names[flight_path_angle] = "flight_path_angle"
    _property_names[compute_delta_altitude] = "compute_delta_altitude"

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

agcls.AgClassCatalog.add_catalog_entry((4736708800223409411, 13979770057904007563), AircraftAdvancedClimbModel)
agcls.AgTypeNameMap["AircraftAdvancedClimbModel"] = AircraftAdvancedClimbModel

class AircraftBasicCruiseModel(IPerformanceModel, ICatalogItem, SupportsDeleteCallback):
    """
    Interface used to access the basic cruise model options for a cruise model of an aircraft in the Aviator catalog.

    Examples
    --------
    Configure the basic cruise performance model of an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the cruise type
    >>> cruise = aviatorAircraft.cruise
    >>> # Get the build in performance model
    >>> basicCruiseModel = cruise.get_built_in_model()
    >>>
    >>> # Set the ceiling altitude
    >>> basicCruiseModel.ceiling_altitude = 50000
    >>> # Set the default cruise altitude
    >>> basicCruiseModel.default_cruise_altitude = 10000
    >>> # Set the airspeed type
    >>> basicCruiseModel.airspeed_type = AirspeedType.TAS
    >>> # Opt to not use the fuel flow calculated by the aero/prop model and instead specify the values
    >>> basicCruiseModel.use_aerodynamic_propulsion_fuel = False
    >>>
    >>> # Set the various airspeeds and fuel flows
    >>> basicCruiseModel.min_airspeed = 110
    >>> basicCruiseModel.min_airspeed_fuel_flow = 10000
    >>>
    >>> basicCruiseModel.max_endurance_airspeed = 135
    >>> basicCruiseModel.max_endurance_fuel_flow = 8000
    >>>
    >>> basicCruiseModel.max_airspeed = 570
    >>> basicCruiseModel.max_airspeed_fuel_flow = 30000
    >>>
    >>> basicCruiseModel.max_range_airspeed = 140
    >>> basicCruiseModel.max_range_fuel_flow = 9000
    >>>
    >>> basicCruiseModel.max_performance_airspeed = 150
    >>> basicCruiseModel.max_performance_airspeed_fuel_flow = 12000
    >>>
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()
    """

    _num_methods = 31
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_ceiling_altitude_method_offset = 1
    _set_ceiling_altitude_method_offset = 2
    _get_default_cruise_altitude_method_offset = 3
    _set_default_cruise_altitude_method_offset = 4
    _get_use_aerodynamic_propulsion_fuel_method_offset = 5
    _set_use_aerodynamic_propulsion_fuel_method_offset = 6
    _get_scale_fuel_flow_by_non_std_density_method_offset = 7
    _set_scale_fuel_flow_by_non_std_density_method_offset = 8
    _get_airspeed_type_method_offset = 9
    _set_airspeed_type_method_offset = 10
    _get_min_airspeed_method_offset = 11
    _set_min_airspeed_method_offset = 12
    _get_max_endurance_airspeed_method_offset = 13
    _set_max_endurance_airspeed_method_offset = 14
    _get_max_range_airspeed_method_offset = 15
    _set_max_range_airspeed_method_offset = 16
    _get_max_airspeed_method_offset = 17
    _set_max_airspeed_method_offset = 18
    _get_max_performance_airspeed_method_offset = 19
    _set_max_performance_airspeed_method_offset = 20
    _get_min_airspeed_fuel_flow_method_offset = 21
    _set_min_airspeed_fuel_flow_method_offset = 22
    _get_max_endurance_fuel_flow_method_offset = 23
    _set_max_endurance_fuel_flow_method_offset = 24
    _get_max_range_fuel_flow_method_offset = 25
    _set_max_range_fuel_flow_method_offset = 26
    _get_max_airspeed_fuel_flow_method_offset = 27
    _set_max_airspeed_fuel_flow_method_offset = 28
    _get_max_performance_airspeed_fuel_flow_method_offset = 29
    _set_max_performance_airspeed_fuel_flow_method_offset = 30
    _get_as_catalog_item_method_offset = 31
    _metadata = {
        "iid_data" : (5314586510594823485, 6471808013847381131),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftBasicCruiseModel)

    _get_ceiling_altitude_metadata = { "offset" : _get_ceiling_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def ceiling_altitude(self) -> float:
        """Get or set the maximum altitude above mean sea level."""
        return self._intf.get_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._get_ceiling_altitude_metadata)

    _set_ceiling_altitude_metadata = { "offset" : _set_ceiling_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @ceiling_altitude.setter
    def ceiling_altitude(self, value:float) -> None:
        """Get or set the maximum altitude above mean sea level."""
        return self._intf.set_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._set_ceiling_altitude_metadata, value)

    _get_default_cruise_altitude_metadata = { "offset" : _get_default_cruise_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def default_cruise_altitude(self) -> float:
        """Get or set the aircraft's default cruise altitude."""
        return self._intf.get_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._get_default_cruise_altitude_metadata)

    _set_default_cruise_altitude_metadata = { "offset" : _set_default_cruise_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @default_cruise_altitude.setter
    def default_cruise_altitude(self, value:float) -> None:
        """Get or set the aircraft's default cruise altitude."""
        return self._intf.set_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._set_default_cruise_altitude_metadata, value)

    _get_use_aerodynamic_propulsion_fuel_metadata = { "offset" : _get_use_aerodynamic_propulsion_fuel_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_aerodynamic_propulsion_fuel(self) -> bool:
        """Opt to use the fuel flow calculated by the acceleration performance model."""
        return self._intf.get_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._get_use_aerodynamic_propulsion_fuel_metadata)

    _set_use_aerodynamic_propulsion_fuel_metadata = { "offset" : _set_use_aerodynamic_propulsion_fuel_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_aerodynamic_propulsion_fuel.setter
    def use_aerodynamic_propulsion_fuel(self, value:bool) -> None:
        """Opt to use the fuel flow calculated by the acceleration performance model."""
        return self._intf.set_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._set_use_aerodynamic_propulsion_fuel_metadata, value)

    _get_scale_fuel_flow_by_non_std_density_metadata = { "offset" : _get_scale_fuel_flow_by_non_std_density_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def scale_fuel_flow_by_non_std_density(self) -> bool:
        """Opt to scale the fuel flow by the aircraft's actual altitude."""
        return self._intf.get_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._get_scale_fuel_flow_by_non_std_density_metadata)

    _set_scale_fuel_flow_by_non_std_density_metadata = { "offset" : _set_scale_fuel_flow_by_non_std_density_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @scale_fuel_flow_by_non_std_density.setter
    def scale_fuel_flow_by_non_std_density(self, value:bool) -> None:
        """Opt to scale the fuel flow by the aircraft's actual altitude."""
        return self._intf.set_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._set_scale_fuel_flow_by_non_std_density_metadata, value)

    _get_airspeed_type_metadata = { "offset" : _get_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_type(self) -> "AirspeedType":
        """Get or set the airspeed type."""
        return self._intf.get_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._get_airspeed_type_metadata)

    _set_airspeed_type_metadata = { "offset" : _set_airspeed_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @airspeed_type.setter
    def airspeed_type(self, value:"AirspeedType") -> None:
        """Get or set the airspeed type."""
        return self._intf.set_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._set_airspeed_type_metadata, value)

    _get_min_airspeed_metadata = { "offset" : _get_min_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_airspeed(self) -> float:
        """Get or set the minimum cruising airspeed."""
        return self._intf.get_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._get_min_airspeed_metadata)

    _set_min_airspeed_metadata = { "offset" : _set_min_airspeed_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_airspeed.setter
    def min_airspeed(self, value:float) -> None:
        """Get or set the minimum cruising airspeed."""
        return self._intf.set_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._set_min_airspeed_metadata, value)

    _get_max_endurance_airspeed_metadata = { "offset" : _get_max_endurance_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_endurance_airspeed(self) -> float:
        """Get or set the cruising airspeed that will provide the maximum flying time for the aircraft."""
        return self._intf.get_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._get_max_endurance_airspeed_metadata)

    _set_max_endurance_airspeed_metadata = { "offset" : _set_max_endurance_airspeed_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_endurance_airspeed.setter
    def max_endurance_airspeed(self, value:float) -> None:
        """Get or set the cruising airspeed that will provide the maximum flying time for the aircraft."""
        return self._intf.set_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._set_max_endurance_airspeed_metadata, value)

    _get_max_range_airspeed_metadata = { "offset" : _get_max_range_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_range_airspeed(self) -> float:
        """Get or set the maximum range cruising airspeed."""
        return self._intf.get_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._get_max_range_airspeed_metadata)

    _set_max_range_airspeed_metadata = { "offset" : _set_max_range_airspeed_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_range_airspeed.setter
    def max_range_airspeed(self, value:float) -> None:
        """Get or set the maximum range cruising airspeed."""
        return self._intf.set_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._set_max_range_airspeed_metadata, value)

    _get_max_airspeed_metadata = { "offset" : _get_max_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_airspeed(self) -> float:
        """Get or set the maximum cruisng airspeed."""
        return self._intf.get_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._get_max_airspeed_metadata)

    _set_max_airspeed_metadata = { "offset" : _set_max_airspeed_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_airspeed.setter
    def max_airspeed(self, value:float) -> None:
        """Get or set the maximum cruisng airspeed."""
        return self._intf.set_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._set_max_airspeed_metadata, value)

    _get_max_performance_airspeed_metadata = { "offset" : _get_max_performance_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_performance_airspeed(self) -> float:
        """Get or set the custom performance airspeed that can be used to model specific flight conditions."""
        return self._intf.get_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._get_max_performance_airspeed_metadata)

    _set_max_performance_airspeed_metadata = { "offset" : _set_max_performance_airspeed_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_performance_airspeed.setter
    def max_performance_airspeed(self, value:float) -> None:
        """Get or set the custom performance airspeed that can be used to model specific flight conditions."""
        return self._intf.set_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._set_max_performance_airspeed_metadata, value)

    _get_min_airspeed_fuel_flow_metadata = { "offset" : _get_min_airspeed_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_airspeed_fuel_flow(self) -> float:
        """Get or set the fuel flow for the minimum cruising airspeed."""
        return self._intf.get_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._get_min_airspeed_fuel_flow_metadata)

    _set_min_airspeed_fuel_flow_metadata = { "offset" : _set_min_airspeed_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_airspeed_fuel_flow.setter
    def min_airspeed_fuel_flow(self, value:float) -> None:
        """Get or set the fuel flow for the minimum cruising airspeed."""
        return self._intf.set_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._set_min_airspeed_fuel_flow_metadata, value)

    _get_max_endurance_fuel_flow_metadata = { "offset" : _get_max_endurance_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_endurance_fuel_flow(self) -> float:
        """Get or set the fuel flow for the maximum endurance cruising airspeed."""
        return self._intf.get_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._get_max_endurance_fuel_flow_metadata)

    _set_max_endurance_fuel_flow_metadata = { "offset" : _set_max_endurance_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_endurance_fuel_flow.setter
    def max_endurance_fuel_flow(self, value:float) -> None:
        """Get or set the fuel flow for the maximumendurance cruising airspeed."""
        return self._intf.set_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._set_max_endurance_fuel_flow_metadata, value)

    _get_max_range_fuel_flow_metadata = { "offset" : _get_max_range_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_range_fuel_flow(self) -> float:
        """Get or set the fuel flow for the maximum range cruising airspeed."""
        return self._intf.get_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._get_max_range_fuel_flow_metadata)

    _set_max_range_fuel_flow_metadata = { "offset" : _set_max_range_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_range_fuel_flow.setter
    def max_range_fuel_flow(self, value:float) -> None:
        """Get or set the fuel flow for the maximum range cruising airspeed."""
        return self._intf.set_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._set_max_range_fuel_flow_metadata, value)

    _get_max_airspeed_fuel_flow_metadata = { "offset" : _get_max_airspeed_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_airspeed_fuel_flow(self) -> float:
        """Get or set the fuel flow for the maximum cruising airspeed."""
        return self._intf.get_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._get_max_airspeed_fuel_flow_metadata)

    _set_max_airspeed_fuel_flow_metadata = { "offset" : _set_max_airspeed_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_airspeed_fuel_flow.setter
    def max_airspeed_fuel_flow(self, value:float) -> None:
        """Get or set the fuel flow for the maximum cruising airspeed."""
        return self._intf.set_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._set_max_airspeed_fuel_flow_metadata, value)

    _get_max_performance_airspeed_fuel_flow_metadata = { "offset" : _get_max_performance_airspeed_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_performance_airspeed_fuel_flow(self) -> float:
        """Get or set the fuel flow for the maximum performance cruising airspeed."""
        return self._intf.get_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._get_max_performance_airspeed_fuel_flow_metadata)

    _set_max_performance_airspeed_fuel_flow_metadata = { "offset" : _set_max_performance_airspeed_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_performance_airspeed_fuel_flow.setter
    def max_performance_airspeed_fuel_flow(self, value:float) -> None:
        """Get or set the fuel flow for the maximum performance cruising airspeed."""
        return self._intf.set_property(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._set_max_performance_airspeed_fuel_flow_metadata, value)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftBasicCruiseModel._metadata, AircraftBasicCruiseModel._get_as_catalog_item_metadata, OutArg())

    _property_names[ceiling_altitude] = "ceiling_altitude"
    _property_names[default_cruise_altitude] = "default_cruise_altitude"
    _property_names[use_aerodynamic_propulsion_fuel] = "use_aerodynamic_propulsion_fuel"
    _property_names[scale_fuel_flow_by_non_std_density] = "scale_fuel_flow_by_non_std_density"
    _property_names[airspeed_type] = "airspeed_type"
    _property_names[min_airspeed] = "min_airspeed"
    _property_names[max_endurance_airspeed] = "max_endurance_airspeed"
    _property_names[max_range_airspeed] = "max_range_airspeed"
    _property_names[max_airspeed] = "max_airspeed"
    _property_names[max_performance_airspeed] = "max_performance_airspeed"
    _property_names[min_airspeed_fuel_flow] = "min_airspeed_fuel_flow"
    _property_names[max_endurance_fuel_flow] = "max_endurance_fuel_flow"
    _property_names[max_range_fuel_flow] = "max_range_fuel_flow"
    _property_names[max_airspeed_fuel_flow] = "max_airspeed_fuel_flow"
    _property_names[max_performance_airspeed_fuel_flow] = "max_performance_airspeed_fuel_flow"

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

agcls.AgClassCatalog.add_catalog_entry((5471844237425838798, 12111710160149214125), AircraftBasicCruiseModel)
agcls.AgTypeNameMap["AircraftBasicCruiseModel"] = AircraftBasicCruiseModel

class AircraftAdvancedCruiseModel(IPerformanceModel, ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the advanced cruise model options for a cruise model of an aircraft in the Aviator catalog."""

    _num_methods = 14
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_default_cruise_altitude_method_offset = 1
    _set_default_cruise_altitude_method_offset = 2
    _get_max_performance_airspeed_method_offset = 3
    _set_max_performance_airspeed_method_offset = 4
    _get_use_airspeed_limit_method_offset = 5
    _set_use_airspeed_limit_method_offset = 6
    _get_altitude_limit_method_offset = 7
    _set_altitude_limit_method_offset = 8
    _get_airspeed_limit_type_method_offset = 9
    _get_airspeed_limit_method_offset = 10
    _set_airspeed_limit_method_offset = 11
    _get_compute_delta_downrange_method_offset = 12
    _set_compute_delta_downrange_method_offset = 13
    _get_as_catalog_item_method_offset = 14
    _metadata = {
        "iid_data" : (4951863565701278341, 9812484038019628430),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftAdvancedCruiseModel)

    _get_default_cruise_altitude_metadata = { "offset" : _get_default_cruise_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def default_cruise_altitude(self) -> float:
        """Get or set the aircraft's default cruising altitude."""
        return self._intf.get_property(AircraftAdvancedCruiseModel._metadata, AircraftAdvancedCruiseModel._get_default_cruise_altitude_metadata)

    _set_default_cruise_altitude_metadata = { "offset" : _set_default_cruise_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @default_cruise_altitude.setter
    def default_cruise_altitude(self, value:float) -> None:
        """Get or set the aircraft's default cruising altitude."""
        return self._intf.set_property(AircraftAdvancedCruiseModel._metadata, AircraftAdvancedCruiseModel._set_default_cruise_altitude_metadata, value)

    _get_max_performance_airspeed_metadata = { "offset" : _get_max_performance_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CruiseMaxPerformanceSpeedType),) }
    @property
    def max_performance_airspeed(self) -> "CruiseMaxPerformanceSpeedType":
        """Get or set the method for defining the maximum performance airspeed of the aircraft with respect to its altitude."""
        return self._intf.get_property(AircraftAdvancedCruiseModel._metadata, AircraftAdvancedCruiseModel._get_max_performance_airspeed_metadata)

    _set_max_performance_airspeed_metadata = { "offset" : _set_max_performance_airspeed_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CruiseMaxPerformanceSpeedType),) }
    @max_performance_airspeed.setter
    def max_performance_airspeed(self, value:"CruiseMaxPerformanceSpeedType") -> None:
        """Get or set the method for defining the maximum performance airspeed of the aircraft with respect to its altitude."""
        return self._intf.set_property(AircraftAdvancedCruiseModel._metadata, AircraftAdvancedCruiseModel._set_max_performance_airspeed_metadata, value)

    _get_use_airspeed_limit_metadata = { "offset" : _get_use_airspeed_limit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_airspeed_limit(self) -> bool:
        """Opt to limit the airspeed below a specified altitude."""
        return self._intf.get_property(AircraftAdvancedCruiseModel._metadata, AircraftAdvancedCruiseModel._get_use_airspeed_limit_metadata)

    _set_use_airspeed_limit_metadata = { "offset" : _set_use_airspeed_limit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_airspeed_limit.setter
    def use_airspeed_limit(self, value:bool) -> None:
        """Opt to limit the airspeed below a specified altitude."""
        return self._intf.set_property(AircraftAdvancedCruiseModel._metadata, AircraftAdvancedCruiseModel._set_use_airspeed_limit_metadata, value)

    _get_altitude_limit_metadata = { "offset" : _get_altitude_limit_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude_limit(self) -> float:
        """Get or set the altitude threshold, below which the airspeed limit will be applied."""
        return self._intf.get_property(AircraftAdvancedCruiseModel._metadata, AircraftAdvancedCruiseModel._get_altitude_limit_metadata)

    _set_altitude_limit_metadata = { "offset" : _set_altitude_limit_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude_limit.setter
    def altitude_limit(self, value:float) -> None:
        """Get or set the altitude threshold, below which the airspeed limit will be applied."""
        return self._intf.set_property(AircraftAdvancedCruiseModel._metadata, AircraftAdvancedCruiseModel._set_altitude_limit_metadata, value)

    _get_airspeed_limit_type_metadata = { "offset" : _get_airspeed_limit_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_limit_type(self) -> "AirspeedType":
        """Get the airspeed limit type."""
        return self._intf.get_property(AircraftAdvancedCruiseModel._metadata, AircraftAdvancedCruiseModel._get_airspeed_limit_type_metadata)

    _get_airspeed_limit_metadata = { "offset" : _get_airspeed_limit_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def airspeed_limit(self) -> float:
        """Get the airsepeed limit below the altitude threshold."""
        return self._intf.get_property(AircraftAdvancedCruiseModel._metadata, AircraftAdvancedCruiseModel._get_airspeed_limit_metadata)

    _set_airspeed_limit_metadata = { "offset" : _set_airspeed_limit_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_airspeed_limit(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the airspeed limit and airspeed type below the altitude threshold."""
        return self._intf.invoke(AircraftAdvancedCruiseModel._metadata, AircraftAdvancedCruiseModel._set_airspeed_limit_metadata, airspeed_type, airspeed)

    _get_compute_delta_downrange_metadata = { "offset" : _get_compute_delta_downrange_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def compute_delta_downrange(self) -> float:
        """Get or set the maximum change in downrange distance in a computed segment before the data is sampled again."""
        return self._intf.get_property(AircraftAdvancedCruiseModel._metadata, AircraftAdvancedCruiseModel._get_compute_delta_downrange_metadata)

    _set_compute_delta_downrange_metadata = { "offset" : _set_compute_delta_downrange_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @compute_delta_downrange.setter
    def compute_delta_downrange(self, value:float) -> None:
        """Get or set the maximum change in downrange distance in a computed segment before the data is sampled again."""
        return self._intf.set_property(AircraftAdvancedCruiseModel._metadata, AircraftAdvancedCruiseModel._set_compute_delta_downrange_metadata, value)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftAdvancedCruiseModel._metadata, AircraftAdvancedCruiseModel._get_as_catalog_item_metadata, OutArg())

    _property_names[default_cruise_altitude] = "default_cruise_altitude"
    _property_names[max_performance_airspeed] = "max_performance_airspeed"
    _property_names[use_airspeed_limit] = "use_airspeed_limit"
    _property_names[altitude_limit] = "altitude_limit"
    _property_names[airspeed_limit_type] = "airspeed_limit_type"
    _property_names[airspeed_limit] = "airspeed_limit"
    _property_names[compute_delta_downrange] = "compute_delta_downrange"

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

agcls.AgClassCatalog.add_catalog_entry((5455870576064233751, 10403403645709593512), AircraftAdvancedCruiseModel)
agcls.AgTypeNameMap["AircraftAdvancedCruiseModel"] = AircraftAdvancedCruiseModel

class AircraftBasicDescentModel(IPerformanceModel, ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the basic descent model options for a descent model of an aircraft in the Aviator catalog."""

    _num_methods = 18
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_ceiling_altitude_method_offset = 1
    _set_ceiling_altitude_method_offset = 2
    _get_airspeed_method_offset = 3
    _get_airspeed_type_method_offset = 4
    _set_airspeed_method_offset = 5
    _get_altitude_rate_method_offset = 6
    _set_altitude_rate_method_offset = 7
    _get_use_aerodynamic_propulsion_fuel_method_offset = 8
    _set_use_aerodynamic_propulsion_fuel_method_offset = 9
    _get_scale_fuel_flow_by_non_std_density_method_offset = 10
    _set_scale_fuel_flow_by_non_std_density_method_offset = 11
    _get_fuel_flow_method_offset = 12
    _set_fuel_flow_method_offset = 13
    _get_enable_relative_airspeed_tolerance_method_offset = 14
    _set_enable_relative_airspeed_tolerance_method_offset = 15
    _get_relative_airspeed_tolerance_method_offset = 16
    _set_relative_airspeed_tolerance_method_offset = 17
    _get_as_catalog_item_method_offset = 18
    _metadata = {
        "iid_data" : (4619424590425145819, 1963764848038236049),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftBasicDescentModel)

    _get_ceiling_altitude_metadata = { "offset" : _get_ceiling_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def ceiling_altitude(self) -> float:
        """Get or set the ceiling altitude."""
        return self._intf.get_property(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._get_ceiling_altitude_metadata)

    _set_ceiling_altitude_metadata = { "offset" : _set_ceiling_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @ceiling_altitude.setter
    def ceiling_altitude(self, value:float) -> None:
        """Get or set the ceiling altitude."""
        return self._intf.set_property(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._set_ceiling_altitude_metadata, value)

    _get_airspeed_metadata = { "offset" : _get_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def airspeed(self) -> float:
        """Get the airsepeed."""
        return self._intf.get_property(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._get_airspeed_metadata)

    _get_airspeed_type_metadata = { "offset" : _get_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type."""
        return self._intf.get_property(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._get_airspeed_type_metadata)

    _set_airspeed_metadata = { "offset" : _set_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the airspeed type and value."""
        return self._intf.invoke(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._set_airspeed_metadata, airspeed_type, airspeed)

    _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 altitude rate."""
        return self._intf.get_property(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._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:
        """Get or set the altitude rate."""
        return self._intf.set_property(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._set_altitude_rate_metadata, value)

    _get_use_aerodynamic_propulsion_fuel_metadata = { "offset" : _get_use_aerodynamic_propulsion_fuel_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_aerodynamic_propulsion_fuel(self) -> bool:
        """Get or set whether to use Aero/Propulsion fuel flow."""
        return self._intf.get_property(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._get_use_aerodynamic_propulsion_fuel_metadata)

    _set_use_aerodynamic_propulsion_fuel_metadata = { "offset" : _set_use_aerodynamic_propulsion_fuel_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_aerodynamic_propulsion_fuel.setter
    def use_aerodynamic_propulsion_fuel(self, value:bool) -> None:
        """Get or set whether to use Aero/Propulsion fuel flow."""
        return self._intf.set_property(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._set_use_aerodynamic_propulsion_fuel_metadata, value)

    _get_scale_fuel_flow_by_non_std_density_metadata = { "offset" : _get_scale_fuel_flow_by_non_std_density_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def scale_fuel_flow_by_non_std_density(self) -> bool:
        """Get or set whether to scale fuel flow by non std density."""
        return self._intf.get_property(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._get_scale_fuel_flow_by_non_std_density_metadata)

    _set_scale_fuel_flow_by_non_std_density_metadata = { "offset" : _set_scale_fuel_flow_by_non_std_density_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @scale_fuel_flow_by_non_std_density.setter
    def scale_fuel_flow_by_non_std_density(self, value:bool) -> None:
        """Get or set whether to scale fuel flow by non std density."""
        return self._intf.set_property(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._set_scale_fuel_flow_by_non_std_density_metadata, value)

    _get_fuel_flow_metadata = { "offset" : _get_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fuel_flow(self) -> float:
        """Get or set the Sea Level Fuel Flow."""
        return self._intf.get_property(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._get_fuel_flow_metadata)

    _set_fuel_flow_metadata = { "offset" : _set_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fuel_flow.setter
    def fuel_flow(self, value:float) -> None:
        """Get or set the Sea Level Fuel Flow."""
        return self._intf.set_property(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._set_fuel_flow_metadata, value)

    _get_enable_relative_airspeed_tolerance_metadata = { "offset" : _get_enable_relative_airspeed_tolerance_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_relative_airspeed_tolerance(self) -> bool:
        """Get or set whether to enable relative airspeed tolerance."""
        return self._intf.get_property(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._get_enable_relative_airspeed_tolerance_metadata)

    _set_enable_relative_airspeed_tolerance_metadata = { "offset" : _set_enable_relative_airspeed_tolerance_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @enable_relative_airspeed_tolerance.setter
    def enable_relative_airspeed_tolerance(self, value:bool) -> None:
        """Get or set whether to enable relative airspeed tolerance."""
        return self._intf.set_property(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._set_enable_relative_airspeed_tolerance_metadata, value)

    _get_relative_airspeed_tolerance_metadata = { "offset" : _get_relative_airspeed_tolerance_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def relative_airspeed_tolerance(self) -> float:
        """Get or set the relative airspeed tolerance."""
        return self._intf.get_property(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._get_relative_airspeed_tolerance_metadata)

    _set_relative_airspeed_tolerance_metadata = { "offset" : _set_relative_airspeed_tolerance_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @relative_airspeed_tolerance.setter
    def relative_airspeed_tolerance(self, value:float) -> None:
        """Get or set the relative airspeed tolerance."""
        return self._intf.set_property(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._set_relative_airspeed_tolerance_metadata, value)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftBasicDescentModel._metadata, AircraftBasicDescentModel._get_as_catalog_item_metadata, OutArg())

    _property_names[ceiling_altitude] = "ceiling_altitude"
    _property_names[airspeed] = "airspeed"
    _property_names[airspeed_type] = "airspeed_type"
    _property_names[altitude_rate] = "altitude_rate"
    _property_names[use_aerodynamic_propulsion_fuel] = "use_aerodynamic_propulsion_fuel"
    _property_names[scale_fuel_flow_by_non_std_density] = "scale_fuel_flow_by_non_std_density"
    _property_names[fuel_flow] = "fuel_flow"
    _property_names[enable_relative_airspeed_tolerance] = "enable_relative_airspeed_tolerance"
    _property_names[relative_airspeed_tolerance] = "relative_airspeed_tolerance"

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

agcls.AgClassCatalog.add_catalog_entry((4788927177679408495, 6388236481941240196), AircraftBasicDescentModel)
agcls.AgTypeNameMap["AircraftBasicDescentModel"] = AircraftBasicDescentModel

class AircraftAdvancedDescentModel(IPerformanceModel, ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the advanced descent model options for a descent model of an aircraft in the Aviator catalog."""

    _num_methods = 19
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_descent_speed_type_method_offset = 1
    _set_descent_speed_type_method_offset = 2
    _get_descent_stall_speed_ratio_method_offset = 3
    _set_descent_stall_speed_ratio_method_offset = 4
    _get_descent_override_airspeed_type_method_offset = 5
    _get_descent_override_airspeed_method_offset = 6
    _set_descent_override_airspeed_method_offset = 7
    _get_speedbrakes_method_offset = 8
    _set_speedbrakes_method_offset = 9
    _get_use_airspeed_limit_method_offset = 10
    _set_use_airspeed_limit_method_offset = 11
    _get_altitude_limit_method_offset = 12
    _set_altitude_limit_method_offset = 13
    _get_airspeed_limit_type_method_offset = 14
    _get_airspeed_limit_method_offset = 15
    _set_airspeed_limit_method_offset = 16
    _get_compute_delta_altitude_method_offset = 17
    _set_compute_delta_altitude_method_offset = 18
    _get_as_catalog_item_method_offset = 19
    _metadata = {
        "iid_data" : (5138930714286807665, 1693484297723898786),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftAdvancedDescentModel)

    _get_descent_speed_type_metadata = { "offset" : _get_descent_speed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DescentSpeedType),) }
    @property
    def descent_speed_type(self) -> "DescentSpeedType":
        """Get or set the mode to calculate the aircraft's airspeed while descending ."""
        return self._intf.get_property(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._get_descent_speed_type_metadata)

    _set_descent_speed_type_metadata = { "offset" : _set_descent_speed_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DescentSpeedType),) }
    @descent_speed_type.setter
    def descent_speed_type(self, value:"DescentSpeedType") -> None:
        """Get or set the mode to calculate the aircraft's airspeed while descending ."""
        return self._intf.set_property(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._set_descent_speed_type_metadata, value)

    _get_descent_stall_speed_ratio_metadata = { "offset" : _get_descent_stall_speed_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def descent_stall_speed_ratio(self) -> float:
        """Get or set the ratio of the airspeed upon leaving the ground to the stall speed."""
        return self._intf.get_property(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._get_descent_stall_speed_ratio_metadata)

    _set_descent_stall_speed_ratio_metadata = { "offset" : _set_descent_stall_speed_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @descent_stall_speed_ratio.setter
    def descent_stall_speed_ratio(self, value:float) -> None:
        """Get or set the ratio of the airspeed upon leaving the ground to the stall speed."""
        return self._intf.set_property(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._set_descent_stall_speed_ratio_metadata, value)

    _get_descent_override_airspeed_type_metadata = { "offset" : _get_descent_override_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def descent_override_airspeed_type(self) -> "AirspeedType":
        """Get the override airspeed type."""
        return self._intf.get_property(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._get_descent_override_airspeed_type_metadata)

    _get_descent_override_airspeed_metadata = { "offset" : _get_descent_override_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def descent_override_airspeed(self) -> float:
        """Get the override airsepeed."""
        return self._intf.get_property(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._get_descent_override_airspeed_metadata)

    _set_descent_override_airspeed_metadata = { "offset" : _set_descent_override_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_descent_override_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the override airspeed and airspeed type."""
        return self._intf.invoke(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._set_descent_override_airspeed_metadata, airspeed_type, airspeed)

    _get_speedbrakes_metadata = { "offset" : _get_speedbrakes_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def speedbrakes(self) -> float:
        """Get or set the extension of the speedbrakes during the landing."""
        return self._intf.get_property(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._get_speedbrakes_metadata)

    _set_speedbrakes_metadata = { "offset" : _set_speedbrakes_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @speedbrakes.setter
    def speedbrakes(self, value:float) -> None:
        """Get or set the extension of the speedbrakes during the landing."""
        return self._intf.set_property(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._set_speedbrakes_metadata, value)

    _get_use_airspeed_limit_metadata = { "offset" : _get_use_airspeed_limit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_airspeed_limit(self) -> bool:
        """Opt to limit the airspeed below a specified altitude."""
        return self._intf.get_property(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._get_use_airspeed_limit_metadata)

    _set_use_airspeed_limit_metadata = { "offset" : _set_use_airspeed_limit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_airspeed_limit.setter
    def use_airspeed_limit(self, value:bool) -> None:
        """Opt to limit the airspeed below a specified altitude."""
        return self._intf.set_property(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._set_use_airspeed_limit_metadata, value)

    _get_altitude_limit_metadata = { "offset" : _get_altitude_limit_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude_limit(self) -> float:
        """Get or set the altitude threshold, below which the airspeed limit will be applied."""
        return self._intf.get_property(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._get_altitude_limit_metadata)

    _set_altitude_limit_metadata = { "offset" : _set_altitude_limit_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude_limit.setter
    def altitude_limit(self, value:float) -> None:
        """Get or set the altitude threshold, below which the airspeed limit will be applied."""
        return self._intf.set_property(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._set_altitude_limit_metadata, value)

    _get_airspeed_limit_type_metadata = { "offset" : _get_airspeed_limit_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_limit_type(self) -> "AirspeedType":
        """Get the airspeed limit type."""
        return self._intf.get_property(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._get_airspeed_limit_type_metadata)

    _get_airspeed_limit_metadata = { "offset" : _get_airspeed_limit_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def airspeed_limit(self) -> float:
        """Get the airsepeed limit below the altitude threshold."""
        return self._intf.get_property(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._get_airspeed_limit_metadata)

    _set_airspeed_limit_metadata = { "offset" : _set_airspeed_limit_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_airspeed_limit(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the airspeed limit and airspeed type below the altitude threshold."""
        return self._intf.invoke(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._set_airspeed_limit_metadata, airspeed_type, airspeed)

    _get_compute_delta_altitude_metadata = { "offset" : _get_compute_delta_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def compute_delta_altitude(self) -> float:
        """Get or set the maximum change in altitude in a computed segment before the data is sampled again."""
        return self._intf.get_property(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._get_compute_delta_altitude_metadata)

    _set_compute_delta_altitude_metadata = { "offset" : _set_compute_delta_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @compute_delta_altitude.setter
    def compute_delta_altitude(self, value:float) -> None:
        """Get or set the maximum change in altitude in a computed segment before the data is sampled again."""
        return self._intf.set_property(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._set_compute_delta_altitude_metadata, value)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftAdvancedDescentModel._metadata, AircraftAdvancedDescentModel._get_as_catalog_item_metadata, OutArg())

    _property_names[descent_speed_type] = "descent_speed_type"
    _property_names[descent_stall_speed_ratio] = "descent_stall_speed_ratio"
    _property_names[descent_override_airspeed_type] = "descent_override_airspeed_type"
    _property_names[descent_override_airspeed] = "descent_override_airspeed"
    _property_names[speedbrakes] = "speedbrakes"
    _property_names[use_airspeed_limit] = "use_airspeed_limit"
    _property_names[altitude_limit] = "altitude_limit"
    _property_names[airspeed_limit_type] = "airspeed_limit_type"
    _property_names[airspeed_limit] = "airspeed_limit"
    _property_names[compute_delta_altitude] = "compute_delta_altitude"

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

agcls.AgClassCatalog.add_catalog_entry((5324825486015993906, 2788835445536991165), AircraftAdvancedDescentModel)
agcls.AgTypeNameMap["AircraftAdvancedDescentModel"] = AircraftAdvancedDescentModel

class AircraftBasicTakeoffModel(IPerformanceModel, ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the basic takeoff model options for a takeoff model of an aircraft in the Aviator catalog."""

    _num_methods = 17
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_takeoff_speed_method_offset = 1
    _get_takeoff_speed_type_method_offset = 2
    _set_takeoff_speed_method_offset = 3
    _get_sea_level_ground_roll_method_offset = 4
    _set_sea_level_ground_roll_method_offset = 5
    _get_departure_speed_method_offset = 6
    _get_departure_speed_type_method_offset = 7
    _set_departure_speed_method_offset = 8
    _get_use_aerodynamic_propulsion_fuel_method_offset = 9
    _set_use_aerodynamic_propulsion_fuel_method_offset = 10
    _get_scale_fuel_flow_by_non_std_density_method_offset = 11
    _set_scale_fuel_flow_by_non_std_density_method_offset = 12
    _get_acceleration_fuel_flow_method_offset = 13
    _set_acceleration_fuel_flow_method_offset = 14
    _get_departure_fuel_flow_method_offset = 15
    _set_departure_fuel_flow_method_offset = 16
    _get_as_catalog_item_method_offset = 17
    _metadata = {
        "iid_data" : (5032744767634970533, 755518156549444771),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftBasicTakeoffModel)

    _get_takeoff_speed_metadata = { "offset" : _get_takeoff_speed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def takeoff_speed(self) -> float:
        """Get the speed to which the aircraft accelerates on its ground roll for takeoff."""
        return self._intf.get_property(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._get_takeoff_speed_metadata)

    _get_takeoff_speed_type_metadata = { "offset" : _get_takeoff_speed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def takeoff_speed_type(self) -> "AirspeedType":
        """Get the takeoff speed type."""
        return self._intf.get_property(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._get_takeoff_speed_type_metadata)

    _set_takeoff_speed_metadata = { "offset" : _set_takeoff_speed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_takeoff_speed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the takeoff speed of the aircraft."""
        return self._intf.invoke(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._set_takeoff_speed_metadata, airspeed_type, airspeed)

    _get_sea_level_ground_roll_metadata = { "offset" : _get_sea_level_ground_roll_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def sea_level_ground_roll(self) -> float:
        """Get or set the distance the aircraft travels along the ground while accelerationg to takeoff at sea level."""
        return self._intf.get_property(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._get_sea_level_ground_roll_metadata)

    _set_sea_level_ground_roll_metadata = { "offset" : _set_sea_level_ground_roll_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @sea_level_ground_roll.setter
    def sea_level_ground_roll(self, value:float) -> None:
        """Get or set the distance the aircraft travels along the ground while accelerationg to takeoff at sea level."""
        return self._intf.set_property(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._set_sea_level_ground_roll_metadata, value)

    _get_departure_speed_metadata = { "offset" : _get_departure_speed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def departure_speed(self) -> float:
        """Get the aircraft's speed upon leaving the ground."""
        return self._intf.get_property(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._get_departure_speed_metadata)

    _get_departure_speed_type_metadata = { "offset" : _get_departure_speed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def departure_speed_type(self) -> "AirspeedType":
        """Get the departure speed type."""
        return self._intf.get_property(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._get_departure_speed_type_metadata)

    _set_departure_speed_metadata = { "offset" : _set_departure_speed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_departure_speed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the departure speed of the aircraft."""
        return self._intf.invoke(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._set_departure_speed_metadata, airspeed_type, airspeed)

    _get_use_aerodynamic_propulsion_fuel_metadata = { "offset" : _get_use_aerodynamic_propulsion_fuel_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_aerodynamic_propulsion_fuel(self) -> bool:
        """Get or set whether to use Aero/Propulsion fuel flow."""
        return self._intf.get_property(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._get_use_aerodynamic_propulsion_fuel_metadata)

    _set_use_aerodynamic_propulsion_fuel_metadata = { "offset" : _set_use_aerodynamic_propulsion_fuel_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_aerodynamic_propulsion_fuel.setter
    def use_aerodynamic_propulsion_fuel(self, value:bool) -> None:
        """Get or set whether to use Aero/Propulsion fuel flow."""
        return self._intf.set_property(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._set_use_aerodynamic_propulsion_fuel_metadata, value)

    _get_scale_fuel_flow_by_non_std_density_metadata = { "offset" : _get_scale_fuel_flow_by_non_std_density_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def scale_fuel_flow_by_non_std_density(self) -> bool:
        """Get or set whether to scale fuel flow by non std density."""
        return self._intf.get_property(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._get_scale_fuel_flow_by_non_std_density_metadata)

    _set_scale_fuel_flow_by_non_std_density_metadata = { "offset" : _set_scale_fuel_flow_by_non_std_density_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @scale_fuel_flow_by_non_std_density.setter
    def scale_fuel_flow_by_non_std_density(self, value:bool) -> None:
        """Get or set whether to scale fuel flow by non std density."""
        return self._intf.set_property(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._set_scale_fuel_flow_by_non_std_density_metadata, value)

    _get_acceleration_fuel_flow_metadata = { "offset" : _get_acceleration_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def acceleration_fuel_flow(self) -> float:
        """Get or set the aircraft's fuel flow rate while accelerating during takeoff."""
        return self._intf.get_property(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._get_acceleration_fuel_flow_metadata)

    _set_acceleration_fuel_flow_metadata = { "offset" : _set_acceleration_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @acceleration_fuel_flow.setter
    def acceleration_fuel_flow(self, value:float) -> None:
        """Get or set the aircraft's fuel flow rate while accelerating during takeoff."""
        return self._intf.set_property(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._set_acceleration_fuel_flow_metadata, value)

    _get_departure_fuel_flow_metadata = { "offset" : _get_departure_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def departure_fuel_flow(self) -> float:
        """Get or set the aircraft's fuel flow rate at departure speed."""
        return self._intf.get_property(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._get_departure_fuel_flow_metadata)

    _set_departure_fuel_flow_metadata = { "offset" : _set_departure_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @departure_fuel_flow.setter
    def departure_fuel_flow(self, value:float) -> None:
        """Get or set the aircraft's fuel flow rate at departure speed."""
        return self._intf.set_property(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._set_departure_fuel_flow_metadata, value)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftBasicTakeoffModel._metadata, AircraftBasicTakeoffModel._get_as_catalog_item_metadata, OutArg())

    _property_names[takeoff_speed] = "takeoff_speed"
    _property_names[takeoff_speed_type] = "takeoff_speed_type"
    _property_names[sea_level_ground_roll] = "sea_level_ground_roll"
    _property_names[departure_speed] = "departure_speed"
    _property_names[departure_speed_type] = "departure_speed_type"
    _property_names[use_aerodynamic_propulsion_fuel] = "use_aerodynamic_propulsion_fuel"
    _property_names[scale_fuel_flow_by_non_std_density] = "scale_fuel_flow_by_non_std_density"
    _property_names[acceleration_fuel_flow] = "acceleration_fuel_flow"
    _property_names[departure_fuel_flow] = "departure_fuel_flow"

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

agcls.AgClassCatalog.add_catalog_entry((5606729336629723337, 16741769561151290246), AircraftBasicTakeoffModel)
agcls.AgTypeNameMap["AircraftBasicTakeoffModel"] = AircraftBasicTakeoffModel

class AircraftAdvancedTakeoffModel(IPerformanceModel, ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the advanced takeoff model options for a takeoff model of an aircraft in the Aviator catalog."""

    _num_methods = 16
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_takeoff_speed_mode_method_offset = 1
    _set_takeoff_speed_mode_method_offset = 2
    _get_stall_speed_ratio_method_offset = 3
    _set_stall_speed_ratio_method_offset = 4
    _get_angle_of_attack_method_offset = 5
    _set_angle_of_attack_method_offset = 6
    _get_flaps_method_offset = 7
    _set_flaps_method_offset = 8
    _get_departure_speed_mode_method_offset = 9
    _set_departure_speed_mode_method_offset = 10
    _get_departure_speed_limit_method_offset = 11
    _get_departure_speed_limit_type_method_offset = 12
    _set_departure_speed_limit_method_offset = 13
    _get_use_afterburner_method_offset = 14
    _set_use_afterburner_method_offset = 15
    _get_as_catalog_item_method_offset = 16
    _metadata = {
        "iid_data" : (5320830156872402224, 10166003988108511629),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftAdvancedTakeoffModel)

    _get_takeoff_speed_mode_metadata = { "offset" : _get_takeoff_speed_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(TakeoffLandingSpeedMode),) }
    @property
    def takeoff_speed_mode(self) -> "TakeoffLandingSpeedMode":
        """Get or set the mode to calculate the aircraft's airspeed upon leaving the ground."""
        return self._intf.get_property(AircraftAdvancedTakeoffModel._metadata, AircraftAdvancedTakeoffModel._get_takeoff_speed_mode_metadata)

    _set_takeoff_speed_mode_metadata = { "offset" : _set_takeoff_speed_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(TakeoffLandingSpeedMode),) }
    @takeoff_speed_mode.setter
    def takeoff_speed_mode(self, value:"TakeoffLandingSpeedMode") -> None:
        """Get or set the mode to calculate the aircraft's airspeed upon leaving the ground."""
        return self._intf.set_property(AircraftAdvancedTakeoffModel._metadata, AircraftAdvancedTakeoffModel._set_takeoff_speed_mode_metadata, value)

    _get_stall_speed_ratio_metadata = { "offset" : _get_stall_speed_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stall_speed_ratio(self) -> float:
        """Get the ratio of the airspeed to the stall speed upon leaving the ground."""
        return self._intf.get_property(AircraftAdvancedTakeoffModel._metadata, AircraftAdvancedTakeoffModel._get_stall_speed_ratio_metadata)

    _set_stall_speed_ratio_metadata = { "offset" : _set_stall_speed_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    def set_stall_speed_ratio(self, stall_speed_ratio:float) -> None:
        """Set the takeoff speed mode to StallSpeedRatio and specify the stall speed ratio."""
        return self._intf.invoke(AircraftAdvancedTakeoffModel._metadata, AircraftAdvancedTakeoffModel._set_stall_speed_ratio_metadata, stall_speed_ratio)

    _get_angle_of_attack_metadata = { "offset" : _get_angle_of_attack_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def angle_of_attack(self) -> typing.Any:
        """Get the Angle of Attack upon leaving the ground."""
        return self._intf.get_property(AircraftAdvancedTakeoffModel._metadata, AircraftAdvancedTakeoffModel._get_angle_of_attack_metadata)

    _set_angle_of_attack_metadata = { "offset" : _set_angle_of_attack_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def set_angle_of_attack(self, angle_of_attack:typing.Any) -> None:
        """Set the takeoff speed mode to AngleOfAttack and specify the angle of attack."""
        return self._intf.invoke(AircraftAdvancedTakeoffModel._metadata, AircraftAdvancedTakeoffModel._set_angle_of_attack_metadata, angle_of_attack)

    _get_flaps_metadata = { "offset" : _get_flaps_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def flaps(self) -> float:
        """Get or set the extension of the flaps during takeoff."""
        return self._intf.get_property(AircraftAdvancedTakeoffModel._metadata, AircraftAdvancedTakeoffModel._get_flaps_metadata)

    _set_flaps_metadata = { "offset" : _set_flaps_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @flaps.setter
    def flaps(self, value:float) -> None:
        """Get or set the extension of the flaps during takeoff."""
        return self._intf.set_property(AircraftAdvancedTakeoffModel._metadata, AircraftAdvancedTakeoffModel._set_flaps_metadata, value)

    _get_departure_speed_mode_metadata = { "offset" : _get_departure_speed_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DepartureSpeedMode),) }
    @property
    def departure_speed_mode(self) -> "DepartureSpeedMode":
        """Get or set the mode to calculate the airspeed upon leaving the ground."""
        return self._intf.get_property(AircraftAdvancedTakeoffModel._metadata, AircraftAdvancedTakeoffModel._get_departure_speed_mode_metadata)

    _set_departure_speed_mode_metadata = { "offset" : _set_departure_speed_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DepartureSpeedMode),) }
    @departure_speed_mode.setter
    def departure_speed_mode(self, value:"DepartureSpeedMode") -> None:
        """Get or set the mode to calculate the airspeed upon leaving the ground."""
        return self._intf.set_property(AircraftAdvancedTakeoffModel._metadata, AircraftAdvancedTakeoffModel._set_departure_speed_mode_metadata, value)

    _get_departure_speed_limit_metadata = { "offset" : _get_departure_speed_limit_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def departure_speed_limit(self) -> float:
        """Get the aircraft's maximum airspeed upon leaving the ground."""
        return self._intf.get_property(AircraftAdvancedTakeoffModel._metadata, AircraftAdvancedTakeoffModel._get_departure_speed_limit_metadata)

    _get_departure_speed_limit_type_metadata = { "offset" : _get_departure_speed_limit_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def departure_speed_limit_type(self) -> "AirspeedType":
        """Get the departure speed limim type."""
        return self._intf.get_property(AircraftAdvancedTakeoffModel._metadata, AircraftAdvancedTakeoffModel._get_departure_speed_limit_type_metadata)

    _set_departure_speed_limit_metadata = { "offset" : _set_departure_speed_limit_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_departure_speed_limit(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the departure speed limit of the aircraft."""
        return self._intf.invoke(AircraftAdvancedTakeoffModel._metadata, AircraftAdvancedTakeoffModel._set_departure_speed_limit_metadata, airspeed_type, airspeed)

    _get_use_afterburner_metadata = { "offset" : _get_use_afterburner_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_afterburner(self) -> bool:
        """Opt whether to use the afterburner if it is possible."""
        return self._intf.get_property(AircraftAdvancedTakeoffModel._metadata, AircraftAdvancedTakeoffModel._get_use_afterburner_metadata)

    _set_use_afterburner_metadata = { "offset" : _set_use_afterburner_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_afterburner.setter
    def use_afterburner(self, value:bool) -> None:
        """Opt whether to use the afterburner if it is possible."""
        return self._intf.set_property(AircraftAdvancedTakeoffModel._metadata, AircraftAdvancedTakeoffModel._set_use_afterburner_metadata, value)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftAdvancedTakeoffModel._metadata, AircraftAdvancedTakeoffModel._get_as_catalog_item_metadata, OutArg())

    _property_names[takeoff_speed_mode] = "takeoff_speed_mode"
    _property_names[stall_speed_ratio] = "stall_speed_ratio"
    _property_names[angle_of_attack] = "angle_of_attack"
    _property_names[flaps] = "flaps"
    _property_names[departure_speed_mode] = "departure_speed_mode"
    _property_names[departure_speed_limit] = "departure_speed_limit"
    _property_names[departure_speed_limit_type] = "departure_speed_limit_type"
    _property_names[use_afterburner] = "use_afterburner"

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

agcls.AgClassCatalog.add_catalog_entry((5096944394266841251, 9249196675554252163), AircraftAdvancedTakeoffModel)
agcls.AgTypeNameMap["AircraftAdvancedTakeoffModel"] = AircraftAdvancedTakeoffModel

class AircraftBasicLandingModel(IPerformanceModel, ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the basic landing model options for a landing model of an aircraft in the Aviator catalog."""

    _num_methods = 12
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_landing_speed_method_offset = 1
    _get_landing_speed_type_method_offset = 2
    _set_landing_speed_method_offset = 3
    _get_sea_level_ground_roll_method_offset = 4
    _set_sea_level_ground_roll_method_offset = 5
    _get_use_aerodynamic_propulsion_fuel_method_offset = 6
    _set_use_aerodynamic_propulsion_fuel_method_offset = 7
    _get_scale_fuel_flow_by_non_std_density_method_offset = 8
    _set_scale_fuel_flow_by_non_std_density_method_offset = 9
    _get_fuel_flow_method_offset = 10
    _set_fuel_flow_method_offset = 11
    _get_as_catalog_item_method_offset = 12
    _metadata = {
        "iid_data" : (4905149018706593974, 16513096893308921742),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftBasicLandingModel)

    _get_landing_speed_metadata = { "offset" : _get_landing_speed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def landing_speed(self) -> float:
        """Get the landing speed of the aircraft."""
        return self._intf.get_property(AircraftBasicLandingModel._metadata, AircraftBasicLandingModel._get_landing_speed_metadata)

    _get_landing_speed_type_metadata = { "offset" : _get_landing_speed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def landing_speed_type(self) -> "AirspeedType":
        """Get the landing speed type."""
        return self._intf.get_property(AircraftBasicLandingModel._metadata, AircraftBasicLandingModel._get_landing_speed_type_metadata)

    _set_landing_speed_metadata = { "offset" : _set_landing_speed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_landing_speed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the landing speed of the aircraft."""
        return self._intf.invoke(AircraftBasicLandingModel._metadata, AircraftBasicLandingModel._set_landing_speed_metadata, airspeed_type, airspeed)

    _get_sea_level_ground_roll_metadata = { "offset" : _get_sea_level_ground_roll_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def sea_level_ground_roll(self) -> float:
        """Get or set the distance the aircraft travels along the ground while decelerating to a stop at sea level."""
        return self._intf.get_property(AircraftBasicLandingModel._metadata, AircraftBasicLandingModel._get_sea_level_ground_roll_metadata)

    _set_sea_level_ground_roll_metadata = { "offset" : _set_sea_level_ground_roll_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @sea_level_ground_roll.setter
    def sea_level_ground_roll(self, value:float) -> None:
        """Get or set the distance the aircraft travels along the ground while decelerating to a stop at sea level."""
        return self._intf.set_property(AircraftBasicLandingModel._metadata, AircraftBasicLandingModel._set_sea_level_ground_roll_metadata, value)

    _get_use_aerodynamic_propulsion_fuel_metadata = { "offset" : _get_use_aerodynamic_propulsion_fuel_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_aerodynamic_propulsion_fuel(self) -> bool:
        """Get or set whether to use Aero/Propulsion fuel flow."""
        return self._intf.get_property(AircraftBasicLandingModel._metadata, AircraftBasicLandingModel._get_use_aerodynamic_propulsion_fuel_metadata)

    _set_use_aerodynamic_propulsion_fuel_metadata = { "offset" : _set_use_aerodynamic_propulsion_fuel_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_aerodynamic_propulsion_fuel.setter
    def use_aerodynamic_propulsion_fuel(self, value:bool) -> None:
        """Get or set whether to use Aero/Propulsion fuel flow."""
        return self._intf.set_property(AircraftBasicLandingModel._metadata, AircraftBasicLandingModel._set_use_aerodynamic_propulsion_fuel_metadata, value)

    _get_scale_fuel_flow_by_non_std_density_metadata = { "offset" : _get_scale_fuel_flow_by_non_std_density_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def scale_fuel_flow_by_non_std_density(self) -> bool:
        """Get or set whether to scale fuel flow by non std density."""
        return self._intf.get_property(AircraftBasicLandingModel._metadata, AircraftBasicLandingModel._get_scale_fuel_flow_by_non_std_density_metadata)

    _set_scale_fuel_flow_by_non_std_density_metadata = { "offset" : _set_scale_fuel_flow_by_non_std_density_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @scale_fuel_flow_by_non_std_density.setter
    def scale_fuel_flow_by_non_std_density(self, value:bool) -> None:
        """Get or set whether to scale fuel flow by non std density."""
        return self._intf.set_property(AircraftBasicLandingModel._metadata, AircraftBasicLandingModel._set_scale_fuel_flow_by_non_std_density_metadata, value)

    _get_fuel_flow_metadata = { "offset" : _get_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fuel_flow(self) -> float:
        """Get or set the Sea Level Fuel Flow."""
        return self._intf.get_property(AircraftBasicLandingModel._metadata, AircraftBasicLandingModel._get_fuel_flow_metadata)

    _set_fuel_flow_metadata = { "offset" : _set_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fuel_flow.setter
    def fuel_flow(self, value:float) -> None:
        """Get or set the Sea Level Fuel Flow."""
        return self._intf.set_property(AircraftBasicLandingModel._metadata, AircraftBasicLandingModel._set_fuel_flow_metadata, value)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftBasicLandingModel._metadata, AircraftBasicLandingModel._get_as_catalog_item_metadata, OutArg())

    _property_names[landing_speed] = "landing_speed"
    _property_names[landing_speed_type] = "landing_speed_type"
    _property_names[sea_level_ground_roll] = "sea_level_ground_roll"
    _property_names[use_aerodynamic_propulsion_fuel] = "use_aerodynamic_propulsion_fuel"
    _property_names[scale_fuel_flow_by_non_std_density] = "scale_fuel_flow_by_non_std_density"
    _property_names[fuel_flow] = "fuel_flow"

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

agcls.AgClassCatalog.add_catalog_entry((4668682694342627584, 2103924401706785409), AircraftBasicLandingModel)
agcls.AgTypeNameMap["AircraftBasicLandingModel"] = AircraftBasicLandingModel

class AircraftAdvancedLandingModel(IPerformanceModel, ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the advanced landing model options for a landing model of an aircraft in the Aviator catalog."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_landing_speed_mode_method_offset = 1
    _set_landing_speed_mode_method_offset = 2
    _get_stall_speed_ratio_method_offset = 3
    _set_stall_speed_ratio_method_offset = 4
    _get_angle_of_attack_method_offset = 5
    _set_angle_of_attack_method_offset = 6
    _get_flaps_method_offset = 7
    _set_flaps_method_offset = 8
    _get_speedbrakes_method_offset = 9
    _set_speedbrakes_method_offset = 10
    _get_braking_deceleration_g_method_offset = 11
    _set_braking_deceleration_g_method_offset = 12
    _get_as_catalog_item_method_offset = 13
    _metadata = {
        "iid_data" : (5277953693984597077, 10394557647785555631),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftAdvancedLandingModel)

    _get_landing_speed_mode_metadata = { "offset" : _get_landing_speed_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(TakeoffLandingSpeedMode),) }
    @property
    def landing_speed_mode(self) -> "TakeoffLandingSpeedMode":
        """Get or set the mode to calculate the aircraft's speed at wheels down."""
        return self._intf.get_property(AircraftAdvancedLandingModel._metadata, AircraftAdvancedLandingModel._get_landing_speed_mode_metadata)

    _set_landing_speed_mode_metadata = { "offset" : _set_landing_speed_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(TakeoffLandingSpeedMode),) }
    @landing_speed_mode.setter
    def landing_speed_mode(self, value:"TakeoffLandingSpeedMode") -> None:
        """Get or set the mode to calculate the aircraft's speed at wheels down."""
        return self._intf.set_property(AircraftAdvancedLandingModel._metadata, AircraftAdvancedLandingModel._set_landing_speed_mode_metadata, value)

    _get_stall_speed_ratio_metadata = { "offset" : _get_stall_speed_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stall_speed_ratio(self) -> float:
        """Get the ratio of the airspeed to the stall speed at wheels down."""
        return self._intf.get_property(AircraftAdvancedLandingModel._metadata, AircraftAdvancedLandingModel._get_stall_speed_ratio_metadata)

    _set_stall_speed_ratio_metadata = { "offset" : _set_stall_speed_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    def set_stall_speed_ratio(self, stall_speed_ratio:float) -> None:
        """Set the landing speed mode to StallSpeedRatio and specify the stall speed ratio."""
        return self._intf.invoke(AircraftAdvancedLandingModel._metadata, AircraftAdvancedLandingModel._set_stall_speed_ratio_metadata, stall_speed_ratio)

    _get_angle_of_attack_metadata = { "offset" : _get_angle_of_attack_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def angle_of_attack(self) -> typing.Any:
        """Get the Angle of Attack at wheels down."""
        return self._intf.get_property(AircraftAdvancedLandingModel._metadata, AircraftAdvancedLandingModel._get_angle_of_attack_metadata)

    _set_angle_of_attack_metadata = { "offset" : _set_angle_of_attack_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def set_angle_of_attack(self, angle_of_attack:typing.Any) -> None:
        """Set the landing speed mode to AngleOfAttack and specify the angle of attack."""
        return self._intf.invoke(AircraftAdvancedLandingModel._metadata, AircraftAdvancedLandingModel._set_angle_of_attack_metadata, angle_of_attack)

    _get_flaps_metadata = { "offset" : _get_flaps_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def flaps(self) -> float:
        """Get or set the extension of the flaps during the landing."""
        return self._intf.get_property(AircraftAdvancedLandingModel._metadata, AircraftAdvancedLandingModel._get_flaps_metadata)

    _set_flaps_metadata = { "offset" : _set_flaps_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @flaps.setter
    def flaps(self, value:float) -> None:
        """Get or set the extension of the flaps during the landing."""
        return self._intf.set_property(AircraftAdvancedLandingModel._metadata, AircraftAdvancedLandingModel._set_flaps_metadata, value)

    _get_speedbrakes_metadata = { "offset" : _get_speedbrakes_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def speedbrakes(self) -> float:
        """Get or set the extension of the speedbrakes during the landing."""
        return self._intf.get_property(AircraftAdvancedLandingModel._metadata, AircraftAdvancedLandingModel._get_speedbrakes_metadata)

    _set_speedbrakes_metadata = { "offset" : _set_speedbrakes_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @speedbrakes.setter
    def speedbrakes(self, value:float) -> None:
        """Get or set the extension of the speedbrakes during the landing."""
        return self._intf.set_property(AircraftAdvancedLandingModel._metadata, AircraftAdvancedLandingModel._set_speedbrakes_metadata, value)

    _get_braking_deceleration_g_metadata = { "offset" : _get_braking_deceleration_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def braking_deceleration_g(self) -> float:
        """Get or set the deceleration rate, in G, when braking."""
        return self._intf.get_property(AircraftAdvancedLandingModel._metadata, AircraftAdvancedLandingModel._get_braking_deceleration_g_metadata)

    _set_braking_deceleration_g_metadata = { "offset" : _set_braking_deceleration_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @braking_deceleration_g.setter
    def braking_deceleration_g(self, value:float) -> None:
        """Get or set the deceleration rate, in G, when braking."""
        return self._intf.set_property(AircraftAdvancedLandingModel._metadata, AircraftAdvancedLandingModel._set_braking_deceleration_g_metadata, value)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftAdvancedLandingModel._metadata, AircraftAdvancedLandingModel._get_as_catalog_item_metadata, OutArg())

    _property_names[landing_speed_mode] = "landing_speed_mode"
    _property_names[stall_speed_ratio] = "stall_speed_ratio"
    _property_names[angle_of_attack] = "angle_of_attack"
    _property_names[flaps] = "flaps"
    _property_names[speedbrakes] = "speedbrakes"
    _property_names[braking_deceleration_g] = "braking_deceleration_g"

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

agcls.AgClassCatalog.add_catalog_entry((4698133591076713687, 3121932985451287191), AircraftAdvancedLandingModel)
agcls.AgTypeNameMap["AircraftAdvancedLandingModel"] = AircraftAdvancedLandingModel

class AirportCategory(SupportsDeleteCallback):
    """Interface used to access the airports in the Aviator catalog."""

    _num_methods = 1
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_arinc424_airports_method_offset = 1
    _metadata = {
        "iid_data" : (4716319275932126710, 2976160558904714927),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AirportCategory)

    _get_arinc424_airports_metadata = { "offset" : _get_arinc424_airports_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def arinc424_airports(self) -> "ARINC424Source":
        """Get the ARINC-424 airports."""
        return self._intf.get_property(AirportCategory._metadata, AirportCategory._get_arinc424_airports_metadata)

    _property_names[arinc424_airports] = "arinc424_airports"

    def __init__(self, source_object=None):
        """Construct an object of type AirportCategory."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AirportCategory)
    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, AirportCategory, [AirportCategory, ])

agcls.AgClassCatalog.add_catalog_entry((4948677995080953579, 11068242944747772575), AirportCategory)
agcls.AgTypeNameMap["AirportCategory"] = AirportCategory

class ARINC424Airport(IARINC424Item, ICatalogAirport, ICatalogWaypoint, ICatalogItem, SupportsDeleteCallback):
    """Class defining an ARINC424 Airport."""
    def __init__(self, source_object=None):
        """Construct an object of type ARINC424Airport."""
        SupportsDeleteCallback.__init__(self)
        IARINC424Item.__init__(self, source_object)
        ICatalogAirport.__init__(self, source_object)
        ICatalogWaypoint.__init__(self, source_object)
        ICatalogItem.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IARINC424Item._private_init(self, intf)
        ICatalogAirport._private_init(self, intf)
        ICatalogWaypoint._private_init(self, intf)
        ICatalogItem._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ARINC424Airport, [IARINC424Item, ICatalogAirport, ICatalogWaypoint, ICatalogItem])

agcls.AgClassCatalog.add_catalog_entry((5153344260385549656, 2532207200311691662), ARINC424Airport)
agcls.AgTypeNameMap["ARINC424Airport"] = ARINC424Airport

class ARINC424Runway(IARINC424Item, ICatalogRunway, ICatalogWaypoint, ICatalogItem, SupportsDeleteCallback):
    """Do not use this interface, as it is deprecated. Use IARINC424Item instead."""

    _num_methods = 1
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_as_catalog_item_method_offset = 1
    _metadata = {
        "iid_data" : (5300123620389747771, 18053247007351242896),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ARINC424Runway)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(ARINC424Runway._metadata, ARINC424Runway._get_as_catalog_item_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((4920080154187198702, 7391099673982507661), ARINC424Runway)
agcls.AgTypeNameMap["ARINC424Runway"] = ARINC424Runway

class DAFIFRunway(IDAFIFItem, ICatalogRunway, ICatalogWaypoint, ICatalogItem, SupportsDeleteCallback):
    """Class defining an DAFIF Runway."""
    def __init__(self, source_object=None):
        """Construct an object of type DAFIFRunway."""
        SupportsDeleteCallback.__init__(self)
        IDAFIFItem.__init__(self, source_object)
        ICatalogRunway.__init__(self, source_object)
        ICatalogWaypoint.__init__(self, source_object)
        ICatalogItem.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IDAFIFItem._private_init(self, intf)
        ICatalogRunway._private_init(self, intf)
        ICatalogWaypoint._private_init(self, intf)
        ICatalogItem._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DAFIFRunway, [IDAFIFItem, ICatalogRunway, ICatalogWaypoint, ICatalogItem])

agcls.AgClassCatalog.add_catalog_entry((4742072681057648609, 7698952542910555306), DAFIFRunway)
agcls.AgTypeNameMap["DAFIFRunway"] = DAFIFRunway

class DAFIFHelipad(IDAFIFItem, ICatalogVTOLPoint, ICatalogWaypoint, ICatalogItem, SupportsDeleteCallback):
    """Class defining an DAFIF Helipad."""
    def __init__(self, source_object=None):
        """Construct an object of type DAFIFHelipad."""
        SupportsDeleteCallback.__init__(self)
        IDAFIFItem.__init__(self, source_object)
        ICatalogVTOLPoint.__init__(self, source_object)
        ICatalogWaypoint.__init__(self, source_object)
        ICatalogItem.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IDAFIFItem._private_init(self, intf)
        ICatalogVTOLPoint._private_init(self, intf)
        ICatalogWaypoint._private_init(self, intf)
        ICatalogItem._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DAFIFHelipad, [IDAFIFItem, ICatalogVTOLPoint, ICatalogWaypoint, ICatalogItem])

agcls.AgClassCatalog.add_catalog_entry((5242889605316044604, 11897854504103653769), DAFIFHelipad)
agcls.AgTypeNameMap["DAFIFHelipad"] = DAFIFHelipad

class DAFIFWaypoint(IDAFIFItem, ICatalogWaypoint, ICatalogItem, SupportsDeleteCallback):
    """Class defining an DAFIF Waypoint."""
    def __init__(self, source_object=None):
        """Construct an object of type DAFIFWaypoint."""
        SupportsDeleteCallback.__init__(self)
        IDAFIFItem.__init__(self, source_object)
        ICatalogWaypoint.__init__(self, source_object)
        ICatalogItem.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IDAFIFItem._private_init(self, intf)
        ICatalogWaypoint._private_init(self, intf)
        ICatalogItem._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, DAFIFWaypoint, [IDAFIFItem, ICatalogWaypoint, ICatalogItem])

agcls.AgClassCatalog.add_catalog_entry((4681954691512884825, 10308348976302292395), DAFIFWaypoint)
agcls.AgTypeNameMap["DAFIFWaypoint"] = DAFIFWaypoint

class RunwayCategory(SupportsDeleteCallback):
    """Interface used to access runways in the Aviator catalog."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_user_runways_method_offset = 1
    _get_arinc424_runways_method_offset = 2
    _get_dafif_runways_method_offset = 3
    _metadata = {
        "iid_data" : (5167318891465223627, 14287069589925218227),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, RunwayCategory)

    _get_user_runways_metadata = { "offset" : _get_user_runways_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def user_runways(self) -> "UserRunwaySource":
        """Get the user runways."""
        return self._intf.get_property(RunwayCategory._metadata, RunwayCategory._get_user_runways_metadata)

    _get_arinc424_runways_metadata = { "offset" : _get_arinc424_runways_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def arinc424_runways(self) -> "ARINC424Source":
        """Get the ARINC-424 runways."""
        return self._intf.get_property(RunwayCategory._metadata, RunwayCategory._get_arinc424_runways_metadata)

    _get_dafif_runways_metadata = { "offset" : _get_dafif_runways_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def dafif_runways(self) -> "DAFIFSource":
        """Get the DAFIF runways."""
        return self._intf.get_property(RunwayCategory._metadata, RunwayCategory._get_dafif_runways_metadata)

    _property_names[user_runways] = "user_runways"
    _property_names[arinc424_runways] = "arinc424_runways"
    _property_names[dafif_runways] = "dafif_runways"

    def __init__(self, source_object=None):
        """Construct an object of type RunwayCategory."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, RunwayCategory)
    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, RunwayCategory, [RunwayCategory, ])

agcls.AgClassCatalog.add_catalog_entry((5469050913701344868, 8227015865766767039), RunwayCategory)
agcls.AgTypeNameMap["RunwayCategory"] = RunwayCategory

class UserRunwaySource(ICatalogSource, SupportsDeleteCallback):
    """
    Interface used to access the user runways in the Aviator catalog.

    Examples
    --------
    Configure a runway site from a runway in the Aviator catalog:
    >>> # SiteRunway runway: Runway object
    >>> # Catalog catalog: Aviator catalog object
    >>> # Get the source of user runways
    >>> userRunways = catalog.runway_category.user_runways
    >>> # Check that the runway exists in the catalog
    >>> if userRunways.contains("New User Runway") is True:
    >>>     # If so, get the user runway with the given name
    >>>     runwayFromCatalog = userRunways.get_user_runway("New User Runway")
    >>>     # Copy the parameters of that runway
    >>>     runway.copy_from_catalog(runwayFromCatalog)
    """

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_user_runway_method_offset = 1
    _add_user_runway_method_offset = 2
    _get_as_catalog_source_method_offset = 3
    _metadata = {
        "iid_data" : (4676451489891113138, 8977042287783605675),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, UserRunwaySource)

    _get_user_runway_metadata = { "offset" : _get_user_runway_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_user_runway(self, name:str) -> "UserRunway":
        """Get the user runway with the given name."""
        return self._intf.invoke(UserRunwaySource._metadata, UserRunwaySource._get_user_runway_metadata, name, OutArg())

    _add_user_runway_metadata = { "offset" : _add_user_runway_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add_user_runway(self, name:str) -> "UserRunway":
        """Create a new user runway with the given name."""
        return self._intf.invoke(UserRunwaySource._metadata, UserRunwaySource._add_user_runway_metadata, name, OutArg())

    _get_as_catalog_source_metadata = { "offset" : _get_as_catalog_source_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_source(self) -> "ICatalogSource":
        """Get the catalog source interface for this object."""
        return self._intf.invoke(UserRunwaySource._metadata, UserRunwaySource._get_as_catalog_source_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((5635637392444233572, 17245173151766416020), UserRunwaySource)
agcls.AgTypeNameMap["UserRunwaySource"] = UserRunwaySource

class UserRunway(ICatalogRunway, ICatalogItem, ICatalogWaypoint, SupportsDeleteCallback):
    """Interface used to access a user runway in the Aviator catalog."""

    _num_methods = 18
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_as_catalog_item_method_offset = 1
    _get_altitude_method_offset = 2
    _set_altitude_method_offset = 3
    _get_terrain_altitude_method_offset = 4
    _get_latitude_method_offset = 5
    _set_latitude_method_offset = 6
    _get_longitude_method_offset = 7
    _set_longitude_method_offset = 8
    _get_length_method_offset = 9
    _set_length_method_offset = 10
    _get_low_end_heading_method_offset = 11
    _set_low_end_heading_method_offset = 12
    _get_high_end_heading_method_offset = 13
    _set_high_end_heading_method_offset = 14
    _get_is_magnetic_method_offset = 15
    _set_is_magnetic_method_offset = 16
    _copy_site_method_offset = 17
    _paste_site_method_offset = 18
    _metadata = {
        "iid_data" : (4820628736157176607, 17908593095754821544),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, UserRunway)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(UserRunway._metadata, UserRunway._get_as_catalog_item_metadata, OutArg())

    _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 runway altitude."""
        return self._intf.get_property(UserRunway._metadata, UserRunway._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:
        """Get or set the runway altitude."""
        return self._intf.set_property(UserRunway._metadata, UserRunway._set_altitude_metadata, value)

    _get_terrain_altitude_metadata = { "offset" : _get_terrain_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    def get_terrain_altitude(self) -> float:
        """Set the runway altitude to the terrain altitude."""
        return self._intf.invoke(UserRunway._metadata, UserRunway._get_terrain_altitude_metadata, OutArg())

    _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 runway latitude."""
        return self._intf.get_property(UserRunway._metadata, UserRunway._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:
        """Get or set the runway latitude."""
        return self._intf.set_property(UserRunway._metadata, UserRunway._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 runway longitude."""
        return self._intf.get_property(UserRunway._metadata, UserRunway._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:
        """Get or set the runway longitude."""
        return self._intf.set_property(UserRunway._metadata, UserRunway._set_longitude_metadata, value)

    _get_length_metadata = { "offset" : _get_length_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def length(self) -> float:
        """Get or set the length of the runway."""
        return self._intf.get_property(UserRunway._metadata, UserRunway._get_length_metadata)

    _set_length_metadata = { "offset" : _set_length_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @length.setter
    def length(self, value:float) -> None:
        """Get or set the length of the runway."""
        return self._intf.set_property(UserRunway._metadata, UserRunway._set_length_metadata, value)

    _get_low_end_heading_metadata = { "offset" : _get_low_end_heading_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def low_end_heading(self) -> typing.Any:
        """Get or set the low end heading of the runway."""
        return self._intf.get_property(UserRunway._metadata, UserRunway._get_low_end_heading_metadata)

    _set_low_end_heading_metadata = { "offset" : _set_low_end_heading_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @low_end_heading.setter
    def low_end_heading(self, value:typing.Any) -> None:
        """Get or set the low end heading of the runway."""
        return self._intf.set_property(UserRunway._metadata, UserRunway._set_low_end_heading_metadata, value)

    _get_high_end_heading_metadata = { "offset" : _get_high_end_heading_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def high_end_heading(self) -> typing.Any:
        """Get or set the high end heading of the runway."""
        return self._intf.get_property(UserRunway._metadata, UserRunway._get_high_end_heading_metadata)

    _set_high_end_heading_metadata = { "offset" : _set_high_end_heading_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @high_end_heading.setter
    def high_end_heading(self, value:typing.Any) -> None:
        """Get or set the high end heading of the runway."""
        return self._intf.set_property(UserRunway._metadata, UserRunway._set_high_end_heading_metadata, value)

    _get_is_magnetic_metadata = { "offset" : _get_is_magnetic_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def is_magnetic(self) -> bool:
        """Opt whether to use a magnetic heading for the runway heading."""
        return self._intf.get_property(UserRunway._metadata, UserRunway._get_is_magnetic_metadata)

    _set_is_magnetic_metadata = { "offset" : _set_is_magnetic_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @is_magnetic.setter
    def is_magnetic(self, value:bool) -> None:
        """Opt whether to use a magnetic heading for the runway heading."""
        return self._intf.set_property(UserRunway._metadata, UserRunway._set_is_magnetic_metadata, value)

    _copy_site_metadata = { "offset" : _copy_site_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def copy_site(self) -> None:
        """Copy the site to the clipboard."""
        return self._intf.invoke(UserRunway._metadata, UserRunway._copy_site_metadata, )

    _paste_site_metadata = { "offset" : _paste_site_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def paste_site(self) -> None:
        """Paste the site to the clipboard."""
        return self._intf.invoke(UserRunway._metadata, UserRunway._paste_site_metadata, )

    _property_names[altitude] = "altitude"
    _property_names[latitude] = "latitude"
    _property_names[longitude] = "longitude"
    _property_names[length] = "length"
    _property_names[low_end_heading] = "low_end_heading"
    _property_names[high_end_heading] = "high_end_heading"
    _property_names[is_magnetic] = "is_magnetic"

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

agcls.AgClassCatalog.add_catalog_entry((5691789674305805005, 304905329320076219), UserRunway)
agcls.AgTypeNameMap["UserRunway"] = UserRunway

class AltitudeMSLOptions(SupportsDeleteCallback):
    """Interface used to access the altitude MSL options for an Aviator procedure."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_default_cruise_altitude_method_offset = 1
    _set_use_default_cruise_altitude_method_offset = 2
    _get_msl_altitude_method_offset = 3
    _set_msl_altitude_method_offset = 4
    _metadata = {
        "iid_data" : (5354678070619953400, 16650566902719874200),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AltitudeMSLOptions)

    _get_use_default_cruise_altitude_metadata = { "offset" : _get_use_default_cruise_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_default_cruise_altitude(self) -> bool:
        """Opt whether to use the default cruise altitude."""
        return self._intf.get_property(AltitudeMSLOptions._metadata, AltitudeMSLOptions._get_use_default_cruise_altitude_metadata)

    _set_use_default_cruise_altitude_metadata = { "offset" : _set_use_default_cruise_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_default_cruise_altitude.setter
    def use_default_cruise_altitude(self, value:bool) -> None:
        """Opt whether to use the default cruise altitude."""
        return self._intf.set_property(AltitudeMSLOptions._metadata, AltitudeMSLOptions._set_use_default_cruise_altitude_metadata, value)

    _get_msl_altitude_metadata = { "offset" : _get_msl_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def msl_altitude(self) -> float:
        """Get or set the MSL altitude. Can only be used when the option to use the default cruise altitude is off."""
        return self._intf.get_property(AltitudeMSLOptions._metadata, AltitudeMSLOptions._get_msl_altitude_metadata)

    _set_msl_altitude_metadata = { "offset" : _set_msl_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @msl_altitude.setter
    def msl_altitude(self, value:float) -> None:
        """Get or set the MSL altitude. Can only be used when the option to use the default cruise altitude is off."""
        return self._intf.set_property(AltitudeMSLOptions._metadata, AltitudeMSLOptions._set_msl_altitude_metadata, value)

    _property_names[use_default_cruise_altitude] = "use_default_cruise_altitude"
    _property_names[msl_altitude] = "msl_altitude"

    def __init__(self, source_object=None):
        """Construct an object of type AltitudeMSLOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AltitudeMSLOptions)
    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, AltitudeMSLOptions, [AltitudeMSLOptions, ])

agcls.AgClassCatalog.add_catalog_entry((4711346236767512285, 12895539298887267007), AltitudeMSLOptions)
agcls.AgTypeNameMap["AltitudeMSLOptions"] = AltitudeMSLOptions

class AltitudeOptions(SupportsDeleteCallback):
    """Interface used to access the altitude options for an Aviator procedure."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_default_cruise_altitude_method_offset = 1
    _set_use_default_cruise_altitude_method_offset = 2
    _get_altitude_reference_method_offset = 3
    _set_altitude_reference_method_offset = 4
    _get_altitude_method_offset = 5
    _set_altitude_method_offset = 6
    _metadata = {
        "iid_data" : (4916664038627200200, 6937122557711862173),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AltitudeOptions)

    _get_use_default_cruise_altitude_metadata = { "offset" : _get_use_default_cruise_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_default_cruise_altitude(self) -> bool:
        """Opt whether to use the default cruise altitude."""
        return self._intf.get_property(AltitudeOptions._metadata, AltitudeOptions._get_use_default_cruise_altitude_metadata)

    _set_use_default_cruise_altitude_metadata = { "offset" : _set_use_default_cruise_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_default_cruise_altitude.setter
    def use_default_cruise_altitude(self, value:bool) -> None:
        """Opt whether to use the default cruise altitude."""
        return self._intf.set_property(AltitudeOptions._metadata, AltitudeOptions._set_use_default_cruise_altitude_metadata, value)

    _get_altitude_reference_metadata = { "offset" : _get_altitude_reference_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AGLMSL),) }
    @property
    def altitude_reference(self) -> "AGLMSL":
        """Get or set the altitude reference."""
        return self._intf.get_property(AltitudeOptions._metadata, AltitudeOptions._get_altitude_reference_metadata)

    _set_altitude_reference_metadata = { "offset" : _set_altitude_reference_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AGLMSL),) }
    @altitude_reference.setter
    def altitude_reference(self, value:"AGLMSL") -> None:
        """Get or set the altitude reference."""
        return self._intf.set_property(AltitudeOptions._metadata, AltitudeOptions._set_altitude_reference_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 for the procedure."""
        return self._intf.get_property(AltitudeOptions._metadata, AltitudeOptions._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:
        """Get or set the altitude for the procedure."""
        return self._intf.set_property(AltitudeOptions._metadata, AltitudeOptions._set_altitude_metadata, value)

    _property_names[use_default_cruise_altitude] = "use_default_cruise_altitude"
    _property_names[altitude_reference] = "altitude_reference"
    _property_names[altitude] = "altitude"

    def __init__(self, source_object=None):
        """Construct an object of type AltitudeOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AltitudeOptions)
    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, AltitudeOptions, [AltitudeOptions, ])

agcls.AgClassCatalog.add_catalog_entry((5605824035098034871, 2592958110125322650), AltitudeOptions)
agcls.AgTypeNameMap["AltitudeOptions"] = AltitudeOptions

class ArcAltitudeOptions(SupportsDeleteCallback):
    """Interface used to access the altitude options for an Arc procedure."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_default_cruise_altitude_method_offset = 1
    _set_use_default_cruise_altitude_method_offset = 2
    _get_start_arc_altitude_method_offset = 3
    _set_start_arc_altitude_method_offset = 4
    _get_stop_arc_altitude_method_offset = 5
    _set_stop_arc_altitude_method_offset = 6
    _metadata = {
        "iid_data" : (5311428139126596917, 7870750672865060761),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ArcAltitudeOptions)

    _get_use_default_cruise_altitude_metadata = { "offset" : _get_use_default_cruise_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_default_cruise_altitude(self) -> bool:
        """Opt whether to use the default cruise altitude."""
        return self._intf.get_property(ArcAltitudeOptions._metadata, ArcAltitudeOptions._get_use_default_cruise_altitude_metadata)

    _set_use_default_cruise_altitude_metadata = { "offset" : _set_use_default_cruise_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_default_cruise_altitude.setter
    def use_default_cruise_altitude(self, value:bool) -> None:
        """Opt whether to use the default cruise altitude."""
        return self._intf.set_property(ArcAltitudeOptions._metadata, ArcAltitudeOptions._set_use_default_cruise_altitude_metadata, value)

    _get_start_arc_altitude_metadata = { "offset" : _get_start_arc_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def start_arc_altitude(self) -> float:
        """Get or set the altitude at the beginning of the arc."""
        return self._intf.get_property(ArcAltitudeOptions._metadata, ArcAltitudeOptions._get_start_arc_altitude_metadata)

    _set_start_arc_altitude_metadata = { "offset" : _set_start_arc_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @start_arc_altitude.setter
    def start_arc_altitude(self, value:float) -> None:
        """Get or set the altitude at the beginning of the arc."""
        return self._intf.set_property(ArcAltitudeOptions._metadata, ArcAltitudeOptions._set_start_arc_altitude_metadata, value)

    _get_stop_arc_altitude_metadata = { "offset" : _get_stop_arc_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stop_arc_altitude(self) -> float:
        """Get or set the altitude at the end of the arc."""
        return self._intf.get_property(ArcAltitudeOptions._metadata, ArcAltitudeOptions._get_stop_arc_altitude_metadata)

    _set_stop_arc_altitude_metadata = { "offset" : _set_stop_arc_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @stop_arc_altitude.setter
    def stop_arc_altitude(self, value:float) -> None:
        """Get or set the altitude at the end of the arc."""
        return self._intf.set_property(ArcAltitudeOptions._metadata, ArcAltitudeOptions._set_stop_arc_altitude_metadata, value)

    _property_names[use_default_cruise_altitude] = "use_default_cruise_altitude"
    _property_names[start_arc_altitude] = "start_arc_altitude"
    _property_names[stop_arc_altitude] = "stop_arc_altitude"

    def __init__(self, source_object=None):
        """Construct an object of type ArcAltitudeOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ArcAltitudeOptions)
    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, ArcAltitudeOptions, [ArcAltitudeOptions, ])

agcls.AgClassCatalog.add_catalog_entry((5643814476002063505, 18340846669876596410), ArcAltitudeOptions)
agcls.AgTypeNameMap["ArcAltitudeOptions"] = ArcAltitudeOptions

class ArcAltitudeAndDelayOptions(SupportsDeleteCallback):
    """Interface used to access the altitude options for an Arc procedure."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_default_cruise_altitude_method_offset = 1
    _set_use_default_cruise_altitude_method_offset = 2
    _get_delay_arc_climb_descents_method_offset = 3
    _set_delay_arc_climb_descents_method_offset = 4
    _get_start_arc_altitude_method_offset = 5
    _set_start_arc_altitude_method_offset = 6
    _get_stop_arc_altitude_method_offset = 7
    _set_stop_arc_altitude_method_offset = 8
    _metadata = {
        "iid_data" : (5091741236913358761, 4527708200198965125),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ArcAltitudeAndDelayOptions)

    _get_use_default_cruise_altitude_metadata = { "offset" : _get_use_default_cruise_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_default_cruise_altitude(self) -> bool:
        """Opt whether to use the default cruise altitude."""
        return self._intf.get_property(ArcAltitudeAndDelayOptions._metadata, ArcAltitudeAndDelayOptions._get_use_default_cruise_altitude_metadata)

    _set_use_default_cruise_altitude_metadata = { "offset" : _set_use_default_cruise_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_default_cruise_altitude.setter
    def use_default_cruise_altitude(self, value:bool) -> None:
        """Opt whether to use the default cruise altitude."""
        return self._intf.set_property(ArcAltitudeAndDelayOptions._metadata, ArcAltitudeAndDelayOptions._set_use_default_cruise_altitude_metadata, value)

    _get_delay_arc_climb_descents_metadata = { "offset" : _get_delay_arc_climb_descents_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def delay_arc_climb_descents(self) -> bool:
        """Delay the climb/descend such that the stop arc altitude will be achieved by the end of the procedure."""
        return self._intf.get_property(ArcAltitudeAndDelayOptions._metadata, ArcAltitudeAndDelayOptions._get_delay_arc_climb_descents_metadata)

    _set_delay_arc_climb_descents_metadata = { "offset" : _set_delay_arc_climb_descents_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @delay_arc_climb_descents.setter
    def delay_arc_climb_descents(self, value:bool) -> None:
        """Delay the climb/descend such that the stop arc altitude will be achieved by the end of the procedure."""
        return self._intf.set_property(ArcAltitudeAndDelayOptions._metadata, ArcAltitudeAndDelayOptions._set_delay_arc_climb_descents_metadata, value)

    _get_start_arc_altitude_metadata = { "offset" : _get_start_arc_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def start_arc_altitude(self) -> float:
        """Get or set the altitude at the beginning of the arc."""
        return self._intf.get_property(ArcAltitudeAndDelayOptions._metadata, ArcAltitudeAndDelayOptions._get_start_arc_altitude_metadata)

    _set_start_arc_altitude_metadata = { "offset" : _set_start_arc_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @start_arc_altitude.setter
    def start_arc_altitude(self, value:float) -> None:
        """Get or set the altitude at the beginning of the arc."""
        return self._intf.set_property(ArcAltitudeAndDelayOptions._metadata, ArcAltitudeAndDelayOptions._set_start_arc_altitude_metadata, value)

    _get_stop_arc_altitude_metadata = { "offset" : _get_stop_arc_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stop_arc_altitude(self) -> float:
        """Get or set the altitude at the end of the arc."""
        return self._intf.get_property(ArcAltitudeAndDelayOptions._metadata, ArcAltitudeAndDelayOptions._get_stop_arc_altitude_metadata)

    _set_stop_arc_altitude_metadata = { "offset" : _set_stop_arc_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @stop_arc_altitude.setter
    def stop_arc_altitude(self, value:float) -> None:
        """Get or set the altitude at the end of the arc."""
        return self._intf.set_property(ArcAltitudeAndDelayOptions._metadata, ArcAltitudeAndDelayOptions._set_stop_arc_altitude_metadata, value)

    _property_names[use_default_cruise_altitude] = "use_default_cruise_altitude"
    _property_names[delay_arc_climb_descents] = "delay_arc_climb_descents"
    _property_names[start_arc_altitude] = "start_arc_altitude"
    _property_names[stop_arc_altitude] = "stop_arc_altitude"

    def __init__(self, source_object=None):
        """Construct an object of type ArcAltitudeAndDelayOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ArcAltitudeAndDelayOptions)
    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, ArcAltitudeAndDelayOptions, [ArcAltitudeAndDelayOptions, ])

agcls.AgClassCatalog.add_catalog_entry((5626426987589423015, 10342354197599988640), ArcAltitudeAndDelayOptions)
agcls.AgTypeNameMap["ArcAltitudeAndDelayOptions"] = ArcAltitudeAndDelayOptions

class ArcOptions(SupportsDeleteCallback):
    """Interface used to access the arc options for a procedure."""

    _num_methods = 14
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_turn_direction_method_offset = 1
    _set_turn_direction_method_offset = 2
    _get_start_bearing_method_offset = 3
    _set_start_bearing_method_offset = 4
    _get_use_magnetic_heading_method_offset = 5
    _set_use_magnetic_heading_method_offset = 6
    _get_radius_method_offset = 7
    _set_radius_method_offset = 8
    _get_turn_angle_method_offset = 9
    _set_turn_angle_method_offset = 10
    _get_join_arc_method_offset = 11
    _set_join_arc_method_offset = 12
    _get_exit_arc_method_offset = 13
    _set_exit_arc_method_offset = 14
    _metadata = {
        "iid_data" : (4881719014414109863, 13875083150837249449),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ArcOptions)

    _get_turn_direction_metadata = { "offset" : _get_turn_direction_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(TurnDirection),) }
    @property
    def turn_direction(self) -> "TurnDirection":
        """Get or set the turn direction to the arc."""
        return self._intf.get_property(ArcOptions._metadata, ArcOptions._get_turn_direction_metadata)

    _set_turn_direction_metadata = { "offset" : _set_turn_direction_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(TurnDirection),) }
    @turn_direction.setter
    def turn_direction(self, value:"TurnDirection") -> None:
        """Get or set the turn direction to the arc."""
        return self._intf.set_property(ArcOptions._metadata, ArcOptions._set_turn_direction_metadata, value)

    _get_start_bearing_metadata = { "offset" : _get_start_bearing_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def start_bearing(self) -> typing.Any:
        """Get or set the bearing from the site to the arc."""
        return self._intf.get_property(ArcOptions._metadata, ArcOptions._get_start_bearing_metadata)

    _set_start_bearing_metadata = { "offset" : _set_start_bearing_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @start_bearing.setter
    def start_bearing(self, value:typing.Any) -> None:
        """Get or set the bearing from the site to the arc."""
        return self._intf.set_property(ArcOptions._metadata, ArcOptions._set_start_bearing_metadata, value)

    _get_use_magnetic_heading_metadata = { "offset" : _get_use_magnetic_heading_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_magnetic_heading(self) -> bool:
        """Get or set the option to use a magnetic heading for the start bearing."""
        return self._intf.get_property(ArcOptions._metadata, ArcOptions._get_use_magnetic_heading_metadata)

    _set_use_magnetic_heading_metadata = { "offset" : _set_use_magnetic_heading_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_magnetic_heading.setter
    def use_magnetic_heading(self, value:bool) -> None:
        """Get or set the option to use a magnetic heading for the start bearing."""
        return self._intf.set_property(ArcOptions._metadata, ArcOptions._set_use_magnetic_heading_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 arc."""
        return self._intf.get_property(ArcOptions._metadata, ArcOptions._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:
        """Get or set the radius of the arc."""
        return self._intf.set_property(ArcOptions._metadata, ArcOptions._set_radius_metadata, value)

    _get_turn_angle_metadata = { "offset" : _get_turn_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def turn_angle(self) -> typing.Any:
        """Get or set the length of the arc the aircraft will fly."""
        return self._intf.get_property(ArcOptions._metadata, ArcOptions._get_turn_angle_metadata)

    _set_turn_angle_metadata = { "offset" : _set_turn_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @turn_angle.setter
    def turn_angle(self, value:typing.Any) -> None:
        """Get or set the length of the arc the aircraft will fly."""
        return self._intf.set_property(ArcOptions._metadata, ArcOptions._set_turn_angle_metadata, value)

    _get_join_arc_metadata = { "offset" : _get_join_arc_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(JoinExitArcMethod),) }
    @property
    def join_arc(self) -> "JoinExitArcMethod":
        """Get or set the method to join the arc."""
        return self._intf.get_property(ArcOptions._metadata, ArcOptions._get_join_arc_metadata)

    _set_join_arc_metadata = { "offset" : _set_join_arc_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(JoinExitArcMethod),) }
    @join_arc.setter
    def join_arc(self, value:"JoinExitArcMethod") -> None:
        """Get or set the method to join the arc."""
        return self._intf.set_property(ArcOptions._metadata, ArcOptions._set_join_arc_metadata, value)

    _get_exit_arc_metadata = { "offset" : _get_exit_arc_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(JoinExitArcMethod),) }
    @property
    def exit_arc(self) -> "JoinExitArcMethod":
        """Get or set the method to exit the arc."""
        return self._intf.get_property(ArcOptions._metadata, ArcOptions._get_exit_arc_metadata)

    _set_exit_arc_metadata = { "offset" : _set_exit_arc_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(JoinExitArcMethod),) }
    @exit_arc.setter
    def exit_arc(self, value:"JoinExitArcMethod") -> None:
        """Get or set the method to exit the arc."""
        return self._intf.set_property(ArcOptions._metadata, ArcOptions._set_exit_arc_metadata, value)

    _property_names[turn_direction] = "turn_direction"
    _property_names[start_bearing] = "start_bearing"
    _property_names[use_magnetic_heading] = "use_magnetic_heading"
    _property_names[radius] = "radius"
    _property_names[turn_angle] = "turn_angle"
    _property_names[join_arc] = "join_arc"
    _property_names[exit_arc] = "exit_arc"

    def __init__(self, source_object=None):
        """Construct an object of type ArcOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ArcOptions)
    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, ArcOptions, [ArcOptions, ])

agcls.AgClassCatalog.add_catalog_entry((4985001686384732151, 3276579562627893893), ArcOptions)
agcls.AgTypeNameMap["ArcOptions"] = ArcOptions

class AltitudeMSLAndLevelOffOptions(SupportsDeleteCallback):
    """
    Interface used to access the altitude MSL and Level off options for an Aviator procedure.

    Examples
    --------
    Add and configure an en-route procedure:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add an enroute procedure with a site type of End of Previous Procedure
    >>> enroute = procedures.add_at_index(1, SiteType.SITE_END_OF_PREV_PROCEDURE, ProcedureType.PROCEDURE_ENROUTE)
    >>> # Get the altitude options
    >>> altitudeOptions = enroute.altitude_msl_options
    >>> # To specify an altitude, turn off the option to use the default cruise altitude
    >>> altitudeOptions.use_default_cruise_altitude = False
    >>> # Set the altitude
    >>> altitudeOptions.msl_altitude = 10000
    >>>
    >>> # Get the navigation options
    >>> navigationOptions = enroute.navigation_options
    >>> # Set the route to arrive on a specified course
    >>> navigationOptions.navigation_mode = PointToPointMode.ARRIVE_ON_COURSE
    >>> # Set the course
    >>> navigationOptions.arrive_on_course = 30
    >>> # Use a magnetic heading
    >>> navigationOptions.use_magnetic_heading = True
    >>>
    >>> # Get the navigation options
    >>> airspeedOptions = enroute.enroute_cruise_airspeed_options
    >>> # Fly at max speed
    >>> airspeedOptions.cruise_speed_type = CruiseSpeed.MAX_AIRSPEED
    >>> # To specify an airspeed to fly at, set the speed type to other airspeed
    >>> airspeedOptions.cruise_speed_type = CruiseSpeed.OTHER_AIRSPEED
    >>> # Then set the airspeed and airspeed type
    >>> airspeedOptions.set_other_airspeed(AirspeedType.TAS, 200)
    """

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_default_cruise_altitude_method_offset = 1
    _set_use_default_cruise_altitude_method_offset = 2
    _get_msl_altitude_method_offset = 3
    _set_msl_altitude_method_offset = 4
    _get_must_level_off_method_offset = 5
    _set_must_level_off_method_offset = 6
    _get_level_off_mode_method_offset = 7
    _set_level_off_mode_method_offset = 8
    _metadata = {
        "iid_data" : (4970555218238608998, 11906085318817631130),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AltitudeMSLAndLevelOffOptions)

    _get_use_default_cruise_altitude_metadata = { "offset" : _get_use_default_cruise_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_default_cruise_altitude(self) -> bool:
        """Opt whether to use the default cruise altitude."""
        return self._intf.get_property(AltitudeMSLAndLevelOffOptions._metadata, AltitudeMSLAndLevelOffOptions._get_use_default_cruise_altitude_metadata)

    _set_use_default_cruise_altitude_metadata = { "offset" : _set_use_default_cruise_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_default_cruise_altitude.setter
    def use_default_cruise_altitude(self, value:bool) -> None:
        """Opt whether to use the default cruise altitude."""
        return self._intf.set_property(AltitudeMSLAndLevelOffOptions._metadata, AltitudeMSLAndLevelOffOptions._set_use_default_cruise_altitude_metadata, value)

    _get_msl_altitude_metadata = { "offset" : _get_msl_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def msl_altitude(self) -> float:
        """Get the MSL altitude. Can only be used when the option to use the default cruise altitude is off."""
        return self._intf.get_property(AltitudeMSLAndLevelOffOptions._metadata, AltitudeMSLAndLevelOffOptions._get_msl_altitude_metadata)

    _set_msl_altitude_metadata = { "offset" : _set_msl_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @msl_altitude.setter
    def msl_altitude(self, value:float) -> None:
        """Set the MSL altitude. Can only be used when the option to use the default cruise altitude is off."""
        return self._intf.set_property(AltitudeMSLAndLevelOffOptions._metadata, AltitudeMSLAndLevelOffOptions._set_msl_altitude_metadata, value)

    _get_must_level_off_metadata = { "offset" : _get_must_level_off_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def must_level_off(self) -> bool:
        """Opt whether the procedure must level off."""
        return self._intf.get_property(AltitudeMSLAndLevelOffOptions._metadata, AltitudeMSLAndLevelOffOptions._get_must_level_off_metadata)

    _set_must_level_off_metadata = { "offset" : _set_must_level_off_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @must_level_off.setter
    def must_level_off(self, value:bool) -> None:
        """Opt whether the procedure must level off."""
        return self._intf.set_property(AltitudeMSLAndLevelOffOptions._metadata, AltitudeMSLAndLevelOffOptions._set_must_level_off_metadata, value)

    _get_level_off_mode_metadata = { "offset" : _get_level_off_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AltitudeConstraintManeuverMode),) }
    @property
    def level_off_mode(self) -> "AltitudeConstraintManeuverMode":
        """Get or set the level off mode. This is only used when the must level off option is on."""
        return self._intf.get_property(AltitudeMSLAndLevelOffOptions._metadata, AltitudeMSLAndLevelOffOptions._get_level_off_mode_metadata)

    _set_level_off_mode_metadata = { "offset" : _set_level_off_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AltitudeConstraintManeuverMode),) }
    @level_off_mode.setter
    def level_off_mode(self, value:"AltitudeConstraintManeuverMode") -> None:
        """Get or set the level off mode. This is only used when the must level off option is on."""
        return self._intf.set_property(AltitudeMSLAndLevelOffOptions._metadata, AltitudeMSLAndLevelOffOptions._set_level_off_mode_metadata, value)

    _property_names[use_default_cruise_altitude] = "use_default_cruise_altitude"
    _property_names[msl_altitude] = "msl_altitude"
    _property_names[must_level_off] = "must_level_off"
    _property_names[level_off_mode] = "level_off_mode"

    def __init__(self, source_object=None):
        """Construct an object of type AltitudeMSLAndLevelOffOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AltitudeMSLAndLevelOffOptions)
    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, AltitudeMSLAndLevelOffOptions, [AltitudeMSLAndLevelOffOptions, ])

agcls.AgClassCatalog.add_catalog_entry((4623922148496958771, 14914904139938911918), AltitudeMSLAndLevelOffOptions)
agcls.AgTypeNameMap["AltitudeMSLAndLevelOffOptions"] = AltitudeMSLAndLevelOffOptions

class CruiseAirspeedOptions(SupportsDeleteCallback):
    """
    Interface used to access the Cruise Airspeed options for an Aviator procedure.

    Examples
    --------
    Add and configure an en-route procedure:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add an enroute procedure with a site type of End of Previous Procedure
    >>> enroute = procedures.add_at_index(1, SiteType.SITE_END_OF_PREV_PROCEDURE, ProcedureType.PROCEDURE_ENROUTE)
    >>> # Get the altitude options
    >>> altitudeOptions = enroute.altitude_msl_options
    >>> # To specify an altitude, turn off the option to use the default cruise altitude
    >>> altitudeOptions.use_default_cruise_altitude = False
    >>> # Set the altitude
    >>> altitudeOptions.msl_altitude = 10000
    >>>
    >>> # Get the navigation options
    >>> navigationOptions = enroute.navigation_options
    >>> # Set the route to arrive on a specified course
    >>> navigationOptions.navigation_mode = PointToPointMode.ARRIVE_ON_COURSE
    >>> # Set the course
    >>> navigationOptions.arrive_on_course = 30
    >>> # Use a magnetic heading
    >>> navigationOptions.use_magnetic_heading = True
    >>>
    >>> # Get the navigation options
    >>> airspeedOptions = enroute.enroute_cruise_airspeed_options
    >>> # Fly at max speed
    >>> airspeedOptions.cruise_speed_type = CruiseSpeed.MAX_AIRSPEED
    >>> # To specify an airspeed to fly at, set the speed type to other airspeed
    >>> airspeedOptions.cruise_speed_type = CruiseSpeed.OTHER_AIRSPEED
    >>> # Then set the airspeed and airspeed type
    >>> airspeedOptions.set_other_airspeed(AirspeedType.TAS, 200)
    """

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_cruise_speed_type_method_offset = 1
    _set_cruise_speed_type_method_offset = 2
    _get_other_airspeed_type_method_offset = 3
    _get_other_airspeed_method_offset = 4
    _set_other_airspeed_method_offset = 5
    _metadata = {
        "iid_data" : (4775037409602090834, 14321643648366655389),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CruiseAirspeedOptions)

    _get_cruise_speed_type_metadata = { "offset" : _get_cruise_speed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CruiseSpeed),) }
    @property
    def cruise_speed_type(self) -> "CruiseSpeed":
        """Get or set the method for determining the aircraft's airspeed."""
        return self._intf.get_property(CruiseAirspeedOptions._metadata, CruiseAirspeedOptions._get_cruise_speed_type_metadata)

    _set_cruise_speed_type_metadata = { "offset" : _set_cruise_speed_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CruiseSpeed),) }
    @cruise_speed_type.setter
    def cruise_speed_type(self, value:"CruiseSpeed") -> None:
        """Get or set the method for determining the aircraft's airspeed."""
        return self._intf.set_property(CruiseAirspeedOptions._metadata, CruiseAirspeedOptions._set_cruise_speed_type_metadata, value)

    _get_other_airspeed_type_metadata = { "offset" : _get_other_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def other_airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type for the other airspeed option."""
        return self._intf.get_property(CruiseAirspeedOptions._metadata, CruiseAirspeedOptions._get_other_airspeed_type_metadata)

    _get_other_airspeed_metadata = { "offset" : _get_other_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def other_airspeed(self) -> float:
        """Get the airspeed for the other airspeed option."""
        return self._intf.get_property(CruiseAirspeedOptions._metadata, CruiseAirspeedOptions._get_other_airspeed_metadata)

    _set_other_airspeed_metadata = { "offset" : _set_other_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_other_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the cruise airspeed. This option is only enabled if the cruise speed type is set to other."""
        return self._intf.invoke(CruiseAirspeedOptions._metadata, CruiseAirspeedOptions._set_other_airspeed_metadata, airspeed_type, airspeed)

    _property_names[cruise_speed_type] = "cruise_speed_type"
    _property_names[other_airspeed_type] = "other_airspeed_type"
    _property_names[other_airspeed] = "other_airspeed"

    def __init__(self, source_object=None):
        """Construct an object of type CruiseAirspeedOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CruiseAirspeedOptions)
    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, CruiseAirspeedOptions, [CruiseAirspeedOptions, ])

agcls.AgClassCatalog.add_catalog_entry((5589499567568918408, 8793492467480374660), CruiseAirspeedOptions)
agcls.AgTypeNameMap["CruiseAirspeedOptions"] = CruiseAirspeedOptions

class CruiseAirspeedProfile(SupportsDeleteCallback):
    """Interface used to access the Cruise Profile options for an Aviator procedure."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_fly_cruise_airspeed_profile_method_offset = 1
    _set_fly_cruise_airspeed_profile_method_offset = 2
    _metadata = {
        "iid_data" : (4932691083798754313, 2757480245686328988),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, CruiseAirspeedProfile)

    _get_fly_cruise_airspeed_profile_metadata = { "offset" : _get_fly_cruise_airspeed_profile_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def fly_cruise_airspeed_profile(self) -> bool:
        """Opt whether the aircraft immediately adopts the selected cruise airspeed or gradually begins accelerating/decelerating in the previous procedure."""
        return self._intf.get_property(CruiseAirspeedProfile._metadata, CruiseAirspeedProfile._get_fly_cruise_airspeed_profile_metadata)

    _set_fly_cruise_airspeed_profile_metadata = { "offset" : _set_fly_cruise_airspeed_profile_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @fly_cruise_airspeed_profile.setter
    def fly_cruise_airspeed_profile(self, value:bool) -> None:
        """Opt whether the aircraft immediately adopts the selected cruise airspeed or gradually begins accelerating/decelerating in the previous procedure."""
        return self._intf.set_property(CruiseAirspeedProfile._metadata, CruiseAirspeedProfile._set_fly_cruise_airspeed_profile_metadata, value)

    _property_names[fly_cruise_airspeed_profile] = "fly_cruise_airspeed_profile"

    def __init__(self, source_object=None):
        """Construct an object of type CruiseAirspeedProfile."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, CruiseAirspeedProfile)
    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, CruiseAirspeedProfile, [CruiseAirspeedProfile, ])

agcls.AgClassCatalog.add_catalog_entry((5042125039608830422, 186775197327029686), CruiseAirspeedProfile)
agcls.AgTypeNameMap["CruiseAirspeedProfile"] = CruiseAirspeedProfile

class CruiseAirspeedAndProfileOptions(ICruiseAirspeedAndProfileOptions, SupportsDeleteCallback):
    """Class defining the cruise airspeed and profile options in a procedure."""
    def __init__(self, source_object=None):
        """Construct an object of type CruiseAirspeedAndProfileOptions."""
        SupportsDeleteCallback.__init__(self)
        ICruiseAirspeedAndProfileOptions.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        ICruiseAirspeedAndProfileOptions._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, CruiseAirspeedAndProfileOptions, [ICruiseAirspeedAndProfileOptions])

agcls.AgClassCatalog.add_catalog_entry((5023146659635499349, 10240031022027307191), CruiseAirspeedAndProfileOptions)
agcls.AgTypeNameMap["CruiseAirspeedAndProfileOptions"] = CruiseAirspeedAndProfileOptions

class LandingCruiseAirspeedAndProfileOptions(ICruiseAirspeedAndProfileOptions, SupportsDeleteCallback):
    """Class defining the cruise airspeed and profile options for a landing procedure."""
    def __init__(self, source_object=None):
        """Construct an object of type LandingCruiseAirspeedAndProfileOptions."""
        SupportsDeleteCallback.__init__(self)
        ICruiseAirspeedAndProfileOptions.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        ICruiseAirspeedAndProfileOptions._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, LandingCruiseAirspeedAndProfileOptions, [ICruiseAirspeedAndProfileOptions])

agcls.AgClassCatalog.add_catalog_entry((5282497060921620892, 7823813257265650837), LandingCruiseAirspeedAndProfileOptions)
agcls.AgTypeNameMap["LandingCruiseAirspeedAndProfileOptions"] = LandingCruiseAirspeedAndProfileOptions

class EnrouteOptions(SupportsDeleteCallback):
    """Interface used to access the Enroute options for an Aviator procedure."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_max_speed_turns_method_offset = 1
    _set_use_max_speed_turns_method_offset = 2
    _get_max_turn_radius_factor_method_offset = 3
    _set_max_turn_radius_factor_method_offset = 4
    _metadata = {
        "iid_data" : (5388097155578164474, 7061394601143800450),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, EnrouteOptions)

    _get_use_max_speed_turns_metadata = { "offset" : _get_use_max_speed_turns_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_max_speed_turns(self) -> bool:
        """Opt whether to use the max speed turns."""
        return self._intf.get_property(EnrouteOptions._metadata, EnrouteOptions._get_use_max_speed_turns_metadata)

    _set_use_max_speed_turns_metadata = { "offset" : _set_use_max_speed_turns_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_max_speed_turns.setter
    def use_max_speed_turns(self, value:bool) -> None:
        """Opt whether to use the max speed turns."""
        return self._intf.set_property(EnrouteOptions._metadata, EnrouteOptions._set_use_max_speed_turns_metadata, value)

    _get_max_turn_radius_factor_metadata = { "offset" : _get_max_turn_radius_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_turn_radius_factor(self) -> float:
        """Get or set the maximum turn radius factor."""
        return self._intf.get_property(EnrouteOptions._metadata, EnrouteOptions._get_max_turn_radius_factor_metadata)

    _set_max_turn_radius_factor_metadata = { "offset" : _set_max_turn_radius_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_turn_radius_factor.setter
    def max_turn_radius_factor(self, value:float) -> None:
        """Get or set the maximum turn radius factor."""
        return self._intf.set_property(EnrouteOptions._metadata, EnrouteOptions._set_max_turn_radius_factor_metadata, value)

    _property_names[use_max_speed_turns] = "use_max_speed_turns"
    _property_names[max_turn_radius_factor] = "max_turn_radius_factor"

    def __init__(self, source_object=None):
        """Construct an object of type EnrouteOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, EnrouteOptions)
    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, EnrouteOptions, [EnrouteOptions, ])

agcls.AgClassCatalog.add_catalog_entry((5601440232813659681, 2626155638734127273), EnrouteOptions)
agcls.AgTypeNameMap["EnrouteOptions"] = EnrouteOptions

class EnrouteAndDelayOptions(IEnrouteAndDelayOptions, SupportsDeleteCallback):
    """Class defining the enroute and delay options in a procedure."""
    def __init__(self, source_object=None):
        """Construct an object of type EnrouteAndDelayOptions."""
        SupportsDeleteCallback.__init__(self)
        IEnrouteAndDelayOptions.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IEnrouteAndDelayOptions._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, EnrouteAndDelayOptions, [IEnrouteAndDelayOptions])

agcls.AgClassCatalog.add_catalog_entry((5633379882483759369, 15566420089287312029), EnrouteAndDelayOptions)
agcls.AgTypeNameMap["EnrouteAndDelayOptions"] = EnrouteAndDelayOptions

class LandingEnrouteOptions(IEnrouteAndDelayOptions, SupportsDeleteCallback):
    """Class defining the enroute options in a landing procedure."""
    def __init__(self, source_object=None):
        """Construct an object of type LandingEnrouteOptions."""
        SupportsDeleteCallback.__init__(self)
        IEnrouteAndDelayOptions.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IEnrouteAndDelayOptions._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, LandingEnrouteOptions, [IEnrouteAndDelayOptions])

agcls.AgClassCatalog.add_catalog_entry((5505692743636881819, 1797000207370880952), LandingEnrouteOptions)
agcls.AgTypeNameMap["LandingEnrouteOptions"] = LandingEnrouteOptions

class EnrouteTurnDirectionOptions(SupportsDeleteCallback):
    """Interface used to access the Enroute Turn Direction options for an Aviator procedure."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_enroute_first_turn_method_offset = 1
    _set_enroute_first_turn_method_offset = 2
    _get_enroute_second_turn_method_offset = 3
    _set_enroute_second_turn_method_offset = 4
    _metadata = {
        "iid_data" : (4825843845888691284, 5666336038605995175),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, EnrouteTurnDirectionOptions)

    _get_enroute_first_turn_metadata = { "offset" : _get_enroute_first_turn_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(NavigatorTurnDirection),) }
    @property
    def enroute_first_turn(self) -> "NavigatorTurnDirection":
        """Option for the first turn."""
        return self._intf.get_property(EnrouteTurnDirectionOptions._metadata, EnrouteTurnDirectionOptions._get_enroute_first_turn_metadata)

    _set_enroute_first_turn_metadata = { "offset" : _set_enroute_first_turn_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(NavigatorTurnDirection),) }
    @enroute_first_turn.setter
    def enroute_first_turn(self, value:"NavigatorTurnDirection") -> None:
        """Option for the first turn."""
        return self._intf.set_property(EnrouteTurnDirectionOptions._metadata, EnrouteTurnDirectionOptions._set_enroute_first_turn_metadata, value)

    _get_enroute_second_turn_metadata = { "offset" : _get_enroute_second_turn_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(NavigatorTurnDirection),) }
    @property
    def enroute_second_turn(self) -> "NavigatorTurnDirection":
        """Option for the second turn."""
        return self._intf.get_property(EnrouteTurnDirectionOptions._metadata, EnrouteTurnDirectionOptions._get_enroute_second_turn_metadata)

    _set_enroute_second_turn_metadata = { "offset" : _set_enroute_second_turn_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(NavigatorTurnDirection),) }
    @enroute_second_turn.setter
    def enroute_second_turn(self, value:"NavigatorTurnDirection") -> None:
        """Option for the second turn."""
        return self._intf.set_property(EnrouteTurnDirectionOptions._metadata, EnrouteTurnDirectionOptions._set_enroute_second_turn_metadata, value)

    _property_names[enroute_first_turn] = "enroute_first_turn"
    _property_names[enroute_second_turn] = "enroute_second_turn"

    def __init__(self, source_object=None):
        """Construct an object of type EnrouteTurnDirectionOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, EnrouteTurnDirectionOptions)
    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, EnrouteTurnDirectionOptions, [EnrouteTurnDirectionOptions, ])

agcls.AgClassCatalog.add_catalog_entry((5525734658029426163, 7829029184116166294), EnrouteTurnDirectionOptions)
agcls.AgTypeNameMap["EnrouteTurnDirectionOptions"] = EnrouteTurnDirectionOptions

class NavigationOptions(SupportsDeleteCallback):
    """
    Interface used to access the navigation options for an Aviator procedure.

    Examples
    --------
    Add and configure an en-route procedure:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add an enroute procedure with a site type of End of Previous Procedure
    >>> enroute = procedures.add_at_index(1, SiteType.SITE_END_OF_PREV_PROCEDURE, ProcedureType.PROCEDURE_ENROUTE)
    >>> # Get the altitude options
    >>> altitudeOptions = enroute.altitude_msl_options
    >>> # To specify an altitude, turn off the option to use the default cruise altitude
    >>> altitudeOptions.use_default_cruise_altitude = False
    >>> # Set the altitude
    >>> altitudeOptions.msl_altitude = 10000
    >>>
    >>> # Get the navigation options
    >>> navigationOptions = enroute.navigation_options
    >>> # Set the route to arrive on a specified course
    >>> navigationOptions.navigation_mode = PointToPointMode.ARRIVE_ON_COURSE
    >>> # Set the course
    >>> navigationOptions.arrive_on_course = 30
    >>> # Use a magnetic heading
    >>> navigationOptions.use_magnetic_heading = True
    >>>
    >>> # Get the navigation options
    >>> airspeedOptions = enroute.enroute_cruise_airspeed_options
    >>> # Fly at max speed
    >>> airspeedOptions.cruise_speed_type = CruiseSpeed.MAX_AIRSPEED
    >>> # To specify an airspeed to fly at, set the speed type to other airspeed
    >>> airspeedOptions.cruise_speed_type = CruiseSpeed.OTHER_AIRSPEED
    >>> # Then set the airspeed and airspeed type
    >>> airspeedOptions.set_other_airspeed(AirspeedType.TAS, 200)
    """

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_navigation_mode_method_offset = 1
    _set_navigation_mode_method_offset = 2
    _get_arrive_on_course_method_offset = 3
    _set_arrive_on_course_method_offset = 4
    _get_use_magnetic_heading_method_offset = 5
    _set_use_magnetic_heading_method_offset = 6
    _get_enroute_first_turn_method_offset = 7
    _set_enroute_first_turn_method_offset = 8
    _get_enroute_second_turn_method_offset = 9
    _set_enroute_second_turn_method_offset = 10
    _metadata = {
        "iid_data" : (4993099939815057319, 3478925526245202352),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, NavigationOptions)

    _get_navigation_mode_metadata = { "offset" : _get_navigation_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PointToPointMode),) }
    @property
    def navigation_mode(self) -> "PointToPointMode":
        """Get or set the navigation mode."""
        return self._intf.get_property(NavigationOptions._metadata, NavigationOptions._get_navigation_mode_metadata)

    _set_navigation_mode_metadata = { "offset" : _set_navigation_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PointToPointMode),) }
    @navigation_mode.setter
    def navigation_mode(self, value:"PointToPointMode") -> None:
        """Get or set the navigation mode."""
        return self._intf.set_property(NavigationOptions._metadata, NavigationOptions._set_navigation_mode_metadata, value)

    _get_arrive_on_course_metadata = { "offset" : _get_arrive_on_course_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def arrive_on_course(self) -> typing.Any:
        """Get or set the aircraft will start or arrive at the procedure site with the specified course. The nav mode must be set to Arrive on Course to set this value."""
        return self._intf.get_property(NavigationOptions._metadata, NavigationOptions._get_arrive_on_course_metadata)

    _set_arrive_on_course_metadata = { "offset" : _set_arrive_on_course_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @arrive_on_course.setter
    def arrive_on_course(self, value:typing.Any) -> None:
        """Get or set the aircraft will start or arrive at the procedure site with the specified course. The nav mode must be set to Arrive on Course to set this value."""
        return self._intf.set_property(NavigationOptions._metadata, NavigationOptions._set_arrive_on_course_metadata, value)

    _get_use_magnetic_heading_metadata = { "offset" : _get_use_magnetic_heading_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_magnetic_heading(self) -> bool:
        """Opt whether to use a magnetic heading to arrive on course. The nav mode must be set to Arrive on Course to set this value."""
        return self._intf.get_property(NavigationOptions._metadata, NavigationOptions._get_use_magnetic_heading_metadata)

    _set_use_magnetic_heading_metadata = { "offset" : _set_use_magnetic_heading_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_magnetic_heading.setter
    def use_magnetic_heading(self, value:bool) -> None:
        """Opt whether to use a magnetic heading to arrive on course. The nav mode must be set to Arrive on Course to set this value."""
        return self._intf.set_property(NavigationOptions._metadata, NavigationOptions._set_use_magnetic_heading_metadata, value)

    _get_enroute_first_turn_metadata = { "offset" : _get_enroute_first_turn_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(NavigatorTurnDirection),) }
    @property
    def enroute_first_turn(self) -> "NavigatorTurnDirection":
        """Option for the first turn."""
        return self._intf.get_property(NavigationOptions._metadata, NavigationOptions._get_enroute_first_turn_metadata)

    _set_enroute_first_turn_metadata = { "offset" : _set_enroute_first_turn_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(NavigatorTurnDirection),) }
    @enroute_first_turn.setter
    def enroute_first_turn(self, value:"NavigatorTurnDirection") -> None:
        """Option for the first turn."""
        return self._intf.set_property(NavigationOptions._metadata, NavigationOptions._set_enroute_first_turn_metadata, value)

    _get_enroute_second_turn_metadata = { "offset" : _get_enroute_second_turn_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(NavigatorTurnDirection),) }
    @property
    def enroute_second_turn(self) -> "NavigatorTurnDirection":
        """Option for the second turn."""
        return self._intf.get_property(NavigationOptions._metadata, NavigationOptions._get_enroute_second_turn_metadata)

    _set_enroute_second_turn_metadata = { "offset" : _set_enroute_second_turn_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(NavigatorTurnDirection),) }
    @enroute_second_turn.setter
    def enroute_second_turn(self, value:"NavigatorTurnDirection") -> None:
        """Option for the second turn."""
        return self._intf.set_property(NavigationOptions._metadata, NavigationOptions._set_enroute_second_turn_metadata, value)

    _property_names[navigation_mode] = "navigation_mode"
    _property_names[arrive_on_course] = "arrive_on_course"
    _property_names[use_magnetic_heading] = "use_magnetic_heading"
    _property_names[enroute_first_turn] = "enroute_first_turn"
    _property_names[enroute_second_turn] = "enroute_second_turn"

    def __init__(self, source_object=None):
        """Construct an object of type NavigationOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, NavigationOptions)
    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, NavigationOptions, [NavigationOptions, ])

agcls.AgClassCatalog.add_catalog_entry((5297554030905568728, 15312492039192405176), NavigationOptions)
agcls.AgTypeNameMap["NavigationOptions"] = NavigationOptions

class VerticalPlaneOptions(IVerticalPlaneOptions, SupportsDeleteCallback):
    """Class defining the vertical plane options in a procedure."""
    def __init__(self, source_object=None):
        """Construct an object of type VerticalPlaneOptions."""
        SupportsDeleteCallback.__init__(self)
        IVerticalPlaneOptions.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IVerticalPlaneOptions._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, VerticalPlaneOptions, [IVerticalPlaneOptions])

agcls.AgClassCatalog.add_catalog_entry((4791831385042236424, 17790584228054945718), VerticalPlaneOptions)
agcls.AgTypeNameMap["VerticalPlaneOptions"] = VerticalPlaneOptions

class ArcVerticalPlaneOptions(SupportsDeleteCallback):
    """Interface used to access the Vertical Plane options for an arc procedure."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_start_arc_flight_path_angle_method_offset = 1
    _set_start_arc_flight_path_angle_method_offset = 2
    _get_stop_arc_flight_path_angle_method_offset = 3
    _set_stop_arc_flight_path_angle_method_offset = 4
    _get_min_enroute_flight_path_angle_method_offset = 5
    _set_min_enroute_flight_path_angle_method_offset = 6
    _get_max_enroute_flight_path_angle_method_offset = 7
    _set_max_enroute_flight_path_angle_method_offset = 8
    _get_max_vert_plane_radius_factor_method_offset = 9
    _set_max_vert_plane_radius_factor_method_offset = 10
    _metadata = {
        "iid_data" : (5401521584591596237, 12745820344260646540),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ArcVerticalPlaneOptions)

    _get_start_arc_flight_path_angle_metadata = { "offset" : _get_start_arc_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def start_arc_flight_path_angle(self) -> typing.Any:
        """Get or set the pitch angle of the flight path at the start of the arc."""
        return self._intf.get_property(ArcVerticalPlaneOptions._metadata, ArcVerticalPlaneOptions._get_start_arc_flight_path_angle_metadata)

    _set_start_arc_flight_path_angle_metadata = { "offset" : _set_start_arc_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @start_arc_flight_path_angle.setter
    def start_arc_flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the pitch angle of the flight path at the start of the arc."""
        return self._intf.set_property(ArcVerticalPlaneOptions._metadata, ArcVerticalPlaneOptions._set_start_arc_flight_path_angle_metadata, value)

    _get_stop_arc_flight_path_angle_metadata = { "offset" : _get_stop_arc_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def stop_arc_flight_path_angle(self) -> typing.Any:
        """Get or set the pitch angle of the flight path at the end of the arc."""
        return self._intf.get_property(ArcVerticalPlaneOptions._metadata, ArcVerticalPlaneOptions._get_stop_arc_flight_path_angle_metadata)

    _set_stop_arc_flight_path_angle_metadata = { "offset" : _set_stop_arc_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @stop_arc_flight_path_angle.setter
    def stop_arc_flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the pitch angle of the flight path at the end of the arc."""
        return self._intf.set_property(ArcVerticalPlaneOptions._metadata, ArcVerticalPlaneOptions._set_stop_arc_flight_path_angle_metadata, value)

    _get_min_enroute_flight_path_angle_metadata = { "offset" : _get_min_enroute_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def min_enroute_flight_path_angle(self) -> typing.Any:
        """Get or set the minimum pitch angle of the flight path during enroute segments of the procedure."""
        return self._intf.get_property(ArcVerticalPlaneOptions._metadata, ArcVerticalPlaneOptions._get_min_enroute_flight_path_angle_metadata)

    _set_min_enroute_flight_path_angle_metadata = { "offset" : _set_min_enroute_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @min_enroute_flight_path_angle.setter
    def min_enroute_flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the minimum pitch angle of the flight path during enroute segments of the procedure."""
        return self._intf.set_property(ArcVerticalPlaneOptions._metadata, ArcVerticalPlaneOptions._set_min_enroute_flight_path_angle_metadata, value)

    _get_max_enroute_flight_path_angle_metadata = { "offset" : _get_max_enroute_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_enroute_flight_path_angle(self) -> typing.Any:
        """Get or set the maximum pitch angle of the flight path during enroute segments of the procedure."""
        return self._intf.get_property(ArcVerticalPlaneOptions._metadata, ArcVerticalPlaneOptions._get_max_enroute_flight_path_angle_metadata)

    _set_max_enroute_flight_path_angle_metadata = { "offset" : _set_max_enroute_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_enroute_flight_path_angle.setter
    def max_enroute_flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the maximum pitch angle of the flight path during enroute segments of the procedure."""
        return self._intf.set_property(ArcVerticalPlaneOptions._metadata, ArcVerticalPlaneOptions._set_max_enroute_flight_path_angle_metadata, value)

    _get_max_vert_plane_radius_factor_metadata = { "offset" : _get_max_vert_plane_radius_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_vert_plane_radius_factor(self) -> float:
        """Get or set the maximum amount the radius of vertical curve will be increased to minimize the flight path angle required to complete it."""
        return self._intf.get_property(ArcVerticalPlaneOptions._metadata, ArcVerticalPlaneOptions._get_max_vert_plane_radius_factor_metadata)

    _set_max_vert_plane_radius_factor_metadata = { "offset" : _set_max_vert_plane_radius_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_vert_plane_radius_factor.setter
    def max_vert_plane_radius_factor(self, value:float) -> None:
        """Get or set the maximum amount the radius of vertical curve will be increased to minimize the flight path angle required to complete it."""
        return self._intf.set_property(ArcVerticalPlaneOptions._metadata, ArcVerticalPlaneOptions._set_max_vert_plane_radius_factor_metadata, value)

    _property_names[start_arc_flight_path_angle] = "start_arc_flight_path_angle"
    _property_names[stop_arc_flight_path_angle] = "stop_arc_flight_path_angle"
    _property_names[min_enroute_flight_path_angle] = "min_enroute_flight_path_angle"
    _property_names[max_enroute_flight_path_angle] = "max_enroute_flight_path_angle"
    _property_names[max_vert_plane_radius_factor] = "max_vert_plane_radius_factor"

    def __init__(self, source_object=None):
        """Construct an object of type ArcVerticalPlaneOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ArcVerticalPlaneOptions)
    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, ArcVerticalPlaneOptions, [ArcVerticalPlaneOptions, ])

agcls.AgClassCatalog.add_catalog_entry((4652016757415061557, 6686714748074581137), ArcVerticalPlaneOptions)
agcls.AgTypeNameMap["ArcVerticalPlaneOptions"] = ArcVerticalPlaneOptions

class VerticalPlaneAndFlightPathOptions(SupportsDeleteCallback):
    """Interface used to access the Vertical Plane and Final Flight Path Angle options for an Aviator procedure."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_final_flight_path_angle_method_offset = 1
    _set_final_flight_path_angle_method_offset = 2
    _get_min_enroute_flight_path_angle_method_offset = 3
    _set_min_enroute_flight_path_angle_method_offset = 4
    _get_max_enroute_flight_path_angle_method_offset = 5
    _set_max_enroute_flight_path_angle_method_offset = 6
    _get_max_vert_plane_radius_factor_method_offset = 7
    _set_max_vert_plane_radius_factor_method_offset = 8
    _metadata = {
        "iid_data" : (4866221299348241801, 14897448743116069797),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, VerticalPlaneAndFlightPathOptions)

    _get_final_flight_path_angle_metadata = { "offset" : _get_final_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def final_flight_path_angle(self) -> typing.Any:
        """Get or set the pitch angle of the flight path at the end of the procedure."""
        return self._intf.get_property(VerticalPlaneAndFlightPathOptions._metadata, VerticalPlaneAndFlightPathOptions._get_final_flight_path_angle_metadata)

    _set_final_flight_path_angle_metadata = { "offset" : _set_final_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @final_flight_path_angle.setter
    def final_flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the pitch angle of the flight path at the end of the procedure."""
        return self._intf.set_property(VerticalPlaneAndFlightPathOptions._metadata, VerticalPlaneAndFlightPathOptions._set_final_flight_path_angle_metadata, value)

    _get_min_enroute_flight_path_angle_metadata = { "offset" : _get_min_enroute_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def min_enroute_flight_path_angle(self) -> typing.Any:
        """Get or set the minimum pitch angle of the flight path during enroute segments of the procedure."""
        return self._intf.get_property(VerticalPlaneAndFlightPathOptions._metadata, VerticalPlaneAndFlightPathOptions._get_min_enroute_flight_path_angle_metadata)

    _set_min_enroute_flight_path_angle_metadata = { "offset" : _set_min_enroute_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @min_enroute_flight_path_angle.setter
    def min_enroute_flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the minimum pitch angle of the flight path during enroute segments of the procedure."""
        return self._intf.set_property(VerticalPlaneAndFlightPathOptions._metadata, VerticalPlaneAndFlightPathOptions._set_min_enroute_flight_path_angle_metadata, value)

    _get_max_enroute_flight_path_angle_metadata = { "offset" : _get_max_enroute_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_enroute_flight_path_angle(self) -> typing.Any:
        """Get or set the maximum pitch angle of the flight path during enroute segments of the procedure."""
        return self._intf.get_property(VerticalPlaneAndFlightPathOptions._metadata, VerticalPlaneAndFlightPathOptions._get_max_enroute_flight_path_angle_metadata)

    _set_max_enroute_flight_path_angle_metadata = { "offset" : _set_max_enroute_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_enroute_flight_path_angle.setter
    def max_enroute_flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the maximum pitch angle of the flight path during enroute segments of the procedure."""
        return self._intf.set_property(VerticalPlaneAndFlightPathOptions._metadata, VerticalPlaneAndFlightPathOptions._set_max_enroute_flight_path_angle_metadata, value)

    _get_max_vert_plane_radius_factor_metadata = { "offset" : _get_max_vert_plane_radius_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_vert_plane_radius_factor(self) -> float:
        """Get or set the maximum amount the radius of vertical curve will be increased to minimize the flight path angle required to complete it."""
        return self._intf.get_property(VerticalPlaneAndFlightPathOptions._metadata, VerticalPlaneAndFlightPathOptions._get_max_vert_plane_radius_factor_metadata)

    _set_max_vert_plane_radius_factor_metadata = { "offset" : _set_max_vert_plane_radius_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_vert_plane_radius_factor.setter
    def max_vert_plane_radius_factor(self, value:float) -> None:
        """Get or set the maximum amount the radius of vertical curve will be increased to minimize the flight path angle required to complete it."""
        return self._intf.set_property(VerticalPlaneAndFlightPathOptions._metadata, VerticalPlaneAndFlightPathOptions._set_max_vert_plane_radius_factor_metadata, value)

    _property_names[final_flight_path_angle] = "final_flight_path_angle"
    _property_names[min_enroute_flight_path_angle] = "min_enroute_flight_path_angle"
    _property_names[max_enroute_flight_path_angle] = "max_enroute_flight_path_angle"
    _property_names[max_vert_plane_radius_factor] = "max_vert_plane_radius_factor"

    def __init__(self, source_object=None):
        """Construct an object of type VerticalPlaneAndFlightPathOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, VerticalPlaneAndFlightPathOptions)
    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, VerticalPlaneAndFlightPathOptions, [VerticalPlaneAndFlightPathOptions, ])

agcls.AgClassCatalog.add_catalog_entry((4880113513667107889, 8420899053888797363), VerticalPlaneAndFlightPathOptions)
agcls.AgTypeNameMap["VerticalPlaneAndFlightPathOptions"] = VerticalPlaneAndFlightPathOptions

class LandingVerticalPlaneOptions(IVerticalPlaneOptions, SupportsDeleteCallback):
    """Class defining the vertical plane options in a landing procedure."""
    def __init__(self, source_object=None):
        """Construct an object of type LandingVerticalPlaneOptions."""
        SupportsDeleteCallback.__init__(self)
        IVerticalPlaneOptions.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IVerticalPlaneOptions._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, LandingVerticalPlaneOptions, [IVerticalPlaneOptions])

agcls.AgClassCatalog.add_catalog_entry((4626924203837884328, 7628565386577197988), LandingVerticalPlaneOptions)
agcls.AgTypeNameMap["LandingVerticalPlaneOptions"] = LandingVerticalPlaneOptions

class RunwayHeadingOptions(SupportsDeleteCallback):
    """
    Interface for the Runway Heading Options found in a Takeoff or Landing procedure.

    Examples
    --------
    Add a takeoff procedure from a runway:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add a takeoff procedure with a runway as a site
    >>> takeoff = procedures.add(SiteType.SITE_RUNWAY, ProcedureType.PROCEDURE_TAKEOFF)
    >>>
    >>> # Get the runway heading options
    >>> headingOptions = takeoff.runway_heading_options
    >>> # Opt to use the headwind runway
    >>> headingOptions.runway_mode = RunwayHighLowEnd.HEADWIND
    >>>
    >>> # Set the takeoff mode and get that interface
    >>> takeoff.takeoff_mode = TakeoffMode.TAKEOFF_NORMAL
    >>> takeoffNormal = takeoff.mode_as_normal
    >>>
    >>> # Set the takeoff climb angle
    >>> takeoffNormal.takeoff_climb_angle = 5
    >>> # Set the departure altitude above the runway
    >>> takeoffNormal.departure_altitude = 600
    >>> # Set the altitude offset for the runway
    >>> takeoffNormal.runway_altitude_offset = 10
    >>> # Use terrain for the runway's altitude
    >>> takeoffNormal.use_runway_terrain = True

    Add and configure a landing procedure:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add a landing procedure
    >>> landing = procedures.add(SiteType.SITE_RUNWAY, ProcedureType.PROCEDURE_LANDING)
    >>>
    >>> # Get the runway heading options
    >>> headingOptions = landing.runway_heading_options
    >>> # Land from the low end
    >>> headingOptions.runway_mode = RunwayHighLowEnd.LOW_END
    >>>
    >>> # Use a standard instrument approach
    >>> landing.approach_mode = ApproachMode.STANDARD_INSTRUMENT_APPROACH
    >>> # Get the options for a standard instrument approach
    >>> sia = landing.mode_as_standard_instrument_approach
    >>> # Change the approach altitude
    >>> sia.approach_altitude = 1000
    >>> # Change the glideslope
    >>> sia.glideslope = 4
    >>> # Offset the runway altitude
    >>> sia.runway_altitude_offset = 10
    >>> # Use the terrain as an altitude reference for the runway
    >>> sia.use_runway_terrain = True
    """

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_runway_mode_method_offset = 1
    _set_runway_mode_method_offset = 2
    _metadata = {
        "iid_data" : (4772948616711334669, 8458670227314885548),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, RunwayHeadingOptions)

    _get_runway_mode_metadata = { "offset" : _get_runway_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RunwayHighLowEnd),) }
    @property
    def runway_mode(self) -> "RunwayHighLowEnd":
        """Get or set the runway heading that the aircraft will use."""
        return self._intf.get_property(RunwayHeadingOptions._metadata, RunwayHeadingOptions._get_runway_mode_metadata)

    _set_runway_mode_metadata = { "offset" : _set_runway_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(RunwayHighLowEnd),) }
    @runway_mode.setter
    def runway_mode(self, value:"RunwayHighLowEnd") -> None:
        """Get or set the runway heading that the aircraft will use."""
        return self._intf.set_property(RunwayHeadingOptions._metadata, RunwayHeadingOptions._set_runway_mode_metadata, value)

    _property_names[runway_mode] = "runway_mode"

    def __init__(self, source_object=None):
        """Construct an object of type RunwayHeadingOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, RunwayHeadingOptions)
    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, RunwayHeadingOptions, [RunwayHeadingOptions, ])

agcls.AgClassCatalog.add_catalog_entry((5151356003940587454, 7154037557713333679), RunwayHeadingOptions)
agcls.AgTypeNameMap["RunwayHeadingOptions"] = RunwayHeadingOptions

class LandingEnterDownwindPattern(SupportsDeleteCallback):
    """The interface used to access the options for a Downwind Pattern approach mode for a landing procedure. The approach mode must be set to Downwind Pattern to access this interface."""

    _num_methods = 18
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_approach_fix_range_method_offset = 1
    _set_approach_fix_range_method_offset = 2
    _get_approach_fix_range_mode_method_offset = 3
    _set_approach_fix_range_mode_method_offset = 4
    _get_abeam_distance_method_offset = 5
    _set_abeam_distance_method_offset = 6
    _get_abeam_altitude_method_offset = 7
    _set_abeam_altitude_method_offset = 8
    _get_final_turn_method_offset = 9
    _set_final_turn_method_offset = 10
    _get_glideslope_method_offset = 11
    _set_glideslope_method_offset = 12
    _get_runway_altitude_offset_method_offset = 13
    _set_runway_altitude_offset_method_offset = 14
    _get_use_runway_terrain_method_offset = 15
    _set_use_runway_terrain_method_offset = 16
    _get_touch_and_go_method_offset = 17
    _set_touch_and_go_method_offset = 18
    _metadata = {
        "iid_data" : (4734513232810016191, 3083046802263741063),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, LandingEnterDownwindPattern)

    _get_approach_fix_range_metadata = { "offset" : _get_approach_fix_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def approach_fix_range(self) -> float:
        """Get or set the range from the reference point of the runway at which the aircraft begins its landing approach."""
        return self._intf.get_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._get_approach_fix_range_metadata)

    _set_approach_fix_range_metadata = { "offset" : _set_approach_fix_range_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @approach_fix_range.setter
    def approach_fix_range(self, value:float) -> None:
        """Get or set the range from the reference point of the runway at which the aircraft begins its landing approach."""
        return self._intf.set_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._set_approach_fix_range_metadata, value)

    _get_approach_fix_range_mode_metadata = { "offset" : _get_approach_fix_range_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(LandingApproachFixRangeMode),) }
    @property
    def approach_fix_range_mode(self) -> "LandingApproachFixRangeMode":
        """Get or set the reference point on the runway for the Approach Fix Range."""
        return self._intf.get_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._get_approach_fix_range_mode_metadata)

    _set_approach_fix_range_mode_metadata = { "offset" : _set_approach_fix_range_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(LandingApproachFixRangeMode),) }
    @approach_fix_range_mode.setter
    def approach_fix_range_mode(self, value:"LandingApproachFixRangeMode") -> None:
        """Get or set the reference point on the runway for the Approach Fix Range."""
        return self._intf.set_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._set_approach_fix_range_mode_metadata, value)

    _get_abeam_distance_metadata = { "offset" : _get_abeam_distance_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def abeam_distance(self) -> float:
        """Get or set the distance from the runway that the aircraft will fly the parallel leg of the landing pattern."""
        return self._intf.get_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._get_abeam_distance_metadata)

    _set_abeam_distance_metadata = { "offset" : _set_abeam_distance_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @abeam_distance.setter
    def abeam_distance(self, value:float) -> None:
        """Get or set the distance from the runway that the aircraft will fly the parallel leg of the landing pattern."""
        return self._intf.set_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._set_abeam_distance_metadata, value)

    _get_abeam_altitude_metadata = { "offset" : _get_abeam_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def abeam_altitude(self) -> float:
        """Get or set the altitude at which the aircraft will fly the parallel leg of the landing pattern."""
        return self._intf.get_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._get_abeam_altitude_metadata)

    _set_abeam_altitude_metadata = { "offset" : _set_abeam_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @abeam_altitude.setter
    def abeam_altitude(self, value:float) -> None:
        """Get or set the altitude at which the aircraft will fly the parallel leg of the landing pattern."""
        return self._intf.set_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._set_abeam_altitude_metadata, value)

    _get_final_turn_metadata = { "offset" : _get_final_turn_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(NavigatorTurnDirection),) }
    @property
    def final_turn(self) -> "NavigatorTurnDirection":
        """Get or set the direction of the turn that the aircraft will make when it lines up over the runway to land."""
        return self._intf.get_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._get_final_turn_metadata)

    _set_final_turn_metadata = { "offset" : _set_final_turn_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(NavigatorTurnDirection),) }
    @final_turn.setter
    def final_turn(self, value:"NavigatorTurnDirection") -> None:
        """Get or set the direction of the turn that the aircraft will make when it lines up over the runway to land."""
        return self._intf.set_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._set_final_turn_metadata, value)

    _get_glideslope_metadata = { "offset" : _get_glideslope_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def glideslope(self) -> typing.Any:
        """Get or set the angle from the horizontal on which the aircraft descends to touchdown."""
        return self._intf.get_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._get_glideslope_metadata)

    _set_glideslope_metadata = { "offset" : _set_glideslope_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @glideslope.setter
    def glideslope(self, value:typing.Any) -> None:
        """Get or set the angle from the horizontal on which the aircraft descends to touchdown."""
        return self._intf.set_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._set_glideslope_metadata, value)

    _get_runway_altitude_offset_metadata = { "offset" : _get_runway_altitude_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def runway_altitude_offset(self) -> float:
        """Get or set the altitude offset above the ground level."""
        return self._intf.get_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._get_runway_altitude_offset_metadata)

    _set_runway_altitude_offset_metadata = { "offset" : _set_runway_altitude_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @runway_altitude_offset.setter
    def runway_altitude_offset(self, value:float) -> None:
        """Get or set the altitude offset above the ground level."""
        return self._intf.set_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._set_runway_altitude_offset_metadata, value)

    _get_use_runway_terrain_metadata = { "offset" : _get_use_runway_terrain_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_runway_terrain(self) -> bool:
        """Opt whether to use terrain data to define the runway's ground level attitude."""
        return self._intf.get_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._get_use_runway_terrain_metadata)

    _set_use_runway_terrain_metadata = { "offset" : _set_use_runway_terrain_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_runway_terrain.setter
    def use_runway_terrain(self, value:bool) -> None:
        """Opt whether to use terrain data to define the runway's ground level attitude."""
        return self._intf.set_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._set_use_runway_terrain_metadata, value)

    _get_touch_and_go_metadata = { "offset" : _get_touch_and_go_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def touch_and_go(self) -> bool:
        """Opt whether to perform a Touch and Go landing. The procedure will stop at wheels down and can be immediately followed by a takeoff procedure."""
        return self._intf.get_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._get_touch_and_go_metadata)

    _set_touch_and_go_metadata = { "offset" : _set_touch_and_go_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @touch_and_go.setter
    def touch_and_go(self, value:bool) -> None:
        """Opt whether to perform a Touch and Go landing. The procedure will stop at wheels down and can be immediately followed by a takeoff procedure."""
        return self._intf.set_property(LandingEnterDownwindPattern._metadata, LandingEnterDownwindPattern._set_touch_and_go_metadata, value)

    _property_names[approach_fix_range] = "approach_fix_range"
    _property_names[approach_fix_range_mode] = "approach_fix_range_mode"
    _property_names[abeam_distance] = "abeam_distance"
    _property_names[abeam_altitude] = "abeam_altitude"
    _property_names[final_turn] = "final_turn"
    _property_names[glideslope] = "glideslope"
    _property_names[runway_altitude_offset] = "runway_altitude_offset"
    _property_names[use_runway_terrain] = "use_runway_terrain"
    _property_names[touch_and_go] = "touch_and_go"

    def __init__(self, source_object=None):
        """Construct an object of type LandingEnterDownwindPattern."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, LandingEnterDownwindPattern)
    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, LandingEnterDownwindPattern, [LandingEnterDownwindPattern, ])

agcls.AgClassCatalog.add_catalog_entry((5264644757506879488, 10964076385913793182), LandingEnterDownwindPattern)
agcls.AgTypeNameMap["LandingEnterDownwindPattern"] = LandingEnterDownwindPattern

class LandingInterceptGlideslope(SupportsDeleteCallback):
    """The interface used to access the options for an Intercept Glideslope approach mode for a landing procedure. The approach mode must be set to Intercept Glideslope to access this interface."""

    _num_methods = 12
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_approach_fix_range_method_offset = 1
    _set_approach_fix_range_method_offset = 2
    _get_approach_fix_range_mode_method_offset = 3
    _set_approach_fix_range_mode_method_offset = 4
    _get_glideslope_method_offset = 5
    _set_glideslope_method_offset = 6
    _get_runway_altitude_offset_method_offset = 7
    _set_runway_altitude_offset_method_offset = 8
    _get_use_runway_terrain_method_offset = 9
    _set_use_runway_terrain_method_offset = 10
    _get_touch_and_go_method_offset = 11
    _set_touch_and_go_method_offset = 12
    _metadata = {
        "iid_data" : (4722193432406915614, 3919694554656369318),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, LandingInterceptGlideslope)

    _get_approach_fix_range_metadata = { "offset" : _get_approach_fix_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def approach_fix_range(self) -> float:
        """Get or set the range from the reference point of the runway at which the aircraft begins its landing approach."""
        return self._intf.get_property(LandingInterceptGlideslope._metadata, LandingInterceptGlideslope._get_approach_fix_range_metadata)

    _set_approach_fix_range_metadata = { "offset" : _set_approach_fix_range_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @approach_fix_range.setter
    def approach_fix_range(self, value:float) -> None:
        """Get or set the range from the reference point of the runway at which the aircraft begins its landing approach."""
        return self._intf.set_property(LandingInterceptGlideslope._metadata, LandingInterceptGlideslope._set_approach_fix_range_metadata, value)

    _get_approach_fix_range_mode_metadata = { "offset" : _get_approach_fix_range_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(LandingApproachFixRangeMode),) }
    @property
    def approach_fix_range_mode(self) -> "LandingApproachFixRangeMode":
        """Get or set the reference point on the runway for the Approach Fix Range."""
        return self._intf.get_property(LandingInterceptGlideslope._metadata, LandingInterceptGlideslope._get_approach_fix_range_mode_metadata)

    _set_approach_fix_range_mode_metadata = { "offset" : _set_approach_fix_range_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(LandingApproachFixRangeMode),) }
    @approach_fix_range_mode.setter
    def approach_fix_range_mode(self, value:"LandingApproachFixRangeMode") -> None:
        """Get or set the reference point on the runway for the Approach Fix Range."""
        return self._intf.set_property(LandingInterceptGlideslope._metadata, LandingInterceptGlideslope._set_approach_fix_range_mode_metadata, value)

    _get_glideslope_metadata = { "offset" : _get_glideslope_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def glideslope(self) -> typing.Any:
        """Get or set the angle from the horizontal on which the aircraft descends to touchdown."""
        return self._intf.get_property(LandingInterceptGlideslope._metadata, LandingInterceptGlideslope._get_glideslope_metadata)

    _set_glideslope_metadata = { "offset" : _set_glideslope_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @glideslope.setter
    def glideslope(self, value:typing.Any) -> None:
        """Get or set the angle from the horizontal on which the aircraft descends to touchdown."""
        return self._intf.set_property(LandingInterceptGlideslope._metadata, LandingInterceptGlideslope._set_glideslope_metadata, value)

    _get_runway_altitude_offset_metadata = { "offset" : _get_runway_altitude_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def runway_altitude_offset(self) -> float:
        """Get or set the altitude offset above the ground level."""
        return self._intf.get_property(LandingInterceptGlideslope._metadata, LandingInterceptGlideslope._get_runway_altitude_offset_metadata)

    _set_runway_altitude_offset_metadata = { "offset" : _set_runway_altitude_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @runway_altitude_offset.setter
    def runway_altitude_offset(self, value:float) -> None:
        """Get or set the altitude offset above the ground level."""
        return self._intf.set_property(LandingInterceptGlideslope._metadata, LandingInterceptGlideslope._set_runway_altitude_offset_metadata, value)

    _get_use_runway_terrain_metadata = { "offset" : _get_use_runway_terrain_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_runway_terrain(self) -> bool:
        """Opt whether to use terrain data to define the runway's ground level attitude."""
        return self._intf.get_property(LandingInterceptGlideslope._metadata, LandingInterceptGlideslope._get_use_runway_terrain_metadata)

    _set_use_runway_terrain_metadata = { "offset" : _set_use_runway_terrain_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_runway_terrain.setter
    def use_runway_terrain(self, value:bool) -> None:
        """Opt whether to use terrain data to define the runway's ground level attitude."""
        return self._intf.set_property(LandingInterceptGlideslope._metadata, LandingInterceptGlideslope._set_use_runway_terrain_metadata, value)

    _get_touch_and_go_metadata = { "offset" : _get_touch_and_go_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def touch_and_go(self) -> bool:
        """Opt whether to perform a Touch and Go landing. The procedure will stop at wheels down and can be immediately followed by a takeoff procedure."""
        return self._intf.get_property(LandingInterceptGlideslope._metadata, LandingInterceptGlideslope._get_touch_and_go_metadata)

    _set_touch_and_go_metadata = { "offset" : _set_touch_and_go_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @touch_and_go.setter
    def touch_and_go(self, value:bool) -> None:
        """Opt whether to perform a Touch and Go landing. The procedure will stop at wheels down and can be immediately followed by a takeoff procedure."""
        return self._intf.set_property(LandingInterceptGlideslope._metadata, LandingInterceptGlideslope._set_touch_and_go_metadata, value)

    _property_names[approach_fix_range] = "approach_fix_range"
    _property_names[approach_fix_range_mode] = "approach_fix_range_mode"
    _property_names[glideslope] = "glideslope"
    _property_names[runway_altitude_offset] = "runway_altitude_offset"
    _property_names[use_runway_terrain] = "use_runway_terrain"
    _property_names[touch_and_go] = "touch_and_go"

    def __init__(self, source_object=None):
        """Construct an object of type LandingInterceptGlideslope."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, LandingInterceptGlideslope)
    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, LandingInterceptGlideslope, [LandingInterceptGlideslope, ])

agcls.AgClassCatalog.add_catalog_entry((5366344207817725495, 12409533042992159899), LandingInterceptGlideslope)
agcls.AgTypeNameMap["LandingInterceptGlideslope"] = LandingInterceptGlideslope

class LandingStandardInstrumentApproach(SupportsDeleteCallback):
    """
    The interface used to access the options for a Standard Instrument Approach mode for a landing procedure. The approach mode must be set to Standard Instrument Approach to access this interface.

    Examples
    --------
    Add and configure a landing procedure:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add a landing procedure
    >>> landing = procedures.add(SiteType.SITE_RUNWAY, ProcedureType.PROCEDURE_LANDING)
    >>>
    >>> # Get the runway heading options
    >>> headingOptions = landing.runway_heading_options
    >>> # Land from the low end
    >>> headingOptions.runway_mode = RunwayHighLowEnd.LOW_END
    >>>
    >>> # Use a standard instrument approach
    >>> landing.approach_mode = ApproachMode.STANDARD_INSTRUMENT_APPROACH
    >>> # Get the options for a standard instrument approach
    >>> sia = landing.mode_as_standard_instrument_approach
    >>> # Change the approach altitude
    >>> sia.approach_altitude = 1000
    >>> # Change the glideslope
    >>> sia.glideslope = 4
    >>> # Offset the runway altitude
    >>> sia.runway_altitude_offset = 10
    >>> # Use the terrain as an altitude reference for the runway
    >>> sia.use_runway_terrain = True
    """

    _num_methods = 16
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_approach_altitude_method_offset = 1
    _set_approach_altitude_method_offset = 2
    _get_level_off_mode_method_offset = 3
    _set_level_off_mode_method_offset = 4
    _get_approach_fix_range_method_offset = 5
    _set_approach_fix_range_method_offset = 6
    _get_approach_fix_range_mode_method_offset = 7
    _set_approach_fix_range_mode_method_offset = 8
    _get_glideslope_method_offset = 9
    _set_glideslope_method_offset = 10
    _get_runway_altitude_offset_method_offset = 11
    _set_runway_altitude_offset_method_offset = 12
    _get_use_runway_terrain_method_offset = 13
    _set_use_runway_terrain_method_offset = 14
    _get_touch_and_go_method_offset = 15
    _set_touch_and_go_method_offset = 16
    _metadata = {
        "iid_data" : (5318231538284992196, 1134507381071316131),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, LandingStandardInstrumentApproach)

    _get_approach_altitude_metadata = { "offset" : _get_approach_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def approach_altitude(self) -> float:
        """Get or set the aircraft's altitude at the Initial Approach Fix Range."""
        return self._intf.get_property(LandingStandardInstrumentApproach._metadata, LandingStandardInstrumentApproach._get_approach_altitude_metadata)

    _set_approach_altitude_metadata = { "offset" : _set_approach_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @approach_altitude.setter
    def approach_altitude(self, value:float) -> None:
        """Get or set the aircraft's altitude at the Initial Approach Fix Range."""
        return self._intf.set_property(LandingStandardInstrumentApproach._metadata, LandingStandardInstrumentApproach._set_approach_altitude_metadata, value)

    _get_level_off_mode_metadata = { "offset" : _get_level_off_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AltitudeConstraintManeuverMode),) }
    @property
    def level_off_mode(self) -> "AltitudeConstraintManeuverMode":
        """Get or set the level off mode. This is only used when the must level off option is on."""
        return self._intf.get_property(LandingStandardInstrumentApproach._metadata, LandingStandardInstrumentApproach._get_level_off_mode_metadata)

    _set_level_off_mode_metadata = { "offset" : _set_level_off_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AltitudeConstraintManeuverMode),) }
    @level_off_mode.setter
    def level_off_mode(self, value:"AltitudeConstraintManeuverMode") -> None:
        """Get or set the level off mode. This is only used when the must level off option is on."""
        return self._intf.set_property(LandingStandardInstrumentApproach._metadata, LandingStandardInstrumentApproach._set_level_off_mode_metadata, value)

    _get_approach_fix_range_metadata = { "offset" : _get_approach_fix_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def approach_fix_range(self) -> float:
        """Get or set the range from the reference point of the runway at which the aircraft begins its landing approach."""
        return self._intf.get_property(LandingStandardInstrumentApproach._metadata, LandingStandardInstrumentApproach._get_approach_fix_range_metadata)

    _set_approach_fix_range_metadata = { "offset" : _set_approach_fix_range_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @approach_fix_range.setter
    def approach_fix_range(self, value:float) -> None:
        """Get or set the range from the reference point of the runway at which the aircraft begins its landing approach."""
        return self._intf.set_property(LandingStandardInstrumentApproach._metadata, LandingStandardInstrumentApproach._set_approach_fix_range_metadata, value)

    _get_approach_fix_range_mode_metadata = { "offset" : _get_approach_fix_range_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(LandingApproachFixRangeMode),) }
    @property
    def approach_fix_range_mode(self) -> "LandingApproachFixRangeMode":
        """Get or set the reference point on the runway for the Approach Fix Range."""
        return self._intf.get_property(LandingStandardInstrumentApproach._metadata, LandingStandardInstrumentApproach._get_approach_fix_range_mode_metadata)

    _set_approach_fix_range_mode_metadata = { "offset" : _set_approach_fix_range_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(LandingApproachFixRangeMode),) }
    @approach_fix_range_mode.setter
    def approach_fix_range_mode(self, value:"LandingApproachFixRangeMode") -> None:
        """Get or set the reference point on the runway for the Approach Fix Range."""
        return self._intf.set_property(LandingStandardInstrumentApproach._metadata, LandingStandardInstrumentApproach._set_approach_fix_range_mode_metadata, value)

    _get_glideslope_metadata = { "offset" : _get_glideslope_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def glideslope(self) -> typing.Any:
        """Get or set the angle from the horizontal on which the aircraft descends to touchdown."""
        return self._intf.get_property(LandingStandardInstrumentApproach._metadata, LandingStandardInstrumentApproach._get_glideslope_metadata)

    _set_glideslope_metadata = { "offset" : _set_glideslope_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @glideslope.setter
    def glideslope(self, value:typing.Any) -> None:
        """Get or set the angle from the horizontal on which the aircraft descends to touchdown."""
        return self._intf.set_property(LandingStandardInstrumentApproach._metadata, LandingStandardInstrumentApproach._set_glideslope_metadata, value)

    _get_runway_altitude_offset_metadata = { "offset" : _get_runway_altitude_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def runway_altitude_offset(self) -> float:
        """Get or set the altitude offset above the ground level."""
        return self._intf.get_property(LandingStandardInstrumentApproach._metadata, LandingStandardInstrumentApproach._get_runway_altitude_offset_metadata)

    _set_runway_altitude_offset_metadata = { "offset" : _set_runway_altitude_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @runway_altitude_offset.setter
    def runway_altitude_offset(self, value:float) -> None:
        """Get or set the altitude offset above the ground level."""
        return self._intf.set_property(LandingStandardInstrumentApproach._metadata, LandingStandardInstrumentApproach._set_runway_altitude_offset_metadata, value)

    _get_use_runway_terrain_metadata = { "offset" : _get_use_runway_terrain_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_runway_terrain(self) -> bool:
        """Opt whether to use terrain data to define the runway's ground level attitude."""
        return self._intf.get_property(LandingStandardInstrumentApproach._metadata, LandingStandardInstrumentApproach._get_use_runway_terrain_metadata)

    _set_use_runway_terrain_metadata = { "offset" : _set_use_runway_terrain_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_runway_terrain.setter
    def use_runway_terrain(self, value:bool) -> None:
        """Opt whether to use terrain data to define the runway's ground level attitude."""
        return self._intf.set_property(LandingStandardInstrumentApproach._metadata, LandingStandardInstrumentApproach._set_use_runway_terrain_metadata, value)

    _get_touch_and_go_metadata = { "offset" : _get_touch_and_go_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def touch_and_go(self) -> bool:
        """Opt whether to perform a Touch and Go landing. The procedure will stop at wheels down and can be immediately followed by a takeoff procedure."""
        return self._intf.get_property(LandingStandardInstrumentApproach._metadata, LandingStandardInstrumentApproach._get_touch_and_go_metadata)

    _set_touch_and_go_metadata = { "offset" : _set_touch_and_go_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @touch_and_go.setter
    def touch_and_go(self, value:bool) -> None:
        """Opt whether to perform a Touch and Go landing. The procedure will stop at wheels down and can be immediately followed by a takeoff procedure."""
        return self._intf.set_property(LandingStandardInstrumentApproach._metadata, LandingStandardInstrumentApproach._set_touch_and_go_metadata, value)

    _property_names[approach_altitude] = "approach_altitude"
    _property_names[level_off_mode] = "level_off_mode"
    _property_names[approach_fix_range] = "approach_fix_range"
    _property_names[approach_fix_range_mode] = "approach_fix_range_mode"
    _property_names[glideslope] = "glideslope"
    _property_names[runway_altitude_offset] = "runway_altitude_offset"
    _property_names[use_runway_terrain] = "use_runway_terrain"
    _property_names[touch_and_go] = "touch_and_go"

    def __init__(self, source_object=None):
        """Construct an object of type LandingStandardInstrumentApproach."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, LandingStandardInstrumentApproach)
    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, LandingStandardInstrumentApproach, [LandingStandardInstrumentApproach, ])

agcls.AgClassCatalog.add_catalog_entry((4840677424178112842, 5244220578861766065), LandingStandardInstrumentApproach)
agcls.AgTypeNameMap["LandingStandardInstrumentApproach"] = LandingStandardInstrumentApproach

class TakeoffDeparturePoint(SupportsDeleteCallback):
    """The interface used to access the options for a Departure Point takeoff mode. The mode must be set to Departure Point to access this interface."""

    _num_methods = 12
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_takeoff_climb_angle_method_offset = 1
    _set_takeoff_climb_angle_method_offset = 2
    _get_departure_altitude_method_offset = 3
    _set_departure_altitude_method_offset = 4
    _get_departure_point_range_method_offset = 5
    _set_departure_point_range_method_offset = 6
    _get_use_runway_terrain_method_offset = 7
    _set_use_runway_terrain_method_offset = 8
    _get_runway_altitude_offset_method_offset = 9
    _set_runway_altitude_offset_method_offset = 10
    _get_hold_on_deck_method_offset = 11
    _set_hold_on_deck_method_offset = 12
    _metadata = {
        "iid_data" : (5384974105934402717, 12902722603171464861),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, TakeoffDeparturePoint)

    _get_takeoff_climb_angle_metadata = { "offset" : _get_takeoff_climb_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def takeoff_climb_angle(self) -> typing.Any:
        """Get or set the angle at which the aircraft will climb from the procedure site to the departure point."""
        return self._intf.get_property(TakeoffDeparturePoint._metadata, TakeoffDeparturePoint._get_takeoff_climb_angle_metadata)

    _set_takeoff_climb_angle_metadata = { "offset" : _set_takeoff_climb_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @takeoff_climb_angle.setter
    def takeoff_climb_angle(self, value:typing.Any) -> None:
        """Get or set the angle at which the aircraft will climb from the procedure site to the departure point."""
        return self._intf.set_property(TakeoffDeparturePoint._metadata, TakeoffDeparturePoint._set_takeoff_climb_angle_metadata, value)

    _get_departure_altitude_metadata = { "offset" : _get_departure_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def departure_altitude(self) -> float:
        """Get or set the aircraft's altitude when it departs the runway."""
        return self._intf.get_property(TakeoffDeparturePoint._metadata, TakeoffDeparturePoint._get_departure_altitude_metadata)

    _set_departure_altitude_metadata = { "offset" : _set_departure_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @departure_altitude.setter
    def departure_altitude(self, value:float) -> None:
        """Get or set the aircraft's altitude when it departs the runway."""
        return self._intf.set_property(TakeoffDeparturePoint._metadata, TakeoffDeparturePoint._set_departure_altitude_metadata, value)

    _get_departure_point_range_metadata = { "offset" : _get_departure_point_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def departure_point_range(self) -> float:
        """Get or set the downrange distance the aircraft will travel when departing the runway."""
        return self._intf.get_property(TakeoffDeparturePoint._metadata, TakeoffDeparturePoint._get_departure_point_range_metadata)

    _set_departure_point_range_metadata = { "offset" : _set_departure_point_range_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @departure_point_range.setter
    def departure_point_range(self, value:float) -> None:
        """Get or set the downrange distance the aircraft will travel when departing the runway."""
        return self._intf.set_property(TakeoffDeparturePoint._metadata, TakeoffDeparturePoint._set_departure_point_range_metadata, value)

    _get_use_runway_terrain_metadata = { "offset" : _get_use_runway_terrain_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_runway_terrain(self) -> bool:
        """Opt whether to use terrain data to define the runway's ground level attitude."""
        return self._intf.get_property(TakeoffDeparturePoint._metadata, TakeoffDeparturePoint._get_use_runway_terrain_metadata)

    _set_use_runway_terrain_metadata = { "offset" : _set_use_runway_terrain_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_runway_terrain.setter
    def use_runway_terrain(self, value:bool) -> None:
        """Opt whether to use terrain data to define the runway's ground level attitude."""
        return self._intf.set_property(TakeoffDeparturePoint._metadata, TakeoffDeparturePoint._set_use_runway_terrain_metadata, value)

    _get_runway_altitude_offset_metadata = { "offset" : _get_runway_altitude_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def runway_altitude_offset(self) -> float:
        """Get or set the altitude offset above the ground level."""
        return self._intf.get_property(TakeoffDeparturePoint._metadata, TakeoffDeparturePoint._get_runway_altitude_offset_metadata)

    _set_runway_altitude_offset_metadata = { "offset" : _set_runway_altitude_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @runway_altitude_offset.setter
    def runway_altitude_offset(self, value:float) -> None:
        """Get or set the altitude offset above the ground level."""
        return self._intf.set_property(TakeoffDeparturePoint._metadata, TakeoffDeparturePoint._set_runway_altitude_offset_metadata, value)

    _get_hold_on_deck_metadata = { "offset" : _get_hold_on_deck_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def hold_on_deck(self) -> typing.Any:
        """Get or set the duration the aircraft will wait before beginning the takeoff."""
        return self._intf.get_property(TakeoffDeparturePoint._metadata, TakeoffDeparturePoint._get_hold_on_deck_metadata)

    _set_hold_on_deck_metadata = { "offset" : _set_hold_on_deck_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @hold_on_deck.setter
    def hold_on_deck(self, value:typing.Any) -> None:
        """Get or set the duration the aircraft will wait before beginning the takeoff."""
        return self._intf.set_property(TakeoffDeparturePoint._metadata, TakeoffDeparturePoint._set_hold_on_deck_metadata, value)

    _property_names[takeoff_climb_angle] = "takeoff_climb_angle"
    _property_names[departure_altitude] = "departure_altitude"
    _property_names[departure_point_range] = "departure_point_range"
    _property_names[use_runway_terrain] = "use_runway_terrain"
    _property_names[runway_altitude_offset] = "runway_altitude_offset"
    _property_names[hold_on_deck] = "hold_on_deck"

    def __init__(self, source_object=None):
        """Construct an object of type TakeoffDeparturePoint."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, TakeoffDeparturePoint)
    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, TakeoffDeparturePoint, [TakeoffDeparturePoint, ])

agcls.AgClassCatalog.add_catalog_entry((5170363125142911430, 3874157076900173501), TakeoffDeparturePoint)
agcls.AgTypeNameMap["TakeoffDeparturePoint"] = TakeoffDeparturePoint

class TakeoffLowTransition(SupportsDeleteCallback):
    """The interface used to access the options for a Low Transition takeoff mode. The mode must be set to Low Transition to access this interface."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_runway_terrain_method_offset = 1
    _set_use_runway_terrain_method_offset = 2
    _get_runway_altitude_offset_method_offset = 3
    _set_runway_altitude_offset_method_offset = 4
    _get_hold_on_deck_method_offset = 5
    _set_hold_on_deck_method_offset = 6
    _metadata = {
        "iid_data" : (5665343166367508418, 13893054072396564138),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, TakeoffLowTransition)

    _get_use_runway_terrain_metadata = { "offset" : _get_use_runway_terrain_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_runway_terrain(self) -> bool:
        """Opt whether to use terrain data to define the runway's ground level attitude."""
        return self._intf.get_property(TakeoffLowTransition._metadata, TakeoffLowTransition._get_use_runway_terrain_metadata)

    _set_use_runway_terrain_metadata = { "offset" : _set_use_runway_terrain_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_runway_terrain.setter
    def use_runway_terrain(self, value:bool) -> None:
        """Opt whether to use terrain data to define the runway's ground level attitude."""
        return self._intf.set_property(TakeoffLowTransition._metadata, TakeoffLowTransition._set_use_runway_terrain_metadata, value)

    _get_runway_altitude_offset_metadata = { "offset" : _get_runway_altitude_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def runway_altitude_offset(self) -> float:
        """Get or set the altitude offset above the ground level."""
        return self._intf.get_property(TakeoffLowTransition._metadata, TakeoffLowTransition._get_runway_altitude_offset_metadata)

    _set_runway_altitude_offset_metadata = { "offset" : _set_runway_altitude_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @runway_altitude_offset.setter
    def runway_altitude_offset(self, value:float) -> None:
        """Get or set the altitude offset above the ground level."""
        return self._intf.set_property(TakeoffLowTransition._metadata, TakeoffLowTransition._set_runway_altitude_offset_metadata, value)

    _get_hold_on_deck_metadata = { "offset" : _get_hold_on_deck_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def hold_on_deck(self) -> typing.Any:
        """Get or set the duration the aircraft will wait before beginning the takeoff."""
        return self._intf.get_property(TakeoffLowTransition._metadata, TakeoffLowTransition._get_hold_on_deck_metadata)

    _set_hold_on_deck_metadata = { "offset" : _set_hold_on_deck_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @hold_on_deck.setter
    def hold_on_deck(self, value:typing.Any) -> None:
        """Get or set the duration the aircraft will wait before beginning the takeoff."""
        return self._intf.set_property(TakeoffLowTransition._metadata, TakeoffLowTransition._set_hold_on_deck_metadata, value)

    _property_names[use_runway_terrain] = "use_runway_terrain"
    _property_names[runway_altitude_offset] = "runway_altitude_offset"
    _property_names[hold_on_deck] = "hold_on_deck"

    def __init__(self, source_object=None):
        """Construct an object of type TakeoffLowTransition."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, TakeoffLowTransition)
    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, TakeoffLowTransition, [TakeoffLowTransition, ])

agcls.AgClassCatalog.add_catalog_entry((5668791560561038875, 16923029776143935925), TakeoffLowTransition)
agcls.AgTypeNameMap["TakeoffLowTransition"] = TakeoffLowTransition

class TakeoffNormal(SupportsDeleteCallback):
    """
    The interface used to access the options for a Normal takeoff mode. The mode must be set to Normal to access this interface.

    Examples
    --------
    Add a takeoff procedure from a runway:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add a takeoff procedure with a runway as a site
    >>> takeoff = procedures.add(SiteType.SITE_RUNWAY, ProcedureType.PROCEDURE_TAKEOFF)
    >>>
    >>> # Get the runway heading options
    >>> headingOptions = takeoff.runway_heading_options
    >>> # Opt to use the headwind runway
    >>> headingOptions.runway_mode = RunwayHighLowEnd.HEADWIND
    >>>
    >>> # Set the takeoff mode and get that interface
    >>> takeoff.takeoff_mode = TakeoffMode.TAKEOFF_NORMAL
    >>> takeoffNormal = takeoff.mode_as_normal
    >>>
    >>> # Set the takeoff climb angle
    >>> takeoffNormal.takeoff_climb_angle = 5
    >>> # Set the departure altitude above the runway
    >>> takeoffNormal.departure_altitude = 600
    >>> # Set the altitude offset for the runway
    >>> takeoffNormal.runway_altitude_offset = 10
    >>> # Use terrain for the runway's altitude
    >>> takeoffNormal.use_runway_terrain = True
    """

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_takeoff_climb_angle_method_offset = 1
    _set_takeoff_climb_angle_method_offset = 2
    _get_departure_altitude_method_offset = 3
    _set_departure_altitude_method_offset = 4
    _get_use_runway_terrain_method_offset = 5
    _set_use_runway_terrain_method_offset = 6
    _get_runway_altitude_offset_method_offset = 7
    _set_runway_altitude_offset_method_offset = 8
    _get_hold_on_deck_method_offset = 9
    _set_hold_on_deck_method_offset = 10
    _metadata = {
        "iid_data" : (5498845233375819305, 14637385257810436005),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, TakeoffNormal)

    _get_takeoff_climb_angle_metadata = { "offset" : _get_takeoff_climb_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def takeoff_climb_angle(self) -> typing.Any:
        """Get or set the angle at which the aircraft will climb from the procedure site to the departure point."""
        return self._intf.get_property(TakeoffNormal._metadata, TakeoffNormal._get_takeoff_climb_angle_metadata)

    _set_takeoff_climb_angle_metadata = { "offset" : _set_takeoff_climb_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @takeoff_climb_angle.setter
    def takeoff_climb_angle(self, value:typing.Any) -> None:
        """Get or set the angle at which the aircraft will climb from the procedure site to the departure point."""
        return self._intf.set_property(TakeoffNormal._metadata, TakeoffNormal._set_takeoff_climb_angle_metadata, value)

    _get_departure_altitude_metadata = { "offset" : _get_departure_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def departure_altitude(self) -> float:
        """Get or set the aircraft's altitude when it departs the runway."""
        return self._intf.get_property(TakeoffNormal._metadata, TakeoffNormal._get_departure_altitude_metadata)

    _set_departure_altitude_metadata = { "offset" : _set_departure_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @departure_altitude.setter
    def departure_altitude(self, value:float) -> None:
        """Get or set the aircraft's altitude when it departs the runway."""
        return self._intf.set_property(TakeoffNormal._metadata, TakeoffNormal._set_departure_altitude_metadata, value)

    _get_use_runway_terrain_metadata = { "offset" : _get_use_runway_terrain_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_runway_terrain(self) -> bool:
        """Opt whether to use terrain data to define the runway's ground level attitude."""
        return self._intf.get_property(TakeoffNormal._metadata, TakeoffNormal._get_use_runway_terrain_metadata)

    _set_use_runway_terrain_metadata = { "offset" : _set_use_runway_terrain_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_runway_terrain.setter
    def use_runway_terrain(self, value:bool) -> None:
        """Opt whether to use terrain data to define the runway's ground level attitude."""
        return self._intf.set_property(TakeoffNormal._metadata, TakeoffNormal._set_use_runway_terrain_metadata, value)

    _get_runway_altitude_offset_metadata = { "offset" : _get_runway_altitude_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def runway_altitude_offset(self) -> float:
        """Get or set the altitude offset above the ground level."""
        return self._intf.get_property(TakeoffNormal._metadata, TakeoffNormal._get_runway_altitude_offset_metadata)

    _set_runway_altitude_offset_metadata = { "offset" : _set_runway_altitude_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @runway_altitude_offset.setter
    def runway_altitude_offset(self, value:float) -> None:
        """Get or set the altitude offset above the ground level."""
        return self._intf.set_property(TakeoffNormal._metadata, TakeoffNormal._set_runway_altitude_offset_metadata, value)

    _get_hold_on_deck_metadata = { "offset" : _get_hold_on_deck_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def hold_on_deck(self) -> typing.Any:
        """Get or set the duration the aircraft will wait before beginning the takeoff."""
        return self._intf.get_property(TakeoffNormal._metadata, TakeoffNormal._get_hold_on_deck_metadata)

    _set_hold_on_deck_metadata = { "offset" : _set_hold_on_deck_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @hold_on_deck.setter
    def hold_on_deck(self, value:typing.Any) -> None:
        """Get or set the duration the aircraft will wait before beginning the takeoff."""
        return self._intf.set_property(TakeoffNormal._metadata, TakeoffNormal._set_hold_on_deck_metadata, value)

    _property_names[takeoff_climb_angle] = "takeoff_climb_angle"
    _property_names[departure_altitude] = "departure_altitude"
    _property_names[use_runway_terrain] = "use_runway_terrain"
    _property_names[runway_altitude_offset] = "runway_altitude_offset"
    _property_names[hold_on_deck] = "hold_on_deck"

    def __init__(self, source_object=None):
        """Construct an object of type TakeoffNormal."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, TakeoffNormal)
    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, TakeoffNormal, [TakeoffNormal, ])

agcls.AgClassCatalog.add_catalog_entry((4982205817421927695, 3283745831502333602), TakeoffNormal)
agcls.AgTypeNameMap["TakeoffNormal"] = TakeoffNormal

class LevelTurns(SupportsDeleteCallback):
    """
    Interface used to access the Level Turns Transitions options found in the Basic Acceleration Model of an aircraft.

    Examples
    --------
    Configure the basic acceleration performance model of an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the acceleration type
    >>> acceleration = aviatorAircraft.acceleration
    >>> # Get the build in performance model
    >>> basicAccModel = acceleration.get_built_in_model()
    >>>
    >>> # Get the level turns options
    >>> levelTurns = basicAccModel.level_turns
    >>> # Set a max bank angle of 25
    >>> levelTurns.set_level_turn(TurnMode.TURN_MODE_BANK_ANGLE, 25)
    >>> # Get the climb and descent transition options
    >>> climbAndDescent = basicAccModel.climb_and_descent_transitions
    >>> # Set the max pull up G to 1
    >>> climbAndDescent.max_pull_up_g = 1.2
    >>> # Get the attitude transition options
    >>> attitudeTransitions = basicAccModel.attitude_transitions
    >>> # Set the max roll rate to 25
    >>> attitudeTransitions.roll_rate = 25
    >>>
    >>> # Get the aerodynamics
    >>> aero = basicAccModel.aerodynamics
    >>> # Use simple aerodynamics
    >>> aero.aerodynamic_strategy = AircraftAerodynamicStrategy.AIRCRAFT_AERODYNAMIC_SIMPLE
    >>> # Get the options for the simple aerodynamics and set some parameters
    >>> simpleAero = aero.mode_as_simple
    >>> simpleAero.s_reference = 5
    >>> simpleAero.cl_max = 3.1
    >>> simpleAero.cd = 0.05
    >>>
    >>> # Get the propulsion
    >>> prop = basicAccModel.propulsion
    >>> # Use simple propulsion
    >>> prop.propulsion_strategy = AircraftPropulsionStrategy.AIRCRAFT_PROPULSION_SIMPLE
    >>> # Get the simple propulsion options and set some parameters
    >>> simpleProp = prop.mode_as_simple
    >>> simpleProp.max_thrust_acceleration = 0.6
    >>> simpleProp.min_thrust_deceleration = 0.4
    >>> simpleProp.set_density_scaling(True, 0.02)
    >>>
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()
    """

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_turn_mode_method_offset = 1
    _get_turn_g_method_offset = 2
    _get_bank_angle_method_offset = 3
    _get_turn_acceleration_method_offset = 4
    _get_turn_radius_method_offset = 5
    _get_turn_rate_method_offset = 6
    _set_level_turn_method_offset = 7
    _get_maneuver_mode_method_offset = 8
    _set_maneuver_mode_method_offset = 9
    _get_maneuver_mode_helper_method_offset = 10
    _metadata = {
        "iid_data" : (5723269250337285450, 7849803881290906029),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, LevelTurns)

    _get_turn_mode_metadata = { "offset" : _get_turn_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(TurnMode),) }
    @property
    def turn_mode(self) -> "TurnMode":
        """Get the turn mode."""
        return self._intf.get_property(LevelTurns._metadata, LevelTurns._get_turn_mode_metadata)

    _get_turn_g_metadata = { "offset" : _get_turn_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def turn_g(self) -> float:
        """Get the TurnG."""
        return self._intf.get_property(LevelTurns._metadata, LevelTurns._get_turn_g_metadata)

    _get_bank_angle_metadata = { "offset" : _get_bank_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def bank_angle(self) -> typing.Any:
        """Get the bank angle."""
        return self._intf.get_property(LevelTurns._metadata, LevelTurns._get_bank_angle_metadata)

    _get_turn_acceleration_metadata = { "offset" : _get_turn_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def turn_acceleration(self) -> float:
        """Get the turn acceleration."""
        return self._intf.get_property(LevelTurns._metadata, LevelTurns._get_turn_acceleration_metadata)

    _get_turn_radius_metadata = { "offset" : _get_turn_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def turn_radius(self) -> float:
        """Get the turn radius."""
        return self._intf.get_property(LevelTurns._metadata, LevelTurns._get_turn_radius_metadata)

    _get_turn_rate_metadata = { "offset" : _get_turn_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def turn_rate(self) -> float:
        """Get the turn rate."""
        return self._intf.get_property(LevelTurns._metadata, LevelTurns._get_turn_rate_metadata)

    _set_level_turn_metadata = { "offset" : _set_level_turn_method_offset,
            "arg_types" : (agcom.LONG, agcom.Variant,),
            "marshallers" : (agmarshall.EnumArg(TurnMode), agmarshall.VariantArg,) }
    def set_level_turn(self, turn_mode:"TurnMode", turn_value:typing.Any) -> None:
        """Set the level turn mode and corresponding value."""
        return self._intf.invoke(LevelTurns._metadata, LevelTurns._set_level_turn_metadata, turn_mode, turn_value)

    _get_maneuver_mode_metadata = { "offset" : _get_maneuver_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AccelerationManeuverMode),) }
    @property
    def maneuver_mode(self) -> "AccelerationManeuverMode":
        """Get or set the mode that the aircraft will adhere to the specified acceleration parameters. Scale by atmospheric density will cause the aircraft to consider dynamic pressure when calculating turn radius."""
        return self._intf.get_property(LevelTurns._metadata, LevelTurns._get_maneuver_mode_metadata)

    _set_maneuver_mode_metadata = { "offset" : _set_maneuver_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AccelerationManeuverMode),) }
    @maneuver_mode.setter
    def maneuver_mode(self, value:"AccelerationManeuverMode") -> None:
        """Get or set the mode that the aircraft will adhere to the specified acceleration parameters. Scale by atmospheric density will cause the aircraft to consider dynamic pressure when calculating turn radius."""
        return self._intf.set_property(LevelTurns._metadata, LevelTurns._set_maneuver_mode_metadata, value)

    _get_maneuver_mode_helper_metadata = { "offset" : _get_maneuver_mode_helper_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def maneuver_mode_helper(self) -> "AerodynamicPropulsionManeuverModeHelper":
        """Get the interface for the Aero/Prop Maneuver Mode helper. The maneuver mode must be set to Aero/Prop to access this interface."""
        return self._intf.get_property(LevelTurns._metadata, LevelTurns._get_maneuver_mode_helper_metadata)

    _property_names[turn_mode] = "turn_mode"
    _property_names[turn_g] = "turn_g"
    _property_names[bank_angle] = "bank_angle"
    _property_names[turn_acceleration] = "turn_acceleration"
    _property_names[turn_radius] = "turn_radius"
    _property_names[turn_rate] = "turn_rate"
    _property_names[maneuver_mode] = "maneuver_mode"
    _property_names[maneuver_mode_helper] = "maneuver_mode_helper"

    def __init__(self, source_object=None):
        """Construct an object of type LevelTurns."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, LevelTurns)
    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, LevelTurns, [LevelTurns, ])

agcls.AgClassCatalog.add_catalog_entry((4842031065400171495, 15335149086412210363), LevelTurns)
agcls.AgTypeNameMap["LevelTurns"] = LevelTurns

class AttitudeTransitions(SupportsDeleteCallback):
    """
    Interface used to access the Attitude Transitions options found in the Basic Acceleration Model of an aircraft.

    Examples
    --------
    Configure the basic acceleration performance model of an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the acceleration type
    >>> acceleration = aviatorAircraft.acceleration
    >>> # Get the build in performance model
    >>> basicAccModel = acceleration.get_built_in_model()
    >>>
    >>> # Get the level turns options
    >>> levelTurns = basicAccModel.level_turns
    >>> # Set a max bank angle of 25
    >>> levelTurns.set_level_turn(TurnMode.TURN_MODE_BANK_ANGLE, 25)
    >>> # Get the climb and descent transition options
    >>> climbAndDescent = basicAccModel.climb_and_descent_transitions
    >>> # Set the max pull up G to 1
    >>> climbAndDescent.max_pull_up_g = 1.2
    >>> # Get the attitude transition options
    >>> attitudeTransitions = basicAccModel.attitude_transitions
    >>> # Set the max roll rate to 25
    >>> attitudeTransitions.roll_rate = 25
    >>>
    >>> # Get the aerodynamics
    >>> aero = basicAccModel.aerodynamics
    >>> # Use simple aerodynamics
    >>> aero.aerodynamic_strategy = AircraftAerodynamicStrategy.AIRCRAFT_AERODYNAMIC_SIMPLE
    >>> # Get the options for the simple aerodynamics and set some parameters
    >>> simpleAero = aero.mode_as_simple
    >>> simpleAero.s_reference = 5
    >>> simpleAero.cl_max = 3.1
    >>> simpleAero.cd = 0.05
    >>>
    >>> # Get the propulsion
    >>> prop = basicAccModel.propulsion
    >>> # Use simple propulsion
    >>> prop.propulsion_strategy = AircraftPropulsionStrategy.AIRCRAFT_PROPULSION_SIMPLE
    >>> # Get the simple propulsion options and set some parameters
    >>> simpleProp = prop.mode_as_simple
    >>> simpleProp.max_thrust_acceleration = 0.6
    >>> simpleProp.min_thrust_deceleration = 0.4
    >>> simpleProp.set_density_scaling(True, 0.02)
    >>>
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()
    """

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_roll_rate_method_offset = 1
    _set_roll_rate_method_offset = 2
    _get_pitch_rate_method_offset = 3
    _set_pitch_rate_method_offset = 4
    _get_yaw_rate_method_offset = 5
    _set_yaw_rate_method_offset = 6
    _metadata = {
        "iid_data" : (4809317354746996248, 3931367782668783024),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AttitudeTransitions)

    _get_roll_rate_metadata = { "offset" : _get_roll_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def roll_rate(self) -> typing.Any:
        """Get or set the roll rate when the aircraft in a turn."""
        return self._intf.get_property(AttitudeTransitions._metadata, AttitudeTransitions._get_roll_rate_metadata)

    _set_roll_rate_metadata = { "offset" : _set_roll_rate_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @roll_rate.setter
    def roll_rate(self, value:typing.Any) -> None:
        """Get or set the roll rate when the aircraft in a turn."""
        return self._intf.set_property(AttitudeTransitions._metadata, AttitudeTransitions._set_roll_rate_metadata, value)

    _get_pitch_rate_metadata = { "offset" : _get_pitch_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def pitch_rate(self) -> typing.Any:
        """Get or set the pitch rate when transitioning between attitude modes."""
        return self._intf.get_property(AttitudeTransitions._metadata, AttitudeTransitions._get_pitch_rate_metadata)

    _set_pitch_rate_metadata = { "offset" : _set_pitch_rate_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @pitch_rate.setter
    def pitch_rate(self, value:typing.Any) -> None:
        """Get or set the pitch rate when transitioning between attitude modes."""
        return self._intf.set_property(AttitudeTransitions._metadata, AttitudeTransitions._set_pitch_rate_metadata, value)

    _get_yaw_rate_metadata = { "offset" : _get_yaw_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def yaw_rate(self) -> typing.Any:
        """Get or set the yaw rate when transitioning between attitude modes."""
        return self._intf.get_property(AttitudeTransitions._metadata, AttitudeTransitions._get_yaw_rate_metadata)

    _set_yaw_rate_metadata = { "offset" : _set_yaw_rate_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @yaw_rate.setter
    def yaw_rate(self, value:typing.Any) -> None:
        """Get or set the yaw rate when transitioning between attitude modes."""
        return self._intf.set_property(AttitudeTransitions._metadata, AttitudeTransitions._set_yaw_rate_metadata, value)

    _property_names[roll_rate] = "roll_rate"
    _property_names[pitch_rate] = "pitch_rate"
    _property_names[yaw_rate] = "yaw_rate"

    def __init__(self, source_object=None):
        """Construct an object of type AttitudeTransitions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AttitudeTransitions)
    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, AttitudeTransitions, [AttitudeTransitions, ])

agcls.AgClassCatalog.add_catalog_entry((5584586404333393428, 12387107037886590612), AttitudeTransitions)
agcls.AgTypeNameMap["AttitudeTransitions"] = AttitudeTransitions

class ClimbAndDescentTransitions(SupportsDeleteCallback):
    """
    Interface used to access the Climb and Descent Transitions options found in the Basic Acceleration Model of an aircraft.

    Examples
    --------
    Configure the basic acceleration performance model of an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the acceleration type
    >>> acceleration = aviatorAircraft.acceleration
    >>> # Get the build in performance model
    >>> basicAccModel = acceleration.get_built_in_model()
    >>>
    >>> # Get the level turns options
    >>> levelTurns = basicAccModel.level_turns
    >>> # Set a max bank angle of 25
    >>> levelTurns.set_level_turn(TurnMode.TURN_MODE_BANK_ANGLE, 25)
    >>> # Get the climb and descent transition options
    >>> climbAndDescent = basicAccModel.climb_and_descent_transitions
    >>> # Set the max pull up G to 1
    >>> climbAndDescent.max_pull_up_g = 1.2
    >>> # Get the attitude transition options
    >>> attitudeTransitions = basicAccModel.attitude_transitions
    >>> # Set the max roll rate to 25
    >>> attitudeTransitions.roll_rate = 25
    >>>
    >>> # Get the aerodynamics
    >>> aero = basicAccModel.aerodynamics
    >>> # Use simple aerodynamics
    >>> aero.aerodynamic_strategy = AircraftAerodynamicStrategy.AIRCRAFT_AERODYNAMIC_SIMPLE
    >>> # Get the options for the simple aerodynamics and set some parameters
    >>> simpleAero = aero.mode_as_simple
    >>> simpleAero.s_reference = 5
    >>> simpleAero.cl_max = 3.1
    >>> simpleAero.cd = 0.05
    >>>
    >>> # Get the propulsion
    >>> prop = basicAccModel.propulsion
    >>> # Use simple propulsion
    >>> prop.propulsion_strategy = AircraftPropulsionStrategy.AIRCRAFT_PROPULSION_SIMPLE
    >>> # Get the simple propulsion options and set some parameters
    >>> simpleProp = prop.mode_as_simple
    >>> simpleProp.max_thrust_acceleration = 0.6
    >>> simpleProp.min_thrust_deceleration = 0.4
    >>> simpleProp.set_density_scaling(True, 0.02)
    >>>
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()
    """

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_max_pull_up_g_method_offset = 1
    _set_max_pull_up_g_method_offset = 2
    _get_max_push_over_g_method_offset = 3
    _set_max_push_over_g_method_offset = 4
    _get_maneuver_mode_method_offset = 5
    _set_maneuver_mode_method_offset = 6
    _get_ignore_flight_path_angle_method_offset = 7
    _set_ignore_flight_path_angle_method_offset = 8
    _get_maneuver_mode_helper_method_offset = 9
    _metadata = {
        "iid_data" : (4787497693753872718, 5667952407318575531),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ClimbAndDescentTransitions)

    _get_max_pull_up_g_metadata = { "offset" : _get_max_pull_up_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_pull_up_g(self) -> float:
        """Get or set the force normal to the velocity vector used to transition into a climb or to a transition out of a dive into the next flight segment."""
        return self._intf.get_property(ClimbAndDescentTransitions._metadata, ClimbAndDescentTransitions._get_max_pull_up_g_metadata)

    _set_max_pull_up_g_metadata = { "offset" : _set_max_pull_up_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_pull_up_g.setter
    def max_pull_up_g(self, value:float) -> None:
        """Get or set the force normal to the velocity vector used to transition into a climb or to a transition out of a dive into the next flight segment."""
        return self._intf.set_property(ClimbAndDescentTransitions._metadata, ClimbAndDescentTransitions._set_max_pull_up_g_metadata, value)

    _get_max_push_over_g_metadata = { "offset" : _get_max_push_over_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_push_over_g(self) -> float:
        """Get or set the force normal to the velocity vector used to transition into a descent or to a transition from a climb into the next flight segment."""
        return self._intf.get_property(ClimbAndDescentTransitions._metadata, ClimbAndDescentTransitions._get_max_push_over_g_metadata)

    _set_max_push_over_g_metadata = { "offset" : _set_max_push_over_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_push_over_g.setter
    def max_push_over_g(self, value:float) -> None:
        """Get or set the force normal to the velocity vector used to transition into a descent or to a transition from a climb into the next flight segment."""
        return self._intf.set_property(ClimbAndDescentTransitions._metadata, ClimbAndDescentTransitions._set_max_push_over_g_metadata, value)

    _get_maneuver_mode_metadata = { "offset" : _get_maneuver_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AccelerationManeuverMode),) }
    @property
    def maneuver_mode(self) -> "AccelerationManeuverMode":
        """Get or set the mode that the aircraft will adhere to the specified acceleration parameters. Scale by atmospheric density will cause the aircraft to consider dynamic pressure when calculating turn radius."""
        return self._intf.get_property(ClimbAndDescentTransitions._metadata, ClimbAndDescentTransitions._get_maneuver_mode_metadata)

    _set_maneuver_mode_metadata = { "offset" : _set_maneuver_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AccelerationManeuverMode),) }
    @maneuver_mode.setter
    def maneuver_mode(self, value:"AccelerationManeuverMode") -> None:
        """Get or set the mode that the aircraft will adhere to the specified acceleration parameters. Scale by atmospheric density will cause the aircraft to consider dynamic pressure when calculating turn radius."""
        return self._intf.set_property(ClimbAndDescentTransitions._metadata, ClimbAndDescentTransitions._set_maneuver_mode_metadata, value)

    _get_ignore_flight_path_angle_metadata = { "offset" : _get_ignore_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def ignore_flight_path_angle(self) -> bool:
        """Opt whether to ignore the flight path angle."""
        return self._intf.get_property(ClimbAndDescentTransitions._metadata, ClimbAndDescentTransitions._get_ignore_flight_path_angle_metadata)

    _set_ignore_flight_path_angle_metadata = { "offset" : _set_ignore_flight_path_angle_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @ignore_flight_path_angle.setter
    def ignore_flight_path_angle(self, value:bool) -> None:
        """Opt whether to ignore the flight path angle."""
        return self._intf.set_property(ClimbAndDescentTransitions._metadata, ClimbAndDescentTransitions._set_ignore_flight_path_angle_metadata, value)

    _get_maneuver_mode_helper_metadata = { "offset" : _get_maneuver_mode_helper_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def maneuver_mode_helper(self) -> "AerodynamicPropulsionManeuverModeHelper":
        """Get the interface for the Aero/Prop Maneuver Mode helper. The maneuver mode must be set to Aero/Prop to access this interface."""
        return self._intf.get_property(ClimbAndDescentTransitions._metadata, ClimbAndDescentTransitions._get_maneuver_mode_helper_metadata)

    _property_names[max_pull_up_g] = "max_pull_up_g"
    _property_names[max_push_over_g] = "max_push_over_g"
    _property_names[maneuver_mode] = "maneuver_mode"
    _property_names[ignore_flight_path_angle] = "ignore_flight_path_angle"
    _property_names[maneuver_mode_helper] = "maneuver_mode_helper"

    def __init__(self, source_object=None):
        """Construct an object of type ClimbAndDescentTransitions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ClimbAndDescentTransitions)
    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, ClimbAndDescentTransitions, [ClimbAndDescentTransitions, ])

agcls.AgClassCatalog.add_catalog_entry((5374744943989914698, 12300077720877790391), ClimbAndDescentTransitions)
agcls.AgTypeNameMap["ClimbAndDescentTransitions"] = ClimbAndDescentTransitions

class AerodynamicPropulsionManeuverModeHelper(SupportsDeleteCallback):
    """Interface used to access the The calculation mode for the Aero/Prop maneuver mode helper. Helper found in the Basic Acceleration Model of an aircraft."""

    _num_methods = 19
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_mode_method_offset = 1
    _set_mode_method_offset = 2
    _get_flight_mode_method_offset = 3
    _set_flight_mode_method_offset = 4
    _get_use_afterburner_method_offset = 5
    _set_use_afterburner_method_offset = 6
    _get_reference_weight_method_offset = 7
    _set_reference_weight_method_offset = 8
    _get_reference_altitude_method_offset = 9
    _set_reference_altitude_method_offset = 10
    _get_reference_airspeed_method_offset = 11
    _get_reference_airspeed_type_method_offset = 12
    _set_reference_airspeed_method_offset = 13
    _get_reference_load_factor_method_offset = 14
    _set_reference_load_factor_method_offset = 15
    _get_estimated_ps_method_offset = 16
    _get_control_authority_method_offset = 17
    _set_control_authority_method_offset = 18
    _get_status_message_method_offset = 19
    _metadata = {
        "iid_data" : (5328095794674712717, 8005940665812164797),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AerodynamicPropulsionManeuverModeHelper)

    _get_mode_metadata = { "offset" : _get_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AccelerationManeuverAerodynamicPropulsionMode),) }
    @property
    def mode(self) -> "AccelerationManeuverAerodynamicPropulsionMode":
        """Get or set the calculation mode for the Aero/Prop maneuver mode helper."""
        return self._intf.get_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._get_mode_metadata)

    _set_mode_metadata = { "offset" : _set_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AccelerationManeuverAerodynamicPropulsionMode),) }
    @mode.setter
    def mode(self, value:"AccelerationManeuverAerodynamicPropulsionMode") -> None:
        """Get or set the calculation mode for the Aero/Prop maneuver mode helper."""
        return self._intf.set_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._set_mode_metadata, value)

    _get_flight_mode_metadata = { "offset" : _get_flight_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AerodynamicPropulsionFlightMode),) }
    @property
    def flight_mode(self) -> "AerodynamicPropulsionFlightMode":
        """Get or set the performance flight mode."""
        return self._intf.get_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._get_flight_mode_metadata)

    _set_flight_mode_metadata = { "offset" : _set_flight_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AerodynamicPropulsionFlightMode),) }
    @flight_mode.setter
    def flight_mode(self, value:"AerodynamicPropulsionFlightMode") -> None:
        """Get or set the performance flight mode."""
        return self._intf.set_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._set_flight_mode_metadata, value)

    _get_use_afterburner_metadata = { "offset" : _get_use_afterburner_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_afterburner(self) -> bool:
        """Opt whether to use the afterburner if it is possible."""
        return self._intf.get_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._get_use_afterburner_metadata)

    _set_use_afterburner_metadata = { "offset" : _set_use_afterburner_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_afterburner.setter
    def use_afterburner(self, value:bool) -> None:
        """Opt whether to use the afterburner if it is possible."""
        return self._intf.set_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._set_use_afterburner_metadata, value)

    _get_reference_weight_metadata = { "offset" : _get_reference_weight_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def reference_weight(self) -> float:
        """Get or set the reference weight."""
        return self._intf.get_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._get_reference_weight_metadata)

    _set_reference_weight_metadata = { "offset" : _set_reference_weight_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @reference_weight.setter
    def reference_weight(self, value:float) -> None:
        """Get or set the reference weight."""
        return self._intf.set_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._set_reference_weight_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."""
        return self._intf.get_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._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:
        """Get or set the reference altitude."""
        return self._intf.set_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._set_reference_altitude_metadata, value)

    _get_reference_airspeed_metadata = { "offset" : _get_reference_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def reference_airspeed(self) -> float:
        """Get the reference airspeed."""
        return self._intf.get_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._get_reference_airspeed_metadata)

    _get_reference_airspeed_type_metadata = { "offset" : _get_reference_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def reference_airspeed_type(self) -> "AirspeedType":
        """Get the reference airspeed type."""
        return self._intf.get_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._get_reference_airspeed_type_metadata)

    _set_reference_airspeed_metadata = { "offset" : _set_reference_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_reference_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the reference airspeed and reference airspeed type."""
        return self._intf.invoke(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._set_reference_airspeed_metadata, airspeed_type, airspeed)

    _get_reference_load_factor_metadata = { "offset" : _get_reference_load_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def reference_load_factor(self) -> float:
        """Get or set the reference load factor."""
        return self._intf.get_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._get_reference_load_factor_metadata)

    _set_reference_load_factor_metadata = { "offset" : _set_reference_load_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @reference_load_factor.setter
    def reference_load_factor(self, value:float) -> None:
        """Get or set the reference load factor."""
        return self._intf.set_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._set_reference_load_factor_metadata, value)

    _get_estimated_ps_metadata = { "offset" : _get_estimated_ps_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def estimated_ps(self) -> float:
        """Get the estimated specific excess power."""
        return self._intf.get_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._get_estimated_ps_metadata)

    _get_control_authority_metadata = { "offset" : _get_control_authority_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def control_authority(self) -> float:
        """Get or set the control authority of how much to factor a turn over push/pull."""
        return self._intf.get_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._get_control_authority_metadata)

    _set_control_authority_metadata = { "offset" : _set_control_authority_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @control_authority.setter
    def control_authority(self, value:float) -> None:
        """Get or set the control authority of how much to factor a turn over push/pull."""
        return self._intf.set_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._set_control_authority_metadata, value)

    _get_status_message_metadata = { "offset" : _get_status_message_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def status_message(self) -> str:
        """Get the status message in the message window."""
        return self._intf.get_property(AerodynamicPropulsionManeuverModeHelper._metadata, AerodynamicPropulsionManeuverModeHelper._get_status_message_metadata)

    _property_names[mode] = "mode"
    _property_names[flight_mode] = "flight_mode"
    _property_names[use_afterburner] = "use_afterburner"
    _property_names[reference_weight] = "reference_weight"
    _property_names[reference_altitude] = "reference_altitude"
    _property_names[reference_airspeed] = "reference_airspeed"
    _property_names[reference_airspeed_type] = "reference_airspeed_type"
    _property_names[reference_load_factor] = "reference_load_factor"
    _property_names[estimated_ps] = "estimated_ps"
    _property_names[control_authority] = "control_authority"
    _property_names[status_message] = "status_message"

    def __init__(self, source_object=None):
        """Construct an object of type AerodynamicPropulsionManeuverModeHelper."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AerodynamicPropulsionManeuverModeHelper)
    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, AerodynamicPropulsionManeuverModeHelper, [AerodynamicPropulsionManeuverModeHelper, ])

agcls.AgClassCatalog.add_catalog_entry((5554483294060101200, 8600938976610717093), AerodynamicPropulsionManeuverModeHelper)
agcls.AgTypeNameMap["AerodynamicPropulsionManeuverModeHelper"] = AerodynamicPropulsionManeuverModeHelper

class AircraftAdvancedAccelerationModel(IPerformanceModel, ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the Advanced Acceleration Model options of an aircraft."""

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_level_turns_method_offset = 1
    _get_attitude_transitions_method_offset = 2
    _get_climb_and_descent_transitions_method_offset = 3
    _get_acceleration_mode_method_offset = 4
    _get_as_catalog_item_method_offset = 5
    _metadata = {
        "iid_data" : (5313840907341593770, 18068732340055302845),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftAdvancedAccelerationModel)

    _get_level_turns_metadata = { "offset" : _get_level_turns_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def level_turns(self) -> "LevelTurns":
        """Get the level turns interface."""
        return self._intf.get_property(AircraftAdvancedAccelerationModel._metadata, AircraftAdvancedAccelerationModel._get_level_turns_metadata)

    _get_attitude_transitions_metadata = { "offset" : _get_attitude_transitions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def attitude_transitions(self) -> "AttitudeTransitions":
        """Get the attitude transitions interface."""
        return self._intf.get_property(AircraftAdvancedAccelerationModel._metadata, AircraftAdvancedAccelerationModel._get_attitude_transitions_metadata)

    _get_climb_and_descent_transitions_metadata = { "offset" : _get_climb_and_descent_transitions_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def climb_and_descent_transitions(self) -> "ClimbAndDescentTransitions":
        """Get the climb and descent transitions interface."""
        return self._intf.get_property(AircraftAdvancedAccelerationModel._metadata, AircraftAdvancedAccelerationModel._get_climb_and_descent_transitions_metadata)

    _get_acceleration_mode_metadata = { "offset" : _get_acceleration_mode_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def acceleration_mode(self) -> "AircraftAccelerationMode":
        """Get the acceleration mode interface."""
        return self._intf.get_property(AircraftAdvancedAccelerationModel._metadata, AircraftAdvancedAccelerationModel._get_acceleration_mode_metadata)

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftAdvancedAccelerationModel._metadata, AircraftAdvancedAccelerationModel._get_as_catalog_item_metadata, OutArg())

    _property_names[level_turns] = "level_turns"
    _property_names[attitude_transitions] = "attitude_transitions"
    _property_names[climb_and_descent_transitions] = "climb_and_descent_transitions"
    _property_names[acceleration_mode] = "acceleration_mode"

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

agcls.AgClassCatalog.add_catalog_entry((5358492534817326369, 10261995905994973359), AircraftAdvancedAccelerationModel)
agcls.AgTypeNameMap["AircraftAdvancedAccelerationModel"] = AircraftAdvancedAccelerationModel

class AircraftAccelerationMode(SupportsDeleteCallback):
    """Interface used to set the Acceleration Mode for the Advanced Acceleration Model of an aircraft."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_acceleration_mode_method_offset = 1
    _set_acceleration_mode_method_offset = 2
    _get_acceleration_g_method_offset = 3
    _set_acceleration_g_method_offset = 4
    _metadata = {
        "iid_data" : (5657217427469576289, 12897697484585064127),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftAccelerationMode)

    _get_acceleration_mode_metadata = { "offset" : _get_acceleration_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AccelerationAdvancedAccelerationMode),) }
    @property
    def acceleration_mode(self) -> "AccelerationAdvancedAccelerationMode":
        """Opt whether to override the acceleration or deceleration of the aircraft."""
        return self._intf.get_property(AircraftAccelerationMode._metadata, AircraftAccelerationMode._get_acceleration_mode_metadata)

    _set_acceleration_mode_metadata = { "offset" : _set_acceleration_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AccelerationAdvancedAccelerationMode),) }
    @acceleration_mode.setter
    def acceleration_mode(self, value:"AccelerationAdvancedAccelerationMode") -> None:
        """Opt whether to override the acceleration or deceleration of the aircraft."""
        return self._intf.set_property(AircraftAccelerationMode._metadata, AircraftAccelerationMode._set_acceleration_mode_metadata, value)

    _get_acceleration_g_metadata = { "offset" : _get_acceleration_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def acceleration_g(self) -> float:
        """Get or set the rate of acceleration or deceleration of the aircraft if the accleeration mode is set to override."""
        return self._intf.get_property(AircraftAccelerationMode._metadata, AircraftAccelerationMode._get_acceleration_g_metadata)

    _set_acceleration_g_metadata = { "offset" : _set_acceleration_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @acceleration_g.setter
    def acceleration_g(self, value:float) -> None:
        """Get or set the rate of acceleration or deceleration of the aircraft if the accleeration mode is set to override."""
        return self._intf.set_property(AircraftAccelerationMode._metadata, AircraftAccelerationMode._set_acceleration_g_metadata, value)

    _property_names[acceleration_mode] = "acceleration_mode"
    _property_names[acceleration_g] = "acceleration_g"

    def __init__(self, source_object=None):
        """Construct an object of type AircraftAccelerationMode."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AircraftAccelerationMode)
    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, AircraftAccelerationMode, [AircraftAccelerationMode, ])

agcls.AgClassCatalog.add_catalog_entry((5216102563964361198, 17187029792935920802), AircraftAccelerationMode)
agcls.AgTypeNameMap["AircraftAccelerationMode"] = AircraftAccelerationMode

class AircraftSimpleAerodynamic(SupportsDeleteCallback):
    """
    Interface used to access the Simple Aerodynamics options for the Basic Acceleration Model of an aircraft.

    Examples
    --------
    Configure the basic acceleration performance model of an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the acceleration type
    >>> acceleration = aviatorAircraft.acceleration
    >>> # Get the build in performance model
    >>> basicAccModel = acceleration.get_built_in_model()
    >>>
    >>> # Get the level turns options
    >>> levelTurns = basicAccModel.level_turns
    >>> # Set a max bank angle of 25
    >>> levelTurns.set_level_turn(TurnMode.TURN_MODE_BANK_ANGLE, 25)
    >>> # Get the climb and descent transition options
    >>> climbAndDescent = basicAccModel.climb_and_descent_transitions
    >>> # Set the max pull up G to 1
    >>> climbAndDescent.max_pull_up_g = 1.2
    >>> # Get the attitude transition options
    >>> attitudeTransitions = basicAccModel.attitude_transitions
    >>> # Set the max roll rate to 25
    >>> attitudeTransitions.roll_rate = 25
    >>>
    >>> # Get the aerodynamics
    >>> aero = basicAccModel.aerodynamics
    >>> # Use simple aerodynamics
    >>> aero.aerodynamic_strategy = AircraftAerodynamicStrategy.AIRCRAFT_AERODYNAMIC_SIMPLE
    >>> # Get the options for the simple aerodynamics and set some parameters
    >>> simpleAero = aero.mode_as_simple
    >>> simpleAero.s_reference = 5
    >>> simpleAero.cl_max = 3.1
    >>> simpleAero.cd = 0.05
    >>>
    >>> # Get the propulsion
    >>> prop = basicAccModel.propulsion
    >>> # Use simple propulsion
    >>> prop.propulsion_strategy = AircraftPropulsionStrategy.AIRCRAFT_PROPULSION_SIMPLE
    >>> # Get the simple propulsion options and set some parameters
    >>> simpleProp = prop.mode_as_simple
    >>> simpleProp.max_thrust_acceleration = 0.6
    >>> simpleProp.min_thrust_deceleration = 0.4
    >>> simpleProp.set_density_scaling(True, 0.02)
    >>>
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()
    """

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_operating_mode_method_offset = 1
    _set_operating_mode_method_offset = 2
    _get_s_reference_method_offset = 3
    _set_s_reference_method_offset = 4
    _get_cl_max_method_offset = 5
    _set_cl_max_method_offset = 6
    _get_cd_method_offset = 7
    _set_cd_method_offset = 8
    _metadata = {
        "iid_data" : (4795364640067016059, 13915158584522730163),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftSimpleAerodynamic)

    _get_operating_mode_metadata = { "offset" : _get_operating_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AerodynamicPropulsionSimpleMode),) }
    @property
    def operating_mode(self) -> "AerodynamicPropulsionSimpleMode":
        """Get or set the mode option to treat the aircraft as a helicopter or a fixed wing aircraft when calculating the aircraft's attitude."""
        return self._intf.get_property(AircraftSimpleAerodynamic._metadata, AircraftSimpleAerodynamic._get_operating_mode_metadata)

    _set_operating_mode_metadata = { "offset" : _set_operating_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AerodynamicPropulsionSimpleMode),) }
    @operating_mode.setter
    def operating_mode(self, value:"AerodynamicPropulsionSimpleMode") -> None:
        """Get or set the mode option to treat the aircraft as a helicopter or a fixed wing aircraft when calculating the aircraft's attitude."""
        return self._intf.set_property(AircraftSimpleAerodynamic._metadata, AircraftSimpleAerodynamic._set_operating_mode_metadata, value)

    _get_s_reference_metadata = { "offset" : _get_s_reference_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def s_reference(self) -> float:
        """Get or set the reference surface area of the aircraft."""
        return self._intf.get_property(AircraftSimpleAerodynamic._metadata, AircraftSimpleAerodynamic._get_s_reference_metadata)

    _set_s_reference_metadata = { "offset" : _set_s_reference_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @s_reference.setter
    def s_reference(self, value:float) -> None:
        """Get or set the reference surface area of the aircraft."""
        return self._intf.set_property(AircraftSimpleAerodynamic._metadata, AircraftSimpleAerodynamic._set_s_reference_metadata, value)

    _get_cl_max_metadata = { "offset" : _get_cl_max_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cl_max(self) -> float:
        """Get or set the max coefficient of lift."""
        return self._intf.get_property(AircraftSimpleAerodynamic._metadata, AircraftSimpleAerodynamic._get_cl_max_metadata)

    _set_cl_max_metadata = { "offset" : _set_cl_max_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cl_max.setter
    def cl_max(self, value:float) -> None:
        """Get or set the max coefficient of lift."""
        return self._intf.set_property(AircraftSimpleAerodynamic._metadata, AircraftSimpleAerodynamic._set_cl_max_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 coefficient of drag."""
        return self._intf.get_property(AircraftSimpleAerodynamic._metadata, AircraftSimpleAerodynamic._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:
        """Get or set the coefficient of drag."""
        return self._intf.set_property(AircraftSimpleAerodynamic._metadata, AircraftSimpleAerodynamic._set_cd_metadata, value)

    _property_names[operating_mode] = "operating_mode"
    _property_names[s_reference] = "s_reference"
    _property_names[cl_max] = "cl_max"
    _property_names[cd] = "cd"

    def __init__(self, source_object=None):
        """Construct an object of type AircraftSimpleAerodynamic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AircraftSimpleAerodynamic)
    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, AircraftSimpleAerodynamic, [AircraftSimpleAerodynamic, ])

agcls.AgClassCatalog.add_catalog_entry((4949274632612681163, 16986168694659548566), AircraftSimpleAerodynamic)
agcls.AgTypeNameMap["AircraftSimpleAerodynamic"] = AircraftSimpleAerodynamic

class AircraftExternalAerodynamic(SupportsDeleteCallback):
    """Interface used to access the External File Aerodynamics options for the Basic Acceleration Model of an aircraft."""

    _num_methods = 14
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_forward_flight_filepath_method_offset = 1
    _set_forward_flight_filepath_method_offset = 2
    _reload_forward_flight_file_method_offset = 3
    _get_forward_flight_reference_area_method_offset = 4
    _set_forward_flight_reference_area_method_offset = 5
    _get_can_set_forward_flight_reference_area_method_offset = 6
    _get_is_forward_flight_valid_method_offset = 7
    _get_takeoff_landing_filepath_method_offset = 8
    _set_takeoff_landing_filepath_method_offset = 9
    _reload_takeoff_landing_file_method_offset = 10
    _get_takeoff_landing_reference_area_method_offset = 11
    _set_takeoff_landing_reference_area_method_offset = 12
    _get_can_set_takeoff_landing_reference_area_method_offset = 13
    _get_is_takeoff_landing_valid_method_offset = 14
    _metadata = {
        "iid_data" : (4995292197392587210, 1860972800833287599),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftExternalAerodynamic)

    _get_forward_flight_filepath_metadata = { "offset" : _get_forward_flight_filepath_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def forward_flight_filepath(self) -> str:
        """Get the filepath for the forward flight aero file."""
        return self._intf.get_property(AircraftExternalAerodynamic._metadata, AircraftExternalAerodynamic._get_forward_flight_filepath_metadata)

    _set_forward_flight_filepath_metadata = { "offset" : _set_forward_flight_filepath_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg,) }
    def set_forward_flight_filepath(self, filepath:str) -> str:
        """Set the filepath for the forward flight aero file."""
        return self._intf.invoke(AircraftExternalAerodynamic._metadata, AircraftExternalAerodynamic._set_forward_flight_filepath_metadata, filepath, OutArg())

    _reload_forward_flight_file_metadata = { "offset" : _reload_forward_flight_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    def reload_forward_flight_file(self) -> str:
        """Reload the forward flight aero file."""
        return self._intf.invoke(AircraftExternalAerodynamic._metadata, AircraftExternalAerodynamic._reload_forward_flight_file_metadata, OutArg())

    _get_forward_flight_reference_area_metadata = { "offset" : _get_forward_flight_reference_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def forward_flight_reference_area(self) -> float:
        """Get or set the area of the lifting surface of the aircraft."""
        return self._intf.get_property(AircraftExternalAerodynamic._metadata, AircraftExternalAerodynamic._get_forward_flight_reference_area_metadata)

    _set_forward_flight_reference_area_metadata = { "offset" : _set_forward_flight_reference_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @forward_flight_reference_area.setter
    def forward_flight_reference_area(self, value:float) -> None:
        """Get or set the area of the lifting surface of the aircraft."""
        return self._intf.set_property(AircraftExternalAerodynamic._metadata, AircraftExternalAerodynamic._set_forward_flight_reference_area_metadata, value)

    _get_can_set_forward_flight_reference_area_metadata = { "offset" : _get_can_set_forward_flight_reference_area_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def can_set_forward_flight_reference_area(self) -> bool:
        """Check whether you can set the reference area or whether it is specified in the file."""
        return self._intf.get_property(AircraftExternalAerodynamic._metadata, AircraftExternalAerodynamic._get_can_set_forward_flight_reference_area_metadata)

    _get_is_forward_flight_valid_metadata = { "offset" : _get_is_forward_flight_valid_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def is_forward_flight_valid(self) -> bool:
        """Check whether the forward flight file is valid."""
        return self._intf.get_property(AircraftExternalAerodynamic._metadata, AircraftExternalAerodynamic._get_is_forward_flight_valid_metadata)

    _get_takeoff_landing_filepath_metadata = { "offset" : _get_takeoff_landing_filepath_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def takeoff_landing_filepath(self) -> str:
        """Get the filepath for the takeoff and landing aero file."""
        return self._intf.get_property(AircraftExternalAerodynamic._metadata, AircraftExternalAerodynamic._get_takeoff_landing_filepath_metadata)

    _set_takeoff_landing_filepath_metadata = { "offset" : _set_takeoff_landing_filepath_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg,) }
    def set_takeoff_landing_filepath(self, filepath:str) -> str:
        """Set the filepath for the takeoff and landing aero file."""
        return self._intf.invoke(AircraftExternalAerodynamic._metadata, AircraftExternalAerodynamic._set_takeoff_landing_filepath_metadata, filepath, OutArg())

    _reload_takeoff_landing_file_metadata = { "offset" : _reload_takeoff_landing_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    def reload_takeoff_landing_file(self) -> str:
        """Reload the takeoff and landing aero file."""
        return self._intf.invoke(AircraftExternalAerodynamic._metadata, AircraftExternalAerodynamic._reload_takeoff_landing_file_metadata, OutArg())

    _get_takeoff_landing_reference_area_metadata = { "offset" : _get_takeoff_landing_reference_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def takeoff_landing_reference_area(self) -> float:
        """Get or set the area of the lifting surface of the aircraft."""
        return self._intf.get_property(AircraftExternalAerodynamic._metadata, AircraftExternalAerodynamic._get_takeoff_landing_reference_area_metadata)

    _set_takeoff_landing_reference_area_metadata = { "offset" : _set_takeoff_landing_reference_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @takeoff_landing_reference_area.setter
    def takeoff_landing_reference_area(self, value:float) -> None:
        """Get or set the area of the lifting surface of the aircraft."""
        return self._intf.set_property(AircraftExternalAerodynamic._metadata, AircraftExternalAerodynamic._set_takeoff_landing_reference_area_metadata, value)

    _get_can_set_takeoff_landing_reference_area_metadata = { "offset" : _get_can_set_takeoff_landing_reference_area_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def can_set_takeoff_landing_reference_area(self) -> bool:
        """Check whether you can set the reference area or whether it is specified in the file."""
        return self._intf.get_property(AircraftExternalAerodynamic._metadata, AircraftExternalAerodynamic._get_can_set_takeoff_landing_reference_area_metadata)

    _get_is_takeoff_landing_valid_metadata = { "offset" : _get_is_takeoff_landing_valid_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def is_takeoff_landing_valid(self) -> bool:
        """Check whether the takeoff and landing file is valid."""
        return self._intf.get_property(AircraftExternalAerodynamic._metadata, AircraftExternalAerodynamic._get_is_takeoff_landing_valid_metadata)

    _property_names[forward_flight_filepath] = "forward_flight_filepath"
    _property_names[forward_flight_reference_area] = "forward_flight_reference_area"
    _property_names[can_set_forward_flight_reference_area] = "can_set_forward_flight_reference_area"
    _property_names[is_forward_flight_valid] = "is_forward_flight_valid"
    _property_names[takeoff_landing_filepath] = "takeoff_landing_filepath"
    _property_names[takeoff_landing_reference_area] = "takeoff_landing_reference_area"
    _property_names[can_set_takeoff_landing_reference_area] = "can_set_takeoff_landing_reference_area"
    _property_names[is_takeoff_landing_valid] = "is_takeoff_landing_valid"

    def __init__(self, source_object=None):
        """Construct an object of type AircraftExternalAerodynamic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AircraftExternalAerodynamic)
    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, AircraftExternalAerodynamic, [AircraftExternalAerodynamic, ])

agcls.AgClassCatalog.add_catalog_entry((5605284744680812914, 13571106235899430788), AircraftExternalAerodynamic)
agcls.AgTypeNameMap["AircraftExternalAerodynamic"] = AircraftExternalAerodynamic

class AircraftAerodynamic(SupportsDeleteCallback):
    """
    Interface used to access the Aerodynamics options for the Basic Acceleration Model of an aircraft.

    Examples
    --------
    Configure the basic acceleration performance model of an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the acceleration type
    >>> acceleration = aviatorAircraft.acceleration
    >>> # Get the build in performance model
    >>> basicAccModel = acceleration.get_built_in_model()
    >>>
    >>> # Get the level turns options
    >>> levelTurns = basicAccModel.level_turns
    >>> # Set a max bank angle of 25
    >>> levelTurns.set_level_turn(TurnMode.TURN_MODE_BANK_ANGLE, 25)
    >>> # Get the climb and descent transition options
    >>> climbAndDescent = basicAccModel.climb_and_descent_transitions
    >>> # Set the max pull up G to 1
    >>> climbAndDescent.max_pull_up_g = 1.2
    >>> # Get the attitude transition options
    >>> attitudeTransitions = basicAccModel.attitude_transitions
    >>> # Set the max roll rate to 25
    >>> attitudeTransitions.roll_rate = 25
    >>>
    >>> # Get the aerodynamics
    >>> aero = basicAccModel.aerodynamics
    >>> # Use simple aerodynamics
    >>> aero.aerodynamic_strategy = AircraftAerodynamicStrategy.AIRCRAFT_AERODYNAMIC_SIMPLE
    >>> # Get the options for the simple aerodynamics and set some parameters
    >>> simpleAero = aero.mode_as_simple
    >>> simpleAero.s_reference = 5
    >>> simpleAero.cl_max = 3.1
    >>> simpleAero.cd = 0.05
    >>>
    >>> # Get the propulsion
    >>> prop = basicAccModel.propulsion
    >>> # Use simple propulsion
    >>> prop.propulsion_strategy = AircraftPropulsionStrategy.AIRCRAFT_PROPULSION_SIMPLE
    >>> # Get the simple propulsion options and set some parameters
    >>> simpleProp = prop.mode_as_simple
    >>> simpleProp.max_thrust_acceleration = 0.6
    >>> simpleProp.min_thrust_deceleration = 0.4
    >>> simpleProp.set_density_scaling(True, 0.02)
    >>>
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()
    """

    _num_methods = 11
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_aerodynamic_strategy_method_offset = 1
    _set_aerodynamic_strategy_method_offset = 2
    _get_mode_as_simple_method_offset = 3
    _get_mode_as_basic_fixed_wing_method_offset = 4
    _get_mode_as_external_method_offset = 5
    _get_mode_as_advanced_missile_method_offset = 6
    _get_lift_factor_method_offset = 7
    _set_lift_factor_method_offset = 8
    _get_drag_factor_method_offset = 9
    _set_drag_factor_method_offset = 10
    _get_mode_as_four_point_method_offset = 11
    _metadata = {
        "iid_data" : (5120934689185363706, 8628502199224761519),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftAerodynamic)

    _get_aerodynamic_strategy_metadata = { "offset" : _get_aerodynamic_strategy_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AircraftAerodynamicStrategy),) }
    @property
    def aerodynamic_strategy(self) -> "AircraftAerodynamicStrategy":
        """Get or set the aerodynamic strategy type."""
        return self._intf.get_property(AircraftAerodynamic._metadata, AircraftAerodynamic._get_aerodynamic_strategy_metadata)

    _set_aerodynamic_strategy_metadata = { "offset" : _set_aerodynamic_strategy_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AircraftAerodynamicStrategy),) }
    @aerodynamic_strategy.setter
    def aerodynamic_strategy(self, value:"AircraftAerodynamicStrategy") -> None:
        """Get or set the aerodynamic strategy type."""
        return self._intf.set_property(AircraftAerodynamic._metadata, AircraftAerodynamic._set_aerodynamic_strategy_metadata, value)

    _get_mode_as_simple_metadata = { "offset" : _get_mode_as_simple_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_simple(self) -> "AircraftSimpleAerodynamic":
        """Get the interface for a simple aerodynamics strategy."""
        return self._intf.get_property(AircraftAerodynamic._metadata, AircraftAerodynamic._get_mode_as_simple_metadata)

    _get_mode_as_basic_fixed_wing_metadata = { "offset" : _get_mode_as_basic_fixed_wing_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_basic_fixed_wing(self) -> "AircraftBasicFixedWingAerodynamic":
        """Get the interface for a basic fixed wing aerodynamics strategy."""
        return self._intf.get_property(AircraftAerodynamic._metadata, AircraftAerodynamic._get_mode_as_basic_fixed_wing_metadata)

    _get_mode_as_external_metadata = { "offset" : _get_mode_as_external_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_external(self) -> "AircraftExternalAerodynamic":
        """Get the interface for an external file aerodynamics strategy."""
        return self._intf.get_property(AircraftAerodynamic._metadata, AircraftAerodynamic._get_mode_as_external_metadata)

    _get_mode_as_advanced_missile_metadata = { "offset" : _get_mode_as_advanced_missile_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_advanced_missile(self) -> "MissileAdvancedAerodynamic":
        """Get the interface for an advanced missile aerodynamics strategy."""
        return self._intf.get_property(AircraftAerodynamic._metadata, AircraftAerodynamic._get_mode_as_advanced_missile_metadata)

    _get_lift_factor_metadata = { "offset" : _get_lift_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def lift_factor(self) -> float:
        """Get or set the scalar value applied to the lift for parametric analysis."""
        return self._intf.get_property(AircraftAerodynamic._metadata, AircraftAerodynamic._get_lift_factor_metadata)

    _set_lift_factor_metadata = { "offset" : _set_lift_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @lift_factor.setter
    def lift_factor(self, value:float) -> None:
        """Get or set the scalar value applied to the lift for parametric analysis."""
        return self._intf.set_property(AircraftAerodynamic._metadata, AircraftAerodynamic._set_lift_factor_metadata, value)

    _get_drag_factor_metadata = { "offset" : _get_drag_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def drag_factor(self) -> float:
        """Get or set the scalar value applied to the drag for parametric analysis."""
        return self._intf.get_property(AircraftAerodynamic._metadata, AircraftAerodynamic._get_drag_factor_metadata)

    _set_drag_factor_metadata = { "offset" : _set_drag_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @drag_factor.setter
    def drag_factor(self, value:float) -> None:
        """Get or set the scalar value applied to the drag for parametric analysis."""
        return self._intf.set_property(AircraftAerodynamic._metadata, AircraftAerodynamic._set_drag_factor_metadata, value)

    _get_mode_as_four_point_metadata = { "offset" : _get_mode_as_four_point_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_four_point(self) -> "FourPointAerodynamic":
        """Get the interface for a four point aerodynamics strategy."""
        return self._intf.get_property(AircraftAerodynamic._metadata, AircraftAerodynamic._get_mode_as_four_point_metadata)

    _property_names[aerodynamic_strategy] = "aerodynamic_strategy"
    _property_names[mode_as_simple] = "mode_as_simple"
    _property_names[mode_as_basic_fixed_wing] = "mode_as_basic_fixed_wing"
    _property_names[mode_as_external] = "mode_as_external"
    _property_names[mode_as_advanced_missile] = "mode_as_advanced_missile"
    _property_names[lift_factor] = "lift_factor"
    _property_names[drag_factor] = "drag_factor"
    _property_names[mode_as_four_point] = "mode_as_four_point"

    def __init__(self, source_object=None):
        """Construct an object of type AircraftAerodynamic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AircraftAerodynamic)
    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, AircraftAerodynamic, [AircraftAerodynamic, ])

agcls.AgClassCatalog.add_catalog_entry((5082480556701513469, 17564547437981405094), AircraftAerodynamic)
agcls.AgTypeNameMap["AircraftAerodynamic"] = AircraftAerodynamic

class AircraftBasicFixedWingAerodynamic(SupportsDeleteCallback):
    """Interface used to access Basic Fixed Wing Aerodynamics interface for the Basic Acceleration Model of an aircraft."""

    _num_methods = 32
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_forward_flight_reference_area_method_offset = 1
    _set_forward_flight_reference_area_method_offset = 2
    _get_forward_flight_use_compressible_flow_method_offset = 3
    _set_forward_flight_use_compressible_flow_method_offset = 4
    _get_forward_flight_cl0_method_offset = 5
    _set_forward_flight_cl0_method_offset = 6
    _get_forward_flight_cl_alpha_method_offset = 7
    _set_forward_flight_cl_alpha_method_offset = 8
    _get_forward_flight_min_aoa_method_offset = 9
    _set_forward_flight_min_aoa_method_offset = 10
    _get_forward_flight_max_aoa_method_offset = 11
    _set_forward_flight_max_aoa_method_offset = 12
    _get_forward_flight_cd0_method_offset = 13
    _set_forward_flight_cd0_method_offset = 14
    _get_forward_flight_k_method_offset = 15
    _set_forward_flight_k_method_offset = 16
    _get_takeoff_landing_reference_area_method_offset = 17
    _set_takeoff_landing_reference_area_method_offset = 18
    _get_takeoff_landing_use_compressible_flow_method_offset = 19
    _set_takeoff_landing_use_compressible_flow_method_offset = 20
    _get_takeoff_landing_cl0_method_offset = 21
    _set_takeoff_landing_cl0_method_offset = 22
    _get_takeoff_landing_cl_alpha_method_offset = 23
    _set_takeoff_landing_cl_alpha_method_offset = 24
    _get_takeoff_landing_min_aoa_method_offset = 25
    _set_takeoff_landing_min_aoa_method_offset = 26
    _get_takeoff_landing_max_aoa_method_offset = 27
    _set_takeoff_landing_max_aoa_method_offset = 28
    _get_takeoff_landing_cd0_method_offset = 29
    _set_takeoff_landing_cd0_method_offset = 30
    _get_takeoff_landing_k_method_offset = 31
    _set_takeoff_landing_k_method_offset = 32
    _metadata = {
        "iid_data" : (5194727978343587927, 16517105265377487783),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftBasicFixedWingAerodynamic)

    _get_forward_flight_reference_area_metadata = { "offset" : _get_forward_flight_reference_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def forward_flight_reference_area(self) -> float:
        """Get or set the area of the lifting surface of the aircraft."""
        return self._intf.get_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._get_forward_flight_reference_area_metadata)

    _set_forward_flight_reference_area_metadata = { "offset" : _set_forward_flight_reference_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @forward_flight_reference_area.setter
    def forward_flight_reference_area(self, value:float) -> None:
        """Get or set the area of the lifting surface of the aircraft."""
        return self._intf.set_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._set_forward_flight_reference_area_metadata, value)

    _get_forward_flight_use_compressible_flow_metadata = { "offset" : _get_forward_flight_use_compressible_flow_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def forward_flight_use_compressible_flow(self) -> bool:
        """Opt to define the aerodynamic parameters for forward flight with respect to supersonic flight conditions."""
        return self._intf.get_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._get_forward_flight_use_compressible_flow_metadata)

    _set_forward_flight_use_compressible_flow_metadata = { "offset" : _set_forward_flight_use_compressible_flow_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @forward_flight_use_compressible_flow.setter
    def forward_flight_use_compressible_flow(self, value:bool) -> None:
        """Opt to define the aerodynamic parameters for forward flight with respect to supersonic flight conditions."""
        return self._intf.set_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._set_forward_flight_use_compressible_flow_metadata, value)

    _get_forward_flight_cl0_metadata = { "offset" : _get_forward_flight_cl0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def forward_flight_cl0(self) -> float:
        """Get or set the coefficient of lift at zero angle of attack."""
        return self._intf.get_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._get_forward_flight_cl0_metadata)

    _set_forward_flight_cl0_metadata = { "offset" : _set_forward_flight_cl0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @forward_flight_cl0.setter
    def forward_flight_cl0(self, value:float) -> None:
        """Get or set the coefficient of lift at zero angle of attack."""
        return self._intf.set_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._set_forward_flight_cl0_metadata, value)

    _get_forward_flight_cl_alpha_metadata = { "offset" : _get_forward_flight_cl_alpha_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def forward_flight_cl_alpha(self) -> float:
        """Get or set the slope of the coefficient of lift curve."""
        return self._intf.get_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._get_forward_flight_cl_alpha_metadata)

    _set_forward_flight_cl_alpha_metadata = { "offset" : _set_forward_flight_cl_alpha_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @forward_flight_cl_alpha.setter
    def forward_flight_cl_alpha(self, value:float) -> None:
        """Get or set the slope of the coefficient of lift curve."""
        return self._intf.set_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._set_forward_flight_cl_alpha_metadata, value)

    _get_forward_flight_min_aoa_metadata = { "offset" : _get_forward_flight_min_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def forward_flight_min_aoa(self) -> typing.Any:
        """Get or set the minimum angle of attack possible."""
        return self._intf.get_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._get_forward_flight_min_aoa_metadata)

    _set_forward_flight_min_aoa_metadata = { "offset" : _set_forward_flight_min_aoa_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @forward_flight_min_aoa.setter
    def forward_flight_min_aoa(self, value:typing.Any) -> None:
        """Get or set the minimum angle of attack possible."""
        return self._intf.set_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._set_forward_flight_min_aoa_metadata, value)

    _get_forward_flight_max_aoa_metadata = { "offset" : _get_forward_flight_max_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def forward_flight_max_aoa(self) -> typing.Any:
        """Get or set the maximum angle of attack possible."""
        return self._intf.get_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._get_forward_flight_max_aoa_metadata)

    _set_forward_flight_max_aoa_metadata = { "offset" : _set_forward_flight_max_aoa_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @forward_flight_max_aoa.setter
    def forward_flight_max_aoa(self, value:typing.Any) -> None:
        """Get or set the maximum angle of attack possible."""
        return self._intf.set_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._set_forward_flight_max_aoa_metadata, value)

    _get_forward_flight_cd0_metadata = { "offset" : _get_forward_flight_cd0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def forward_flight_cd0(self) -> float:
        """Get or set the coefficient of drag of the lifting surface at zero angle of attack."""
        return self._intf.get_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._get_forward_flight_cd0_metadata)

    _set_forward_flight_cd0_metadata = { "offset" : _set_forward_flight_cd0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @forward_flight_cd0.setter
    def forward_flight_cd0(self, value:float) -> None:
        """Get or set the coefficient of drag of the lifting surface at zero angle of attack."""
        return self._intf.set_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._set_forward_flight_cd0_metadata, value)

    _get_forward_flight_k_metadata = { "offset" : _get_forward_flight_k_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def forward_flight_k(self) -> float:
        """Get or set the coefficient of induced drag."""
        return self._intf.get_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._get_forward_flight_k_metadata)

    _set_forward_flight_k_metadata = { "offset" : _set_forward_flight_k_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @forward_flight_k.setter
    def forward_flight_k(self, value:float) -> None:
        """Get or set the coefficient of induced drag."""
        return self._intf.set_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._set_forward_flight_k_metadata, value)

    _get_takeoff_landing_reference_area_metadata = { "offset" : _get_takeoff_landing_reference_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def takeoff_landing_reference_area(self) -> float:
        """Get or set the area of the lifting surface of the aircraft."""
        return self._intf.get_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._get_takeoff_landing_reference_area_metadata)

    _set_takeoff_landing_reference_area_metadata = { "offset" : _set_takeoff_landing_reference_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @takeoff_landing_reference_area.setter
    def takeoff_landing_reference_area(self, value:float) -> None:
        """Get or set the area of the lifting surface of the aircraft."""
        return self._intf.set_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._set_takeoff_landing_reference_area_metadata, value)

    _get_takeoff_landing_use_compressible_flow_metadata = { "offset" : _get_takeoff_landing_use_compressible_flow_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def takeoff_landing_use_compressible_flow(self) -> bool:
        """Opt to define the aerodynamic parameters for takeoff and landing with respect to supersonic flight conditions."""
        return self._intf.get_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._get_takeoff_landing_use_compressible_flow_metadata)

    _set_takeoff_landing_use_compressible_flow_metadata = { "offset" : _set_takeoff_landing_use_compressible_flow_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @takeoff_landing_use_compressible_flow.setter
    def takeoff_landing_use_compressible_flow(self, value:bool) -> None:
        """Opt to define the aerodynamic parameters for takeoff and landing with respect to supersonic flight conditions."""
        return self._intf.set_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._set_takeoff_landing_use_compressible_flow_metadata, value)

    _get_takeoff_landing_cl0_metadata = { "offset" : _get_takeoff_landing_cl0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def takeoff_landing_cl0(self) -> float:
        """Get or set the coefficient of lift at zero angle of attack."""
        return self._intf.get_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._get_takeoff_landing_cl0_metadata)

    _set_takeoff_landing_cl0_metadata = { "offset" : _set_takeoff_landing_cl0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @takeoff_landing_cl0.setter
    def takeoff_landing_cl0(self, value:float) -> None:
        """Get or set the coefficient of lift at zero angle of attack."""
        return self._intf.set_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._set_takeoff_landing_cl0_metadata, value)

    _get_takeoff_landing_cl_alpha_metadata = { "offset" : _get_takeoff_landing_cl_alpha_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def takeoff_landing_cl_alpha(self) -> float:
        """Get or set the slope of the coefficient of lift curve."""
        return self._intf.get_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._get_takeoff_landing_cl_alpha_metadata)

    _set_takeoff_landing_cl_alpha_metadata = { "offset" : _set_takeoff_landing_cl_alpha_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @takeoff_landing_cl_alpha.setter
    def takeoff_landing_cl_alpha(self, value:float) -> None:
        """Get or set the slope of the coefficient of lift curve."""
        return self._intf.set_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._set_takeoff_landing_cl_alpha_metadata, value)

    _get_takeoff_landing_min_aoa_metadata = { "offset" : _get_takeoff_landing_min_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def takeoff_landing_min_aoa(self) -> typing.Any:
        """Get or set the minimum angle of attack possible."""
        return self._intf.get_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._get_takeoff_landing_min_aoa_metadata)

    _set_takeoff_landing_min_aoa_metadata = { "offset" : _set_takeoff_landing_min_aoa_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @takeoff_landing_min_aoa.setter
    def takeoff_landing_min_aoa(self, value:typing.Any) -> None:
        """Get or set the minimum angle of attack possible."""
        return self._intf.set_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._set_takeoff_landing_min_aoa_metadata, value)

    _get_takeoff_landing_max_aoa_metadata = { "offset" : _get_takeoff_landing_max_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def takeoff_landing_max_aoa(self) -> typing.Any:
        """Get or set the maximum angle of attack possible."""
        return self._intf.get_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._get_takeoff_landing_max_aoa_metadata)

    _set_takeoff_landing_max_aoa_metadata = { "offset" : _set_takeoff_landing_max_aoa_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @takeoff_landing_max_aoa.setter
    def takeoff_landing_max_aoa(self, value:typing.Any) -> None:
        """Get or set the maximum angle of attack possible."""
        return self._intf.set_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._set_takeoff_landing_max_aoa_metadata, value)

    _get_takeoff_landing_cd0_metadata = { "offset" : _get_takeoff_landing_cd0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def takeoff_landing_cd0(self) -> float:
        """Get or set the coefficient of drag of the lifting surface at zero angle of attack."""
        return self._intf.get_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._get_takeoff_landing_cd0_metadata)

    _set_takeoff_landing_cd0_metadata = { "offset" : _set_takeoff_landing_cd0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @takeoff_landing_cd0.setter
    def takeoff_landing_cd0(self, value:float) -> None:
        """Get or set the coefficient of drag of the lifting surface at zero angle of attack."""
        return self._intf.set_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._set_takeoff_landing_cd0_metadata, value)

    _get_takeoff_landing_k_metadata = { "offset" : _get_takeoff_landing_k_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def takeoff_landing_k(self) -> float:
        """Get or set the coefficient of induced drag."""
        return self._intf.get_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._get_takeoff_landing_k_metadata)

    _set_takeoff_landing_k_metadata = { "offset" : _set_takeoff_landing_k_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @takeoff_landing_k.setter
    def takeoff_landing_k(self, value:float) -> None:
        """Get or set the coefficient of induced drag."""
        return self._intf.set_property(AircraftBasicFixedWingAerodynamic._metadata, AircraftBasicFixedWingAerodynamic._set_takeoff_landing_k_metadata, value)

    _property_names[forward_flight_reference_area] = "forward_flight_reference_area"
    _property_names[forward_flight_use_compressible_flow] = "forward_flight_use_compressible_flow"
    _property_names[forward_flight_cl0] = "forward_flight_cl0"
    _property_names[forward_flight_cl_alpha] = "forward_flight_cl_alpha"
    _property_names[forward_flight_min_aoa] = "forward_flight_min_aoa"
    _property_names[forward_flight_max_aoa] = "forward_flight_max_aoa"
    _property_names[forward_flight_cd0] = "forward_flight_cd0"
    _property_names[forward_flight_k] = "forward_flight_k"
    _property_names[takeoff_landing_reference_area] = "takeoff_landing_reference_area"
    _property_names[takeoff_landing_use_compressible_flow] = "takeoff_landing_use_compressible_flow"
    _property_names[takeoff_landing_cl0] = "takeoff_landing_cl0"
    _property_names[takeoff_landing_cl_alpha] = "takeoff_landing_cl_alpha"
    _property_names[takeoff_landing_min_aoa] = "takeoff_landing_min_aoa"
    _property_names[takeoff_landing_max_aoa] = "takeoff_landing_max_aoa"
    _property_names[takeoff_landing_cd0] = "takeoff_landing_cd0"
    _property_names[takeoff_landing_k] = "takeoff_landing_k"

    def __init__(self, source_object=None):
        """Construct an object of type AircraftBasicFixedWingAerodynamic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AircraftBasicFixedWingAerodynamic)
    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, AircraftBasicFixedWingAerodynamic, [AircraftBasicFixedWingAerodynamic, ])

agcls.AgClassCatalog.add_catalog_entry((4615386614829789996, 13505783508724948142), AircraftBasicFixedWingAerodynamic)
agcls.AgTypeNameMap["AircraftBasicFixedWingAerodynamic"] = AircraftBasicFixedWingAerodynamic

class AircraftPropulsion(SupportsDeleteCallback):
    """
    Interface used to access the propulsion options for the Basic Acceleration Model of an aircraft.

    Examples
    --------
    Configure the basic acceleration performance model of an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the acceleration type
    >>> acceleration = aviatorAircraft.acceleration
    >>> # Get the build in performance model
    >>> basicAccModel = acceleration.get_built_in_model()
    >>>
    >>> # Get the level turns options
    >>> levelTurns = basicAccModel.level_turns
    >>> # Set a max bank angle of 25
    >>> levelTurns.set_level_turn(TurnMode.TURN_MODE_BANK_ANGLE, 25)
    >>> # Get the climb and descent transition options
    >>> climbAndDescent = basicAccModel.climb_and_descent_transitions
    >>> # Set the max pull up G to 1
    >>> climbAndDescent.max_pull_up_g = 1.2
    >>> # Get the attitude transition options
    >>> attitudeTransitions = basicAccModel.attitude_transitions
    >>> # Set the max roll rate to 25
    >>> attitudeTransitions.roll_rate = 25
    >>>
    >>> # Get the aerodynamics
    >>> aero = basicAccModel.aerodynamics
    >>> # Use simple aerodynamics
    >>> aero.aerodynamic_strategy = AircraftAerodynamicStrategy.AIRCRAFT_AERODYNAMIC_SIMPLE
    >>> # Get the options for the simple aerodynamics and set some parameters
    >>> simpleAero = aero.mode_as_simple
    >>> simpleAero.s_reference = 5
    >>> simpleAero.cl_max = 3.1
    >>> simpleAero.cd = 0.05
    >>>
    >>> # Get the propulsion
    >>> prop = basicAccModel.propulsion
    >>> # Use simple propulsion
    >>> prop.propulsion_strategy = AircraftPropulsionStrategy.AIRCRAFT_PROPULSION_SIMPLE
    >>> # Get the simple propulsion options and set some parameters
    >>> simpleProp = prop.mode_as_simple
    >>> simpleProp.max_thrust_acceleration = 0.6
    >>> simpleProp.min_thrust_deceleration = 0.4
    >>> simpleProp.set_density_scaling(True, 0.02)
    >>>
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()
    """

    _num_methods = 12
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_propulsion_strategy_method_offset = 1
    _set_propulsion_strategy_method_offset = 2
    _get_mode_as_simple_method_offset = 3
    _get_mode_as_basic_fixed_wing_method_offset = 4
    _get_mode_as_external_method_offset = 5
    _get_lift_factor_method_offset = 6
    _set_lift_factor_method_offset = 7
    _get_drag_factor_method_offset = 8
    _set_drag_factor_method_offset = 9
    _get_mode_as_ramjet_method_offset = 10
    _get_mode_as_turbojet_method_offset = 11
    _get_mode_as_rocket_method_offset = 12
    _metadata = {
        "iid_data" : (4760545169458717566, 10855594368442160788),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftPropulsion)

    _get_propulsion_strategy_metadata = { "offset" : _get_propulsion_strategy_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AircraftPropulsionStrategy),) }
    @property
    def propulsion_strategy(self) -> "AircraftPropulsionStrategy":
        """Get or set the propulsion strategy type."""
        return self._intf.get_property(AircraftPropulsion._metadata, AircraftPropulsion._get_propulsion_strategy_metadata)

    _set_propulsion_strategy_metadata = { "offset" : _set_propulsion_strategy_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AircraftPropulsionStrategy),) }
    @propulsion_strategy.setter
    def propulsion_strategy(self, value:"AircraftPropulsionStrategy") -> None:
        """Get or set the propulsion strategy type."""
        return self._intf.set_property(AircraftPropulsion._metadata, AircraftPropulsion._set_propulsion_strategy_metadata, value)

    _get_mode_as_simple_metadata = { "offset" : _get_mode_as_simple_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_simple(self) -> "AircraftSimplePropulsion":
        """Get the interface for a simple propulsion strategy."""
        return self._intf.get_property(AircraftPropulsion._metadata, AircraftPropulsion._get_mode_as_simple_metadata)

    _get_mode_as_basic_fixed_wing_metadata = { "offset" : _get_mode_as_basic_fixed_wing_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_basic_fixed_wing(self) -> "AircraftBasicFixedWingPropulsion":
        """Get the interface for a basic fixed wing propulsion strategy."""
        return self._intf.get_property(AircraftPropulsion._metadata, AircraftPropulsion._get_mode_as_basic_fixed_wing_metadata)

    _get_mode_as_external_metadata = { "offset" : _get_mode_as_external_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_external(self) -> "AircraftExternalPropulsion":
        """Get the interface for an external file propulsion strategy."""
        return self._intf.get_property(AircraftPropulsion._metadata, AircraftPropulsion._get_mode_as_external_metadata)

    _get_lift_factor_metadata = { "offset" : _get_lift_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def lift_factor(self) -> float:
        """Get or set the scalar value applied to the lift for parametric analysis."""
        return self._intf.get_property(AircraftPropulsion._metadata, AircraftPropulsion._get_lift_factor_metadata)

    _set_lift_factor_metadata = { "offset" : _set_lift_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @lift_factor.setter
    def lift_factor(self, value:float) -> None:
        """Get or set the scalar value applied to the lift for parametric analysis."""
        return self._intf.set_property(AircraftPropulsion._metadata, AircraftPropulsion._set_lift_factor_metadata, value)

    _get_drag_factor_metadata = { "offset" : _get_drag_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def drag_factor(self) -> float:
        """Get or set the scalar value applied to the drag for parametric analysis."""
        return self._intf.get_property(AircraftPropulsion._metadata, AircraftPropulsion._get_drag_factor_metadata)

    _set_drag_factor_metadata = { "offset" : _set_drag_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @drag_factor.setter
    def drag_factor(self, value:float) -> None:
        """Get or set the scalar value applied to the drag for parametric analysis."""
        return self._intf.set_property(AircraftPropulsion._metadata, AircraftPropulsion._set_drag_factor_metadata, value)

    _get_mode_as_ramjet_metadata = { "offset" : _get_mode_as_ramjet_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_ramjet(self) -> "MissileRamjetPropulsion":
        """Get the interface for a Ramjet propulsion strategy."""
        return self._intf.get_property(AircraftPropulsion._metadata, AircraftPropulsion._get_mode_as_ramjet_metadata)

    _get_mode_as_turbojet_metadata = { "offset" : _get_mode_as_turbojet_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_turbojet(self) -> "MissileTurbojetPropulsion":
        """Get the interface for a Turbojet propulsion strategy."""
        return self._intf.get_property(AircraftPropulsion._metadata, AircraftPropulsion._get_mode_as_turbojet_metadata)

    _get_mode_as_rocket_metadata = { "offset" : _get_mode_as_rocket_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_rocket(self) -> "MissileRocketPropulsion":
        """Get the interface for a Rocket propulsion strategy."""
        return self._intf.get_property(AircraftPropulsion._metadata, AircraftPropulsion._get_mode_as_rocket_metadata)

    _property_names[propulsion_strategy] = "propulsion_strategy"
    _property_names[mode_as_simple] = "mode_as_simple"
    _property_names[mode_as_basic_fixed_wing] = "mode_as_basic_fixed_wing"
    _property_names[mode_as_external] = "mode_as_external"
    _property_names[lift_factor] = "lift_factor"
    _property_names[drag_factor] = "drag_factor"
    _property_names[mode_as_ramjet] = "mode_as_ramjet"
    _property_names[mode_as_turbojet] = "mode_as_turbojet"
    _property_names[mode_as_rocket] = "mode_as_rocket"

    def __init__(self, source_object=None):
        """Construct an object of type AircraftPropulsion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AircraftPropulsion)
    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, AircraftPropulsion, [AircraftPropulsion, ])

agcls.AgClassCatalog.add_catalog_entry((5577330394102227800, 15792983096793871031), AircraftPropulsion)
agcls.AgTypeNameMap["AircraftPropulsion"] = AircraftPropulsion

class AircraftSimplePropulsion(SupportsDeleteCallback):
    """
    Interface used to access the Simple Propulsion options for the Basic Acceleration Model of an aircraft.

    Examples
    --------
    Configure the basic acceleration performance model of an aircraft:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the acceleration type
    >>> acceleration = aviatorAircraft.acceleration
    >>> # Get the build in performance model
    >>> basicAccModel = acceleration.get_built_in_model()
    >>>
    >>> # Get the level turns options
    >>> levelTurns = basicAccModel.level_turns
    >>> # Set a max bank angle of 25
    >>> levelTurns.set_level_turn(TurnMode.TURN_MODE_BANK_ANGLE, 25)
    >>> # Get the climb and descent transition options
    >>> climbAndDescent = basicAccModel.climb_and_descent_transitions
    >>> # Set the max pull up G to 1
    >>> climbAndDescent.max_pull_up_g = 1.2
    >>> # Get the attitude transition options
    >>> attitudeTransitions = basicAccModel.attitude_transitions
    >>> # Set the max roll rate to 25
    >>> attitudeTransitions.roll_rate = 25
    >>>
    >>> # Get the aerodynamics
    >>> aero = basicAccModel.aerodynamics
    >>> # Use simple aerodynamics
    >>> aero.aerodynamic_strategy = AircraftAerodynamicStrategy.AIRCRAFT_AERODYNAMIC_SIMPLE
    >>> # Get the options for the simple aerodynamics and set some parameters
    >>> simpleAero = aero.mode_as_simple
    >>> simpleAero.s_reference = 5
    >>> simpleAero.cl_max = 3.1
    >>> simpleAero.cd = 0.05
    >>>
    >>> # Get the propulsion
    >>> prop = basicAccModel.propulsion
    >>> # Use simple propulsion
    >>> prop.propulsion_strategy = AircraftPropulsionStrategy.AIRCRAFT_PROPULSION_SIMPLE
    >>> # Get the simple propulsion options and set some parameters
    >>> simpleProp = prop.mode_as_simple
    >>> simpleProp.max_thrust_acceleration = 0.6
    >>> simpleProp.min_thrust_deceleration = 0.4
    >>> simpleProp.set_density_scaling(True, 0.02)
    >>>
    >>> # Save the changes to the catalog
    >>> aviatorAircraft.save()
    """

    _num_methods = 7
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_max_thrust_acceleration_method_offset = 1
    _set_max_thrust_acceleration_method_offset = 2
    _get_min_thrust_deceleration_method_offset = 3
    _set_min_thrust_deceleration_method_offset = 4
    _get_use_density_scaling_method_offset = 5
    _get_density_ratio_exponent_method_offset = 6
    _set_density_scaling_method_offset = 7
    _metadata = {
        "iid_data" : (5408389755499298173, 7791957774431135407),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftSimplePropulsion)

    _get_max_thrust_acceleration_metadata = { "offset" : _get_max_thrust_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_thrust_acceleration(self) -> float:
        """Get or set the rate at which the aircraft speeds up at max throttle."""
        return self._intf.get_property(AircraftSimplePropulsion._metadata, AircraftSimplePropulsion._get_max_thrust_acceleration_metadata)

    _set_max_thrust_acceleration_metadata = { "offset" : _set_max_thrust_acceleration_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_thrust_acceleration.setter
    def max_thrust_acceleration(self, value:float) -> None:
        """Get or set the rate at which the aircraft speeds up at max throttle."""
        return self._intf.set_property(AircraftSimplePropulsion._metadata, AircraftSimplePropulsion._set_max_thrust_acceleration_metadata, value)

    _get_min_thrust_deceleration_metadata = { "offset" : _get_min_thrust_deceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_thrust_deceleration(self) -> float:
        """Get or set the rate at which the aircraft slows down at minimum throttle setting."""
        return self._intf.get_property(AircraftSimplePropulsion._metadata, AircraftSimplePropulsion._get_min_thrust_deceleration_metadata)

    _set_min_thrust_deceleration_metadata = { "offset" : _set_min_thrust_deceleration_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_thrust_deceleration.setter
    def min_thrust_deceleration(self, value:float) -> None:
        """Get or set the rate at which the aircraft slows down at minimum throttle setting."""
        return self._intf.set_property(AircraftSimplePropulsion._metadata, AircraftSimplePropulsion._set_min_thrust_deceleration_metadata, value)

    _get_use_density_scaling_metadata = { "offset" : _get_use_density_scaling_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_density_scaling(self) -> bool:
        """Opt whether to scale the accel/decel performance by the density ratio."""
        return self._intf.get_property(AircraftSimplePropulsion._metadata, AircraftSimplePropulsion._get_use_density_scaling_metadata)

    _get_density_ratio_exponent_metadata = { "offset" : _get_density_ratio_exponent_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def density_ratio_exponent(self) -> float:
        """Get the relative impace of atmospheric density on the aircraft's performance."""
        return self._intf.get_property(AircraftSimplePropulsion._metadata, AircraftSimplePropulsion._get_density_ratio_exponent_metadata)

    _set_density_scaling_metadata = { "offset" : _set_density_scaling_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.DoubleArg,) }
    def set_density_scaling(self, use_scaling:bool, exponent:float) -> None:
        """Set the option to use density scaling and set the density ratio exponent."""
        return self._intf.invoke(AircraftSimplePropulsion._metadata, AircraftSimplePropulsion._set_density_scaling_metadata, use_scaling, exponent)

    _property_names[max_thrust_acceleration] = "max_thrust_acceleration"
    _property_names[min_thrust_deceleration] = "min_thrust_deceleration"
    _property_names[use_density_scaling] = "use_density_scaling"
    _property_names[density_ratio_exponent] = "density_ratio_exponent"

    def __init__(self, source_object=None):
        """Construct an object of type AircraftSimplePropulsion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AircraftSimplePropulsion)
    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, AircraftSimplePropulsion, [AircraftSimplePropulsion, ])

agcls.AgClassCatalog.add_catalog_entry((5707285421522482526, 1559585226005544595), AircraftSimplePropulsion)
agcls.AgTypeNameMap["AircraftSimplePropulsion"] = AircraftSimplePropulsion

class AircraftExternalPropulsion(SupportsDeleteCallback):
    """Interface used to access the External File Propulsion options for the Basic Acceleration Model of an aircraft."""

    _num_methods = 12
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_propulsion_filepath_method_offset = 1
    _set_propulsion_filepath_method_offset = 2
    _reload_propulsion_file_method_offset = 3
    _get_is_valid_method_offset = 4
    _get_can_set_acceleration_deceleration_method_offset = 5
    _get_max_thrust_acceleration_method_offset = 6
    _set_max_thrust_acceleration_method_offset = 7
    _get_min_thrust_deceleration_method_offset = 8
    _set_min_thrust_deceleration_method_offset = 9
    _get_use_density_scaling_method_offset = 10
    _get_density_ratio_exponent_method_offset = 11
    _set_density_scaling_method_offset = 12
    _metadata = {
        "iid_data" : (4857533303974722191, 17014078191631793548),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftExternalPropulsion)

    _get_propulsion_filepath_metadata = { "offset" : _get_propulsion_filepath_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def propulsion_filepath(self) -> str:
        """Get the filepath for the prop file."""
        return self._intf.get_property(AircraftExternalPropulsion._metadata, AircraftExternalPropulsion._get_propulsion_filepath_metadata)

    _set_propulsion_filepath_metadata = { "offset" : _set_propulsion_filepath_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg,) }
    def set_propulsion_filepath(self, filepath:str) -> str:
        """Set the filepath for the prop file."""
        return self._intf.invoke(AircraftExternalPropulsion._metadata, AircraftExternalPropulsion._set_propulsion_filepath_metadata, filepath, OutArg())

    _reload_propulsion_file_metadata = { "offset" : _reload_propulsion_file_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    def reload_propulsion_file(self) -> str:
        """Reload the prop file."""
        return self._intf.invoke(AircraftExternalPropulsion._metadata, AircraftExternalPropulsion._reload_propulsion_file_metadata, OutArg())

    _get_is_valid_metadata = { "offset" : _get_is_valid_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def is_valid(self) -> bool:
        """Check if the prop file is valid."""
        return self._intf.get_property(AircraftExternalPropulsion._metadata, AircraftExternalPropulsion._get_is_valid_metadata)

    _get_can_set_acceleration_deceleration_metadata = { "offset" : _get_can_set_acceleration_deceleration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def can_set_acceleration_deceleration(self) -> bool:
        """Check whether you can set the acceleration and deceleration values or whether they are specified in the file."""
        return self._intf.get_property(AircraftExternalPropulsion._metadata, AircraftExternalPropulsion._get_can_set_acceleration_deceleration_metadata)

    _get_max_thrust_acceleration_metadata = { "offset" : _get_max_thrust_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_thrust_acceleration(self) -> float:
        """Get or set the rate at which the aircraft speeds up at max throttle."""
        return self._intf.get_property(AircraftExternalPropulsion._metadata, AircraftExternalPropulsion._get_max_thrust_acceleration_metadata)

    _set_max_thrust_acceleration_metadata = { "offset" : _set_max_thrust_acceleration_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_thrust_acceleration.setter
    def max_thrust_acceleration(self, value:float) -> None:
        """Get or set the rate at which the aircraft speeds up at max throttle."""
        return self._intf.set_property(AircraftExternalPropulsion._metadata, AircraftExternalPropulsion._set_max_thrust_acceleration_metadata, value)

    _get_min_thrust_deceleration_metadata = { "offset" : _get_min_thrust_deceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_thrust_deceleration(self) -> float:
        """Get or set the rate at which the aircraft slows down at minimum throttle setting."""
        return self._intf.get_property(AircraftExternalPropulsion._metadata, AircraftExternalPropulsion._get_min_thrust_deceleration_metadata)

    _set_min_thrust_deceleration_metadata = { "offset" : _set_min_thrust_deceleration_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_thrust_deceleration.setter
    def min_thrust_deceleration(self, value:float) -> None:
        """Get or set the rate at which the aircraft slows down at minimum throttle setting."""
        return self._intf.set_property(AircraftExternalPropulsion._metadata, AircraftExternalPropulsion._set_min_thrust_deceleration_metadata, value)

    _get_use_density_scaling_metadata = { "offset" : _get_use_density_scaling_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_density_scaling(self) -> bool:
        """Opt whether to scale the accel/decel performance by the density ratio."""
        return self._intf.get_property(AircraftExternalPropulsion._metadata, AircraftExternalPropulsion._get_use_density_scaling_metadata)

    _get_density_ratio_exponent_metadata = { "offset" : _get_density_ratio_exponent_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def density_ratio_exponent(self) -> float:
        """Get the relative impace of atmospheric density on the aircraft's performance."""
        return self._intf.get_property(AircraftExternalPropulsion._metadata, AircraftExternalPropulsion._get_density_ratio_exponent_metadata)

    _set_density_scaling_metadata = { "offset" : _set_density_scaling_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.DoubleArg,) }
    def set_density_scaling(self, use_scaling:bool, exponent:float) -> None:
        """Set the option to use density scaling and set the density ratio exponent."""
        return self._intf.invoke(AircraftExternalPropulsion._metadata, AircraftExternalPropulsion._set_density_scaling_metadata, use_scaling, exponent)

    _property_names[propulsion_filepath] = "propulsion_filepath"
    _property_names[is_valid] = "is_valid"
    _property_names[can_set_acceleration_deceleration] = "can_set_acceleration_deceleration"
    _property_names[max_thrust_acceleration] = "max_thrust_acceleration"
    _property_names[min_thrust_deceleration] = "min_thrust_deceleration"
    _property_names[use_density_scaling] = "use_density_scaling"
    _property_names[density_ratio_exponent] = "density_ratio_exponent"

    def __init__(self, source_object=None):
        """Construct an object of type AircraftExternalPropulsion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AircraftExternalPropulsion)
    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, AircraftExternalPropulsion, [AircraftExternalPropulsion, ])

agcls.AgClassCatalog.add_catalog_entry((4931266991254779167, 11152857308621733023), AircraftExternalPropulsion)
agcls.AgTypeNameMap["AircraftExternalPropulsion"] = AircraftExternalPropulsion

class AircraftBasicFixedWingPropulsion(SupportsDeleteCallback):
    """Interface used to access the Basic Fixed Wing Propulsion options for the Basic Acceleration Model of an aircraft."""

    _num_methods = 23
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_propulsion_mode_method_offset = 1
    _set_propulsion_mode_method_offset = 2
    _get_propeller_count_method_offset = 3
    _set_propeller_count_method_offset = 4
    _get_propeller_diameter_method_offset = 5
    _set_propeller_diameter_method_offset = 6
    _get_propeller_rpm_method_offset = 7
    _set_propeller_rpm_method_offset = 8
    _get_min_power_thrust_method_offset = 9
    _set_min_power_thrust_method_offset = 10
    _get_min_fuel_flow_method_offset = 11
    _set_min_fuel_flow_method_offset = 12
    _get_max_power_thrust_method_offset = 13
    _set_max_power_thrust_method_offset = 14
    _get_max_fuel_flow_method_offset = 15
    _set_max_fuel_flow_method_offset = 16
    _get_max_thrust_acceleration_method_offset = 17
    _set_max_thrust_acceleration_method_offset = 18
    _get_min_thrust_deceleration_method_offset = 19
    _set_min_thrust_deceleration_method_offset = 20
    _get_use_density_scaling_method_offset = 21
    _get_density_ratio_exponent_method_offset = 22
    _set_density_scaling_method_offset = 23
    _metadata = {
        "iid_data" : (5283772667304000625, 2502042123150193025),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftBasicFixedWingPropulsion)

    _get_propulsion_mode_metadata = { "offset" : _get_propulsion_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicFixedWingPropulsionMode),) }
    @property
    def propulsion_mode(self) -> "BasicFixedWingPropulsionMode":
        """Get or set the option of whether to specify net thrust or net power."""
        return self._intf.get_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._get_propulsion_mode_metadata)

    _set_propulsion_mode_metadata = { "offset" : _set_propulsion_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BasicFixedWingPropulsionMode),) }
    @propulsion_mode.setter
    def propulsion_mode(self, value:"BasicFixedWingPropulsionMode") -> None:
        """Get or set the option of whether to specify net thrust or net power."""
        return self._intf.set_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._set_propulsion_mode_metadata, value)

    _get_propeller_count_metadata = { "offset" : _get_propeller_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def propeller_count(self) -> int:
        """Get or set the number of propellers."""
        return self._intf.get_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._get_propeller_count_metadata)

    _set_propeller_count_metadata = { "offset" : _set_propeller_count_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @propeller_count.setter
    def propeller_count(self, value:int) -> None:
        """Get or set the number of propellers."""
        return self._intf.set_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._set_propeller_count_metadata, value)

    _get_propeller_diameter_metadata = { "offset" : _get_propeller_diameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def propeller_diameter(self) -> float:
        """Get or set the propeller diameter."""
        return self._intf.get_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._get_propeller_diameter_metadata)

    _set_propeller_diameter_metadata = { "offset" : _set_propeller_diameter_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @propeller_diameter.setter
    def propeller_diameter(self, value:float) -> None:
        """Get or set the propeller diameter."""
        return self._intf.set_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._set_propeller_diameter_metadata, value)

    _get_propeller_rpm_metadata = { "offset" : _get_propeller_rpm_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def propeller_rpm(self) -> float:
        """Get or set the propeller RPM."""
        return self._intf.get_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._get_propeller_rpm_metadata)

    _set_propeller_rpm_metadata = { "offset" : _set_propeller_rpm_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @propeller_rpm.setter
    def propeller_rpm(self, value:float) -> None:
        """Get or set the propeller RPM."""
        return self._intf.set_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._set_propeller_rpm_metadata, value)

    _get_min_power_thrust_metadata = { "offset" : _get_min_power_thrust_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_power_thrust(self) -> float:
        """Get or set the minimum power/thrust depending on the propulsion mode."""
        return self._intf.get_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._get_min_power_thrust_metadata)

    _set_min_power_thrust_metadata = { "offset" : _set_min_power_thrust_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_power_thrust.setter
    def min_power_thrust(self, value:float) -> None:
        """Get or set the minimum power/thrust depending on the propulsion mode."""
        return self._intf.set_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._set_min_power_thrust_metadata, value)

    _get_min_fuel_flow_metadata = { "offset" : _get_min_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_fuel_flow(self) -> float:
        """Get or set the fuel flow for the minimum thrust/power setting."""
        return self._intf.get_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._get_min_fuel_flow_metadata)

    _set_min_fuel_flow_metadata = { "offset" : _set_min_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_fuel_flow.setter
    def min_fuel_flow(self, value:float) -> None:
        """Get or set the fuel flow for the minimum thrust/power setting."""
        return self._intf.set_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._set_min_fuel_flow_metadata, value)

    _get_max_power_thrust_metadata = { "offset" : _get_max_power_thrust_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_power_thrust(self) -> float:
        """Get or set the maximum power/thrust depending on the propulsion mode."""
        return self._intf.get_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._get_max_power_thrust_metadata)

    _set_max_power_thrust_metadata = { "offset" : _set_max_power_thrust_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_power_thrust.setter
    def max_power_thrust(self, value:float) -> None:
        """Get or set the maximum power/thrust depending on the propulsion mode."""
        return self._intf.set_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._set_max_power_thrust_metadata, value)

    _get_max_fuel_flow_metadata = { "offset" : _get_max_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_fuel_flow(self) -> float:
        """Get or set the fuel flow for the maximum thrust/power setting."""
        return self._intf.get_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._get_max_fuel_flow_metadata)

    _set_max_fuel_flow_metadata = { "offset" : _set_max_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_fuel_flow.setter
    def max_fuel_flow(self, value:float) -> None:
        """Get or set the fuel flow for the maximum thrust/power setting."""
        return self._intf.set_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._set_max_fuel_flow_metadata, value)

    _get_max_thrust_acceleration_metadata = { "offset" : _get_max_thrust_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_thrust_acceleration(self) -> float:
        """Get or set the rate at which the aircraft speeds up at max throttle."""
        return self._intf.get_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._get_max_thrust_acceleration_metadata)

    _set_max_thrust_acceleration_metadata = { "offset" : _set_max_thrust_acceleration_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_thrust_acceleration.setter
    def max_thrust_acceleration(self, value:float) -> None:
        """Get or set the rate at which the aircraft speeds up at max throttle."""
        return self._intf.set_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._set_max_thrust_acceleration_metadata, value)

    _get_min_thrust_deceleration_metadata = { "offset" : _get_min_thrust_deceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_thrust_deceleration(self) -> float:
        """Get or set the rate at which the aircraft slows down at minimum throttle setting."""
        return self._intf.get_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._get_min_thrust_deceleration_metadata)

    _set_min_thrust_deceleration_metadata = { "offset" : _set_min_thrust_deceleration_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_thrust_deceleration.setter
    def min_thrust_deceleration(self, value:float) -> None:
        """Get or set the rate at which the aircraft slows down at minimum throttle setting."""
        return self._intf.set_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._set_min_thrust_deceleration_metadata, value)

    _get_use_density_scaling_metadata = { "offset" : _get_use_density_scaling_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_density_scaling(self) -> bool:
        """Opt whether to scale the accel/decel performance by the density ratio."""
        return self._intf.get_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._get_use_density_scaling_metadata)

    _get_density_ratio_exponent_metadata = { "offset" : _get_density_ratio_exponent_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def density_ratio_exponent(self) -> float:
        """Get the relative impace of atmospheric density on the aircraft's performance."""
        return self._intf.get_property(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._get_density_ratio_exponent_metadata)

    _set_density_scaling_metadata = { "offset" : _set_density_scaling_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.DoubleArg,) }
    def set_density_scaling(self, use_scaling:bool, exponent:float) -> None:
        """Set the option to use density scaling and set the density ratio exponent."""
        return self._intf.invoke(AircraftBasicFixedWingPropulsion._metadata, AircraftBasicFixedWingPropulsion._set_density_scaling_metadata, use_scaling, exponent)

    _property_names[propulsion_mode] = "propulsion_mode"
    _property_names[propeller_count] = "propeller_count"
    _property_names[propeller_diameter] = "propeller_diameter"
    _property_names[propeller_rpm] = "propeller_rpm"
    _property_names[min_power_thrust] = "min_power_thrust"
    _property_names[min_fuel_flow] = "min_fuel_flow"
    _property_names[max_power_thrust] = "max_power_thrust"
    _property_names[max_fuel_flow] = "max_fuel_flow"
    _property_names[max_thrust_acceleration] = "max_thrust_acceleration"
    _property_names[min_thrust_deceleration] = "min_thrust_deceleration"
    _property_names[use_density_scaling] = "use_density_scaling"
    _property_names[density_ratio_exponent] = "density_ratio_exponent"

    def __init__(self, source_object=None):
        """Construct an object of type AircraftBasicFixedWingPropulsion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AircraftBasicFixedWingPropulsion)
    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, AircraftBasicFixedWingPropulsion, [AircraftBasicFixedWingPropulsion, ])

agcls.AgClassCatalog.add_catalog_entry((5671810767600845155, 12908412790033902229), AircraftBasicFixedWingPropulsion)
agcls.AgTypeNameMap["AircraftBasicFixedWingPropulsion"] = AircraftBasicFixedWingPropulsion

class ARINC424Source(ICatalogSource, SupportsDeleteCallback):
    """Interface used to access the options for any ARINC424 source in the Aviator catalog."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_arinc424_item_method_offset = 1
    _get_use_master_data_file_method_offset = 2
    _set_use_master_data_file_method_offset = 3
    _get_master_data_filepath_method_offset = 4
    _set_master_data_filepath_method_offset = 5
    _get_override_data_filepath_method_offset = 6
    _set_override_data_filepath_method_offset = 7
    _get_as_catalog_source_method_offset = 8
    _metadata = {
        "iid_data" : (5252096220626246087, 6835548189431916434),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ARINC424Source)

    _get_arinc424_item_metadata = { "offset" : _get_arinc424_item_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_arinc424_item(self, name:str) -> "IARINC424Item":
        """Get the ARINC-424 item with the given name."""
        return self._intf.invoke(ARINC424Source._metadata, ARINC424Source._get_arinc424_item_metadata, name, OutArg())

    _get_use_master_data_file_metadata = { "offset" : _get_use_master_data_file_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_master_data_file(self) -> bool:
        """Opt whether to use the master data file."""
        return self._intf.get_property(ARINC424Source._metadata, ARINC424Source._get_use_master_data_file_metadata)

    _set_use_master_data_file_metadata = { "offset" : _set_use_master_data_file_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_master_data_file.setter
    def use_master_data_file(self, value:bool) -> None:
        """Opt whether to use the master data file."""
        return self._intf.set_property(ARINC424Source._metadata, ARINC424Source._set_use_master_data_file_metadata, value)

    _get_master_data_filepath_metadata = { "offset" : _get_master_data_filepath_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def master_data_filepath(self) -> str:
        """Get or set the master data file path."""
        return self._intf.get_property(ARINC424Source._metadata, ARINC424Source._get_master_data_filepath_metadata)

    _set_master_data_filepath_metadata = { "offset" : _set_master_data_filepath_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @master_data_filepath.setter
    def master_data_filepath(self, value:str) -> None:
        """Get or set the master data file path."""
        return self._intf.set_property(ARINC424Source._metadata, ARINC424Source._set_master_data_filepath_metadata, value)

    _get_override_data_filepath_metadata = { "offset" : _get_override_data_filepath_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def override_data_filepath(self) -> str:
        """Get or set the file path to the data overriding the mader data file."""
        return self._intf.get_property(ARINC424Source._metadata, ARINC424Source._get_override_data_filepath_metadata)

    _set_override_data_filepath_metadata = { "offset" : _set_override_data_filepath_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @override_data_filepath.setter
    def override_data_filepath(self, value:str) -> None:
        """Get or set the file path to the data overriding the mader data file."""
        return self._intf.set_property(ARINC424Source._metadata, ARINC424Source._set_override_data_filepath_metadata, value)

    _get_as_catalog_source_metadata = { "offset" : _get_as_catalog_source_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_source(self) -> "ICatalogSource":
        """Get the catalog source interface for this object."""
        return self._intf.invoke(ARINC424Source._metadata, ARINC424Source._get_as_catalog_source_metadata, OutArg())

    _property_names[use_master_data_file] = "use_master_data_file"
    _property_names[master_data_filepath] = "master_data_filepath"
    _property_names[override_data_filepath] = "override_data_filepath"

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

agcls.AgClassCatalog.add_catalog_entry((4990508709075858532, 869911397036924554), ARINC424Source)
agcls.AgTypeNameMap["ARINC424Source"] = ARINC424Source

class DAFIFSource(ICatalogSource, SupportsDeleteCallback):
    """Interface used to access the options for any DAFIF source in the Aviator catalog."""

    _num_methods = 7
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_dafif_item_method_offset = 1
    _get_data_path_method_offset = 2
    _set_data_path_method_offset = 3
    _get_effective_date_method_offset = 4
    _get_expiration_date_method_offset = 5
    _get_spec_revision_method_offset = 6
    _get_as_catalog_source_method_offset = 7
    _metadata = {
        "iid_data" : (4761423141073607641, 6693699497707172788),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, DAFIFSource)

    _get_dafif_item_metadata = { "offset" : _get_dafif_item_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_dafif_item(self, name:str) -> "IDAFIFItem":
        """Get the DAFIF item with the given name."""
        return self._intf.invoke(DAFIFSource._metadata, DAFIFSource._get_dafif_item_metadata, name, OutArg())

    _get_data_path_metadata = { "offset" : _get_data_path_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def data_path(self) -> str:
        """Get or set the DAFIF data path."""
        return self._intf.get_property(DAFIFSource._metadata, DAFIFSource._get_data_path_metadata)

    _set_data_path_metadata = { "offset" : _set_data_path_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @data_path.setter
    def data_path(self, value:str) -> None:
        """Get or set the DAFIF data path."""
        return self._intf.set_property(DAFIFSource._metadata, DAFIFSource._set_data_path_metadata, value)

    _get_effective_date_metadata = { "offset" : _get_effective_date_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def effective_date(self) -> str:
        """Get the effective date of the DAFIF catalog."""
        return self._intf.get_property(DAFIFSource._metadata, DAFIFSource._get_effective_date_metadata)

    _get_expiration_date_metadata = { "offset" : _get_expiration_date_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def expiration_date(self) -> str:
        """Get the expiration date of the DAFIF catalog."""
        return self._intf.get_property(DAFIFSource._metadata, DAFIFSource._get_expiration_date_metadata)

    _get_spec_revision_metadata = { "offset" : _get_spec_revision_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def spec_revision(self) -> str:
        """Get the DAFIF edition."""
        return self._intf.get_property(DAFIFSource._metadata, DAFIFSource._get_spec_revision_metadata)

    _get_as_catalog_source_metadata = { "offset" : _get_as_catalog_source_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_source(self) -> "ICatalogSource":
        """Get the catalog source interface for this object."""
        return self._intf.invoke(DAFIFSource._metadata, DAFIFSource._get_as_catalog_source_metadata, OutArg())

    _property_names[data_path] = "data_path"
    _property_names[effective_date] = "effective_date"
    _property_names[expiration_date] = "expiration_date"
    _property_names[spec_revision] = "spec_revision"

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

agcls.AgClassCatalog.add_catalog_entry((4669407446549507698, 4351897649948657831), DAFIFSource)
agcls.AgTypeNameMap["DAFIFSource"] = DAFIFSource

class BasicFixedWingForwardFlightLiftHelper(IBasicFixedWingLiftHelper, SupportsDeleteCallback):
    """Class defining the Lift Coefficient Helper for Forward Flight in the Basic Fixed Wing Aerodynamics interface for the Basic Acceleration Model of an aircraft."""
    def __init__(self, source_object=None):
        """Construct an object of type BasicFixedWingForwardFlightLiftHelper."""
        SupportsDeleteCallback.__init__(self)
        IBasicFixedWingLiftHelper.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IBasicFixedWingLiftHelper._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, BasicFixedWingForwardFlightLiftHelper, [IBasicFixedWingLiftHelper])

agcls.AgClassCatalog.add_catalog_entry((4835967416678721147, 2787928793404869025), BasicFixedWingForwardFlightLiftHelper)
agcls.AgTypeNameMap["BasicFixedWingForwardFlightLiftHelper"] = BasicFixedWingForwardFlightLiftHelper

class BasicManeuverStrategyStraightAhead(IBasicManeuverStrategy, SupportsDeleteCallback):
    """
    Interface used to access options for a Straight Ahead Strategy of a Basic Maneuver Procedure.

    Examples
    --------
    Add and configure a basic maneuver procedure:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add a basic maneuver procedure
    >>> basicManeuver = procedures.add(SiteType.SITE_END_OF_PREV_PROCEDURE, ProcedureType.PROCEDURE_BASIC_MANEUVER)
    >>>
    >>> # Set the navigation to use a Straight Ahead strategy
    >>> basicManeuver.navigation_strategy_type = "Straight Ahead"
    >>> # Get the options for the straight ahead strategy
    >>> straightAhead = basicManeuver.navigation
    >>> # Opt to maintain course (as opposed to maintain heading)
    >>> straightAhead.reference_frame = StraightAheadReferenceFrame.MAINTAIN_COURSE
    >>>
    >>> # Set the profile to use a Autopilot - Vertical Plane strategy
    >>> basicManeuver.profile_strategy_type = "Autopilot - Vertical Plane"
    >>> # Get the options for the profile strategy
    >>> autopilot = basicManeuver.profile
    >>> # Opt to maintain the initial altitude
    >>> autopilot.altitude_mode = AutopilotAltitudeMode.AUTOPILOT_HOLD_INIT_ALTITUDE
    >>> airspeedOptions = autopilot.airspeed_options
    >>> # Opt to maintain a specified airspeed
    >>> airspeedOptions.airspeed_mode = BasicManeuverAirspeedMode.MAINTAIN_SPECIFIED_AIRSPEED
    >>> # Specify the airspeed
    >>> airspeedOptions.specified_airspeed = 250
    >>>
    >>> # Configure the options on the Attitude / Performance / Fuel page
    >>> basicManeuver.flight_mode = PhaseOfFlight.FLIGHT_PHASE_CRUISE
    >>> # Override the fuel flow
    >>> basicManeuver.fuel_flow_type = BasicManeuverFuelFlowType.BASIC_MANEUVER_FUEL_FLOW_OVERRIDE
    >>> basicManeuver.override_fuel_flow_value = 1000
    >>>
    >>> # Set the basic stopping conditions
    >>> basicManeuver.use_max_downrange = True
    >>> basicManeuver.max_downrange = 10
    >>> basicManeuver.use_stop_fuel_state = False
    >>> basicManeuver.use_max_time_of_flight = False
    """

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_reference_frame_method_offset = 1
    _set_reference_frame_method_offset = 2
    _get_compensate_for_coriolis_acceleration_method_offset = 3
    _set_compensate_for_coriolis_acceleration_method_offset = 4
    _metadata = {
        "iid_data" : (5334953136761860956, 12274532353622486171),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyStraightAhead)

    _get_reference_frame_metadata = { "offset" : _get_reference_frame_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(StraightAheadReferenceFrame),) }
    @property
    def reference_frame(self) -> "StraightAheadReferenceFrame":
        """Get or set the reference frame the aircraft will use to fly straight ahead."""
        return self._intf.get_property(BasicManeuverStrategyStraightAhead._metadata, BasicManeuverStrategyStraightAhead._get_reference_frame_metadata)

    _set_reference_frame_metadata = { "offset" : _set_reference_frame_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(StraightAheadReferenceFrame),) }
    @reference_frame.setter
    def reference_frame(self, value:"StraightAheadReferenceFrame") -> None:
        return self._intf.set_property(BasicManeuverStrategyStraightAhead._metadata, BasicManeuverStrategyStraightAhead._set_reference_frame_metadata, value)

    _get_compensate_for_coriolis_acceleration_metadata = { "offset" : _get_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def compensate_for_coriolis_acceleration(self) -> bool:
        """Get or set the option to compensate for the acceleration due to the Coriolis effect."""
        return self._intf.get_property(BasicManeuverStrategyStraightAhead._metadata, BasicManeuverStrategyStraightAhead._get_compensate_for_coriolis_acceleration_metadata)

    _set_compensate_for_coriolis_acceleration_metadata = { "offset" : _set_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @compensate_for_coriolis_acceleration.setter
    def compensate_for_coriolis_acceleration(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyStraightAhead._metadata, BasicManeuverStrategyStraightAhead._set_compensate_for_coriolis_acceleration_metadata, value)

    _property_names[reference_frame] = "reference_frame"
    _property_names[compensate_for_coriolis_acceleration] = "compensate_for_coriolis_acceleration"

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

agcls.AgClassCatalog.add_catalog_entry((5762754887795241020, 9551154128583839911), BasicManeuverStrategyStraightAhead)
agcls.AgTypeNameMap["BasicManeuverStrategyStraightAhead"] = BasicManeuverStrategyStraightAhead

class BasicManeuverStrategyCruiseProfile(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Cruise Profile Strategy of a Basic Maneuver Procedure."""

    _num_methods = 13
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_reference_frame_method_offset = 1
    _set_reference_frame_method_offset = 2
    _get_use_default_cruise_altitude_method_offset = 3
    _set_use_default_cruise_altitude_method_offset = 4
    _get_level_off_method_offset = 5
    _set_level_off_method_offset = 6
    _get_requested_altitude_method_offset = 7
    _set_requested_altitude_method_offset = 8
    _get_cruise_airspeed_options_method_offset = 9
    _get_stop_after_level_off_method_offset = 10
    _set_stop_after_level_off_method_offset = 11
    _get_compensate_for_coriolis_acceleration_method_offset = 12
    _set_compensate_for_coriolis_acceleration_method_offset = 13
    _metadata = {
        "iid_data" : (5262849801508960856, 3879152463803584443),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyCruiseProfile)

    _get_reference_frame_metadata = { "offset" : _get_reference_frame_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverReferenceFrame),) }
    @property
    def reference_frame(self) -> "BasicManeuverReferenceFrame":
        """Get or set the reference frame the aircraft will use. Earth Frame will force the aircraft to overcome wind effects. Wind frame will allow the maneuver to be perturbed by wind."""
        return self._intf.get_property(BasicManeuverStrategyCruiseProfile._metadata, BasicManeuverStrategyCruiseProfile._get_reference_frame_metadata)

    _set_reference_frame_metadata = { "offset" : _set_reference_frame_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverReferenceFrame),) }
    @reference_frame.setter
    def reference_frame(self, value:"BasicManeuverReferenceFrame") -> None:
        return self._intf.set_property(BasicManeuverStrategyCruiseProfile._metadata, BasicManeuverStrategyCruiseProfile._set_reference_frame_metadata, value)

    _get_use_default_cruise_altitude_metadata = { "offset" : _get_use_default_cruise_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_default_cruise_altitude(self) -> bool:
        """Opt whether to use the aircraft's default cruise altitude."""
        return self._intf.get_property(BasicManeuverStrategyCruiseProfile._metadata, BasicManeuverStrategyCruiseProfile._get_use_default_cruise_altitude_metadata)

    _set_use_default_cruise_altitude_metadata = { "offset" : _set_use_default_cruise_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_default_cruise_altitude.setter
    def use_default_cruise_altitude(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyCruiseProfile._metadata, BasicManeuverStrategyCruiseProfile._set_use_default_cruise_altitude_metadata, value)

    _get_level_off_metadata = { "offset" : _get_level_off_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def level_off(self) -> bool:
        """Opt whether to require the aircraft to level off at the specified altitude. This altitude is only enabled of the Default Cruise Altitude option is not selected."""
        return self._intf.get_property(BasicManeuverStrategyCruiseProfile._metadata, BasicManeuverStrategyCruiseProfile._get_level_off_metadata)

    _set_level_off_metadata = { "offset" : _set_level_off_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @level_off.setter
    def level_off(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyCruiseProfile._metadata, BasicManeuverStrategyCruiseProfile._set_level_off_metadata, value)

    _get_requested_altitude_metadata = { "offset" : _get_requested_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def requested_altitude(self) -> float:
        """Get or set the desired MSL Altitude for the maneuver. This altitude is only enabled of the Default Cruise Altitude option is not selected."""
        return self._intf.get_property(BasicManeuverStrategyCruiseProfile._metadata, BasicManeuverStrategyCruiseProfile._get_requested_altitude_metadata)

    _set_requested_altitude_metadata = { "offset" : _set_requested_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @requested_altitude.setter
    def requested_altitude(self, value:float) -> None:
        return self._intf.set_property(BasicManeuverStrategyCruiseProfile._metadata, BasicManeuverStrategyCruiseProfile._set_requested_altitude_metadata, value)

    _get_cruise_airspeed_options_metadata = { "offset" : _get_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the interface for the cruise airspeed options."""
        return self._intf.get_property(BasicManeuverStrategyCruiseProfile._metadata, BasicManeuverStrategyCruiseProfile._get_cruise_airspeed_options_metadata)

    _get_stop_after_level_off_metadata = { "offset" : _get_stop_after_level_off_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def stop_after_level_off(self) -> bool:
        """Select to stop the maneuver as soon as the aircraft achieves its goal altitude and levels off, regardless if any basic stopping conditions have been triggered."""
        return self._intf.get_property(BasicManeuverStrategyCruiseProfile._metadata, BasicManeuverStrategyCruiseProfile._get_stop_after_level_off_metadata)

    _set_stop_after_level_off_metadata = { "offset" : _set_stop_after_level_off_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @stop_after_level_off.setter
    def stop_after_level_off(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyCruiseProfile._metadata, BasicManeuverStrategyCruiseProfile._set_stop_after_level_off_metadata, value)

    _get_compensate_for_coriolis_acceleration_metadata = { "offset" : _get_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def compensate_for_coriolis_acceleration(self) -> bool:
        """Get or set the option to compensate for the acceleration due to the Coriolis effect."""
        return self._intf.get_property(BasicManeuverStrategyCruiseProfile._metadata, BasicManeuverStrategyCruiseProfile._get_compensate_for_coriolis_acceleration_metadata)

    _set_compensate_for_coriolis_acceleration_metadata = { "offset" : _set_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @compensate_for_coriolis_acceleration.setter
    def compensate_for_coriolis_acceleration(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyCruiseProfile._metadata, BasicManeuverStrategyCruiseProfile._set_compensate_for_coriolis_acceleration_metadata, value)

    _property_names[reference_frame] = "reference_frame"
    _property_names[use_default_cruise_altitude] = "use_default_cruise_altitude"
    _property_names[level_off] = "level_off"
    _property_names[requested_altitude] = "requested_altitude"
    _property_names[cruise_airspeed_options] = "cruise_airspeed_options"
    _property_names[stop_after_level_off] = "stop_after_level_off"
    _property_names[compensate_for_coriolis_acceleration] = "compensate_for_coriolis_acceleration"

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

agcls.AgClassCatalog.add_catalog_entry((5155340788332291990, 16249532636986922650), BasicManeuverStrategyCruiseProfile)
agcls.AgTypeNameMap["BasicManeuverStrategyCruiseProfile"] = BasicManeuverStrategyCruiseProfile

class BasicManeuverStrategyGlideProfile(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Glide Profile Strategy of a Basic Maneuver Procedure."""

    _num_methods = 21
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_hold_initial_airspeed_method_offset = 1
    _set_hold_initial_airspeed_method_offset = 2
    _get_airspeed_method_offset = 3
    _get_airspeed_type_method_offset = 4
    _get_min_g_method_offset = 5
    _set_min_g_method_offset = 6
    _get_max_g_method_offset = 7
    _set_max_g_method_offset = 8
    _get_max_speed_limits_method_offset = 9
    _set_max_speed_limits_method_offset = 10
    _set_airspeed_method_offset = 11
    _get_compensate_for_coriolis_acceleration_method_offset = 12
    _set_compensate_for_coriolis_acceleration_method_offset = 13
    _get_powered_cruise_mode_method_offset = 14
    _set_powered_cruise_mode_method_offset = 15
    _get_powered_cruise_throttle_method_offset = 16
    _set_powered_cruise_throttle_method_offset = 17
    _get_powered_cruise_thrust_model_method_offset = 18
    _get_glide_speed_control_mode_method_offset = 19
    _get_glide_speed_control_altitude_method_offset = 20
    _set_glide_speed_control_mode_method_offset = 21
    _metadata = {
        "iid_data" : (4628954868529909208, 11969696804235099030),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyGlideProfile)

    _get_hold_initial_airspeed_metadata = { "offset" : _get_hold_initial_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def hold_initial_airspeed(self) -> bool:
        """Select whether to maintain the airspeed of the aircraft at the beginning of the procedure throughout the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._get_hold_initial_airspeed_metadata)

    _set_hold_initial_airspeed_metadata = { "offset" : _set_hold_initial_airspeed_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @hold_initial_airspeed.setter
    def hold_initial_airspeed(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._set_hold_initial_airspeed_metadata, value)

    _get_airspeed_metadata = { "offset" : _get_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def airspeed(self) -> float:
        """Get the airspeed the aircraft will attempt to achieve and maintain if the hold initial airspeed option is not enabled."""
        return self._intf.get_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._get_airspeed_metadata)

    _get_airspeed_type_metadata = { "offset" : _get_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type."""
        return self._intf.get_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._get_airspeed_type_metadata)

    _get_min_g_metadata = { "offset" : _get_min_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_g(self) -> float:
        """Get or set the minimum load factor the aircraft can withstand."""
        return self._intf.get_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._get_min_g_metadata)

    _set_min_g_metadata = { "offset" : _set_min_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_g.setter
    def min_g(self, value:float) -> None:
        return self._intf.set_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._set_min_g_metadata, value)

    _get_max_g_metadata = { "offset" : _get_max_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_g(self) -> float:
        """Get or set the maximum load factor the aircraft can withstand."""
        return self._intf.get_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._get_max_g_metadata)

    _set_max_g_metadata = { "offset" : _set_max_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_g.setter
    def max_g(self, value:float) -> None:
        return self._intf.set_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._set_max_g_metadata, value)

    _get_max_speed_limits_metadata = { "offset" : _get_max_speed_limits_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyAirspeedPerformanceLimits),) }
    @property
    def max_speed_limits(self) -> "BasicManeuverStrategyAirspeedPerformanceLimits":
        """Get or set the options of what the procedure will do if the aircraft has exceeded the maximum speed limits."""
        return self._intf.get_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._get_max_speed_limits_metadata)

    _set_max_speed_limits_metadata = { "offset" : _set_max_speed_limits_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyAirspeedPerformanceLimits),) }
    @max_speed_limits.setter
    def max_speed_limits(self, value:"BasicManeuverStrategyAirspeedPerformanceLimits") -> None:
        return self._intf.set_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._set_max_speed_limits_metadata, value)

    _set_airspeed_metadata = { "offset" : _set_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the airspeed and airspeed type that the aircraft will attempt to achieve and maintain if the hold initial airspeed option is not enabled."""
        return self._intf.invoke(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._set_airspeed_metadata, airspeed_type, airspeed)

    _get_compensate_for_coriolis_acceleration_metadata = { "offset" : _get_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def compensate_for_coriolis_acceleration(self) -> bool:
        """Get or set the option to compensate for the acceleration due to the Coriolis effect."""
        return self._intf.get_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._get_compensate_for_coriolis_acceleration_metadata)

    _set_compensate_for_coriolis_acceleration_metadata = { "offset" : _set_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @compensate_for_coriolis_acceleration.setter
    def compensate_for_coriolis_acceleration(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._set_compensate_for_coriolis_acceleration_metadata, value)

    _get_powered_cruise_mode_metadata = { "offset" : _get_powered_cruise_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyPoweredCruiseMode),) }
    @property
    def powered_cruise_mode(self) -> "BasicManeuverStrategyPoweredCruiseMode":
        """Get or set the powered cruise mode."""
        return self._intf.get_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._get_powered_cruise_mode_metadata)

    _set_powered_cruise_mode_metadata = { "offset" : _set_powered_cruise_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyPoweredCruiseMode),) }
    @powered_cruise_mode.setter
    def powered_cruise_mode(self, value:"BasicManeuverStrategyPoweredCruiseMode") -> None:
        return self._intf.set_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._set_powered_cruise_mode_metadata, value)

    _get_powered_cruise_throttle_metadata = { "offset" : _get_powered_cruise_throttle_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def powered_cruise_throttle(self) -> float:
        """Get or set the powered cruise throttle."""
        return self._intf.get_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._get_powered_cruise_throttle_metadata)

    _set_powered_cruise_throttle_metadata = { "offset" : _set_powered_cruise_throttle_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @powered_cruise_throttle.setter
    def powered_cruise_throttle(self, value:float) -> None:
        return self._intf.set_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._set_powered_cruise_throttle_metadata, value)

    _get_powered_cruise_thrust_model_metadata = { "offset" : _get_powered_cruise_thrust_model_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def powered_cruise_thrust_model(self) -> "PropulsionThrust":
        """Get the powered cruise thrust model."""
        return self._intf.get_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._get_powered_cruise_thrust_model_metadata)

    _get_glide_speed_control_mode_metadata = { "offset" : _get_glide_speed_control_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverGlideSpeedControlMode),) }
    @property
    def glide_speed_control_mode(self) -> "BasicManeuverGlideSpeedControlMode":
        """Get the glide speed control mode."""
        return self._intf.get_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._get_glide_speed_control_mode_metadata)

    _get_glide_speed_control_altitude_metadata = { "offset" : _get_glide_speed_control_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def glide_speed_control_altitude(self) -> float:
        """Get the glide speed altitude when using the altitude control mode."""
        return self._intf.get_property(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._get_glide_speed_control_altitude_metadata)

    _set_glide_speed_control_mode_metadata = { "offset" : _set_glide_speed_control_mode_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverGlideSpeedControlMode), agmarshall.DoubleArg,) }
    def set_glide_speed_control_mode(self, glide_speed_mode:"BasicManeuverGlideSpeedControlMode", control_altitude:float) -> None:
        """Set the glide speed control mode and altitude."""
        return self._intf.invoke(BasicManeuverStrategyGlideProfile._metadata, BasicManeuverStrategyGlideProfile._set_glide_speed_control_mode_metadata, glide_speed_mode, control_altitude)

    _property_names[hold_initial_airspeed] = "hold_initial_airspeed"
    _property_names[airspeed] = "airspeed"
    _property_names[airspeed_type] = "airspeed_type"
    _property_names[min_g] = "min_g"
    _property_names[max_g] = "max_g"
    _property_names[max_speed_limits] = "max_speed_limits"
    _property_names[compensate_for_coriolis_acceleration] = "compensate_for_coriolis_acceleration"
    _property_names[powered_cruise_mode] = "powered_cruise_mode"
    _property_names[powered_cruise_throttle] = "powered_cruise_throttle"
    _property_names[powered_cruise_thrust_model] = "powered_cruise_thrust_model"
    _property_names[glide_speed_control_mode] = "glide_speed_control_mode"
    _property_names[glide_speed_control_altitude] = "glide_speed_control_altitude"

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

agcls.AgClassCatalog.add_catalog_entry((4657086743565098834, 777569838434134160), BasicManeuverStrategyGlideProfile)
agcls.AgTypeNameMap["BasicManeuverStrategyGlideProfile"] = BasicManeuverStrategyGlideProfile

class AircraftModels(ICatalogSource, SupportsDeleteCallback):
    """
    Interface for the User Aircraft Models in the Aviator Catalog.

    Examples
    --------
    Set the aircraft used for the mission to an aircraft found in the Aviator catalog:
    >>> # AviatorPropagator propagator: Aviator Propagator object
    >>> # Get the Aviator catalog
    >>> catalog = propagator.aviator_catalog
    >>> # Get the aircraft category
    >>> category = catalog.aircraft_category
    >>> # Get the user aircraft models
    >>> aircraftModels = category.aircraft_models
    >>> # Get the basic fighter
    >>> fighter = aircraftModels.get_aircraft("Basic Fighter")
    >>> # Get the mission
    >>> mission = propagator.aviator_mission
    >>> # Set the vehicle used for the mission
    >>> mission.vehicle = fighter
    """

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_aircraft_method_offset = 1
    _add_aircraft_method_offset = 2
    _get_as_catalog_source_method_offset = 3
    _metadata = {
        "iid_data" : (5532977963223465883, 2562918225304965306),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftModels)

    _get_aircraft_metadata = { "offset" : _get_aircraft_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_aircraft(self, aircraft_name:str) -> "AircraftModel":
        """Get the aircraft with the given name."""
        return self._intf.invoke(AircraftModels._metadata, AircraftModels._get_aircraft_metadata, aircraft_name, OutArg())

    _add_aircraft_metadata = { "offset" : _add_aircraft_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add_aircraft(self, aircraft_name:str) -> "AircraftModel":
        """Create a new aircraft with the given name."""
        return self._intf.invoke(AircraftModels._metadata, AircraftModels._add_aircraft_metadata, aircraft_name, OutArg())

    _get_as_catalog_source_metadata = { "offset" : _get_as_catalog_source_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_source(self) -> "ICatalogSource":
        """Get the catalog source interface for this object."""
        return self._intf.invoke(AircraftModels._metadata, AircraftModels._get_as_catalog_source_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((5011113197862459825, 1955468045810840253), AircraftModels)
agcls.AgTypeNameMap["AircraftModels"] = AircraftModels

class MissileModels(ICatalogSource, SupportsDeleteCallback):
    """Interface for the User Missile Models in the Aviator Catalog."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_missile_method_offset = 1
    _add_missile_method_offset = 2
    _get_as_catalog_source_method_offset = 3
    _metadata = {
        "iid_data" : (5743346569435433873, 13121286000592656059),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MissileModels)

    _get_missile_metadata = { "offset" : _get_missile_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_missile(self, name:str) -> "MissileModel":
        """Get the missile with the given name."""
        return self._intf.invoke(MissileModels._metadata, MissileModels._get_missile_metadata, name, OutArg())

    _add_missile_metadata = { "offset" : _add_missile_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add_missile(self, name:str) -> "MissileModel":
        """Create a new missile with the given name."""
        return self._intf.invoke(MissileModels._metadata, MissileModels._add_missile_metadata, name, OutArg())

    _get_as_catalog_source_metadata = { "offset" : _get_as_catalog_source_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_source(self) -> "ICatalogSource":
        """Get the catalog source interface for this object."""
        return self._intf.invoke(MissileModels._metadata, MissileModels._get_as_catalog_source_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((5458626493784151642, 8851974794936787594), MissileModels)
agcls.AgTypeNameMap["MissileModels"] = MissileModels

class RotorcraftModels(ICatalogSource, SupportsDeleteCallback):
    """Interface for the User Rotorcraft Models in the Aviator Catalog."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_rotorcraft_method_offset = 1
    _add_rotorcraft_method_offset = 2
    _get_as_catalog_source_method_offset = 3
    _metadata = {
        "iid_data" : (4915094205029700951, 4941116414444796071),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, RotorcraftModels)

    _get_rotorcraft_metadata = { "offset" : _get_rotorcraft_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_rotorcraft(self, name:str) -> "RotorcraftModel":
        """Get the rotorcraft with the given name."""
        return self._intf.invoke(RotorcraftModels._metadata, RotorcraftModels._get_rotorcraft_metadata, name, OutArg())

    _add_rotorcraft_metadata = { "offset" : _add_rotorcraft_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add_rotorcraft(self, name:str) -> "RotorcraftModel":
        """Create a new rotorcraft with the given name."""
        return self._intf.invoke(RotorcraftModels._metadata, RotorcraftModels._add_rotorcraft_metadata, name, OutArg())

    _get_as_catalog_source_metadata = { "offset" : _get_as_catalog_source_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_source(self) -> "ICatalogSource":
        """Get the catalog source interface for this object."""
        return self._intf.invoke(RotorcraftModels._metadata, RotorcraftModels._get_as_catalog_source_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((4915131170068152456, 13033369765679804092), RotorcraftModels)
agcls.AgTypeNameMap["RotorcraftModels"] = RotorcraftModels

class Configuration(SupportsDeleteCallback):
    """
    Interface used to change an aircraft's configuration for an Aviator mission.

    Examples
    --------
    Set the Configuration used for the Mission:
    >>> # Mission mission: Aviator Mission object
    >>> # Get the configuration used for the mission
    >>> configuration = mission.configuration
    >>> # Set the max landing weight
    >>> configuration.max_landing_weight = 300000
    >>> # Set the empty weight
    >>> configuration.empty_weight = 210000
    >>> # Update the center of gravity of the aircraft when empty
    >>> configuration.set_empty_cg(2, 0, 1)
    >>>
    >>> # Get the stations
    >>> stations = configuration.get_stations()
    >>> # Check if there is an internal fuel station
    >>> if stations.contains_station("Internal Fuel") is True:
    >>>     # Get the fuel tank
    >>>     fuelTank = stations.get_internal_fuel_tank_by_name("Internal Fuel")
    >>>     # Set the capacity of the fuel tank
    >>>     fuelTank.capacity = 175000
    >>>     # Set the initial state of the fuel tank
    >>>     fuelTank.initial_fuel_state = 125000
    >>>
    >>> # Add a new payload station
    >>> newPayload = stations.add_payload_station()
    >>> # Set the position of the payload station
    >>> newPayload.set_position(0, 2, 0)
    >>> # Add an external fuel tank
    >>> externalTank = newPayload.add_external_fuel_tank()
    >>> # Set the empty weight of the tank
    >>> externalTank.empty_weight = 2000
    """

    _num_methods = 21
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_empty_weight_method_offset = 1
    _set_empty_weight_method_offset = 2
    _get_max_landing_weight_method_offset = 3
    _set_max_landing_weight_method_offset = 4
    _get_base_drag_index_method_offset = 5
    _set_base_drag_index_method_offset = 6
    _get_empty_cgx_method_offset = 7
    _get_empty_cgy_method_offset = 8
    _get_empty_cgz_method_offset = 9
    _set_empty_cg_method_offset = 10
    _get_total_weight_method_offset = 11
    _get_total_weight_max_fuel_method_offset = 12
    _get_total_drag_index_method_offset = 13
    _get_total_cgx_method_offset = 14
    _get_total_cgy_method_offset = 15
    _get_total_cgz_method_offset = 16
    _paste_configuration_method_offset = 17
    _get_stations_method_offset = 18
    _get_total_capacity_method_offset = 19
    _get_initial_fuel_state_method_offset = 20
    _save_method_offset = 21
    _metadata = {
        "iid_data" : (5280899498048713762, 810766960610207137),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, Configuration)

    _get_empty_weight_metadata = { "offset" : _get_empty_weight_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def empty_weight(self) -> float:
        """Get or set the empty weight of the aircraft."""
        return self._intf.get_property(Configuration._metadata, Configuration._get_empty_weight_metadata)

    _set_empty_weight_metadata = { "offset" : _set_empty_weight_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @empty_weight.setter
    def empty_weight(self, value:float) -> None:
        """Get or set the empty weight of the aircraft."""
        return self._intf.set_property(Configuration._metadata, Configuration._set_empty_weight_metadata, value)

    _get_max_landing_weight_metadata = { "offset" : _get_max_landing_weight_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_landing_weight(self) -> float:
        """Get or set the max landing weight of the aircraft."""
        return self._intf.get_property(Configuration._metadata, Configuration._get_max_landing_weight_metadata)

    _set_max_landing_weight_metadata = { "offset" : _set_max_landing_weight_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_landing_weight.setter
    def max_landing_weight(self, value:float) -> None:
        """Get or set the max landing weight of the aircraft."""
        return self._intf.set_property(Configuration._metadata, Configuration._set_max_landing_weight_metadata, value)

    _get_base_drag_index_metadata = { "offset" : _get_base_drag_index_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def base_drag_index(self) -> float:
        """Get or set the base drag index of the aircraft."""
        return self._intf.get_property(Configuration._metadata, Configuration._get_base_drag_index_metadata)

    _set_base_drag_index_metadata = { "offset" : _set_base_drag_index_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @base_drag_index.setter
    def base_drag_index(self, value:float) -> None:
        """Get or set the base drag index of the aircraft."""
        return self._intf.set_property(Configuration._metadata, Configuration._set_base_drag_index_metadata, value)

    _get_empty_cgx_metadata = { "offset" : _get_empty_cgx_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def empty_cgx(self) -> float:
        """Get the X value of the aircraft's Empty CG position."""
        return self._intf.get_property(Configuration._metadata, Configuration._get_empty_cgx_metadata)

    _get_empty_cgy_metadata = { "offset" : _get_empty_cgy_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def empty_cgy(self) -> float:
        """Get the Y value of the aircraft's Empty CG position."""
        return self._intf.get_property(Configuration._metadata, Configuration._get_empty_cgy_metadata)

    _get_empty_cgz_metadata = { "offset" : _get_empty_cgz_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def empty_cgz(self) -> float:
        """Get the Z value of the aircraft's Empty CG position."""
        return self._intf.get_property(Configuration._metadata, Configuration._get_empty_cgz_metadata)

    _set_empty_cg_metadata = { "offset" : _set_empty_cg_method_offset,
            "arg_types" : (agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg,) }
    def set_empty_cg(self, x:float, y:float, z:float) -> None:
        """Set the aircraft's Empty CG position."""
        return self._intf.invoke(Configuration._metadata, Configuration._set_empty_cg_metadata, x, y, z)

    _get_total_weight_metadata = { "offset" : _get_total_weight_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def total_weight(self) -> float:
        """Get the total weight of the aircraft."""
        return self._intf.get_property(Configuration._metadata, Configuration._get_total_weight_metadata)

    _get_total_weight_max_fuel_metadata = { "offset" : _get_total_weight_max_fuel_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def total_weight_max_fuel(self) -> float:
        """Get the total weight of the aircraft with all fuel tanks full."""
        return self._intf.get_property(Configuration._metadata, Configuration._get_total_weight_max_fuel_metadata)

    _get_total_drag_index_metadata = { "offset" : _get_total_drag_index_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def total_drag_index(self) -> float:
        """Get the total drag index of the aircraft."""
        return self._intf.get_property(Configuration._metadata, Configuration._get_total_drag_index_metadata)

    _get_total_cgx_metadata = { "offset" : _get_total_cgx_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def total_cgx(self) -> float:
        """Get the X value of the aircraft's Total CG position."""
        return self._intf.get_property(Configuration._metadata, Configuration._get_total_cgx_metadata)

    _get_total_cgy_metadata = { "offset" : _get_total_cgy_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def total_cgy(self) -> float:
        """Get the Y value of the aircraft's Total CG position."""
        return self._intf.get_property(Configuration._metadata, Configuration._get_total_cgy_metadata)

    _get_total_cgz_metadata = { "offset" : _get_total_cgz_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def total_cgz(self) -> float:
        """Get the Z value of the aircraft's Total CG position."""
        return self._intf.get_property(Configuration._metadata, Configuration._get_total_cgz_metadata)

    _paste_configuration_metadata = { "offset" : _paste_configuration_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("Configuration"),) }
    def paste_configuration(self, other_configuration:"Configuration") -> None:
        """Paste the aircraft's configuration."""
        return self._intf.invoke(Configuration._metadata, Configuration._paste_configuration_metadata, other_configuration)

    _get_stations_metadata = { "offset" : _get_stations_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_stations(self) -> "StationCollection":
        """Get a collection of the aircraft's payload stations."""
        return self._intf.invoke(Configuration._metadata, Configuration._get_stations_metadata, OutArg())

    _get_total_capacity_metadata = { "offset" : _get_total_capacity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def total_capacity(self) -> float:
        """Get the total fuel capacity of the aircraft."""
        return self._intf.get_property(Configuration._metadata, Configuration._get_total_capacity_metadata)

    _get_initial_fuel_state_metadata = { "offset" : _get_initial_fuel_state_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def initial_fuel_state(self) -> float:
        """Get the initial fuel state of the aircraft."""
        return self._intf.get_property(Configuration._metadata, Configuration._get_initial_fuel_state_metadata)

    _save_metadata = { "offset" : _save_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def save(self) -> None:
        """Save."""
        return self._intf.invoke(Configuration._metadata, Configuration._save_metadata, )

    _property_names[empty_weight] = "empty_weight"
    _property_names[max_landing_weight] = "max_landing_weight"
    _property_names[base_drag_index] = "base_drag_index"
    _property_names[empty_cgx] = "empty_cgx"
    _property_names[empty_cgy] = "empty_cgy"
    _property_names[empty_cgz] = "empty_cgz"
    _property_names[total_weight] = "total_weight"
    _property_names[total_weight_max_fuel] = "total_weight_max_fuel"
    _property_names[total_drag_index] = "total_drag_index"
    _property_names[total_cgx] = "total_cgx"
    _property_names[total_cgy] = "total_cgy"
    _property_names[total_cgz] = "total_cgz"
    _property_names[total_capacity] = "total_capacity"
    _property_names[initial_fuel_state] = "initial_fuel_state"

    def __init__(self, source_object=None):
        """Construct an object of type Configuration."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, Configuration)
    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, Configuration, [Configuration, ])

agcls.AgClassCatalog.add_catalog_entry((5502172263085938336, 11038115258664074394), Configuration)
agcls.AgTypeNameMap["Configuration"] = Configuration

class FuelTankInternal(IStation, SupportsDeleteCallback):
    """Interface used to set an aircraft's internal fuel tank."""

    _num_methods = 12
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_name_method_offset = 1
    _set_name_method_offset = 2
    _get_capacity_method_offset = 3
    _set_capacity_method_offset = 4
    _get_consumption_order_method_offset = 5
    _set_consumption_order_method_offset = 6
    _get_initial_fuel_state_method_offset = 7
    _set_initial_fuel_state_method_offset = 8
    _get_position_x_method_offset = 9
    _get_position_y_method_offset = 10
    _get_position_z_method_offset = 11
    _set_position_method_offset = 12
    _metadata = {
        "iid_data" : (5440065042223753089, 12828699753905969307),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, FuelTankInternal)

    _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 fuel tank."""
        return self._intf.get_property(FuelTankInternal._metadata, FuelTankInternal._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 fuel tank."""
        return self._intf.set_property(FuelTankInternal._metadata, FuelTankInternal._set_name_metadata, value)

    _get_capacity_metadata = { "offset" : _get_capacity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def capacity(self) -> float:
        """Get or set the capacity of the fuel tank."""
        return self._intf.get_property(FuelTankInternal._metadata, FuelTankInternal._get_capacity_metadata)

    _set_capacity_metadata = { "offset" : _set_capacity_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @capacity.setter
    def capacity(self, value:float) -> None:
        """Get or set the capacity of the fuel tank."""
        return self._intf.set_property(FuelTankInternal._metadata, FuelTankInternal._set_capacity_metadata, value)

    _get_consumption_order_metadata = { "offset" : _get_consumption_order_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def consumption_order(self) -> int:
        """Get or set the consumption order of the fuel tank."""
        return self._intf.get_property(FuelTankInternal._metadata, FuelTankInternal._get_consumption_order_metadata)

    _set_consumption_order_metadata = { "offset" : _set_consumption_order_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @consumption_order.setter
    def consumption_order(self, value:int) -> None:
        """Get or set the consumption order of the fuel tank."""
        return self._intf.set_property(FuelTankInternal._metadata, FuelTankInternal._set_consumption_order_metadata, value)

    _get_initial_fuel_state_metadata = { "offset" : _get_initial_fuel_state_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def initial_fuel_state(self) -> float:
        """Get or set the initial fuel state of the fuel tank."""
        return self._intf.get_property(FuelTankInternal._metadata, FuelTankInternal._get_initial_fuel_state_metadata)

    _set_initial_fuel_state_metadata = { "offset" : _set_initial_fuel_state_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @initial_fuel_state.setter
    def initial_fuel_state(self, value:float) -> None:
        """Get or set the initial fuel state of the fuel tank."""
        return self._intf.set_property(FuelTankInternal._metadata, FuelTankInternal._set_initial_fuel_state_metadata, value)

    _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 value of the fuel tank's parent relative position."""
        return self._intf.get_property(FuelTankInternal._metadata, FuelTankInternal._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 value of the fuel tank's parent relative position."""
        return self._intf.get_property(FuelTankInternal._metadata, FuelTankInternal._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 value of the fuel tank's parent relative position."""
        return self._intf.get_property(FuelTankInternal._metadata, FuelTankInternal._get_position_z_metadata)

    _set_position_metadata = { "offset" : _set_position_method_offset,
            "arg_types" : (agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg,) }
    def set_position(self, x:float, y:float, z:float) -> None:
        """Set the fuel tank's parent relative position."""
        return self._intf.invoke(FuelTankInternal._metadata, FuelTankInternal._set_position_metadata, x, y, z)

    _property_names[name] = "name"
    _property_names[capacity] = "capacity"
    _property_names[consumption_order] = "consumption_order"
    _property_names[initial_fuel_state] = "initial_fuel_state"
    _property_names[position_x] = "position_x"
    _property_names[position_y] = "position_y"
    _property_names[position_z] = "position_z"

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

agcls.AgClassCatalog.add_catalog_entry((5698710575945433930, 4905622930256443042), FuelTankInternal)
agcls.AgTypeNameMap["FuelTankInternal"] = FuelTankInternal

class FuelTankExternal(SupportsDeleteCallback):
    """
    Interface used to set an aircraft's external fuel tank.

    Examples
    --------
    Set the Configuration used for the Mission:
    >>> # Mission mission: Aviator Mission object
    >>> # Get the configuration used for the mission
    >>> configuration = mission.configuration
    >>> # Set the max landing weight
    >>> configuration.max_landing_weight = 300000
    >>> # Set the empty weight
    >>> configuration.empty_weight = 210000
    >>> # Update the center of gravity of the aircraft when empty
    >>> configuration.set_empty_cg(2, 0, 1)
    >>>
    >>> # Get the stations
    >>> stations = configuration.get_stations()
    >>> # Check if there is an internal fuel station
    >>> if stations.contains_station("Internal Fuel") is True:
    >>>     # Get the fuel tank
    >>>     fuelTank = stations.get_internal_fuel_tank_by_name("Internal Fuel")
    >>>     # Set the capacity of the fuel tank
    >>>     fuelTank.capacity = 175000
    >>>     # Set the initial state of the fuel tank
    >>>     fuelTank.initial_fuel_state = 125000
    >>>
    >>> # Add a new payload station
    >>> newPayload = stations.add_payload_station()
    >>> # Set the position of the payload station
    >>> newPayload.set_position(0, 2, 0)
    >>> # Add an external fuel tank
    >>> externalTank = newPayload.add_external_fuel_tank()
    >>> # Set the empty weight of the tank
    >>> externalTank.empty_weight = 2000
    """

    _num_methods = 12
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_name_method_offset = 1
    _set_name_method_offset = 2
    _get_empty_weight_method_offset = 3
    _set_empty_weight_method_offset = 4
    _get_capacity_method_offset = 5
    _set_capacity_method_offset = 6
    _get_initial_fuel_state_method_offset = 7
    _set_initial_fuel_state_method_offset = 8
    _get_consumption_order_method_offset = 9
    _set_consumption_order_method_offset = 10
    _get_drag_index_method_offset = 11
    _set_drag_index_method_offset = 12
    _metadata = {
        "iid_data" : (4846798690762926704, 3432907411207715728),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, FuelTankExternal)

    _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 fuel tank."""
        return self._intf.get_property(FuelTankExternal._metadata, FuelTankExternal._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 fuel tank."""
        return self._intf.set_property(FuelTankExternal._metadata, FuelTankExternal._set_name_metadata, value)

    _get_empty_weight_metadata = { "offset" : _get_empty_weight_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def empty_weight(self) -> float:
        """Get or set the empty weight of the fuel tank."""
        return self._intf.get_property(FuelTankExternal._metadata, FuelTankExternal._get_empty_weight_metadata)

    _set_empty_weight_metadata = { "offset" : _set_empty_weight_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @empty_weight.setter
    def empty_weight(self, value:float) -> None:
        """Get or set the empty weight of the fuel tank."""
        return self._intf.set_property(FuelTankExternal._metadata, FuelTankExternal._set_empty_weight_metadata, value)

    _get_capacity_metadata = { "offset" : _get_capacity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def capacity(self) -> float:
        """Get or set the capacity of the fuel tank."""
        return self._intf.get_property(FuelTankExternal._metadata, FuelTankExternal._get_capacity_metadata)

    _set_capacity_metadata = { "offset" : _set_capacity_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @capacity.setter
    def capacity(self, value:float) -> None:
        """Get or set the capacity of the fuel tank."""
        return self._intf.set_property(FuelTankExternal._metadata, FuelTankExternal._set_capacity_metadata, value)

    _get_initial_fuel_state_metadata = { "offset" : _get_initial_fuel_state_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def initial_fuel_state(self) -> float:
        """Get or set the initial fuel state of the fuel tank."""
        return self._intf.get_property(FuelTankExternal._metadata, FuelTankExternal._get_initial_fuel_state_metadata)

    _set_initial_fuel_state_metadata = { "offset" : _set_initial_fuel_state_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @initial_fuel_state.setter
    def initial_fuel_state(self, value:float) -> None:
        """Get or set the initial fuel state of the fuel tank."""
        return self._intf.set_property(FuelTankExternal._metadata, FuelTankExternal._set_initial_fuel_state_metadata, value)

    _get_consumption_order_metadata = { "offset" : _get_consumption_order_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def consumption_order(self) -> int:
        """Get or set the consumption order of the fuel tank."""
        return self._intf.get_property(FuelTankExternal._metadata, FuelTankExternal._get_consumption_order_metadata)

    _set_consumption_order_metadata = { "offset" : _set_consumption_order_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @consumption_order.setter
    def consumption_order(self, value:int) -> None:
        """Get or set the consumption order of the fuel tank."""
        return self._intf.set_property(FuelTankExternal._metadata, FuelTankExternal._set_consumption_order_metadata, value)

    _get_drag_index_metadata = { "offset" : _get_drag_index_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def drag_index(self) -> float:
        """Get or set the drag index of the fuel tank."""
        return self._intf.get_property(FuelTankExternal._metadata, FuelTankExternal._get_drag_index_metadata)

    _set_drag_index_metadata = { "offset" : _set_drag_index_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @drag_index.setter
    def drag_index(self, value:float) -> None:
        """Get or set the drag index of the fuel tank."""
        return self._intf.set_property(FuelTankExternal._metadata, FuelTankExternal._set_drag_index_metadata, value)

    _property_names[name] = "name"
    _property_names[empty_weight] = "empty_weight"
    _property_names[capacity] = "capacity"
    _property_names[initial_fuel_state] = "initial_fuel_state"
    _property_names[consumption_order] = "consumption_order"
    _property_names[drag_index] = "drag_index"

    def __init__(self, source_object=None):
        """Construct an object of type FuelTankExternal."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, FuelTankExternal)
    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, FuelTankExternal, [FuelTankExternal, ])

agcls.AgClassCatalog.add_catalog_entry((5088636907529171975, 9695710133478895033), FuelTankExternal)
agcls.AgTypeNameMap["FuelTankExternal"] = FuelTankExternal

class PayloadStation(IStation, SupportsDeleteCallback):
    """
    Interface used to set an aircraft's payload station.

    Examples
    --------
    Set the Configuration used for the Mission:
    >>> # Mission mission: Aviator Mission object
    >>> # Get the configuration used for the mission
    >>> configuration = mission.configuration
    >>> # Set the max landing weight
    >>> configuration.max_landing_weight = 300000
    >>> # Set the empty weight
    >>> configuration.empty_weight = 210000
    >>> # Update the center of gravity of the aircraft when empty
    >>> configuration.set_empty_cg(2, 0, 1)
    >>>
    >>> # Get the stations
    >>> stations = configuration.get_stations()
    >>> # Check if there is an internal fuel station
    >>> if stations.contains_station("Internal Fuel") is True:
    >>>     # Get the fuel tank
    >>>     fuelTank = stations.get_internal_fuel_tank_by_name("Internal Fuel")
    >>>     # Set the capacity of the fuel tank
    >>>     fuelTank.capacity = 175000
    >>>     # Set the initial state of the fuel tank
    >>>     fuelTank.initial_fuel_state = 125000
    >>>
    >>> # Add a new payload station
    >>> newPayload = stations.add_payload_station()
    >>> # Set the position of the payload station
    >>> newPayload.set_position(0, 2, 0)
    >>> # Add an external fuel tank
    >>> externalTank = newPayload.add_external_fuel_tank()
    >>> # Set the empty weight of the tank
    >>> externalTank.empty_weight = 2000
    """

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_name_method_offset = 1
    _set_name_method_offset = 2
    _get_position_x_method_offset = 3
    _get_position_y_method_offset = 4
    _get_position_z_method_offset = 5
    _set_position_method_offset = 6
    _remove_sub_item_method_offset = 7
    _add_external_fuel_tank_method_offset = 8
    _get_external_fuel_tank_method_offset = 9
    _metadata = {
        "iid_data" : (5521773172300241787, 15166706855028673429),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, PayloadStation)

    _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 payload station."""
        return self._intf.get_property(PayloadStation._metadata, PayloadStation._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 payload station."""
        return self._intf.set_property(PayloadStation._metadata, PayloadStation._set_name_metadata, value)

    _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 value of the payload station's parent relative position."""
        return self._intf.get_property(PayloadStation._metadata, PayloadStation._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 value of the payload station's parent relative position."""
        return self._intf.get_property(PayloadStation._metadata, PayloadStation._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 value of the payload station's parent relative position."""
        return self._intf.get_property(PayloadStation._metadata, PayloadStation._get_position_z_metadata)

    _set_position_metadata = { "offset" : _set_position_method_offset,
            "arg_types" : (agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg,) }
    def set_position(self, x:float, y:float, z:float) -> None:
        """Set the payload station's parent relative position."""
        return self._intf.invoke(PayloadStation._metadata, PayloadStation._set_position_metadata, x, y, z)

    _remove_sub_item_metadata = { "offset" : _remove_sub_item_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def remove_sub_item(self) -> None:
        """Remove any sub item that may be attached to the payload station."""
        return self._intf.invoke(PayloadStation._metadata, PayloadStation._remove_sub_item_metadata, )

    _add_external_fuel_tank_metadata = { "offset" : _add_external_fuel_tank_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def add_external_fuel_tank(self) -> "FuelTankExternal":
        """Add an external fuel tank to the payload station."""
        return self._intf.invoke(PayloadStation._metadata, PayloadStation._add_external_fuel_tank_metadata, OutArg())

    _get_external_fuel_tank_metadata = { "offset" : _get_external_fuel_tank_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_external_fuel_tank(self) -> "FuelTankExternal":
        """Get the external fuel tank attached to the payload station."""
        return self._intf.invoke(PayloadStation._metadata, PayloadStation._get_external_fuel_tank_metadata, OutArg())

    _property_names[name] = "name"
    _property_names[position_x] = "position_x"
    _property_names[position_y] = "position_y"
    _property_names[position_z] = "position_z"

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

agcls.AgClassCatalog.add_catalog_entry((4867009326142863941, 2812515302507571881), PayloadStation)
agcls.AgTypeNameMap["PayloadStation"] = PayloadStation

class StationCollection(SupportsDeleteCallback):
    """
    Interface used to access the list of stations for an Aviator aircraft.

    Examples
    --------
    Set the Configuration used for the Mission:
    >>> # Mission mission: Aviator Mission object
    >>> # Get the configuration used for the mission
    >>> configuration = mission.configuration
    >>> # Set the max landing weight
    >>> configuration.max_landing_weight = 300000
    >>> # Set the empty weight
    >>> configuration.empty_weight = 210000
    >>> # Update the center of gravity of the aircraft when empty
    >>> configuration.set_empty_cg(2, 0, 1)
    >>>
    >>> # Get the stations
    >>> stations = configuration.get_stations()
    >>> # Check if there is an internal fuel station
    >>> if stations.contains_station("Internal Fuel") is True:
    >>>     # Get the fuel tank
    >>>     fuelTank = stations.get_internal_fuel_tank_by_name("Internal Fuel")
    >>>     # Set the capacity of the fuel tank
    >>>     fuelTank.capacity = 175000
    >>>     # Set the initial state of the fuel tank
    >>>     fuelTank.initial_fuel_state = 125000
    >>>
    >>> # Add a new payload station
    >>> newPayload = stations.add_payload_station()
    >>> # Set the position of the payload station
    >>> newPayload.set_position(0, 2, 0)
    >>> # Add an external fuel tank
    >>> externalTank = newPayload.add_external_fuel_tank()
    >>> # Set the empty weight of the tank
    >>> externalTank.empty_weight = 2000
    """

    _num_methods = 11
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _get_count_method_offset = 1
    _item_method_offset = 2
    _get__new_enum_method_offset = 3
    _get_internal_fuel_tank_by_name_method_offset = 4
    _add_internal_fuel_tank_method_offset = 5
    _get_payload_station_by_name_method_offset = 6
    _add_payload_station_method_offset = 7
    _contains_station_method_offset = 8
    _remove_station_by_name_method_offset = 9
    _remove_at_index_method_offset = 10
    _get_station_names_method_offset = 11
    _metadata = {
        "iid_data" : (5717486039973532966, 2606205282693497753),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, StationCollection)
    def __iter__(self):
        """Create an iterator for the StationCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "IStation":
        """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

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

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "IStation":
        """Given an index, returns an element in the collection."""
        return self._intf.invoke(StationCollection._metadata, StationCollection._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:
        """Return an enumerator that can iterate through the collection."""
        return self._intf.get_property(StationCollection._metadata, StationCollection._get__new_enum_metadata)

    _get_internal_fuel_tank_by_name_metadata = { "offset" : _get_internal_fuel_tank_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_internal_fuel_tank_by_name(self, name:str) -> "FuelTankInternal":
        """Get the internal fuel tank with the given name."""
        return self._intf.invoke(StationCollection._metadata, StationCollection._get_internal_fuel_tank_by_name_metadata, name, OutArg())

    _add_internal_fuel_tank_metadata = { "offset" : _add_internal_fuel_tank_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def add_internal_fuel_tank(self) -> "FuelTankInternal":
        """Add an internal fuel tank."""
        return self._intf.invoke(StationCollection._metadata, StationCollection._add_internal_fuel_tank_metadata, OutArg())

    _get_payload_station_by_name_metadata = { "offset" : _get_payload_station_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_payload_station_by_name(self, name:str) -> "PayloadStation":
        """Get the payload station with the given name."""
        return self._intf.invoke(StationCollection._metadata, StationCollection._get_payload_station_by_name_metadata, name, OutArg())

    _add_payload_station_metadata = { "offset" : _add_payload_station_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def add_payload_station(self) -> "PayloadStation":
        """Add a payload station."""
        return self._intf.invoke(StationCollection._metadata, StationCollection._add_payload_station_metadata, OutArg())

    _contains_station_metadata = { "offset" : _contains_station_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.VariantBoolArg,) }
    def contains_station(self, name:str) -> bool:
        """Get whether the station list contains an item with the given name."""
        return self._intf.invoke(StationCollection._metadata, StationCollection._contains_station_metadata, name, OutArg())

    _remove_station_by_name_metadata = { "offset" : _remove_station_by_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def remove_station_by_name(self, name:str) -> None:
        """Remove an station by name."""
        return self._intf.invoke(StationCollection._metadata, StationCollection._remove_station_by_name_metadata, name)

    _remove_at_index_metadata = { "offset" : _remove_at_index_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    def remove_at_index(self, index:int) -> None:
        """Remove procedure at the given index."""
        return self._intf.invoke(StationCollection._metadata, StationCollection._remove_at_index_metadata, index)

    _get_station_names_metadata = { "offset" : _get_station_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def station_names(self) -> list:
        """Return the station names."""
        return self._intf.get_property(StationCollection._metadata, StationCollection._get_station_names_metadata)

    __getitem__ = item


    _property_names[count] = "count"
    _property_names[_new_enum] = "_new_enum"
    _property_names[station_names] = "station_names"

    def __init__(self, source_object=None):
        """Construct an object of type StationCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, StationCollection)
    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, StationCollection, [StationCollection, ])

agcls.AgClassCatalog.add_catalog_entry((5099395785168966975, 1882908027836215685), StationCollection)
agcls.AgTypeNameMap["StationCollection"] = StationCollection

class WindModel(SupportsDeleteCallback):
    """
    Interface used to access the wind model for a mission, scenario, or procedure.

    Examples
    --------
    Configure the weather and atmosphere of the Mission:
    >>> # Mission mission: Aviator Mission object
    >>> # Get the wind model used for the mission
    >>> windModel = mission.wind_model
    >>> # Let's use the mission model
    >>> windModel.wind_model_source = WindAtmosphereModelSource.MISSION_MODEL
    >>> # Let's use constant wind
    >>> windModel.wind_model_type = WindModelType.CONSTANT_WIND
    >>> # Get the constant wind model options
    >>> constantWind = windModel.mode_as_constant
    >>> # Set the wind bearing
    >>> constantWind.wind_bearing = 30
    >>> # Set the wind speed
    >>> constantWind.wind_speed = 5
    >>>
    >>> # Get the atmosphere model used for the mission
    >>> atmosphere = mission.atmosphere_model
    >>> # Let's use the mission model
    >>> atmosphere.atmosphere_model_source = WindAtmosphereModelSource.MISSION_MODEL
    >>> # Get the basic atmosphere options
    >>> basicAtmosphere = atmosphere.mode_as_basic
    >>> # Use standard 1976 atmosphere
    >>> basicAtmosphere.basic_model_type = AtmosphereModelType.STANDARD1976
    >>> # Opt to override the values
    >>> basicAtmosphere.use_non_standard_atmosphere = True
    >>> # Override the temperature
    >>> basicAtmosphere.temperature = 290

    Configure the wind and atmosphere for a procedure:
    >>> # IProcedure procedure: Procedure object
    >>> # Get the wind model for the procedure
    >>> windModel = procedure.wind_model
    >>> # Use the procedure model
    >>> windModel.wind_model_source = WindAtmosphereModelSource.PROCEDURE_MODEL
    >>> # Let's use constant wind
    >>> windModel.wind_model_type = WindModelType.CONSTANT_WIND
    >>> # Get the constant wind model options
    >>> constantWind = windModel.mode_as_constant
    >>> # Set the wind bearing
    >>> constantWind.wind_bearing = 30
    >>> # Set the wind speed
    >>> constantWind.wind_speed = 5
    >>>
    >>> # Get the atmosphere model used for the procedure
    >>> atmosphere = procedure.atmosphere_model
    >>> # Let's use the procedure model
    >>> atmosphere.atmosphere_model_source = WindAtmosphereModelSource.PROCEDURE_MODEL
    >>> # Get the basic atmosphere options
    >>> basicAtmosphere = atmosphere.mode_as_basic
    >>> # Use standard 1976 atmosphere
    >>> basicAtmosphere.basic_model_type = AtmosphereModelType.STANDARD1976
    """

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_wind_model_type_method_offset = 1
    _set_wind_model_type_method_offset = 2
    _get_wind_model_type_string_method_offset = 3
    _set_wind_model_type_string_method_offset = 4
    _get_wind_model_source_method_offset = 5
    _set_wind_model_source_method_offset = 6
    _get_mode_as_constant_method_offset = 7
    _get_mode_as_adds_method_offset = 8
    _copy_method_offset = 9
    _paste_method_offset = 10
    _metadata = {
        "iid_data" : (5313829494376101000, 1944389693743602836),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, WindModel)

    _get_wind_model_type_metadata = { "offset" : _get_wind_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(WindModelType),) }
    @property
    def wind_model_type(self) -> "WindModelType":
        """Get or set the wind model type."""
        return self._intf.get_property(WindModel._metadata, WindModel._get_wind_model_type_metadata)

    _set_wind_model_type_metadata = { "offset" : _set_wind_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(WindModelType),) }
    @wind_model_type.setter
    def wind_model_type(self, value:"WindModelType") -> None:
        """Get or set the wind model type."""
        return self._intf.set_property(WindModel._metadata, WindModel._set_wind_model_type_metadata, value)

    _get_wind_model_type_string_metadata = { "offset" : _get_wind_model_type_string_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def wind_model_type_string(self) -> str:
        """Get or set the wind model type as a string value. Use this for custom models."""
        return self._intf.get_property(WindModel._metadata, WindModel._get_wind_model_type_string_metadata)

    _set_wind_model_type_string_metadata = { "offset" : _set_wind_model_type_string_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @wind_model_type_string.setter
    def wind_model_type_string(self, value:str) -> None:
        """Get or set the wind model type as a string value. Use this for custom models."""
        return self._intf.set_property(WindModel._metadata, WindModel._set_wind_model_type_string_metadata, value)

    _get_wind_model_source_metadata = { "offset" : _get_wind_model_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(WindAtmosphereModelSource),) }
    @property
    def wind_model_source(self) -> "WindAtmosphereModelSource":
        """Get or set the wind model source."""
        return self._intf.get_property(WindModel._metadata, WindModel._get_wind_model_source_metadata)

    _set_wind_model_source_metadata = { "offset" : _set_wind_model_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(WindAtmosphereModelSource),) }
    @wind_model_source.setter
    def wind_model_source(self, value:"WindAtmosphereModelSource") -> None:
        """Get or set the wind model source."""
        return self._intf.set_property(WindModel._metadata, WindModel._set_wind_model_source_metadata, value)

    _get_mode_as_constant_metadata = { "offset" : _get_mode_as_constant_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_constant(self) -> "WindModelConstant":
        """Get the options for a Constant Bearing/Speed wind model."""
        return self._intf.get_property(WindModel._metadata, WindModel._get_mode_as_constant_metadata)

    _get_mode_as_adds_metadata = { "offset" : _get_mode_as_adds_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_adds(self) -> "WindModelADDS":
        """Get the options for a NOAA ADDS Service wind model."""
        return self._intf.get_property(WindModel._metadata, WindModel._get_mode_as_adds_metadata)

    _copy_metadata = { "offset" : _copy_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def copy(self) -> None:
        """Copy the wind model."""
        return self._intf.invoke(WindModel._metadata, WindModel._copy_metadata, )

    _paste_metadata = { "offset" : _paste_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def paste(self) -> None:
        """Paste the wind model."""
        return self._intf.invoke(WindModel._metadata, WindModel._paste_metadata, )

    _property_names[wind_model_type] = "wind_model_type"
    _property_names[wind_model_type_string] = "wind_model_type_string"
    _property_names[wind_model_source] = "wind_model_source"
    _property_names[mode_as_constant] = "mode_as_constant"
    _property_names[mode_as_adds] = "mode_as_adds"

    def __init__(self, source_object=None):
        """Construct an object of type WindModel."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, WindModel)
    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, WindModel, [WindModel, ])

agcls.AgClassCatalog.add_catalog_entry((5465426116498822924, 12151378126490156939), WindModel)
agcls.AgTypeNameMap["WindModel"] = WindModel

class WindModelConstant(SupportsDeleteCallback):
    """
    Interface used to access the options for a Constant Bearing/Speed wind model.

    Examples
    --------
    Configure the weather and atmosphere of the Mission:
    >>> # Mission mission: Aviator Mission object
    >>> # Get the wind model used for the mission
    >>> windModel = mission.wind_model
    >>> # Let's use the mission model
    >>> windModel.wind_model_source = WindAtmosphereModelSource.MISSION_MODEL
    >>> # Let's use constant wind
    >>> windModel.wind_model_type = WindModelType.CONSTANT_WIND
    >>> # Get the constant wind model options
    >>> constantWind = windModel.mode_as_constant
    >>> # Set the wind bearing
    >>> constantWind.wind_bearing = 30
    >>> # Set the wind speed
    >>> constantWind.wind_speed = 5
    >>>
    >>> # Get the atmosphere model used for the mission
    >>> atmosphere = mission.atmosphere_model
    >>> # Let's use the mission model
    >>> atmosphere.atmosphere_model_source = WindAtmosphereModelSource.MISSION_MODEL
    >>> # Get the basic atmosphere options
    >>> basicAtmosphere = atmosphere.mode_as_basic
    >>> # Use standard 1976 atmosphere
    >>> basicAtmosphere.basic_model_type = AtmosphereModelType.STANDARD1976
    >>> # Opt to override the values
    >>> basicAtmosphere.use_non_standard_atmosphere = True
    >>> # Override the temperature
    >>> basicAtmosphere.temperature = 290

    Configure the wind and atmosphere for a procedure:
    >>> # IProcedure procedure: Procedure object
    >>> # Get the wind model for the procedure
    >>> windModel = procedure.wind_model
    >>> # Use the procedure model
    >>> windModel.wind_model_source = WindAtmosphereModelSource.PROCEDURE_MODEL
    >>> # Let's use constant wind
    >>> windModel.wind_model_type = WindModelType.CONSTANT_WIND
    >>> # Get the constant wind model options
    >>> constantWind = windModel.mode_as_constant
    >>> # Set the wind bearing
    >>> constantWind.wind_bearing = 30
    >>> # Set the wind speed
    >>> constantWind.wind_speed = 5
    >>>
    >>> # Get the atmosphere model used for the procedure
    >>> atmosphere = procedure.atmosphere_model
    >>> # Let's use the procedure model
    >>> atmosphere.atmosphere_model_source = WindAtmosphereModelSource.PROCEDURE_MODEL
    >>> # Get the basic atmosphere options
    >>> basicAtmosphere = atmosphere.mode_as_basic
    >>> # Use standard 1976 atmosphere
    >>> basicAtmosphere.basic_model_type = AtmosphereModelType.STANDARD1976
    """

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_name_method_offset = 1
    _set_name_method_offset = 2
    _get_blend_time_method_offset = 3
    _set_blend_time_method_offset = 4
    _get_wind_speed_method_offset = 5
    _set_wind_speed_method_offset = 6
    _get_wind_bearing_method_offset = 7
    _set_wind_bearing_method_offset = 8
    _metadata = {
        "iid_data" : (4784209068649467141, 469699507877676171),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, WindModelConstant)

    _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 wind model."""
        return self._intf.get_property(WindModelConstant._metadata, WindModelConstant._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 wind model."""
        return self._intf.set_property(WindModelConstant._metadata, WindModelConstant._set_name_metadata, value)

    _get_blend_time_metadata = { "offset" : _get_blend_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def blend_time(self) -> float:
        """Get or set the blend time to transition from the previous wind model if one exists."""
        return self._intf.get_property(WindModelConstant._metadata, WindModelConstant._get_blend_time_metadata)

    _set_blend_time_metadata = { "offset" : _set_blend_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @blend_time.setter
    def blend_time(self, value:float) -> None:
        """Get or set the blend time to transition from the previous wind model if one exists."""
        return self._intf.set_property(WindModelConstant._metadata, WindModelConstant._set_blend_time_metadata, value)

    _get_wind_speed_metadata = { "offset" : _get_wind_speed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def wind_speed(self) -> float:
        """Get or set the constant wind speed."""
        return self._intf.get_property(WindModelConstant._metadata, WindModelConstant._get_wind_speed_metadata)

    _set_wind_speed_metadata = { "offset" : _set_wind_speed_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @wind_speed.setter
    def wind_speed(self, value:float) -> None:
        """Get or set the constant wind speed."""
        return self._intf.set_property(WindModelConstant._metadata, WindModelConstant._set_wind_speed_metadata, value)

    _get_wind_bearing_metadata = { "offset" : _get_wind_bearing_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def wind_bearing(self) -> typing.Any:
        """Get or set the wind's true bearing."""
        return self._intf.get_property(WindModelConstant._metadata, WindModelConstant._get_wind_bearing_metadata)

    _set_wind_bearing_metadata = { "offset" : _set_wind_bearing_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @wind_bearing.setter
    def wind_bearing(self, value:typing.Any) -> None:
        """Get or set the wind's true bearing."""
        return self._intf.set_property(WindModelConstant._metadata, WindModelConstant._set_wind_bearing_metadata, value)

    _property_names[name] = "name"
    _property_names[blend_time] = "blend_time"
    _property_names[wind_speed] = "wind_speed"
    _property_names[wind_bearing] = "wind_bearing"

    def __init__(self, source_object=None):
        """Construct an object of type WindModelConstant."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, WindModelConstant)
    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, WindModelConstant, [WindModelConstant, ])

agcls.AgClassCatalog.add_catalog_entry((4773128217099375110, 6648421707046788495), WindModelConstant)
agcls.AgTypeNameMap["WindModelConstant"] = WindModelConstant

class WindModelADDS(SupportsDeleteCallback):
    """Interface used to access the options for a NOAA ADDS wind model."""

    _num_methods = 14
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_name_method_offset = 1
    _set_name_method_offset = 2
    _get_blend_time_method_offset = 3
    _set_blend_time_method_offset = 4
    _get_message_interpolation_type_method_offset = 5
    _set_message_interpolation_type_method_offset = 6
    _get_message_extrapolation_type_method_offset = 7
    _set_message_extrapolation_type_method_offset = 8
    _get_missing_message_type_method_offset = 9
    _set_missing_message_type_method_offset = 10
    _get_interpolation_blend_time_method_offset = 11
    _set_interpolation_blend_time_method_offset = 12
    _add_current_forecast_method_offset = 13
    _get_messages_method_offset = 14
    _metadata = {
        "iid_data" : (4929481172783018289, 15319225642889104538),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, WindModelADDS)

    _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 wind model."""
        return self._intf.get_property(WindModelADDS._metadata, WindModelADDS._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 wind model."""
        return self._intf.set_property(WindModelADDS._metadata, WindModelADDS._set_name_metadata, value)

    _get_blend_time_metadata = { "offset" : _get_blend_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def blend_time(self) -> float:
        """Get or set the blend time to transition from the previous wind model if one exists."""
        return self._intf.get_property(WindModelADDS._metadata, WindModelADDS._get_blend_time_metadata)

    _set_blend_time_metadata = { "offset" : _set_blend_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @blend_time.setter
    def blend_time(self, value:float) -> None:
        """Get or set the blend time to transition from the previous wind model if one exists."""
        return self._intf.set_property(WindModelADDS._metadata, WindModelADDS._set_blend_time_metadata, value)

    _get_message_interpolation_type_metadata = { "offset" : _get_message_interpolation_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ADDSMessageInterpolationType),) }
    @property
    def message_interpolation_type(self) -> "ADDSMessageInterpolationType":
        """Get or set the message interpolation type."""
        return self._intf.get_property(WindModelADDS._metadata, WindModelADDS._get_message_interpolation_type_metadata)

    _set_message_interpolation_type_metadata = { "offset" : _set_message_interpolation_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ADDSMessageInterpolationType),) }
    @message_interpolation_type.setter
    def message_interpolation_type(self, value:"ADDSMessageInterpolationType") -> None:
        """Get or set the message interpolation type."""
        return self._intf.set_property(WindModelADDS._metadata, WindModelADDS._set_message_interpolation_type_metadata, value)

    _get_message_extrapolation_type_metadata = { "offset" : _get_message_extrapolation_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ADDSMessageExtrapolationType),) }
    @property
    def message_extrapolation_type(self) -> "ADDSMessageExtrapolationType":
        """Get or set the message extrapolation type."""
        return self._intf.get_property(WindModelADDS._metadata, WindModelADDS._get_message_extrapolation_type_metadata)

    _set_message_extrapolation_type_metadata = { "offset" : _set_message_extrapolation_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ADDSMessageExtrapolationType),) }
    @message_extrapolation_type.setter
    def message_extrapolation_type(self, value:"ADDSMessageExtrapolationType") -> None:
        """Get or set the message extrapolation type."""
        return self._intf.set_property(WindModelADDS._metadata, WindModelADDS._set_message_extrapolation_type_metadata, value)

    _get_missing_message_type_metadata = { "offset" : _get_missing_message_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ADDSMissingMessageType),) }
    @property
    def missing_message_type(self) -> "ADDSMissingMessageType":
        """Get or set the missing message type."""
        return self._intf.get_property(WindModelADDS._metadata, WindModelADDS._get_missing_message_type_metadata)

    _set_missing_message_type_metadata = { "offset" : _set_missing_message_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ADDSMissingMessageType),) }
    @missing_message_type.setter
    def missing_message_type(self, value:"ADDSMissingMessageType") -> None:
        """Get or set the missing message type."""
        return self._intf.set_property(WindModelADDS._metadata, WindModelADDS._set_missing_message_type_metadata, value)

    _get_interpolation_blend_time_metadata = { "offset" : _get_interpolation_blend_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def interpolation_blend_time(self) -> float:
        """Get or set the blend time to transition from the previous wind condition."""
        return self._intf.get_property(WindModelADDS._metadata, WindModelADDS._get_interpolation_blend_time_metadata)

    _set_interpolation_blend_time_metadata = { "offset" : _set_interpolation_blend_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @interpolation_blend_time.setter
    def interpolation_blend_time(self, value:float) -> None:
        """Get or set the blend time to transition from the previous wind condition."""
        return self._intf.set_property(WindModelADDS._metadata, WindModelADDS._set_interpolation_blend_time_metadata, value)

    _add_current_forecast_metadata = { "offset" : _add_current_forecast_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    def add_current_forecast(self) -> str:
        """Add the current forecast from the ADDS service."""
        return self._intf.invoke(WindModelADDS._metadata, WindModelADDS._add_current_forecast_metadata, OutArg())

    _get_messages_metadata = { "offset" : _get_messages_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def messages(self) -> "ADDSMessageCollection":
        """Get the messages from the current forecast."""
        return self._intf.get_property(WindModelADDS._metadata, WindModelADDS._get_messages_metadata)

    _property_names[name] = "name"
    _property_names[blend_time] = "blend_time"
    _property_names[message_interpolation_type] = "message_interpolation_type"
    _property_names[message_extrapolation_type] = "message_extrapolation_type"
    _property_names[missing_message_type] = "missing_message_type"
    _property_names[interpolation_blend_time] = "interpolation_blend_time"
    _property_names[messages] = "messages"

    def __init__(self, source_object=None):
        """Construct an object of type WindModelADDS."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, WindModelADDS)
    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, WindModelADDS, [WindModelADDS, ])

agcls.AgClassCatalog.add_catalog_entry((5314200917457773823, 13436542406830958478), WindModelADDS)
agcls.AgTypeNameMap["WindModelADDS"] = WindModelADDS

class ADDSMessage(SupportsDeleteCallback):
    """Interface used to access a message from the NOAA ADDS forecast."""

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_start_time_method_offset = 1
    _get_stop_time_method_offset = 2
    _get_message_time_method_offset = 3
    _get_type_method_offset = 4
    _get_source_method_offset = 5
    _metadata = {
        "iid_data" : (4954408490634457473, 9817060035689406896),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ADDSMessage)

    _get_start_time_metadata = { "offset" : _get_start_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def start_time(self) -> typing.Any:
        """Valid start time for the ADDS message."""
        return self._intf.get_property(ADDSMessage._metadata, ADDSMessage._get_start_time_metadata)

    _get_stop_time_metadata = { "offset" : _get_stop_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def stop_time(self) -> typing.Any:
        """Valid stop time for the ADDS message."""
        return self._intf.get_property(ADDSMessage._metadata, ADDSMessage._get_stop_time_metadata)

    _get_message_time_metadata = { "offset" : _get_message_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def message_time(self) -> typing.Any:
        """Get the message time for the ADDS message."""
        return self._intf.get_property(ADDSMessage._metadata, ADDSMessage._get_message_time_metadata)

    _get_type_metadata = { "offset" : _get_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ADDSForecastType),) }
    @property
    def type(self) -> "ADDSForecastType":
        """Get the ADDS message type."""
        return self._intf.get_property(ADDSMessage._metadata, ADDSMessage._get_type_metadata)

    _get_source_metadata = { "offset" : _get_source_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def source(self) -> str:
        """Get the ADDS message source."""
        return self._intf.get_property(ADDSMessage._metadata, ADDSMessage._get_source_metadata)

    _property_names[start_time] = "start_time"
    _property_names[stop_time] = "stop_time"
    _property_names[message_time] = "message_time"
    _property_names[type] = "type"
    _property_names[source] = "source"

    def __init__(self, source_object=None):
        """Construct an object of type ADDSMessage."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ADDSMessage)
    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, ADDSMessage, [ADDSMessage, ])

agcls.AgClassCatalog.add_catalog_entry((5002038927778140066, 17045237219658894480), ADDSMessage)
agcls.AgTypeNameMap["ADDSMessage"] = ADDSMessage

class ADDSMessageCollection(SupportsDeleteCallback):
    """Interface used to access the collection of messages from the NOAA ADDS forecast."""

    _num_methods = 5
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _get_count_method_offset = 1
    _item_method_offset = 2
    _get__new_enum_method_offset = 3
    _remove_message_method_offset = 4
    _clear_messages_method_offset = 5
    _metadata = {
        "iid_data" : (5658302478233079681, 5797263501393998991),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ADDSMessageCollection)
    def __iter__(self):
        """Create an iterator for the ADDSMessageCollection object."""
        self.__dict__["_enumerator"] = self._new_enum
        self._enumerator.reset()
        return self
    def __next__(self) -> "ADDSMessage":
        """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

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

    _item_metadata = { "offset" : _item_method_offset,
            "arg_types" : (agcom.LONG, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.LongArg, agmarshall.InterfaceOutArg,) }
    def item(self, index:int) -> "ADDSMessage":
        """Given an index, returns an element in the collection."""
        return self._intf.invoke(ADDSMessageCollection._metadata, ADDSMessageCollection._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:
        """Return an enumerator that can iterate through the collection."""
        return self._intf.get_property(ADDSMessageCollection._metadata, ADDSMessageCollection._get__new_enum_metadata)

    _remove_message_metadata = { "offset" : _remove_message_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("ADDSMessage"),) }
    def remove_message(self, message:"ADDSMessage") -> None:
        """Remove this message from the forecast."""
        return self._intf.invoke(ADDSMessageCollection._metadata, ADDSMessageCollection._remove_message_metadata, message)

    _clear_messages_metadata = { "offset" : _clear_messages_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def clear_messages(self) -> None:
        """Clear all of the messages in the collection."""
        return self._intf.invoke(ADDSMessageCollection._metadata, ADDSMessageCollection._clear_messages_metadata, )

    __getitem__ = item


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

    def __init__(self, source_object=None):
        """Construct an object of type ADDSMessageCollection."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ADDSMessageCollection)
    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, ADDSMessageCollection, [ADDSMessageCollection, ])

agcls.AgClassCatalog.add_catalog_entry((4843115847057028331, 5361510963980995996), ADDSMessageCollection)
agcls.AgTypeNameMap["ADDSMessageCollection"] = ADDSMessageCollection

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

agcls.AgClassCatalog.add_catalog_entry((5442570590760532794, 10773970218224780928), Procedure)
agcls.AgTypeNameMap["Procedure"] = Procedure

class AtmosphereModel(SupportsDeleteCallback):
    """
    Interface used to access the atmosphere model for a mission, scenario, or procedure.

    Examples
    --------
    Configure the weather and atmosphere of the Mission:
    >>> # Mission mission: Aviator Mission object
    >>> # Get the wind model used for the mission
    >>> windModel = mission.wind_model
    >>> # Let's use the mission model
    >>> windModel.wind_model_source = WindAtmosphereModelSource.MISSION_MODEL
    >>> # Let's use constant wind
    >>> windModel.wind_model_type = WindModelType.CONSTANT_WIND
    >>> # Get the constant wind model options
    >>> constantWind = windModel.mode_as_constant
    >>> # Set the wind bearing
    >>> constantWind.wind_bearing = 30
    >>> # Set the wind speed
    >>> constantWind.wind_speed = 5
    >>>
    >>> # Get the atmosphere model used for the mission
    >>> atmosphere = mission.atmosphere_model
    >>> # Let's use the mission model
    >>> atmosphere.atmosphere_model_source = WindAtmosphereModelSource.MISSION_MODEL
    >>> # Get the basic atmosphere options
    >>> basicAtmosphere = atmosphere.mode_as_basic
    >>> # Use standard 1976 atmosphere
    >>> basicAtmosphere.basic_model_type = AtmosphereModelType.STANDARD1976
    >>> # Opt to override the values
    >>> basicAtmosphere.use_non_standard_atmosphere = True
    >>> # Override the temperature
    >>> basicAtmosphere.temperature = 290

    Configure the wind and atmosphere for a procedure:
    >>> # IProcedure procedure: Procedure object
    >>> # Get the wind model for the procedure
    >>> windModel = procedure.wind_model
    >>> # Use the procedure model
    >>> windModel.wind_model_source = WindAtmosphereModelSource.PROCEDURE_MODEL
    >>> # Let's use constant wind
    >>> windModel.wind_model_type = WindModelType.CONSTANT_WIND
    >>> # Get the constant wind model options
    >>> constantWind = windModel.mode_as_constant
    >>> # Set the wind bearing
    >>> constantWind.wind_bearing = 30
    >>> # Set the wind speed
    >>> constantWind.wind_speed = 5
    >>>
    >>> # Get the atmosphere model used for the procedure
    >>> atmosphere = procedure.atmosphere_model
    >>> # Let's use the procedure model
    >>> atmosphere.atmosphere_model_source = WindAtmosphereModelSource.PROCEDURE_MODEL
    >>> # Get the basic atmosphere options
    >>> basicAtmosphere = atmosphere.mode_as_basic
    >>> # Use standard 1976 atmosphere
    >>> basicAtmosphere.basic_model_type = AtmosphereModelType.STANDARD1976
    """

    _num_methods = 7
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_atmosphere_model_type_string_method_offset = 1
    _set_atmosphere_model_type_string_method_offset = 2
    _get_atmosphere_model_source_method_offset = 3
    _set_atmosphere_model_source_method_offset = 4
    _get_mode_as_basic_method_offset = 5
    _copy_method_offset = 6
    _paste_method_offset = 7
    _metadata = {
        "iid_data" : (4612100852660352663, 4935595692858863267),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AtmosphereModel)

    _get_atmosphere_model_type_string_metadata = { "offset" : _get_atmosphere_model_type_string_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def atmosphere_model_type_string(self) -> str:
        """Get or set the atmosphere model type as a string value."""
        return self._intf.get_property(AtmosphereModel._metadata, AtmosphereModel._get_atmosphere_model_type_string_metadata)

    _set_atmosphere_model_type_string_metadata = { "offset" : _set_atmosphere_model_type_string_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @atmosphere_model_type_string.setter
    def atmosphere_model_type_string(self, value:str) -> None:
        """Get or set the atmosphere model type as a string value."""
        return self._intf.set_property(AtmosphereModel._metadata, AtmosphereModel._set_atmosphere_model_type_string_metadata, value)

    _get_atmosphere_model_source_metadata = { "offset" : _get_atmosphere_model_source_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(WindAtmosphereModelSource),) }
    @property
    def atmosphere_model_source(self) -> "WindAtmosphereModelSource":
        """Get or set the atmosphere model source."""
        return self._intf.get_property(AtmosphereModel._metadata, AtmosphereModel._get_atmosphere_model_source_metadata)

    _set_atmosphere_model_source_metadata = { "offset" : _set_atmosphere_model_source_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(WindAtmosphereModelSource),) }
    @atmosphere_model_source.setter
    def atmosphere_model_source(self, value:"WindAtmosphereModelSource") -> None:
        """Get or set the atmosphere model source."""
        return self._intf.set_property(AtmosphereModel._metadata, AtmosphereModel._set_atmosphere_model_source_metadata, value)

    _get_mode_as_basic_metadata = { "offset" : _get_mode_as_basic_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_basic(self) -> "AtmosphereModelBasic":
        """Get the options for a Basic Atmosphere model."""
        return self._intf.get_property(AtmosphereModel._metadata, AtmosphereModel._get_mode_as_basic_metadata)

    _copy_metadata = { "offset" : _copy_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def copy(self) -> None:
        """Copy the atmosphere model."""
        return self._intf.invoke(AtmosphereModel._metadata, AtmosphereModel._copy_metadata, )

    _paste_metadata = { "offset" : _paste_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def paste(self) -> None:
        """Paste the atmosphere model."""
        return self._intf.invoke(AtmosphereModel._metadata, AtmosphereModel._paste_metadata, )

    _property_names[atmosphere_model_type_string] = "atmosphere_model_type_string"
    _property_names[atmosphere_model_source] = "atmosphere_model_source"
    _property_names[mode_as_basic] = "mode_as_basic"

    def __init__(self, source_object=None):
        """Construct an object of type AtmosphereModel."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AtmosphereModel)
    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, AtmosphereModel, [AtmosphereModel, ])

agcls.AgClassCatalog.add_catalog_entry((4816409432479909563, 6760252487080053377), AtmosphereModel)
agcls.AgTypeNameMap["AtmosphereModel"] = AtmosphereModel

class AtmosphereModelBasic(SupportsDeleteCallback):
    """
    Interface used to access the basic atmosphere model.

    Examples
    --------
    Configure the weather and atmosphere of the Mission:
    >>> # Mission mission: Aviator Mission object
    >>> # Get the wind model used for the mission
    >>> windModel = mission.wind_model
    >>> # Let's use the mission model
    >>> windModel.wind_model_source = WindAtmosphereModelSource.MISSION_MODEL
    >>> # Let's use constant wind
    >>> windModel.wind_model_type = WindModelType.CONSTANT_WIND
    >>> # Get the constant wind model options
    >>> constantWind = windModel.mode_as_constant
    >>> # Set the wind bearing
    >>> constantWind.wind_bearing = 30
    >>> # Set the wind speed
    >>> constantWind.wind_speed = 5
    >>>
    >>> # Get the atmosphere model used for the mission
    >>> atmosphere = mission.atmosphere_model
    >>> # Let's use the mission model
    >>> atmosphere.atmosphere_model_source = WindAtmosphereModelSource.MISSION_MODEL
    >>> # Get the basic atmosphere options
    >>> basicAtmosphere = atmosphere.mode_as_basic
    >>> # Use standard 1976 atmosphere
    >>> basicAtmosphere.basic_model_type = AtmosphereModelType.STANDARD1976
    >>> # Opt to override the values
    >>> basicAtmosphere.use_non_standard_atmosphere = True
    >>> # Override the temperature
    >>> basicAtmosphere.temperature = 290

    Configure the wind and atmosphere for a procedure:
    >>> # IProcedure procedure: Procedure object
    >>> # Get the wind model for the procedure
    >>> windModel = procedure.wind_model
    >>> # Use the procedure model
    >>> windModel.wind_model_source = WindAtmosphereModelSource.PROCEDURE_MODEL
    >>> # Let's use constant wind
    >>> windModel.wind_model_type = WindModelType.CONSTANT_WIND
    >>> # Get the constant wind model options
    >>> constantWind = windModel.mode_as_constant
    >>> # Set the wind bearing
    >>> constantWind.wind_bearing = 30
    >>> # Set the wind speed
    >>> constantWind.wind_speed = 5
    >>>
    >>> # Get the atmosphere model used for the procedure
    >>> atmosphere = procedure.atmosphere_model
    >>> # Let's use the procedure model
    >>> atmosphere.atmosphere_model_source = WindAtmosphereModelSource.PROCEDURE_MODEL
    >>> # Get the basic atmosphere options
    >>> basicAtmosphere = atmosphere.mode_as_basic
    >>> # Use standard 1976 atmosphere
    >>> basicAtmosphere.basic_model_type = AtmosphereModelType.STANDARD1976
    """

    _num_methods = 11
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_name_method_offset = 1
    _set_name_method_offset = 2
    _get_basic_model_type_method_offset = 3
    _set_basic_model_type_method_offset = 4
    _get_use_non_standard_atmosphere_method_offset = 5
    _set_use_non_standard_atmosphere_method_offset = 6
    _get_temperature_method_offset = 7
    _set_temperature_method_offset = 8
    _get_pressure_method_offset = 9
    _set_pressure_method_offset = 10
    _get_density_altitude_method_offset = 11
    _metadata = {
        "iid_data" : (4838283917811043743, 3421562503707738005),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AtmosphereModelBasic)

    _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 atmosphere model."""
        return self._intf.get_property(AtmosphereModelBasic._metadata, AtmosphereModelBasic._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 atmosphere model."""
        return self._intf.set_property(AtmosphereModelBasic._metadata, AtmosphereModelBasic._set_name_metadata, value)

    _get_basic_model_type_metadata = { "offset" : _get_basic_model_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AtmosphereModelType),) }
    @property
    def basic_model_type(self) -> "AtmosphereModelType":
        """Get or set the type of basic atmosphere."""
        return self._intf.get_property(AtmosphereModelBasic._metadata, AtmosphereModelBasic._get_basic_model_type_metadata)

    _set_basic_model_type_metadata = { "offset" : _set_basic_model_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AtmosphereModelType),) }
    @basic_model_type.setter
    def basic_model_type(self, value:"AtmosphereModelType") -> None:
        """Get or set the type of basic atmosphere."""
        return self._intf.set_property(AtmosphereModelBasic._metadata, AtmosphereModelBasic._set_basic_model_type_metadata, value)

    _get_use_non_standard_atmosphere_metadata = { "offset" : _get_use_non_standard_atmosphere_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_non_standard_atmosphere(self) -> bool:
        """Opt whether to use non standard atmosphere conditions."""
        return self._intf.get_property(AtmosphereModelBasic._metadata, AtmosphereModelBasic._get_use_non_standard_atmosphere_metadata)

    _set_use_non_standard_atmosphere_metadata = { "offset" : _set_use_non_standard_atmosphere_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_non_standard_atmosphere.setter
    def use_non_standard_atmosphere(self, value:bool) -> None:
        """Opt whether to use non standard atmosphere conditions."""
        return self._intf.set_property(AtmosphereModelBasic._metadata, AtmosphereModelBasic._set_use_non_standard_atmosphere_metadata, value)

    _get_temperature_metadata = { "offset" : _get_temperature_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def temperature(self) -> float:
        """Get or set the sea-level temperature."""
        return self._intf.get_property(AtmosphereModelBasic._metadata, AtmosphereModelBasic._get_temperature_metadata)

    _set_temperature_metadata = { "offset" : _set_temperature_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @temperature.setter
    def temperature(self, value:float) -> None:
        """Get or set the sea-level temperature."""
        return self._intf.set_property(AtmosphereModelBasic._metadata, AtmosphereModelBasic._set_temperature_metadata, value)

    _get_pressure_metadata = { "offset" : _get_pressure_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def pressure(self) -> float:
        """Get or set the sea-level pressure."""
        return self._intf.get_property(AtmosphereModelBasic._metadata, AtmosphereModelBasic._get_pressure_metadata)

    _set_pressure_metadata = { "offset" : _set_pressure_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @pressure.setter
    def pressure(self, value:float) -> None:
        """Get or set the sea-level pressure."""
        return self._intf.set_property(AtmosphereModelBasic._metadata, AtmosphereModelBasic._set_pressure_metadata, value)

    _get_density_altitude_metadata = { "offset" : _get_density_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def density_altitude(self) -> float:
        """Get the sea-level density altitude."""
        return self._intf.get_property(AtmosphereModelBasic._metadata, AtmosphereModelBasic._get_density_altitude_metadata)

    _property_names[name] = "name"
    _property_names[basic_model_type] = "basic_model_type"
    _property_names[use_non_standard_atmosphere] = "use_non_standard_atmosphere"
    _property_names[temperature] = "temperature"
    _property_names[pressure] = "pressure"
    _property_names[density_altitude] = "density_altitude"

    def __init__(self, source_object=None):
        """Construct an object of type AtmosphereModelBasic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AtmosphereModelBasic)
    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, AtmosphereModelBasic, [AtmosphereModelBasic, ])

agcls.AgClassCatalog.add_catalog_entry((5663532273578424694, 5065893472194973362), AtmosphereModelBasic)
agcls.AgTypeNameMap["AtmosphereModelBasic"] = AtmosphereModelBasic

class BasicManeuverStrategySimpleTurn(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Simple Turn Strategy of a Basic Maneuver Procedure."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_reference_frame_method_offset = 1
    _set_reference_frame_method_offset = 2
    _get_turn_angle_method_offset = 3
    _set_turn_angle_method_offset = 4
    _get_turn_radius_factor_method_offset = 5
    _set_turn_radius_factor_method_offset = 6
    _get_compensate_for_coriolis_acceleration_method_offset = 7
    _set_compensate_for_coriolis_acceleration_method_offset = 8
    _metadata = {
        "iid_data" : (5493616845962227984, 7381268894000172433),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategySimpleTurn)

    _get_reference_frame_metadata = { "offset" : _get_reference_frame_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverReferenceFrame),) }
    @property
    def reference_frame(self) -> "BasicManeuverReferenceFrame":
        """Get or set the reference frame for the simple turn."""
        return self._intf.get_property(BasicManeuverStrategySimpleTurn._metadata, BasicManeuverStrategySimpleTurn._get_reference_frame_metadata)

    _set_reference_frame_metadata = { "offset" : _set_reference_frame_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverReferenceFrame),) }
    @reference_frame.setter
    def reference_frame(self, value:"BasicManeuverReferenceFrame") -> None:
        """Get or set the reference frame for the simple turn."""
        return self._intf.set_property(BasicManeuverStrategySimpleTurn._metadata, BasicManeuverStrategySimpleTurn._set_reference_frame_metadata, value)

    _get_turn_angle_metadata = { "offset" : _get_turn_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def turn_angle(self) -> typing.Any:
        """Get or set the turn angle for the simple turn."""
        return self._intf.get_property(BasicManeuverStrategySimpleTurn._metadata, BasicManeuverStrategySimpleTurn._get_turn_angle_metadata)

    _set_turn_angle_metadata = { "offset" : _set_turn_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @turn_angle.setter
    def turn_angle(self, value:typing.Any) -> None:
        """Get or set the turn angle for the simple turn."""
        return self._intf.set_property(BasicManeuverStrategySimpleTurn._metadata, BasicManeuverStrategySimpleTurn._set_turn_angle_metadata, value)

    _get_turn_radius_factor_metadata = { "offset" : _get_turn_radius_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def turn_radius_factor(self) -> float:
        """Get or set the turn radius factor for the simple turn."""
        return self._intf.get_property(BasicManeuverStrategySimpleTurn._metadata, BasicManeuverStrategySimpleTurn._get_turn_radius_factor_metadata)

    _set_turn_radius_factor_metadata = { "offset" : _set_turn_radius_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @turn_radius_factor.setter
    def turn_radius_factor(self, value:float) -> None:
        """Get or set the turn radius factor for the simple turn."""
        return self._intf.set_property(BasicManeuverStrategySimpleTurn._metadata, BasicManeuverStrategySimpleTurn._set_turn_radius_factor_metadata, value)

    _get_compensate_for_coriolis_acceleration_metadata = { "offset" : _get_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def compensate_for_coriolis_acceleration(self) -> bool:
        """Get or set the option to compensate for the acceleration due to the Coriolis effect."""
        return self._intf.get_property(BasicManeuverStrategySimpleTurn._metadata, BasicManeuverStrategySimpleTurn._get_compensate_for_coriolis_acceleration_metadata)

    _set_compensate_for_coriolis_acceleration_metadata = { "offset" : _set_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @compensate_for_coriolis_acceleration.setter
    def compensate_for_coriolis_acceleration(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategySimpleTurn._metadata, BasicManeuverStrategySimpleTurn._set_compensate_for_coriolis_acceleration_metadata, value)

    _property_names[reference_frame] = "reference_frame"
    _property_names[turn_angle] = "turn_angle"
    _property_names[turn_radius_factor] = "turn_radius_factor"
    _property_names[compensate_for_coriolis_acceleration] = "compensate_for_coriolis_acceleration"

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

agcls.AgClassCatalog.add_catalog_entry((5173456712779159400, 17189367846460491146), BasicManeuverStrategySimpleTurn)
agcls.AgTypeNameMap["BasicManeuverStrategySimpleTurn"] = BasicManeuverStrategySimpleTurn

class BasicManeuverStrategyAileronRoll(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Aileron Roll Strategy of a Basic Maneuver Procedure."""

    _num_methods = 15
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_flight_path_option_method_offset = 1
    _set_flight_path_option_method_offset = 2
    _get_active_mode_method_offset = 3
    _set_active_mode_method_offset = 4
    _get_active_turn_direction_method_offset = 5
    _set_active_turn_direction_method_offset = 6
    _get_active_angle_method_offset = 7
    _set_active_angle_method_offset = 8
    _get_roll_orientation_method_offset = 9
    _set_roll_orientation_method_offset = 10
    _get_roll_rate_mode_method_offset = 11
    _set_roll_rate_mode_method_offset = 12
    _get_override_roll_rate_method_offset = 13
    _set_override_roll_rate_method_offset = 14
    _get_airspeed_options_method_offset = 15
    _metadata = {
        "iid_data" : (5221198706419766648, 15496892745081320075),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyAileronRoll)

    _get_flight_path_option_metadata = { "offset" : _get_flight_path_option_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AileronRollFlightPath),) }
    @property
    def flight_path_option(self) -> "AileronRollFlightPath":
        """Get or set the flight path option."""
        return self._intf.get_property(BasicManeuverStrategyAileronRoll._metadata, BasicManeuverStrategyAileronRoll._get_flight_path_option_metadata)

    _set_flight_path_option_metadata = { "offset" : _set_flight_path_option_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AileronRollFlightPath),) }
    @flight_path_option.setter
    def flight_path_option(self, value:"AileronRollFlightPath") -> None:
        """Get or set the flight path option."""
        return self._intf.set_property(BasicManeuverStrategyAileronRoll._metadata, BasicManeuverStrategyAileronRoll._set_flight_path_option_metadata, value)

    _get_active_mode_metadata = { "offset" : _get_active_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AileronRollMode),) }
    @property
    def active_mode(self) -> "AileronRollMode":
        """Get or set the aileron roll mode."""
        return self._intf.get_property(BasicManeuverStrategyAileronRoll._metadata, BasicManeuverStrategyAileronRoll._get_active_mode_metadata)

    _set_active_mode_metadata = { "offset" : _set_active_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AileronRollMode),) }
    @active_mode.setter
    def active_mode(self, value:"AileronRollMode") -> None:
        """Get or set the aileron roll mode."""
        return self._intf.set_property(BasicManeuverStrategyAileronRoll._metadata, BasicManeuverStrategyAileronRoll._set_active_mode_metadata, value)

    _get_active_turn_direction_metadata = { "offset" : _get_active_turn_direction_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RollLeftRight),) }
    @property
    def active_turn_direction(self) -> "RollLeftRight":
        """Get or set the roll turn direction for the active roll mode."""
        return self._intf.get_property(BasicManeuverStrategyAileronRoll._metadata, BasicManeuverStrategyAileronRoll._get_active_turn_direction_metadata)

    _set_active_turn_direction_metadata = { "offset" : _set_active_turn_direction_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(RollLeftRight),) }
    @active_turn_direction.setter
    def active_turn_direction(self, value:"RollLeftRight") -> None:
        """Get or set the roll turn direction for the active roll mode."""
        return self._intf.set_property(BasicManeuverStrategyAileronRoll._metadata, BasicManeuverStrategyAileronRoll._set_active_turn_direction_metadata, value)

    _get_active_angle_metadata = { "offset" : _get_active_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def active_angle(self) -> typing.Any:
        """Get or set the roll angle for the active roll mode."""
        return self._intf.get_property(BasicManeuverStrategyAileronRoll._metadata, BasicManeuverStrategyAileronRoll._get_active_angle_metadata)

    _set_active_angle_metadata = { "offset" : _set_active_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @active_angle.setter
    def active_angle(self, value:typing.Any) -> None:
        """Get or set the roll angle for the active roll mode."""
        return self._intf.set_property(BasicManeuverStrategyAileronRoll._metadata, BasicManeuverStrategyAileronRoll._set_active_angle_metadata, value)

    _get_roll_orientation_metadata = { "offset" : _get_roll_orientation_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RollUprightInverted),) }
    @property
    def roll_orientation(self) -> "RollUprightInverted":
        """Get or set the orientation to roll to for the roll to orientation mode."""
        return self._intf.get_property(BasicManeuverStrategyAileronRoll._metadata, BasicManeuverStrategyAileronRoll._get_roll_orientation_metadata)

    _set_roll_orientation_metadata = { "offset" : _set_roll_orientation_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(RollUprightInverted),) }
    @roll_orientation.setter
    def roll_orientation(self, value:"RollUprightInverted") -> None:
        """Get or set the orientation to roll to for the roll to orientation mode."""
        return self._intf.set_property(BasicManeuverStrategyAileronRoll._metadata, BasicManeuverStrategyAileronRoll._set_roll_orientation_metadata, value)

    _get_roll_rate_mode_metadata = { "offset" : _get_roll_rate_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @property
    def roll_rate_mode(self) -> "PerformanceModelOverride":
        """Get or set the roll rate mode for the aileron roll."""
        return self._intf.get_property(BasicManeuverStrategyAileronRoll._metadata, BasicManeuverStrategyAileronRoll._get_roll_rate_mode_metadata)

    _set_roll_rate_mode_metadata = { "offset" : _set_roll_rate_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @roll_rate_mode.setter
    def roll_rate_mode(self, value:"PerformanceModelOverride") -> None:
        """Get or set the roll rate mode for the aileron roll."""
        return self._intf.set_property(BasicManeuverStrategyAileronRoll._metadata, BasicManeuverStrategyAileronRoll._set_roll_rate_mode_metadata, value)

    _get_override_roll_rate_metadata = { "offset" : _get_override_roll_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def override_roll_rate(self) -> typing.Any:
        """Get or set the roll rate override value for the aileron roll turn. The roll rate mode must be set to override to access this property."""
        return self._intf.get_property(BasicManeuverStrategyAileronRoll._metadata, BasicManeuverStrategyAileronRoll._get_override_roll_rate_metadata)

    _set_override_roll_rate_metadata = { "offset" : _set_override_roll_rate_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @override_roll_rate.setter
    def override_roll_rate(self, value:typing.Any) -> None:
        """Get or set the roll rate override value for the aileron roll turn. The roll rate mode must be set to override to access this property."""
        return self._intf.set_property(BasicManeuverStrategyAileronRoll._metadata, BasicManeuverStrategyAileronRoll._set_override_roll_rate_metadata, value)

    _get_airspeed_options_metadata = { "offset" : _get_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def airspeed_options(self) -> "BasicManeuverAirspeedOptions":
        """Get the airspeed options."""
        return self._intf.get_property(BasicManeuverStrategyAileronRoll._metadata, BasicManeuverStrategyAileronRoll._get_airspeed_options_metadata)

    _property_names[flight_path_option] = "flight_path_option"
    _property_names[active_mode] = "active_mode"
    _property_names[active_turn_direction] = "active_turn_direction"
    _property_names[active_angle] = "active_angle"
    _property_names[roll_orientation] = "roll_orientation"
    _property_names[roll_rate_mode] = "roll_rate_mode"
    _property_names[override_roll_rate] = "override_roll_rate"
    _property_names[airspeed_options] = "airspeed_options"

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

agcls.AgClassCatalog.add_catalog_entry((5093290527015015737, 14374001182007497380), BasicManeuverStrategyAileronRoll)
agcls.AgTypeNameMap["BasicManeuverStrategyAileronRoll"] = BasicManeuverStrategyAileronRoll

class BasicManeuverStrategyFlyAOA(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Fly AOA Strategy of a Basic Maneuver Procedure."""

    _num_methods = 17
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_turn_direction_method_offset = 1
    _set_turn_direction_method_offset = 2
    _get_roll_rate_mode_method_offset = 3
    _set_roll_rate_mode_method_offset = 4
    _get_override_roll_rate_method_offset = 5
    _set_override_roll_rate_method_offset = 6
    _get_roll_rate_dot_method_offset = 7
    _set_roll_rate_dot_method_offset = 8
    _get_control_roll_angle_method_offset = 9
    _set_control_roll_angle_method_offset = 10
    _get_roll_angle_method_offset = 11
    _set_roll_angle_method_offset = 12
    _get_stop_on_roll_angle_method_offset = 13
    _set_stop_on_roll_angle_method_offset = 14
    _get_aoa_method_offset = 15
    _set_aoa_method_offset = 16
    _get_airspeed_options_method_offset = 17
    _metadata = {
        "iid_data" : (5644301695187384245, 6051879162680875696),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyFlyAOA)

    _get_turn_direction_metadata = { "offset" : _get_turn_direction_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(FlyAOALeftRight),) }
    @property
    def turn_direction(self) -> "FlyAOALeftRight":
        """Get or set the roll turn direction for a Fly AOA basic maneuver strategy."""
        return self._intf.get_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._get_turn_direction_metadata)

    _set_turn_direction_metadata = { "offset" : _set_turn_direction_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(FlyAOALeftRight),) }
    @turn_direction.setter
    def turn_direction(self, value:"FlyAOALeftRight") -> None:
        """Get or set the roll turn direction for a Fly AOA basic maneuver strategy."""
        return self._intf.set_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._set_turn_direction_metadata, value)

    _get_roll_rate_mode_metadata = { "offset" : _get_roll_rate_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @property
    def roll_rate_mode(self) -> "PerformanceModelOverride":
        """Get or set the roll rate mode for a Fly AOA basic maneuver strategy."""
        return self._intf.get_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._get_roll_rate_mode_metadata)

    _set_roll_rate_mode_metadata = { "offset" : _set_roll_rate_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @roll_rate_mode.setter
    def roll_rate_mode(self, value:"PerformanceModelOverride") -> None:
        """Get or set the roll rate mode for a Fly AOA basic maneuver strategy."""
        return self._intf.set_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._set_roll_rate_mode_metadata, value)

    _get_override_roll_rate_metadata = { "offset" : _get_override_roll_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def override_roll_rate(self) -> typing.Any:
        """Get or set the roll rate override value for the Fly AOA basic maneuver strategy. The roll rate mode must be set to override to access this property."""
        return self._intf.get_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._get_override_roll_rate_metadata)

    _set_override_roll_rate_metadata = { "offset" : _set_override_roll_rate_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @override_roll_rate.setter
    def override_roll_rate(self, value:typing.Any) -> None:
        """Get or set the roll rate override value for the Fly AOA basic maneuver strategy. The roll rate mode must be set to override to access this property."""
        return self._intf.set_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._set_override_roll_rate_metadata, value)

    _get_roll_rate_dot_metadata = { "offset" : _get_roll_rate_dot_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def roll_rate_dot(self) -> typing.Any:
        """Get or set the rate of change of the roll rate."""
        return self._intf.get_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._get_roll_rate_dot_metadata)

    _set_roll_rate_dot_metadata = { "offset" : _set_roll_rate_dot_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @roll_rate_dot.setter
    def roll_rate_dot(self, value:typing.Any) -> None:
        """Get or set the rate of change of the roll rate."""
        return self._intf.set_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._set_roll_rate_dot_metadata, value)

    _get_control_roll_angle_metadata = { "offset" : _get_control_roll_angle_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_roll_angle(self) -> bool:
        """Get or set the option to define a goal value for the aircraft's roll angle."""
        return self._intf.get_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._get_control_roll_angle_metadata)

    _set_control_roll_angle_metadata = { "offset" : _set_control_roll_angle_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @control_roll_angle.setter
    def control_roll_angle(self, value:bool) -> None:
        """Get or set the option to define a goal value for the aircraft's roll angle."""
        return self._intf.set_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._set_control_roll_angle_metadata, value)

    _get_roll_angle_metadata = { "offset" : _get_roll_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def roll_angle(self) -> typing.Any:
        """Get or set the goal value for the roll angle."""
        return self._intf.get_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._get_roll_angle_metadata)

    _set_roll_angle_metadata = { "offset" : _set_roll_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @roll_angle.setter
    def roll_angle(self, value:typing.Any) -> None:
        """Get or set the goal value for the roll angle."""
        return self._intf.set_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._set_roll_angle_metadata, value)

    _get_stop_on_roll_angle_metadata = { "offset" : _get_stop_on_roll_angle_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def stop_on_roll_angle(self) -> bool:
        """Get or set the option to stop the maneuver if the specified roll angle is achieved."""
        return self._intf.get_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._get_stop_on_roll_angle_metadata)

    _set_stop_on_roll_angle_metadata = { "offset" : _set_stop_on_roll_angle_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @stop_on_roll_angle.setter
    def stop_on_roll_angle(self, value:bool) -> None:
        """Get or set the option to stop the maneuver if the specified roll angle is achieved."""
        return self._intf.set_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._set_stop_on_roll_angle_metadata, value)

    _get_aoa_metadata = { "offset" : _get_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def aoa(self) -> typing.Any:
        """Get or set the angle of attack."""
        return self._intf.get_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._get_aoa_metadata)

    _set_aoa_metadata = { "offset" : _set_aoa_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @aoa.setter
    def aoa(self, value:typing.Any) -> None:
        """Get or set the angle of attack."""
        return self._intf.set_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._set_aoa_metadata, value)

    _get_airspeed_options_metadata = { "offset" : _get_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def airspeed_options(self) -> "BasicManeuverAirspeedOptions":
        """Get the airspeed options."""
        return self._intf.get_property(BasicManeuverStrategyFlyAOA._metadata, BasicManeuverStrategyFlyAOA._get_airspeed_options_metadata)

    _property_names[turn_direction] = "turn_direction"
    _property_names[roll_rate_mode] = "roll_rate_mode"
    _property_names[override_roll_rate] = "override_roll_rate"
    _property_names[roll_rate_dot] = "roll_rate_dot"
    _property_names[control_roll_angle] = "control_roll_angle"
    _property_names[roll_angle] = "roll_angle"
    _property_names[stop_on_roll_angle] = "stop_on_roll_angle"
    _property_names[aoa] = "aoa"
    _property_names[airspeed_options] = "airspeed_options"

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

agcls.AgClassCatalog.add_catalog_entry((4797166551721930210, 6154861526904101792), BasicManeuverStrategyFlyAOA)
agcls.AgTypeNameMap["BasicManeuverStrategyFlyAOA"] = BasicManeuverStrategyFlyAOA

class BasicManeuverStrategyPull(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Pull Strategy of a Basic Maneuver Procedure."""

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_active_mode_method_offset = 1
    _set_active_mode_method_offset = 2
    _get_active_angle_method_offset = 3
    _set_active_angle_method_offset = 4
    _get_pull_g_mode_method_offset = 5
    _set_pull_g_mode_method_offset = 6
    _get_override_pull_g_method_offset = 7
    _set_override_pull_g_method_offset = 8
    _get_airspeed_options_method_offset = 9
    _metadata = {
        "iid_data" : (5637166632065085547, 16269096880734304689),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyPull)

    _get_active_mode_metadata = { "offset" : _get_active_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PullMode),) }
    @property
    def active_mode(self) -> "PullMode":
        """Get or set the pull mode for the pull basic maneuver strategy."""
        return self._intf.get_property(BasicManeuverStrategyPull._metadata, BasicManeuverStrategyPull._get_active_mode_metadata)

    _set_active_mode_metadata = { "offset" : _set_active_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PullMode),) }
    @active_mode.setter
    def active_mode(self, value:"PullMode") -> None:
        """Get or set the pull mode for the pull basic maneuver strategy."""
        return self._intf.set_property(BasicManeuverStrategyPull._metadata, BasicManeuverStrategyPull._set_active_mode_metadata, value)

    _get_active_angle_metadata = { "offset" : _get_active_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def active_angle(self) -> typing.Any:
        """Get or set the pull angle for the active mode."""
        return self._intf.get_property(BasicManeuverStrategyPull._metadata, BasicManeuverStrategyPull._get_active_angle_metadata)

    _set_active_angle_metadata = { "offset" : _set_active_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @active_angle.setter
    def active_angle(self, value:typing.Any) -> None:
        """Get or set the roll angle for the active mode."""
        return self._intf.set_property(BasicManeuverStrategyPull._metadata, BasicManeuverStrategyPull._set_active_angle_metadata, value)

    _get_pull_g_mode_metadata = { "offset" : _get_pull_g_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @property
    def pull_g_mode(self) -> "PerformanceModelOverride":
        """Get or set the pull G mode for a pull basic maneuver strategy."""
        return self._intf.get_property(BasicManeuverStrategyPull._metadata, BasicManeuverStrategyPull._get_pull_g_mode_metadata)

    _set_pull_g_mode_metadata = { "offset" : _set_pull_g_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @pull_g_mode.setter
    def pull_g_mode(self, value:"PerformanceModelOverride") -> None:
        """Get or set the pull G mode for a pull basic maneuver strategy."""
        return self._intf.set_property(BasicManeuverStrategyPull._metadata, BasicManeuverStrategyPull._set_pull_g_mode_metadata, value)

    _get_override_pull_g_metadata = { "offset" : _get_override_pull_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def override_pull_g(self) -> float:
        """Get or set the pull G override value. The pull G mode must be set to override to access this property."""
        return self._intf.get_property(BasicManeuverStrategyPull._metadata, BasicManeuverStrategyPull._get_override_pull_g_metadata)

    _set_override_pull_g_metadata = { "offset" : _set_override_pull_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @override_pull_g.setter
    def override_pull_g(self, value:float) -> None:
        """Get or set the pull G override value. The pull G mode must be set to override to access this property."""
        return self._intf.set_property(BasicManeuverStrategyPull._metadata, BasicManeuverStrategyPull._set_override_pull_g_metadata, value)

    _get_airspeed_options_metadata = { "offset" : _get_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def airspeed_options(self) -> "BasicManeuverAirspeedOptions":
        """Get the airspeed options."""
        return self._intf.get_property(BasicManeuverStrategyPull._metadata, BasicManeuverStrategyPull._get_airspeed_options_metadata)

    _property_names[active_mode] = "active_mode"
    _property_names[active_angle] = "active_angle"
    _property_names[pull_g_mode] = "pull_g_mode"
    _property_names[override_pull_g] = "override_pull_g"
    _property_names[airspeed_options] = "airspeed_options"

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

agcls.AgClassCatalog.add_catalog_entry((5112232216588763203, 9403131292386721187), BasicManeuverStrategyPull)
agcls.AgTypeNameMap["BasicManeuverStrategyPull"] = BasicManeuverStrategyPull

class BasicManeuverStrategyRollingPull(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Rolling Pull Strategy of a Basic Maneuver Procedure."""

    _num_methods = 17
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_active_mode_method_offset = 1
    _set_active_mode_method_offset = 2
    _get_turn_direction_method_offset = 3
    _set_turn_direction_method_offset = 4
    _get_angle_method_offset = 5
    _set_angle_method_offset = 6
    _get_roll_orientation_method_offset = 7
    _set_roll_orientation_method_offset = 8
    _get_roll_rate_mode_method_offset = 9
    _set_roll_rate_mode_method_offset = 10
    _get_override_roll_rate_method_offset = 11
    _set_override_roll_rate_method_offset = 12
    _get_pull_g_mode_method_offset = 13
    _set_pull_g_mode_method_offset = 14
    _get_override_pull_g_method_offset = 15
    _set_override_pull_g_method_offset = 16
    _get_airspeed_options_method_offset = 17
    _metadata = {
        "iid_data" : (5112425247810861068, 15870398362261631162),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyRollingPull)

    _get_active_mode_metadata = { "offset" : _get_active_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RollingPullMode),) }
    @property
    def active_mode(self) -> "RollingPullMode":
        """Get or set the active mode for the rolling pull basic maneuver strategy."""
        return self._intf.get_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._get_active_mode_metadata)

    _set_active_mode_metadata = { "offset" : _set_active_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(RollingPullMode),) }
    @active_mode.setter
    def active_mode(self, value:"RollingPullMode") -> None:
        """Get or set the active mode for the rolling pull basic maneuver strategy."""
        return self._intf.set_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._set_active_mode_metadata, value)

    _get_turn_direction_metadata = { "offset" : _get_turn_direction_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RollLeftRight),) }
    @property
    def turn_direction(self) -> "RollLeftRight":
        """Get or set the turn direction for the active mode."""
        return self._intf.get_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._get_turn_direction_metadata)

    _set_turn_direction_metadata = { "offset" : _set_turn_direction_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(RollLeftRight),) }
    @turn_direction.setter
    def turn_direction(self, value:"RollLeftRight") -> None:
        """Get or set the turn direction for the active mode."""
        return self._intf.set_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._set_turn_direction_metadata, value)

    _get_angle_metadata = { "offset" : _get_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def angle(self) -> typing.Any:
        """Get or set the angle value for the active mode."""
        return self._intf.get_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._get_angle_metadata)

    _set_angle_metadata = { "offset" : _set_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @angle.setter
    def angle(self, value:typing.Any) -> None:
        """Get or set the angle value for the active mode."""
        return self._intf.set_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._set_angle_metadata, value)

    _get_roll_orientation_metadata = { "offset" : _get_roll_orientation_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RollUprightInverted),) }
    @property
    def roll_orientation(self) -> "RollUprightInverted":
        """Get or set the orientation to roll to for the roll to orientation mode."""
        return self._intf.get_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._get_roll_orientation_metadata)

    _set_roll_orientation_metadata = { "offset" : _set_roll_orientation_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(RollUprightInverted),) }
    @roll_orientation.setter
    def roll_orientation(self, value:"RollUprightInverted") -> None:
        """Get or set the orientation to roll to for the roll to orientation mode."""
        return self._intf.set_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._set_roll_orientation_metadata, value)

    _get_roll_rate_mode_metadata = { "offset" : _get_roll_rate_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @property
    def roll_rate_mode(self) -> "PerformanceModelOverride":
        """Get or set the roll rate mode for the rolling pull."""
        return self._intf.get_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._get_roll_rate_mode_metadata)

    _set_roll_rate_mode_metadata = { "offset" : _set_roll_rate_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @roll_rate_mode.setter
    def roll_rate_mode(self, value:"PerformanceModelOverride") -> None:
        """Get or set the roll rate mode for the rolling pull."""
        return self._intf.set_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._set_roll_rate_mode_metadata, value)

    _get_override_roll_rate_metadata = { "offset" : _get_override_roll_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def override_roll_rate(self) -> typing.Any:
        """Get or set the roll rate override value. The roll rate mode must be set to override to access this property."""
        return self._intf.get_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._get_override_roll_rate_metadata)

    _set_override_roll_rate_metadata = { "offset" : _set_override_roll_rate_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @override_roll_rate.setter
    def override_roll_rate(self, value:typing.Any) -> None:
        """Get or set the roll rate override. The roll rate mode must be set to override to access this property."""
        return self._intf.set_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._set_override_roll_rate_metadata, value)

    _get_pull_g_mode_metadata = { "offset" : _get_pull_g_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @property
    def pull_g_mode(self) -> "PerformanceModelOverride":
        """Get or set the pull G mode for a rolling pull."""
        return self._intf.get_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._get_pull_g_mode_metadata)

    _set_pull_g_mode_metadata = { "offset" : _set_pull_g_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @pull_g_mode.setter
    def pull_g_mode(self, value:"PerformanceModelOverride") -> None:
        """Get or set the pull G mode for a rolling pull."""
        return self._intf.set_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._set_pull_g_mode_metadata, value)

    _get_override_pull_g_metadata = { "offset" : _get_override_pull_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def override_pull_g(self) -> float:
        """Get or set the pull G override value. The pull G mode must be set to override to access this property."""
        return self._intf.get_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._get_override_pull_g_metadata)

    _set_override_pull_g_metadata = { "offset" : _set_override_pull_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @override_pull_g.setter
    def override_pull_g(self, value:float) -> None:
        """Get or set the pull G override value. The pull G mode must be set to override to access this property."""
        return self._intf.set_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._set_override_pull_g_metadata, value)

    _get_airspeed_options_metadata = { "offset" : _get_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def airspeed_options(self) -> "BasicManeuverAirspeedOptions":
        """Get the airspeed options."""
        return self._intf.get_property(BasicManeuverStrategyRollingPull._metadata, BasicManeuverStrategyRollingPull._get_airspeed_options_metadata)

    _property_names[active_mode] = "active_mode"
    _property_names[turn_direction] = "turn_direction"
    _property_names[angle] = "angle"
    _property_names[roll_orientation] = "roll_orientation"
    _property_names[roll_rate_mode] = "roll_rate_mode"
    _property_names[override_roll_rate] = "override_roll_rate"
    _property_names[pull_g_mode] = "pull_g_mode"
    _property_names[override_pull_g] = "override_pull_g"
    _property_names[airspeed_options] = "airspeed_options"

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

agcls.AgClassCatalog.add_catalog_entry((5201286070707408939, 16266359450549158825), BasicManeuverStrategyRollingPull)
agcls.AgTypeNameMap["BasicManeuverStrategyRollingPull"] = BasicManeuverStrategyRollingPull

class BasicManeuverStrategySmoothAcceleration(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Smooth Accel Strategy of a Basic Maneuver Procedure."""

    _num_methods = 29
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_turn_direction_method_offset = 1
    _set_turn_direction_method_offset = 2
    _get_roll_rate_mode_method_offset = 3
    _set_roll_rate_mode_method_offset = 4
    _get_override_roll_rate_method_offset = 5
    _set_override_roll_rate_method_offset = 6
    _get_roll_rate_dot_method_offset = 7
    _set_roll_rate_dot_method_offset = 8
    _get_control_roll_angle_method_offset = 9
    _set_control_roll_angle_method_offset = 10
    _get_roll_angle_method_offset = 11
    _set_roll_angle_method_offset = 12
    _get_load_factor_mode_method_offset = 13
    _set_load_factor_mode_method_offset = 14
    _get_override_load_factor_method_offset = 15
    _set_override_load_factor_method_offset = 16
    _get_load_factor_dot_method_offset = 17
    _set_load_factor_dot_method_offset = 18
    _get_control_pitch_angle_method_offset = 19
    _set_control_pitch_angle_method_offset = 20
    _get_pitch_angle_method_offset = 21
    _set_pitch_angle_method_offset = 22
    _get_stop_conditions_method_offset = 23
    _set_stop_conditions_method_offset = 24
    _get_stop_on_roll_angle_method_offset = 25
    _set_stop_on_roll_angle_method_offset = 26
    _get_stop_on_pitch_angle_method_offset = 27
    _set_stop_on_pitch_angle_method_offset = 28
    _get_airspeed_options_method_offset = 29
    _metadata = {
        "iid_data" : (5575657865929804238, 7979276300648358334),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategySmoothAcceleration)

    _get_turn_direction_metadata = { "offset" : _get_turn_direction_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SmoothAccelerationLeftRight),) }
    @property
    def turn_direction(self) -> "SmoothAccelerationLeftRight":
        """Get or set the roll turn direction for a Smooth Accel basic maneuver strategy."""
        return self._intf.get_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._get_turn_direction_metadata)

    _set_turn_direction_metadata = { "offset" : _set_turn_direction_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SmoothAccelerationLeftRight),) }
    @turn_direction.setter
    def turn_direction(self, value:"SmoothAccelerationLeftRight") -> None:
        """Get or set the roll turn direction for a Smooth Accel  basic maneuver strategy."""
        return self._intf.set_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._set_turn_direction_metadata, value)

    _get_roll_rate_mode_metadata = { "offset" : _get_roll_rate_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @property
    def roll_rate_mode(self) -> "PerformanceModelOverride":
        """Get or set the roll rate mode for a Smooth Accel basic maneuver strategy."""
        return self._intf.get_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._get_roll_rate_mode_metadata)

    _set_roll_rate_mode_metadata = { "offset" : _set_roll_rate_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @roll_rate_mode.setter
    def roll_rate_mode(self, value:"PerformanceModelOverride") -> None:
        """Get or set the roll rate mode for a Smooth Accel basic maneuver strategy."""
        return self._intf.set_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._set_roll_rate_mode_metadata, value)

    _get_override_roll_rate_metadata = { "offset" : _get_override_roll_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def override_roll_rate(self) -> typing.Any:
        """Get or set the roll rate override value for the Smooth Accel basic maneuver strategy. The roll rate mode must be set to override to access this property."""
        return self._intf.get_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._get_override_roll_rate_metadata)

    _set_override_roll_rate_metadata = { "offset" : _set_override_roll_rate_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @override_roll_rate.setter
    def override_roll_rate(self, value:typing.Any) -> None:
        """Get or set the roll rate override value for the Smooth Accel basic maneuver strategy. The roll rate mode must be set to override to access this property."""
        return self._intf.set_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._set_override_roll_rate_metadata, value)

    _get_roll_rate_dot_metadata = { "offset" : _get_roll_rate_dot_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def roll_rate_dot(self) -> typing.Any:
        """Get or set the rate of change of the roll rate."""
        return self._intf.get_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._get_roll_rate_dot_metadata)

    _set_roll_rate_dot_metadata = { "offset" : _set_roll_rate_dot_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @roll_rate_dot.setter
    def roll_rate_dot(self, value:typing.Any) -> None:
        """Get or set the rate of change of the roll rate."""
        return self._intf.set_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._set_roll_rate_dot_metadata, value)

    _get_control_roll_angle_metadata = { "offset" : _get_control_roll_angle_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_roll_angle(self) -> bool:
        """Get or set the option to define a goal value for the aircraft's roll angle."""
        return self._intf.get_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._get_control_roll_angle_metadata)

    _set_control_roll_angle_metadata = { "offset" : _set_control_roll_angle_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @control_roll_angle.setter
    def control_roll_angle(self, value:bool) -> None:
        """Get or set the option to define a goal value for the aircraft's roll angle."""
        return self._intf.set_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._set_control_roll_angle_metadata, value)

    _get_roll_angle_metadata = { "offset" : _get_roll_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def roll_angle(self) -> typing.Any:
        """Get or set the goal value for the roll angle."""
        return self._intf.get_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._get_roll_angle_metadata)

    _set_roll_angle_metadata = { "offset" : _set_roll_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @roll_angle.setter
    def roll_angle(self, value:typing.Any) -> None:
        """Get or set the goal value for the roll angle."""
        return self._intf.set_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._set_roll_angle_metadata, value)

    _get_load_factor_mode_metadata = { "offset" : _get_load_factor_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @property
    def load_factor_mode(self) -> "PerformanceModelOverride":
        """Get or set the load factor mode for the Smooth Accel basic maneuver strategy."""
        return self._intf.get_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._get_load_factor_mode_metadata)

    _set_load_factor_mode_metadata = { "offset" : _set_load_factor_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @load_factor_mode.setter
    def load_factor_mode(self, value:"PerformanceModelOverride") -> None:
        """Get or set the load factormode for the Smooth Accel basic maneuver strategy."""
        return self._intf.set_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._set_load_factor_mode_metadata, value)

    _get_override_load_factor_metadata = { "offset" : _get_override_load_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def override_load_factor(self) -> float:
        """Get or set the load factor override value for the smooth accel. The load factor mode must be set to override to access this property."""
        return self._intf.get_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._get_override_load_factor_metadata)

    _set_override_load_factor_metadata = { "offset" : _set_override_load_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @override_load_factor.setter
    def override_load_factor(self, value:float) -> None:
        """Get or set the load factor override value for the smooth accel. The load factor mode must be set to override to access this property."""
        return self._intf.set_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._set_override_load_factor_metadata, value)

    _get_load_factor_dot_metadata = { "offset" : _get_load_factor_dot_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def load_factor_dot(self) -> float:
        """Get or set the rate of change of the load factor."""
        return self._intf.get_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._get_load_factor_dot_metadata)

    _set_load_factor_dot_metadata = { "offset" : _set_load_factor_dot_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @load_factor_dot.setter
    def load_factor_dot(self, value:float) -> None:
        """Get or set the rate of change of the load factor."""
        return self._intf.set_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._set_load_factor_dot_metadata, value)

    _get_control_pitch_angle_metadata = { "offset" : _get_control_pitch_angle_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def control_pitch_angle(self) -> bool:
        """Get or set the option to define a goal value for the aircraft's pitch angle."""
        return self._intf.get_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._get_control_pitch_angle_metadata)

    _set_control_pitch_angle_metadata = { "offset" : _set_control_pitch_angle_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @control_pitch_angle.setter
    def control_pitch_angle(self, value:bool) -> None:
        """Get or set the option to define a goal value for the aircraft's pitch angle."""
        return self._intf.set_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._set_control_pitch_angle_metadata, value)

    _get_pitch_angle_metadata = { "offset" : _get_pitch_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def pitch_angle(self) -> typing.Any:
        """Get or set the goal value for the pitch angle."""
        return self._intf.get_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._get_pitch_angle_metadata)

    _set_pitch_angle_metadata = { "offset" : _set_pitch_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @pitch_angle.setter
    def pitch_angle(self, value:typing.Any) -> None:
        """Get or set the goal value for the pitch angle."""
        return self._intf.set_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._set_pitch_angle_metadata, value)

    _get_stop_conditions_metadata = { "offset" : _get_stop_conditions_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SmoothAccelerationStopConditions),) }
    @property
    def stop_conditions(self) -> "SmoothAccelerationStopConditions":
        """Get or set the stop condition for the Smooth Accel basic maneuver strategy."""
        return self._intf.get_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._get_stop_conditions_metadata)

    _set_stop_conditions_metadata = { "offset" : _set_stop_conditions_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SmoothAccelerationStopConditions),) }
    @stop_conditions.setter
    def stop_conditions(self, value:"SmoothAccelerationStopConditions") -> None:
        """Get or set the stop condition for the Smooth Accel  basic maneuver strategy."""
        return self._intf.set_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._set_stop_conditions_metadata, value)

    _get_stop_on_roll_angle_metadata = { "offset" : _get_stop_on_roll_angle_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def stop_on_roll_angle(self) -> bool:
        """Get or set the option to stop the maneuver if the specified roll angle is achieved."""
        return self._intf.get_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._get_stop_on_roll_angle_metadata)

    _set_stop_on_roll_angle_metadata = { "offset" : _set_stop_on_roll_angle_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @stop_on_roll_angle.setter
    def stop_on_roll_angle(self, value:bool) -> None:
        """Get or set the option to stop the maneuver if the specified roll angle is achieved."""
        return self._intf.set_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._set_stop_on_roll_angle_metadata, value)

    _get_stop_on_pitch_angle_metadata = { "offset" : _get_stop_on_pitch_angle_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def stop_on_pitch_angle(self) -> bool:
        """Get or set the option to stop the maneuver if the specified pitch angle is achieved."""
        return self._intf.get_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._get_stop_on_pitch_angle_metadata)

    _set_stop_on_pitch_angle_metadata = { "offset" : _set_stop_on_pitch_angle_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @stop_on_pitch_angle.setter
    def stop_on_pitch_angle(self, value:bool) -> None:
        """Get or set the option to stop the maneuver if the specified pitch angle is achieved."""
        return self._intf.set_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._set_stop_on_pitch_angle_metadata, value)

    _get_airspeed_options_metadata = { "offset" : _get_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def airspeed_options(self) -> "BasicManeuverAirspeedOptions":
        """Get the airspeed options."""
        return self._intf.get_property(BasicManeuverStrategySmoothAcceleration._metadata, BasicManeuverStrategySmoothAcceleration._get_airspeed_options_metadata)

    _property_names[turn_direction] = "turn_direction"
    _property_names[roll_rate_mode] = "roll_rate_mode"
    _property_names[override_roll_rate] = "override_roll_rate"
    _property_names[roll_rate_dot] = "roll_rate_dot"
    _property_names[control_roll_angle] = "control_roll_angle"
    _property_names[roll_angle] = "roll_angle"
    _property_names[load_factor_mode] = "load_factor_mode"
    _property_names[override_load_factor] = "override_load_factor"
    _property_names[load_factor_dot] = "load_factor_dot"
    _property_names[control_pitch_angle] = "control_pitch_angle"
    _property_names[pitch_angle] = "pitch_angle"
    _property_names[stop_conditions] = "stop_conditions"
    _property_names[stop_on_roll_angle] = "stop_on_roll_angle"
    _property_names[stop_on_pitch_angle] = "stop_on_pitch_angle"
    _property_names[airspeed_options] = "airspeed_options"

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

agcls.AgClassCatalog.add_catalog_entry((5309213016362285124, 9310491107287959706), BasicManeuverStrategySmoothAcceleration)
agcls.AgTypeNameMap["BasicManeuverStrategySmoothAcceleration"] = BasicManeuverStrategySmoothAcceleration

class BasicManeuverStrategySmoothTurn(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Smooth Turn Strategy of a Basic Maneuver Procedure."""

    _num_methods = 19
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_heading_change_method_offset = 1
    _set_heading_change_method_offset = 2
    _get_turn_mode_method_offset = 3
    _set_turn_mode_method_offset = 4
    _get_load_factor_mode_method_offset = 5
    _set_load_factor_mode_method_offset = 6
    _get_max_load_factor_rate_method_offset = 7
    _set_max_load_factor_rate_method_offset = 8
    _get_override_load_factor_method_offset = 9
    _set_override_load_factor_method_offset = 10
    _get_roll_rate_mode_method_offset = 11
    _set_roll_rate_mode_method_offset = 12
    _get_roll_angle_method_offset = 13
    _set_roll_angle_method_offset = 14
    _get_override_roll_rate_method_offset = 15
    _set_override_roll_rate_method_offset = 16
    _get_airspeed_options_method_offset = 17
    _get_flight_path_angle_mode_method_offset = 18
    _set_flight_path_angle_mode_method_offset = 19
    _metadata = {
        "iid_data" : (5493265518926974794, 14820752937463885992),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategySmoothTurn)

    _get_heading_change_metadata = { "offset" : _get_heading_change_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def heading_change(self) -> typing.Any:
        """Get or set the heading change for the smooth turn."""
        return self._intf.get_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._get_heading_change_metadata)

    _set_heading_change_metadata = { "offset" : _set_heading_change_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @heading_change.setter
    def heading_change(self, value:typing.Any) -> None:
        """Get or set the heading change for the smooth turn."""
        return self._intf.set_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._set_heading_change_metadata, value)

    _get_turn_mode_metadata = { "offset" : _get_turn_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SmoothTurnMode),) }
    @property
    def turn_mode(self) -> "SmoothTurnMode":
        """Get or set the turn mode for the smooth turn."""
        return self._intf.get_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._get_turn_mode_metadata)

    _set_turn_mode_metadata = { "offset" : _set_turn_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SmoothTurnMode),) }
    @turn_mode.setter
    def turn_mode(self, value:"SmoothTurnMode") -> None:
        """Get or set the turn mode for the smooth turn."""
        return self._intf.set_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._set_turn_mode_metadata, value)

    _get_load_factor_mode_metadata = { "offset" : _get_load_factor_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @property
    def load_factor_mode(self) -> "PerformanceModelOverride":
        """Get or set the load factor mode for the smooth turn."""
        return self._intf.get_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._get_load_factor_mode_metadata)

    _set_load_factor_mode_metadata = { "offset" : _set_load_factor_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @load_factor_mode.setter
    def load_factor_mode(self, value:"PerformanceModelOverride") -> None:
        """Get or set the load factormode for the smooth turn."""
        return self._intf.set_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._set_load_factor_mode_metadata, value)

    _get_max_load_factor_rate_metadata = { "offset" : _get_max_load_factor_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_load_factor_rate(self) -> float:
        """Get or set the max load factor rate for the smooth turn."""
        return self._intf.get_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._get_max_load_factor_rate_metadata)

    _set_max_load_factor_rate_metadata = { "offset" : _set_max_load_factor_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_load_factor_rate.setter
    def max_load_factor_rate(self, value:float) -> None:
        """Get or set the max load factor rate for the smooth turn."""
        return self._intf.set_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._set_max_load_factor_rate_metadata, value)

    _get_override_load_factor_metadata = { "offset" : _get_override_load_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def override_load_factor(self) -> float:
        """Get or set the max load factor override value for the smooth turn. The load factor mode must be set to override to access this property."""
        return self._intf.get_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._get_override_load_factor_metadata)

    _set_override_load_factor_metadata = { "offset" : _set_override_load_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @override_load_factor.setter
    def override_load_factor(self, value:float) -> None:
        """Get or set the max load factor override value for the smooth turn. The load factor mode must be set to override to access this property."""
        return self._intf.set_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._set_override_load_factor_metadata, value)

    _get_roll_rate_mode_metadata = { "offset" : _get_roll_rate_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @property
    def roll_rate_mode(self) -> "PerformanceModelOverride":
        """Get or set the roll rate mode for the smooth turn."""
        return self._intf.get_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._get_roll_rate_mode_metadata)

    _set_roll_rate_mode_metadata = { "offset" : _set_roll_rate_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @roll_rate_mode.setter
    def roll_rate_mode(self, value:"PerformanceModelOverride") -> None:
        """Get or set the roll rate mode for the smooth turn."""
        return self._intf.set_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._set_roll_rate_mode_metadata, value)

    _get_roll_angle_metadata = { "offset" : _get_roll_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def roll_angle(self) -> typing.Any:
        """Get or set the roll angle for the smooth turn."""
        return self._intf.get_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._get_roll_angle_metadata)

    _set_roll_angle_metadata = { "offset" : _set_roll_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @roll_angle.setter
    def roll_angle(self, value:typing.Any) -> None:
        """Get or set the roll angle for the smooth turn."""
        return self._intf.set_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._set_roll_angle_metadata, value)

    _get_override_roll_rate_metadata = { "offset" : _get_override_roll_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def override_roll_rate(self) -> typing.Any:
        """Get or set the max roll rate override value for the smooth turn. The roll rate mode must be set to override to access this property."""
        return self._intf.get_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._get_override_roll_rate_metadata)

    _set_override_roll_rate_metadata = { "offset" : _set_override_roll_rate_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @override_roll_rate.setter
    def override_roll_rate(self, value:typing.Any) -> None:
        """Get or set the max roll rate override value for the smooth turn. The roll rate mode must be set to override to access this property."""
        return self._intf.set_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._set_override_roll_rate_metadata, value)

    _get_airspeed_options_metadata = { "offset" : _get_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def airspeed_options(self) -> "BasicManeuverAirspeedOptions":
        """Get the airspeed options."""
        return self._intf.get_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._get_airspeed_options_metadata)

    _get_flight_path_angle_mode_metadata = { "offset" : _get_flight_path_angle_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SmoothTurnFlightPathAngleMode),) }
    @property
    def flight_path_angle_mode(self) -> "SmoothTurnFlightPathAngleMode":
        """Get or set the flight path angle mode."""
        return self._intf.get_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._get_flight_path_angle_mode_metadata)

    _set_flight_path_angle_mode_metadata = { "offset" : _set_flight_path_angle_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SmoothTurnFlightPathAngleMode),) }
    @flight_path_angle_mode.setter
    def flight_path_angle_mode(self, value:"SmoothTurnFlightPathAngleMode") -> None:
        """Get or set the flight path angle mode."""
        return self._intf.set_property(BasicManeuverStrategySmoothTurn._metadata, BasicManeuverStrategySmoothTurn._set_flight_path_angle_mode_metadata, value)

    _property_names[heading_change] = "heading_change"
    _property_names[turn_mode] = "turn_mode"
    _property_names[load_factor_mode] = "load_factor_mode"
    _property_names[max_load_factor_rate] = "max_load_factor_rate"
    _property_names[override_load_factor] = "override_load_factor"
    _property_names[roll_rate_mode] = "roll_rate_mode"
    _property_names[roll_angle] = "roll_angle"
    _property_names[override_roll_rate] = "override_roll_rate"
    _property_names[airspeed_options] = "airspeed_options"
    _property_names[flight_path_angle_mode] = "flight_path_angle_mode"

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

agcls.AgClassCatalog.add_catalog_entry((4631515585365048851, 223936628880623543), BasicManeuverStrategySmoothTurn)
agcls.AgTypeNameMap["BasicManeuverStrategySmoothTurn"] = BasicManeuverStrategySmoothTurn

class BasicManeuverAirspeedOptions(SupportsDeleteCallback):
    """
    Interface used to access airspeed options for basic maneuver strategies.

    Examples
    --------
    Add and configure a basic maneuver procedure:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add a basic maneuver procedure
    >>> basicManeuver = procedures.add(SiteType.SITE_END_OF_PREV_PROCEDURE, ProcedureType.PROCEDURE_BASIC_MANEUVER)
    >>>
    >>> # Set the navigation to use a Straight Ahead strategy
    >>> basicManeuver.navigation_strategy_type = "Straight Ahead"
    >>> # Get the options for the straight ahead strategy
    >>> straightAhead = basicManeuver.navigation
    >>> # Opt to maintain course (as opposed to maintain heading)
    >>> straightAhead.reference_frame = StraightAheadReferenceFrame.MAINTAIN_COURSE
    >>>
    >>> # Set the profile to use a Autopilot - Vertical Plane strategy
    >>> basicManeuver.profile_strategy_type = "Autopilot - Vertical Plane"
    >>> # Get the options for the profile strategy
    >>> autopilot = basicManeuver.profile
    >>> # Opt to maintain the initial altitude
    >>> autopilot.altitude_mode = AutopilotAltitudeMode.AUTOPILOT_HOLD_INIT_ALTITUDE
    >>> airspeedOptions = autopilot.airspeed_options
    >>> # Opt to maintain a specified airspeed
    >>> airspeedOptions.airspeed_mode = BasicManeuverAirspeedMode.MAINTAIN_SPECIFIED_AIRSPEED
    >>> # Specify the airspeed
    >>> airspeedOptions.specified_airspeed = 250
    >>>
    >>> # Configure the options on the Attitude / Performance / Fuel page
    >>> basicManeuver.flight_mode = PhaseOfFlight.FLIGHT_PHASE_CRUISE
    >>> # Override the fuel flow
    >>> basicManeuver.fuel_flow_type = BasicManeuverFuelFlowType.BASIC_MANEUVER_FUEL_FLOW_OVERRIDE
    >>> basicManeuver.override_fuel_flow_value = 1000
    >>>
    >>> # Set the basic stopping conditions
    >>> basicManeuver.use_max_downrange = True
    >>> basicManeuver.max_downrange = 10
    >>> basicManeuver.use_stop_fuel_state = False
    >>> basicManeuver.use_max_time_of_flight = False
    """

    _num_methods = 35
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_airspeed_mode_method_offset = 1
    _set_airspeed_mode_method_offset = 2
    _get_min_speed_limits_method_offset = 3
    _set_min_speed_limits_method_offset = 4
    _get_max_speed_limits_method_offset = 5
    _set_max_speed_limits_method_offset = 6
    _get_maintain_airspeed_type_method_offset = 7
    _set_maintain_airspeed_type_method_offset = 8
    _get_specified_airspeed_type_method_offset = 9
    _set_specified_airspeed_type_method_offset = 10
    _get_specified_acceleration_deceleration_mode_method_offset = 11
    _set_specified_acceleration_deceleration_mode_method_offset = 12
    _get_specified_airspeed_method_offset = 13
    _set_specified_airspeed_method_offset = 14
    _get_specified_acceleration_deceleration_g_method_offset = 15
    _set_specified_acceleration_deceleration_g_method_offset = 16
    _get_acceleration_g_method_offset = 17
    _set_acceleration_g_method_offset = 18
    _get_deceleration_g_method_offset = 19
    _set_deceleration_g_method_offset = 20
    _get_acceleration_mode_method_offset = 21
    _set_acceleration_mode_method_offset = 22
    _get_deceleration_mode_method_offset = 23
    _set_deceleration_mode_method_offset = 24
    _get_throttle_method_offset = 25
    _set_throttle_method_offset = 26
    _get_interpolate_init_g_method_offset = 27
    _set_interpolate_init_g_method_offset = 28
    _get_interpolate_end_g_method_offset = 29
    _set_interpolate_end_g_method_offset = 30
    _get_interpolate_end_time_method_offset = 31
    _set_interpolate_end_time_method_offset = 32
    _get_interpolate_stop_at_end_time_method_offset = 33
    _set_interpolate_stop_at_end_time_method_offset = 34
    _get_thrust_method_offset = 35
    _metadata = {
        "iid_data" : (5465091044897022664, 7818739737937967787),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverAirspeedOptions)

    _get_airspeed_mode_metadata = { "offset" : _get_airspeed_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverAirspeedMode),) }
    @property
    def airspeed_mode(self) -> "BasicManeuverAirspeedMode":
        """Get or set the active airspeed mode."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_airspeed_mode_metadata)

    _set_airspeed_mode_metadata = { "offset" : _set_airspeed_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverAirspeedMode),) }
    @airspeed_mode.setter
    def airspeed_mode(self, value:"BasicManeuverAirspeedMode") -> None:
        """Get or set the active airspeed mode."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_airspeed_mode_metadata, value)

    _get_min_speed_limits_metadata = { "offset" : _get_min_speed_limits_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyAirspeedPerformanceLimits),) }
    @property
    def min_speed_limits(self) -> "BasicManeuverStrategyAirspeedPerformanceLimits":
        """Get or set the minimum speed limit type to enforce."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_min_speed_limits_metadata)

    _set_min_speed_limits_metadata = { "offset" : _set_min_speed_limits_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyAirspeedPerformanceLimits),) }
    @min_speed_limits.setter
    def min_speed_limits(self, value:"BasicManeuverStrategyAirspeedPerformanceLimits") -> None:
        """Get or set the minimum speed limit type to enforce."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_min_speed_limits_metadata, value)

    _get_max_speed_limits_metadata = { "offset" : _get_max_speed_limits_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyAirspeedPerformanceLimits),) }
    @property
    def max_speed_limits(self) -> "BasicManeuverStrategyAirspeedPerformanceLimits":
        """Get or set the maximum speed limit type to enforce."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_max_speed_limits_metadata)

    _set_max_speed_limits_metadata = { "offset" : _set_max_speed_limits_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyAirspeedPerformanceLimits),) }
    @max_speed_limits.setter
    def max_speed_limits(self, value:"BasicManeuverStrategyAirspeedPerformanceLimits") -> None:
        """Get or set the maximum speed limit type to enforce."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_max_speed_limits_metadata, value)

    _get_maintain_airspeed_type_metadata = { "offset" : _get_maintain_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def maintain_airspeed_type(self) -> "AirspeedType":
        """Get or set the airspeed type option in the Maintain Current Airspeed mode."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_maintain_airspeed_type_metadata)

    _set_maintain_airspeed_type_metadata = { "offset" : _set_maintain_airspeed_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @maintain_airspeed_type.setter
    def maintain_airspeed_type(self, value:"AirspeedType") -> None:
        """Get or set the airspeed type option in the Maintain Current Airspeed mode."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_maintain_airspeed_type_metadata, value)

    _get_specified_airspeed_type_metadata = { "offset" : _get_specified_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def specified_airspeed_type(self) -> "AirspeedType":
        """Get or set the airspeed type option in the Maintain Specified Airspeed mode."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_specified_airspeed_type_metadata)

    _set_specified_airspeed_type_metadata = { "offset" : _set_specified_airspeed_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @specified_airspeed_type.setter
    def specified_airspeed_type(self, value:"AirspeedType") -> None:
        """Get or set the airspeed type option in the Maintain Specified Airspeed mode."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_specified_airspeed_type_metadata, value)

    _get_specified_acceleration_deceleration_mode_metadata = { "offset" : _get_specified_acceleration_deceleration_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @property
    def specified_acceleration_deceleration_mode(self) -> "PerformanceModelOverride":
        """Get or set the accel/decel mode for the Maintain Specified Airspeed mode."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_specified_acceleration_deceleration_mode_metadata)

    _set_specified_acceleration_deceleration_mode_metadata = { "offset" : _set_specified_acceleration_deceleration_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @specified_acceleration_deceleration_mode.setter
    def specified_acceleration_deceleration_mode(self, value:"PerformanceModelOverride") -> None:
        """Get or set the accel/decel mode for the Maintain Specified Airspeed mode."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_specified_acceleration_deceleration_mode_metadata, value)

    _get_specified_airspeed_metadata = { "offset" : _get_specified_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def specified_airspeed(self) -> float:
        """Get or set the airspeed for the Maintain Specified Airspeed mode."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_specified_airspeed_metadata)

    _set_specified_airspeed_metadata = { "offset" : _set_specified_airspeed_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @specified_airspeed.setter
    def specified_airspeed(self, value:float) -> None:
        """Get or set the airspeed for the Maintain Specified Airspeed mode."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_specified_airspeed_metadata, value)

    _get_specified_acceleration_deceleration_g_metadata = { "offset" : _get_specified_acceleration_deceleration_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def specified_acceleration_deceleration_g(self) -> float:
        """Get or set the accel/decel G for the Maintain Specified Airspeed mode."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_specified_acceleration_deceleration_g_metadata)

    _set_specified_acceleration_deceleration_g_metadata = { "offset" : _set_specified_acceleration_deceleration_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @specified_acceleration_deceleration_g.setter
    def specified_acceleration_deceleration_g(self, value:float) -> None:
        """Get or set the accel/decel G for the Maintain Specified Airspeed mode."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_specified_acceleration_deceleration_g_metadata, value)

    _get_acceleration_g_metadata = { "offset" : _get_acceleration_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def acceleration_g(self) -> float:
        """Get or set the accel G for the Accelerate at mode."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_acceleration_g_metadata)

    _set_acceleration_g_metadata = { "offset" : _set_acceleration_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @acceleration_g.setter
    def acceleration_g(self, value:float) -> None:
        """Get or set the accel G for the Accelerate at mode."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_acceleration_g_metadata, value)

    _get_deceleration_g_metadata = { "offset" : _get_deceleration_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def deceleration_g(self) -> float:
        """Get or set the decel G for the Decelerate at mode."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_deceleration_g_metadata)

    _set_deceleration_g_metadata = { "offset" : _set_deceleration_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @deceleration_g.setter
    def deceleration_g(self, value:float) -> None:
        """Get or set the decel G for the Decelerate at mode."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_deceleration_g_metadata, value)

    _get_acceleration_mode_metadata = { "offset" : _get_acceleration_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @property
    def acceleration_mode(self) -> "PerformanceModelOverride":
        """Get or set the accel mode for the Accelerate at mode."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_acceleration_mode_metadata)

    _set_acceleration_mode_metadata = { "offset" : _set_acceleration_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @acceleration_mode.setter
    def acceleration_mode(self, value:"PerformanceModelOverride") -> None:
        """Get or set the accel mode for the Accelerate at mode."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_acceleration_mode_metadata, value)

    _get_deceleration_mode_metadata = { "offset" : _get_deceleration_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @property
    def deceleration_mode(self) -> "PerformanceModelOverride":
        """Get or set the accel mode for the Decelerate at mode."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_deceleration_mode_metadata)

    _set_deceleration_mode_metadata = { "offset" : _set_deceleration_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @deceleration_mode.setter
    def deceleration_mode(self, value:"PerformanceModelOverride") -> None:
        """Get or set the accel mode for the Decelerate at mode."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_deceleration_mode_metadata, value)

    _get_throttle_metadata = { "offset" : _get_throttle_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def throttle(self) -> float:
        """Get or set the throttle setting for the Accel/Decel using Aero/Propulsion at mode."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_throttle_metadata)

    _set_throttle_metadata = { "offset" : _set_throttle_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @throttle.setter
    def throttle(self, value:float) -> None:
        """Get or set the throttle setting for the Accel/Decel using Aero/Propulsion at mode."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_throttle_metadata, value)

    _get_interpolate_init_g_metadata = { "offset" : _get_interpolate_init_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def interpolate_init_g(self) -> float:
        """Get or set the initial G for the Interpolate Accel/Decel over Interval mode."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_interpolate_init_g_metadata)

    _set_interpolate_init_g_metadata = { "offset" : _set_interpolate_init_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @interpolate_init_g.setter
    def interpolate_init_g(self, value:float) -> None:
        """Get or set the initial G for the Interpolate Accel/Decel over Interval mode."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_interpolate_init_g_metadata, value)

    _get_interpolate_end_g_metadata = { "offset" : _get_interpolate_end_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def interpolate_end_g(self) -> float:
        """Get or set the end G for the Interpolate Accel/Decel over Interval mode."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_interpolate_end_g_metadata)

    _set_interpolate_end_g_metadata = { "offset" : _set_interpolate_end_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @interpolate_end_g.setter
    def interpolate_end_g(self, value:float) -> None:
        """Get or set the end G for the Interpolate Accel/Decel over Interval mode."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_interpolate_end_g_metadata, value)

    _get_interpolate_end_time_metadata = { "offset" : _get_interpolate_end_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def interpolate_end_time(self) -> float:
        """Get or set the end time for the Interpolate Accel/Decel over Interval mode."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_interpolate_end_time_metadata)

    _set_interpolate_end_time_metadata = { "offset" : _set_interpolate_end_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @interpolate_end_time.setter
    def interpolate_end_time(self, value:float) -> None:
        """Get or set the end time for the Interpolate Accel/Decel over Interval mode."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_interpolate_end_time_metadata, value)

    _get_interpolate_stop_at_end_time_metadata = { "offset" : _get_interpolate_stop_at_end_time_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def interpolate_stop_at_end_time(self) -> bool:
        """Get or set the option to stop at the end time for the Interpolate Accel/Decel over Interval mode."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_interpolate_stop_at_end_time_metadata)

    _set_interpolate_stop_at_end_time_metadata = { "offset" : _set_interpolate_stop_at_end_time_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @interpolate_stop_at_end_time.setter
    def interpolate_stop_at_end_time(self, value:bool) -> None:
        """Get or set the option to stop at the end time for the Interpolate Accel/Decel over Interval mode."""
        return self._intf.set_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._set_interpolate_stop_at_end_time_metadata, value)

    _get_thrust_metadata = { "offset" : _get_thrust_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def thrust(self) -> "PropulsionThrust":
        """Get the thrust options for the Specify Thrust mode."""
        return self._intf.get_property(BasicManeuverAirspeedOptions._metadata, BasicManeuverAirspeedOptions._get_thrust_metadata)

    _property_names[airspeed_mode] = "airspeed_mode"
    _property_names[min_speed_limits] = "min_speed_limits"
    _property_names[max_speed_limits] = "max_speed_limits"
    _property_names[maintain_airspeed_type] = "maintain_airspeed_type"
    _property_names[specified_airspeed_type] = "specified_airspeed_type"
    _property_names[specified_acceleration_deceleration_mode] = "specified_acceleration_deceleration_mode"
    _property_names[specified_airspeed] = "specified_airspeed"
    _property_names[specified_acceleration_deceleration_g] = "specified_acceleration_deceleration_g"
    _property_names[acceleration_g] = "acceleration_g"
    _property_names[deceleration_g] = "deceleration_g"
    _property_names[acceleration_mode] = "acceleration_mode"
    _property_names[deceleration_mode] = "deceleration_mode"
    _property_names[throttle] = "throttle"
    _property_names[interpolate_init_g] = "interpolate_init_g"
    _property_names[interpolate_end_g] = "interpolate_end_g"
    _property_names[interpolate_end_time] = "interpolate_end_time"
    _property_names[interpolate_stop_at_end_time] = "interpolate_stop_at_end_time"
    _property_names[thrust] = "thrust"

    def __init__(self, source_object=None):
        """Construct an object of type BasicManeuverAirspeedOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BasicManeuverAirspeedOptions)
    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, BasicManeuverAirspeedOptions, [BasicManeuverAirspeedOptions, ])

agcls.AgClassCatalog.add_catalog_entry((4817576889599620828, 4935414545747067064), BasicManeuverAirspeedOptions)
agcls.AgTypeNameMap["BasicManeuverAirspeedOptions"] = BasicManeuverAirspeedOptions

class PropulsionThrust(SupportsDeleteCallback):
    """Interface used to access propulsion thrust for basic maneuver strategies."""

    _num_methods = 18
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_use_constant_thrust_method_offset = 1
    _set_use_constant_thrust_method_offset = 2
    _get_constant_thrust_method_offset = 3
    _set_constant_thrust_method_offset = 4
    _get_boost_thrust_method_offset = 5
    _set_boost_thrust_method_offset = 6
    _get_boost_thrust_time_limit_method_offset = 7
    _set_boost_thrust_time_limit_method_offset = 8
    _get_sustain_thrust_method_offset = 9
    _set_sustain_thrust_method_offset = 10
    _get_sustain_thrust_time_limit_method_offset = 11
    _set_sustain_thrust_time_limit_method_offset = 12
    _get_min_airspeed_type_method_offset = 13
    _get_min_airspeed_method_offset = 14
    _set_min_airspeed_method_offset = 15
    _get_max_airspeed_type_method_offset = 16
    _get_max_airspeed_method_offset = 17
    _set_max_airspeed_method_offset = 18
    _metadata = {
        "iid_data" : (4642771003123318015, 5598955518200320685),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, PropulsionThrust)

    _get_use_constant_thrust_metadata = { "offset" : _get_use_constant_thrust_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_constant_thrust(self) -> bool:
        """Get or set the option to use a constant thrust for a thrust model."""
        return self._intf.get_property(PropulsionThrust._metadata, PropulsionThrust._get_use_constant_thrust_metadata)

    _set_use_constant_thrust_metadata = { "offset" : _set_use_constant_thrust_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_constant_thrust.setter
    def use_constant_thrust(self, value:bool) -> None:
        """Get or set the option to use a constant thrust for a thrust model."""
        return self._intf.set_property(PropulsionThrust._metadata, PropulsionThrust._set_use_constant_thrust_metadata, value)

    _get_constant_thrust_metadata = { "offset" : _get_constant_thrust_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def constant_thrust(self) -> float:
        """Get or set the constant thrust value for a thrust model set to Constant Thrust mode."""
        return self._intf.get_property(PropulsionThrust._metadata, PropulsionThrust._get_constant_thrust_metadata)

    _set_constant_thrust_metadata = { "offset" : _set_constant_thrust_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @constant_thrust.setter
    def constant_thrust(self, value:float) -> None:
        """Get or set the constant thrust value for a thrust model set to Constant Thrust mode."""
        return self._intf.set_property(PropulsionThrust._metadata, PropulsionThrust._set_constant_thrust_metadata, value)

    _get_boost_thrust_metadata = { "offset" : _get_boost_thrust_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def boost_thrust(self) -> float:
        """Get or set the boost thrust value for a thrust model set to Boost/Sustain Thrust mode."""
        return self._intf.get_property(PropulsionThrust._metadata, PropulsionThrust._get_boost_thrust_metadata)

    _set_boost_thrust_metadata = { "offset" : _set_boost_thrust_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @boost_thrust.setter
    def boost_thrust(self, value:float) -> None:
        """Get or set the boost thrust value for a thrust model set to Boost/Sustain Thrust mode."""
        return self._intf.set_property(PropulsionThrust._metadata, PropulsionThrust._set_boost_thrust_metadata, value)

    _get_boost_thrust_time_limit_metadata = { "offset" : _get_boost_thrust_time_limit_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def boost_thrust_time_limit(self) -> float:
        """Get or set the boost thrust time limit for a thrust model set to Boost/Sustain Thrust mode."""
        return self._intf.get_property(PropulsionThrust._metadata, PropulsionThrust._get_boost_thrust_time_limit_metadata)

    _set_boost_thrust_time_limit_metadata = { "offset" : _set_boost_thrust_time_limit_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @boost_thrust_time_limit.setter
    def boost_thrust_time_limit(self, value:float) -> None:
        """Get or set the boost thrust time limit for a thrust model set to Boost/Sustain Thrust mode."""
        return self._intf.set_property(PropulsionThrust._metadata, PropulsionThrust._set_boost_thrust_time_limit_metadata, value)

    _get_sustain_thrust_metadata = { "offset" : _get_sustain_thrust_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def sustain_thrust(self) -> float:
        """Get or set the sustain thrust value for a thrust model set to Boost/Sustain Thrust mode."""
        return self._intf.get_property(PropulsionThrust._metadata, PropulsionThrust._get_sustain_thrust_metadata)

    _set_sustain_thrust_metadata = { "offset" : _set_sustain_thrust_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @sustain_thrust.setter
    def sustain_thrust(self, value:float) -> None:
        """Get or set the sustain thrust value for a thrust model set to Boost/Sustain Thrust mode."""
        return self._intf.set_property(PropulsionThrust._metadata, PropulsionThrust._set_sustain_thrust_metadata, value)

    _get_sustain_thrust_time_limit_metadata = { "offset" : _get_sustain_thrust_time_limit_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def sustain_thrust_time_limit(self) -> float:
        """Get or set the sustain thrust time limit for a thrust model set to Boost/Sustain Thrust mode."""
        return self._intf.get_property(PropulsionThrust._metadata, PropulsionThrust._get_sustain_thrust_time_limit_metadata)

    _set_sustain_thrust_time_limit_metadata = { "offset" : _set_sustain_thrust_time_limit_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @sustain_thrust_time_limit.setter
    def sustain_thrust_time_limit(self, value:float) -> None:
        """Get or set the sustain thrust time limit for a thrust model set to Boost/Sustain Thrust mode."""
        return self._intf.set_property(PropulsionThrust._metadata, PropulsionThrust._set_sustain_thrust_time_limit_metadata, value)

    _get_min_airspeed_type_metadata = { "offset" : _get_min_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def min_airspeed_type(self) -> "AirspeedType":
        """Get the min airspeed type for a thrust model."""
        return self._intf.get_property(PropulsionThrust._metadata, PropulsionThrust._get_min_airspeed_type_metadata)

    _get_min_airspeed_metadata = { "offset" : _get_min_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_airspeed(self) -> float:
        """Get the min airspeed for a thrust model."""
        return self._intf.get_property(PropulsionThrust._metadata, PropulsionThrust._get_min_airspeed_metadata)

    _set_min_airspeed_metadata = { "offset" : _set_min_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_min_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the min airspeed type and value for a thrust model."""
        return self._intf.invoke(PropulsionThrust._metadata, PropulsionThrust._set_min_airspeed_metadata, airspeed_type, airspeed)

    _get_max_airspeed_type_metadata = { "offset" : _get_max_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def max_airspeed_type(self) -> "AirspeedType":
        """Get the max airspeed type for a thrust model."""
        return self._intf.get_property(PropulsionThrust._metadata, PropulsionThrust._get_max_airspeed_type_metadata)

    _get_max_airspeed_metadata = { "offset" : _get_max_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_airspeed(self) -> float:
        """Get the max airspeed for a thrust model."""
        return self._intf.get_property(PropulsionThrust._metadata, PropulsionThrust._get_max_airspeed_metadata)

    _set_max_airspeed_metadata = { "offset" : _set_max_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_max_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the max airspeed type and value for a thrust model."""
        return self._intf.invoke(PropulsionThrust._metadata, PropulsionThrust._set_max_airspeed_metadata, airspeed_type, airspeed)

    _property_names[use_constant_thrust] = "use_constant_thrust"
    _property_names[constant_thrust] = "constant_thrust"
    _property_names[boost_thrust] = "boost_thrust"
    _property_names[boost_thrust_time_limit] = "boost_thrust_time_limit"
    _property_names[sustain_thrust] = "sustain_thrust"
    _property_names[sustain_thrust_time_limit] = "sustain_thrust_time_limit"
    _property_names[min_airspeed_type] = "min_airspeed_type"
    _property_names[min_airspeed] = "min_airspeed"
    _property_names[max_airspeed_type] = "max_airspeed_type"
    _property_names[max_airspeed] = "max_airspeed"

    def __init__(self, source_object=None):
        """Construct an object of type PropulsionThrust."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, PropulsionThrust)
    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, PropulsionThrust, [PropulsionThrust, ])

agcls.AgClassCatalog.add_catalog_entry((5602735193462223002, 11939510195580016258), PropulsionThrust)
agcls.AgTypeNameMap["PropulsionThrust"] = PropulsionThrust

class BasicManeuverStrategyAutopilotNavigation(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for the Autopilot - Horizontal Plane Strategy of a Basic Maneuver Procedure."""

    _num_methods = 15
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_active_mode_method_offset = 1
    _set_active_mode_method_offset = 2
    _get_active_heading_course_value_method_offset = 3
    _set_active_heading_course_value_method_offset = 4
    _get_damping_ratio_method_offset = 5
    _set_damping_ratio_method_offset = 6
    _get_control_limit_mode_method_offset = 7
    _get_control_limit_turn_radius_method_offset = 8
    _get_control_limit_turn_rate_method_offset = 9
    _get_control_limit_horizontal_acceleration_method_offset = 10
    _set_control_limit_method_offset = 11
    _get_compensate_for_coriolis_acceleration_method_offset = 12
    _set_compensate_for_coriolis_acceleration_method_offset = 13
    _get_stop_when_conditions_met_method_offset = 14
    _set_stop_when_conditions_met_method_offset = 15
    _metadata = {
        "iid_data" : (5500937120651946827, 13117878096294151558),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyAutopilotNavigation)

    _get_active_mode_metadata = { "offset" : _get_active_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AutopilotHorizontalPlaneMode),) }
    @property
    def active_mode(self) -> "AutopilotHorizontalPlaneMode":
        """Get or set the autopilot - horizontal plane mode."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotNavigation._metadata, BasicManeuverStrategyAutopilotNavigation._get_active_mode_metadata)

    _set_active_mode_metadata = { "offset" : _set_active_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AutopilotHorizontalPlaneMode),) }
    @active_mode.setter
    def active_mode(self, value:"AutopilotHorizontalPlaneMode") -> None:
        """Get or set the autopilot - horizontal plane mode."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotNavigation._metadata, BasicManeuverStrategyAutopilotNavigation._set_active_mode_metadata, value)

    _get_active_heading_course_value_metadata = { "offset" : _get_active_heading_course_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def active_heading_course_value(self) -> typing.Any:
        """Get or set the heading/course angle or rate for the active mode."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotNavigation._metadata, BasicManeuverStrategyAutopilotNavigation._get_active_heading_course_value_metadata)

    _set_active_heading_course_value_metadata = { "offset" : _set_active_heading_course_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @active_heading_course_value.setter
    def active_heading_course_value(self, value:typing.Any) -> None:
        """Get or set the heading/course angle or rate for the active mode."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotNavigation._metadata, BasicManeuverStrategyAutopilotNavigation._set_active_heading_course_value_metadata, value)

    _get_damping_ratio_metadata = { "offset" : _get_damping_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def damping_ratio(self) -> float:
        """Get or set the damping ratio of the control law."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotNavigation._metadata, BasicManeuverStrategyAutopilotNavigation._get_damping_ratio_metadata)

    _set_damping_ratio_metadata = { "offset" : _set_damping_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @damping_ratio.setter
    def damping_ratio(self, value:float) -> None:
        """Get or set the damping ratio of the control law."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotNavigation._metadata, BasicManeuverStrategyAutopilotNavigation._set_damping_ratio_metadata, value)

    _get_control_limit_mode_metadata = { "offset" : _get_control_limit_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyNavigationControlLimit),) }
    @property
    def control_limit_mode(self) -> "BasicManeuverStrategyNavigationControlLimit":
        """Get the method to define the control limits of the aircraft during the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotNavigation._metadata, BasicManeuverStrategyAutopilotNavigation._get_control_limit_mode_metadata)

    _get_control_limit_turn_radius_metadata = { "offset" : _get_control_limit_turn_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def control_limit_turn_radius(self) -> float:
        """Get the specified turn radius for a control limit mode of specify min turn radius."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotNavigation._metadata, BasicManeuverStrategyAutopilotNavigation._get_control_limit_turn_radius_metadata)

    _get_control_limit_turn_rate_metadata = { "offset" : _get_control_limit_turn_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def control_limit_turn_rate(self) -> typing.Any:
        """Get the specified turn rate for a control limit mode of specify max turn rate."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotNavigation._metadata, BasicManeuverStrategyAutopilotNavigation._get_control_limit_turn_rate_metadata)

    _get_control_limit_horizontal_acceleration_metadata = { "offset" : _get_control_limit_horizontal_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def control_limit_horizontal_acceleration(self) -> float:
        """Get the specified horizontal acceleration for a control limit mode of specify max horiz accel."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotNavigation._metadata, BasicManeuverStrategyAutopilotNavigation._get_control_limit_horizontal_acceleration_metadata)

    _set_control_limit_metadata = { "offset" : _set_control_limit_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyNavigationControlLimit), agmarshall.DoubleArg,) }
    def set_control_limit(self, control_limit_mode:"BasicManeuverStrategyNavigationControlLimit", control_limit_value:float) -> None:
        """Set the method and corresponding value to define the control limits of the aircraft during the maneuver."""
        return self._intf.invoke(BasicManeuverStrategyAutopilotNavigation._metadata, BasicManeuverStrategyAutopilotNavigation._set_control_limit_metadata, control_limit_mode, control_limit_value)

    _get_compensate_for_coriolis_acceleration_metadata = { "offset" : _get_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def compensate_for_coriolis_acceleration(self) -> bool:
        """Get or set the option to compensate for the acceleration due to the Coriolis effect."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotNavigation._metadata, BasicManeuverStrategyAutopilotNavigation._get_compensate_for_coriolis_acceleration_metadata)

    _set_compensate_for_coriolis_acceleration_metadata = { "offset" : _set_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @compensate_for_coriolis_acceleration.setter
    def compensate_for_coriolis_acceleration(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyAutopilotNavigation._metadata, BasicManeuverStrategyAutopilotNavigation._set_compensate_for_coriolis_acceleration_metadata, value)

    _get_stop_when_conditions_met_metadata = { "offset" : _get_stop_when_conditions_met_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def stop_when_conditions_met(self) -> bool:
        """Stop when conditions are met."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotNavigation._metadata, BasicManeuverStrategyAutopilotNavigation._get_stop_when_conditions_met_metadata)

    _set_stop_when_conditions_met_metadata = { "offset" : _set_stop_when_conditions_met_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @stop_when_conditions_met.setter
    def stop_when_conditions_met(self, value:bool) -> None:
        """Stop when conditions are met."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotNavigation._metadata, BasicManeuverStrategyAutopilotNavigation._set_stop_when_conditions_met_metadata, value)

    _property_names[active_mode] = "active_mode"
    _property_names[active_heading_course_value] = "active_heading_course_value"
    _property_names[damping_ratio] = "damping_ratio"
    _property_names[control_limit_mode] = "control_limit_mode"
    _property_names[control_limit_turn_radius] = "control_limit_turn_radius"
    _property_names[control_limit_turn_rate] = "control_limit_turn_rate"
    _property_names[control_limit_horizontal_acceleration] = "control_limit_horizontal_acceleration"
    _property_names[compensate_for_coriolis_acceleration] = "compensate_for_coriolis_acceleration"
    _property_names[stop_when_conditions_met] = "stop_when_conditions_met"

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

agcls.AgClassCatalog.add_catalog_entry((4732726606686848626, 4213261683524251822), BasicManeuverStrategyAutopilotNavigation)
agcls.AgTypeNameMap["BasicManeuverStrategyAutopilotNavigation"] = BasicManeuverStrategyAutopilotNavigation

class BasicManeuverStrategyAutopilotProf(IBasicManeuverStrategy, SupportsDeleteCallback):
    """
    Interface used to access options for the Autopilot - Vertical Plane Strategy of a Basic Maneuver Procedure.

    Examples
    --------
    Add and configure a basic maneuver procedure:
    >>> # IProcedureCollection procedures: Procedure Collection object
    >>> # Add a basic maneuver procedure
    >>> basicManeuver = procedures.add(SiteType.SITE_END_OF_PREV_PROCEDURE, ProcedureType.PROCEDURE_BASIC_MANEUVER)
    >>>
    >>> # Set the navigation to use a Straight Ahead strategy
    >>> basicManeuver.navigation_strategy_type = "Straight Ahead"
    >>> # Get the options for the straight ahead strategy
    >>> straightAhead = basicManeuver.navigation
    >>> # Opt to maintain course (as opposed to maintain heading)
    >>> straightAhead.reference_frame = StraightAheadReferenceFrame.MAINTAIN_COURSE
    >>>
    >>> # Set the profile to use a Autopilot - Vertical Plane strategy
    >>> basicManeuver.profile_strategy_type = "Autopilot - Vertical Plane"
    >>> # Get the options for the profile strategy
    >>> autopilot = basicManeuver.profile
    >>> # Opt to maintain the initial altitude
    >>> autopilot.altitude_mode = AutopilotAltitudeMode.AUTOPILOT_HOLD_INIT_ALTITUDE
    >>> airspeedOptions = autopilot.airspeed_options
    >>> # Opt to maintain a specified airspeed
    >>> airspeedOptions.airspeed_mode = BasicManeuverAirspeedMode.MAINTAIN_SPECIFIED_AIRSPEED
    >>> # Specify the airspeed
    >>> airspeedOptions.specified_airspeed = 250
    >>>
    >>> # Configure the options on the Attitude / Performance / Fuel page
    >>> basicManeuver.flight_mode = PhaseOfFlight.FLIGHT_PHASE_CRUISE
    >>> # Override the fuel flow
    >>> basicManeuver.fuel_flow_type = BasicManeuverFuelFlowType.BASIC_MANEUVER_FUEL_FLOW_OVERRIDE
    >>> basicManeuver.override_fuel_flow_value = 1000
    >>>
    >>> # Set the basic stopping conditions
    >>> basicManeuver.use_max_downrange = True
    >>> basicManeuver.max_downrange = 10
    >>> basicManeuver.use_stop_fuel_state = False
    >>> basicManeuver.use_max_time_of_flight = False
    """

    _num_methods = 29
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_mode_method_offset = 1
    _set_altitude_mode_method_offset = 2
    _get_absolute_altitude_method_offset = 3
    _set_absolute_altitude_method_offset = 4
    _get_relative_altitude_change_method_offset = 5
    _set_relative_altitude_change_method_offset = 6
    _get_altitude_rate_method_offset = 7
    _set_altitude_rate_method_offset = 8
    _get_flight_path_angle_method_offset = 9
    _set_flight_path_angle_method_offset = 10
    _get_altitude_control_mode_method_offset = 11
    _set_altitude_control_mode_method_offset = 12
    _get_control_altitude_rate_value_method_offset = 13
    _set_control_altitude_rate_value_method_offset = 14
    _get_control_flight_path_angle_value_method_offset = 15
    _set_control_flight_path_angle_value_method_offset = 16
    _get_control_limit_mode_method_offset = 17
    _set_control_limit_mode_method_offset = 18
    _get_max_pitch_rate_method_offset = 19
    _set_max_pitch_rate_method_offset = 20
    _get_fly_ballistic_method_offset = 21
    _set_fly_ballistic_method_offset = 22
    _get_damping_ratio_method_offset = 23
    _set_damping_ratio_method_offset = 24
    _get_airspeed_options_method_offset = 25
    _get_compensate_for_coriolis_acceleration_method_offset = 26
    _set_compensate_for_coriolis_acceleration_method_offset = 27
    _get_stop_when_conditions_met_method_offset = 28
    _set_stop_when_conditions_met_method_offset = 29
    _metadata = {
        "iid_data" : (4666067371598022379, 6220797713878132123),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyAutopilotProf)

    _get_altitude_mode_metadata = { "offset" : _get_altitude_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AutopilotAltitudeMode),) }
    @property
    def altitude_mode(self) -> "AutopilotAltitudeMode":
        """Get or set the altitude mode of the autopilot - vertical plane strategy."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._get_altitude_mode_metadata)

    _set_altitude_mode_metadata = { "offset" : _set_altitude_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AutopilotAltitudeMode),) }
    @altitude_mode.setter
    def altitude_mode(self, value:"AutopilotAltitudeMode") -> None:
        """Get or set the altitude mode of the autopilot - vertical plane strategy."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._set_altitude_mode_metadata, value)

    _get_absolute_altitude_metadata = { "offset" : _get_absolute_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def absolute_altitude(self) -> float:
        """Get or set the absolute altitude for the specify altitude mode."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._get_absolute_altitude_metadata)

    _set_absolute_altitude_metadata = { "offset" : _set_absolute_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @absolute_altitude.setter
    def absolute_altitude(self, value:float) -> None:
        """Get or set the absolute altitude for the specify altitude mode."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._set_absolute_altitude_metadata, value)

    _get_relative_altitude_change_metadata = { "offset" : _get_relative_altitude_change_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def relative_altitude_change(self) -> float:
        """Get or set the relative altitude change for the specify altitude change mode."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._get_relative_altitude_change_metadata)

    _set_relative_altitude_change_metadata = { "offset" : _set_relative_altitude_change_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @relative_altitude_change.setter
    def relative_altitude_change(self, value:float) -> None:
        """Get or set the relative altitude change for the specify altitude change mode."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._set_relative_altitude_change_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 altitude rate for the specify altitude rate mode."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._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:
        """Get or set the altitude rate for the specify altitude rate mode."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._set_altitude_rate_metadata, value)

    _get_flight_path_angle_metadata = { "offset" : _get_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def flight_path_angle(self) -> typing.Any:
        """Get or set the flight path angle for the specify wind frame flight path angle mode."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._get_flight_path_angle_metadata)

    _set_flight_path_angle_metadata = { "offset" : _set_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @flight_path_angle.setter
    def flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the flight path angle for the specify wind frame flight path angle mode."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._set_flight_path_angle_metadata, value)

    _get_altitude_control_mode_metadata = { "offset" : _get_altitude_control_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AutopilotAltitudeControlMode),) }
    @property
    def altitude_control_mode(self) -> "AutopilotAltitudeControlMode":
        """Get or set the altitude control mode for the hold initial altitude, specify altitude, and specify altitude change modes."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._get_altitude_control_mode_metadata)

    _set_altitude_control_mode_metadata = { "offset" : _set_altitude_control_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AutopilotAltitudeControlMode),) }
    @altitude_control_mode.setter
    def altitude_control_mode(self, value:"AutopilotAltitudeControlMode") -> None:
        """Get or set the altitude control mode for the hold initial altitude, specify altitude, and specify altitude change modes."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._set_altitude_control_mode_metadata, value)

    _get_control_altitude_rate_value_metadata = { "offset" : _get_control_altitude_rate_value_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def control_altitude_rate_value(self) -> float:
        """Get or set the altitude rate control value for the hold initial altitude, specify altitude, and specify altitude change modes."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._get_control_altitude_rate_value_metadata)

    _set_control_altitude_rate_value_metadata = { "offset" : _set_control_altitude_rate_value_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @control_altitude_rate_value.setter
    def control_altitude_rate_value(self, value:float) -> None:
        """Get or set the altitude rate control value for the hold initial altitude, specify altitude, and specify altitude change modes."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._set_control_altitude_rate_value_metadata, value)

    _get_control_flight_path_angle_value_metadata = { "offset" : _get_control_flight_path_angle_value_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def control_flight_path_angle_value(self) -> typing.Any:
        """Get or set the control flight path angle value for the hold initial altitude, specify altitude, and specify altitude change modes."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._get_control_flight_path_angle_value_metadata)

    _set_control_flight_path_angle_value_metadata = { "offset" : _set_control_flight_path_angle_value_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @control_flight_path_angle_value.setter
    def control_flight_path_angle_value(self, value:typing.Any) -> None:
        """Get or set the control flight path angle value for the hold initial altitude, specify altitude, and specify altitude change modes."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._set_control_flight_path_angle_value_metadata, value)

    _get_control_limit_mode_metadata = { "offset" : _get_control_limit_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @property
    def control_limit_mode(self) -> "PerformanceModelOverride":
        """Get or set the control limits mode."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._get_control_limit_mode_metadata)

    _set_control_limit_mode_metadata = { "offset" : _set_control_limit_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PerformanceModelOverride),) }
    @control_limit_mode.setter
    def control_limit_mode(self, value:"PerformanceModelOverride") -> None:
        """Get or set the control limits mode."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._set_control_limit_mode_metadata, value)

    _get_max_pitch_rate_metadata = { "offset" : _get_max_pitch_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_pitch_rate(self) -> typing.Any:
        """Get or set the max pitch rate for the control limits."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._get_max_pitch_rate_metadata)

    _set_max_pitch_rate_metadata = { "offset" : _set_max_pitch_rate_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_pitch_rate.setter
    def max_pitch_rate(self, value:typing.Any) -> None:
        """Get or set the max pitch rate for the control limits."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._set_max_pitch_rate_metadata, value)

    _get_fly_ballistic_metadata = { "offset" : _get_fly_ballistic_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def fly_ballistic(self) -> bool:
        """Get or set the option to fly a ballistic trajectory when the performance is insufficient."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._get_fly_ballistic_metadata)

    _set_fly_ballistic_metadata = { "offset" : _set_fly_ballistic_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @fly_ballistic.setter
    def fly_ballistic(self, value:bool) -> None:
        """Get or set the option to fly a ballistic trajectory when the performance is insufficient."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._set_fly_ballistic_metadata, value)

    _get_damping_ratio_metadata = { "offset" : _get_damping_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def damping_ratio(self) -> float:
        """Get or set the damping ratio of the control law."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._get_damping_ratio_metadata)

    _set_damping_ratio_metadata = { "offset" : _set_damping_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @damping_ratio.setter
    def damping_ratio(self, value:float) -> None:
        """Get or set the damping ratio of the control law."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._set_damping_ratio_metadata, value)

    _get_airspeed_options_metadata = { "offset" : _get_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def airspeed_options(self) -> "BasicManeuverAirspeedOptions":
        """Get the airspeed options."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._get_airspeed_options_metadata)

    _get_compensate_for_coriolis_acceleration_metadata = { "offset" : _get_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def compensate_for_coriolis_acceleration(self) -> bool:
        """Get or set the option to compensate for the acceleration due to the Coriolis effect."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._get_compensate_for_coriolis_acceleration_metadata)

    _set_compensate_for_coriolis_acceleration_metadata = { "offset" : _set_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @compensate_for_coriolis_acceleration.setter
    def compensate_for_coriolis_acceleration(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._set_compensate_for_coriolis_acceleration_metadata, value)

    _get_stop_when_conditions_met_metadata = { "offset" : _get_stop_when_conditions_met_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def stop_when_conditions_met(self) -> bool:
        """Stop when conditions are met."""
        return self._intf.get_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._get_stop_when_conditions_met_metadata)

    _set_stop_when_conditions_met_metadata = { "offset" : _set_stop_when_conditions_met_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @stop_when_conditions_met.setter
    def stop_when_conditions_met(self, value:bool) -> None:
        """Stop when conditions are met."""
        return self._intf.set_property(BasicManeuverStrategyAutopilotProf._metadata, BasicManeuverStrategyAutopilotProf._set_stop_when_conditions_met_metadata, value)

    _property_names[altitude_mode] = "altitude_mode"
    _property_names[absolute_altitude] = "absolute_altitude"
    _property_names[relative_altitude_change] = "relative_altitude_change"
    _property_names[altitude_rate] = "altitude_rate"
    _property_names[flight_path_angle] = "flight_path_angle"
    _property_names[altitude_control_mode] = "altitude_control_mode"
    _property_names[control_altitude_rate_value] = "control_altitude_rate_value"
    _property_names[control_flight_path_angle_value] = "control_flight_path_angle_value"
    _property_names[control_limit_mode] = "control_limit_mode"
    _property_names[max_pitch_rate] = "max_pitch_rate"
    _property_names[fly_ballistic] = "fly_ballistic"
    _property_names[damping_ratio] = "damping_ratio"
    _property_names[airspeed_options] = "airspeed_options"
    _property_names[compensate_for_coriolis_acceleration] = "compensate_for_coriolis_acceleration"
    _property_names[stop_when_conditions_met] = "stop_when_conditions_met"

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

agcls.AgClassCatalog.add_catalog_entry((5709838463678627713, 16791243628197529479), BasicManeuverStrategyAutopilotProf)
agcls.AgTypeNameMap["BasicManeuverStrategyAutopilotProf"] = BasicManeuverStrategyAutopilotProf

class BasicManeuverStrategyBarrelRoll(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Barrel Roll Strategy of a Basic Maneuver Procedure."""

    _num_methods = 16
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_helix_angle_method_offset = 1
    _set_helix_angle_method_offset = 2
    _get_helix_angle_mode_method_offset = 3
    _set_helix_angle_mode_method_offset = 4
    _get_top_load_factor_method_offset = 5
    _set_top_load_factor_method_offset = 6
    _get_bottom_load_factor_method_offset = 7
    _set_bottom_load_factor_method_offset = 8
    _get_torsion_angle_method_offset = 9
    _set_torsion_angle_method_offset = 10
    _get_hold_init_tas_method_offset = 11
    _set_hold_init_tas_method_offset = 12
    _get_airspeed_type_method_offset = 13
    _get_top_airspeed_method_offset = 14
    _get_bottom_airspeed_method_offset = 15
    _set_airspeeds_method_offset = 16
    _metadata = {
        "iid_data" : (4690648775118107246, 6407640789399177151),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyBarrelRoll)

    _get_helix_angle_metadata = { "offset" : _get_helix_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def helix_angle(self) -> typing.Any:
        """Get or set the helix angle for the barrel roll. The angle that the aircraft travels around the velocity vector."""
        return self._intf.get_property(BasicManeuverStrategyBarrelRoll._metadata, BasicManeuverStrategyBarrelRoll._get_helix_angle_metadata)

    _set_helix_angle_metadata = { "offset" : _set_helix_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @helix_angle.setter
    def helix_angle(self, value:typing.Any) -> None:
        """Get or set the helix angle for the barrel roll. The angle that the aircraft travels around the velocity vector."""
        return self._intf.set_property(BasicManeuverStrategyBarrelRoll._metadata, BasicManeuverStrategyBarrelRoll._set_helix_angle_metadata, value)

    _get_helix_angle_mode_metadata = { "offset" : _get_helix_angle_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AngleMode),) }
    @property
    def helix_angle_mode(self) -> "AngleMode":
        """Get or set the helix angle mode for the barrel roll."""
        return self._intf.get_property(BasicManeuverStrategyBarrelRoll._metadata, BasicManeuverStrategyBarrelRoll._get_helix_angle_mode_metadata)

    _set_helix_angle_mode_metadata = { "offset" : _set_helix_angle_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AngleMode),) }
    @helix_angle_mode.setter
    def helix_angle_mode(self, value:"AngleMode") -> None:
        """Get or set the helix angle mode for the barrel roll."""
        return self._intf.set_property(BasicManeuverStrategyBarrelRoll._metadata, BasicManeuverStrategyBarrelRoll._set_helix_angle_mode_metadata, value)

    _get_top_load_factor_metadata = { "offset" : _get_top_load_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def top_load_factor(self) -> float:
        """Get or set the load factor at the top of the loop."""
        return self._intf.get_property(BasicManeuverStrategyBarrelRoll._metadata, BasicManeuverStrategyBarrelRoll._get_top_load_factor_metadata)

    _set_top_load_factor_metadata = { "offset" : _set_top_load_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @top_load_factor.setter
    def top_load_factor(self, value:float) -> None:
        """Get or set the load factor at the top of the loop."""
        return self._intf.set_property(BasicManeuverStrategyBarrelRoll._metadata, BasicManeuverStrategyBarrelRoll._set_top_load_factor_metadata, value)

    _get_bottom_load_factor_metadata = { "offset" : _get_bottom_load_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def bottom_load_factor(self) -> float:
        """Get or set the load factor at the bottom of the loop."""
        return self._intf.get_property(BasicManeuverStrategyBarrelRoll._metadata, BasicManeuverStrategyBarrelRoll._get_bottom_load_factor_metadata)

    _set_bottom_load_factor_metadata = { "offset" : _set_bottom_load_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @bottom_load_factor.setter
    def bottom_load_factor(self, value:float) -> None:
        """Get or set the load factor at the bottom of the loop."""
        return self._intf.set_property(BasicManeuverStrategyBarrelRoll._metadata, BasicManeuverStrategyBarrelRoll._set_bottom_load_factor_metadata, value)

    _get_torsion_angle_metadata = { "offset" : _get_torsion_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def torsion_angle(self) -> typing.Any:
        """Get or set the torsion angle for the barrel roll. The angle of the turn from the aircraft's velocity vector."""
        return self._intf.get_property(BasicManeuverStrategyBarrelRoll._metadata, BasicManeuverStrategyBarrelRoll._get_torsion_angle_metadata)

    _set_torsion_angle_metadata = { "offset" : _set_torsion_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @torsion_angle.setter
    def torsion_angle(self, value:typing.Any) -> None:
        """Get or set the torsion angle for the barrel roll. The angle of the turn from the aircraft's velocity vector."""
        return self._intf.set_property(BasicManeuverStrategyBarrelRoll._metadata, BasicManeuverStrategyBarrelRoll._set_torsion_angle_metadata, value)

    _get_hold_init_tas_metadata = { "offset" : _get_hold_init_tas_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def hold_init_tas(self) -> bool:
        """Get or set the option to hold the initial true airspeed."""
        return self._intf.get_property(BasicManeuverStrategyBarrelRoll._metadata, BasicManeuverStrategyBarrelRoll._get_hold_init_tas_metadata)

    _set_hold_init_tas_metadata = { "offset" : _set_hold_init_tas_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @hold_init_tas.setter
    def hold_init_tas(self, value:bool) -> None:
        """Get or set the option to hold the initial true airspeed."""
        return self._intf.set_property(BasicManeuverStrategyBarrelRoll._metadata, BasicManeuverStrategyBarrelRoll._set_hold_init_tas_metadata, value)

    _get_airspeed_type_metadata = { "offset" : _get_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type."""
        return self._intf.get_property(BasicManeuverStrategyBarrelRoll._metadata, BasicManeuverStrategyBarrelRoll._get_airspeed_type_metadata)

    _get_top_airspeed_metadata = { "offset" : _get_top_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def top_airspeed(self) -> float:
        """Get the speed at the top of the loop."""
        return self._intf.get_property(BasicManeuverStrategyBarrelRoll._metadata, BasicManeuverStrategyBarrelRoll._get_top_airspeed_metadata)

    _get_bottom_airspeed_metadata = { "offset" : _get_bottom_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def bottom_airspeed(self) -> float:
        """Get the speed at the bottom of the loop."""
        return self._intf.get_property(BasicManeuverStrategyBarrelRoll._metadata, BasicManeuverStrategyBarrelRoll._get_bottom_airspeed_metadata)

    _set_airspeeds_metadata = { "offset" : _set_airspeeds_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg, agmarshall.DoubleArg,) }
    def set_airspeeds(self, airspeed_type:"AirspeedType", top_airspeed:float, bottom_airspeed:float) -> None:
        """Set the speeds at the top and bottom of the loop."""
        return self._intf.invoke(BasicManeuverStrategyBarrelRoll._metadata, BasicManeuverStrategyBarrelRoll._set_airspeeds_metadata, airspeed_type, top_airspeed, bottom_airspeed)

    _property_names[helix_angle] = "helix_angle"
    _property_names[helix_angle_mode] = "helix_angle_mode"
    _property_names[top_load_factor] = "top_load_factor"
    _property_names[bottom_load_factor] = "bottom_load_factor"
    _property_names[torsion_angle] = "torsion_angle"
    _property_names[hold_init_tas] = "hold_init_tas"
    _property_names[airspeed_type] = "airspeed_type"
    _property_names[top_airspeed] = "top_airspeed"
    _property_names[bottom_airspeed] = "bottom_airspeed"

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

agcls.AgClassCatalog.add_catalog_entry((5355659262358528065, 9078756396061716909), BasicManeuverStrategyBarrelRoll)
agcls.AgTypeNameMap["BasicManeuverStrategyBarrelRoll"] = BasicManeuverStrategyBarrelRoll

class BasicManeuverStrategyLoop(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Loop Strategy of a Basic Maneuver Procedure."""

    _num_methods = 14
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_loop_angle_method_offset = 1
    _set_loop_angle_method_offset = 2
    _get_loop_angle_mode_method_offset = 3
    _set_loop_angle_mode_method_offset = 4
    _get_top_load_factor_method_offset = 5
    _set_top_load_factor_method_offset = 6
    _get_bottom_load_factor_method_offset = 7
    _set_bottom_load_factor_method_offset = 8
    _get_hold_init_tas_method_offset = 9
    _set_hold_init_tas_method_offset = 10
    _get_airspeed_type_method_offset = 11
    _get_top_airspeed_method_offset = 12
    _get_bottom_airspeed_method_offset = 13
    _set_airspeeds_method_offset = 14
    _metadata = {
        "iid_data" : (4966194871769355176, 4776523075554737546),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyLoop)

    _get_loop_angle_metadata = { "offset" : _get_loop_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def loop_angle(self) -> typing.Any:
        """Get or set the loop angle for maneuver. The total change in pitch angle the aircraft flies."""
        return self._intf.get_property(BasicManeuverStrategyLoop._metadata, BasicManeuverStrategyLoop._get_loop_angle_metadata)

    _set_loop_angle_metadata = { "offset" : _set_loop_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @loop_angle.setter
    def loop_angle(self, value:typing.Any) -> None:
        """Get or set the loop angle for maneuver. The total change in pitch angle the aircraft flies."""
        return self._intf.set_property(BasicManeuverStrategyLoop._metadata, BasicManeuverStrategyLoop._set_loop_angle_metadata, value)

    _get_loop_angle_mode_metadata = { "offset" : _get_loop_angle_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AngleMode),) }
    @property
    def loop_angle_mode(self) -> "AngleMode":
        """Get or set the loop angle mode for the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyLoop._metadata, BasicManeuverStrategyLoop._get_loop_angle_mode_metadata)

    _set_loop_angle_mode_metadata = { "offset" : _set_loop_angle_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AngleMode),) }
    @loop_angle_mode.setter
    def loop_angle_mode(self, value:"AngleMode") -> None:
        """Get or set the loop angle mode for the maneuver."""
        return self._intf.set_property(BasicManeuverStrategyLoop._metadata, BasicManeuverStrategyLoop._set_loop_angle_mode_metadata, value)

    _get_top_load_factor_metadata = { "offset" : _get_top_load_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def top_load_factor(self) -> float:
        """Get or set the load factor at the top of the loop."""
        return self._intf.get_property(BasicManeuverStrategyLoop._metadata, BasicManeuverStrategyLoop._get_top_load_factor_metadata)

    _set_top_load_factor_metadata = { "offset" : _set_top_load_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @top_load_factor.setter
    def top_load_factor(self, value:float) -> None:
        """Get or set the load factor at the top of the loop."""
        return self._intf.set_property(BasicManeuverStrategyLoop._metadata, BasicManeuverStrategyLoop._set_top_load_factor_metadata, value)

    _get_bottom_load_factor_metadata = { "offset" : _get_bottom_load_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def bottom_load_factor(self) -> float:
        """Get or set the load factor at the bottom of the loop."""
        return self._intf.get_property(BasicManeuverStrategyLoop._metadata, BasicManeuverStrategyLoop._get_bottom_load_factor_metadata)

    _set_bottom_load_factor_metadata = { "offset" : _set_bottom_load_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @bottom_load_factor.setter
    def bottom_load_factor(self, value:float) -> None:
        """Get or set the load factor at the bottom of the loop."""
        return self._intf.set_property(BasicManeuverStrategyLoop._metadata, BasicManeuverStrategyLoop._set_bottom_load_factor_metadata, value)

    _get_hold_init_tas_metadata = { "offset" : _get_hold_init_tas_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def hold_init_tas(self) -> bool:
        """Get or set the option to hold the initial true airspeed."""
        return self._intf.get_property(BasicManeuverStrategyLoop._metadata, BasicManeuverStrategyLoop._get_hold_init_tas_metadata)

    _set_hold_init_tas_metadata = { "offset" : _set_hold_init_tas_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @hold_init_tas.setter
    def hold_init_tas(self, value:bool) -> None:
        """Get or set the option to hold the initial true airspeed."""
        return self._intf.set_property(BasicManeuverStrategyLoop._metadata, BasicManeuverStrategyLoop._set_hold_init_tas_metadata, value)

    _get_airspeed_type_metadata = { "offset" : _get_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type."""
        return self._intf.get_property(BasicManeuverStrategyLoop._metadata, BasicManeuverStrategyLoop._get_airspeed_type_metadata)

    _get_top_airspeed_metadata = { "offset" : _get_top_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def top_airspeed(self) -> float:
        """Get the speed at the top of the loop."""
        return self._intf.get_property(BasicManeuverStrategyLoop._metadata, BasicManeuverStrategyLoop._get_top_airspeed_metadata)

    _get_bottom_airspeed_metadata = { "offset" : _get_bottom_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def bottom_airspeed(self) -> float:
        """Get the speed at the bottom of the loop."""
        return self._intf.get_property(BasicManeuverStrategyLoop._metadata, BasicManeuverStrategyLoop._get_bottom_airspeed_metadata)

    _set_airspeeds_metadata = { "offset" : _set_airspeeds_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg, agmarshall.DoubleArg,) }
    def set_airspeeds(self, airspeed_type:"AirspeedType", top_airspeed:float, bottom_airspeed:float) -> None:
        """Set the speeds at the top and bottom of the loop."""
        return self._intf.invoke(BasicManeuverStrategyLoop._metadata, BasicManeuverStrategyLoop._set_airspeeds_metadata, airspeed_type, top_airspeed, bottom_airspeed)

    _property_names[loop_angle] = "loop_angle"
    _property_names[loop_angle_mode] = "loop_angle_mode"
    _property_names[top_load_factor] = "top_load_factor"
    _property_names[bottom_load_factor] = "bottom_load_factor"
    _property_names[hold_init_tas] = "hold_init_tas"
    _property_names[airspeed_type] = "airspeed_type"
    _property_names[top_airspeed] = "top_airspeed"
    _property_names[bottom_airspeed] = "bottom_airspeed"

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

agcls.AgClassCatalog.add_catalog_entry((4691659063102541300, 9389394676268526500), BasicManeuverStrategyLoop)
agcls.AgTypeNameMap["BasicManeuverStrategyLoop"] = BasicManeuverStrategyLoop

class BasicManeuverStrategyLTAHover(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Lighter than Air Hover Strategy of a Basic Maneuver Procedure."""

    _num_methods = 24
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_heading_mode_method_offset = 1
    _set_heading_mode_method_offset = 2
    _get_relative_heading_method_offset = 3
    _set_relative_heading_method_offset = 4
    _get_absolute_heading_method_offset = 5
    _set_absolute_heading_method_offset = 6
    _get_use_magnetic_heading_method_offset = 7
    _set_use_magnetic_heading_method_offset = 8
    _get_heading_rate_method_offset = 9
    _set_heading_rate_method_offset = 10
    _get_altitude_mode_method_offset = 11
    _set_altitude_mode_method_offset = 12
    _get_absolute_altitude_method_offset = 13
    _set_absolute_altitude_method_offset = 14
    _get_relative_altitude_change_method_offset = 15
    _set_relative_altitude_change_method_offset = 16
    _get_control_altitude_rate_method_offset = 17
    _set_control_altitude_rate_method_offset = 18
    _get_altitude_rate_method_offset = 19
    _set_altitude_rate_method_offset = 20
    _get_parachute_area_method_offset = 21
    _set_parachute_area_method_offset = 22
    _get_parachute_cd_method_offset = 23
    _set_parachute_cd_method_offset = 24
    _metadata = {
        "iid_data" : (5443386974052830055, 10444063467016189095),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyLTAHover)

    _get_heading_mode_metadata = { "offset" : _get_heading_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(HoverHeadingMode),) }
    @property
    def heading_mode(self) -> "HoverHeadingMode":
        """Get or set the heading mode for the lighter than air hover."""
        return self._intf.get_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._get_heading_mode_metadata)

    _set_heading_mode_metadata = { "offset" : _set_heading_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(HoverHeadingMode),) }
    @heading_mode.setter
    def heading_mode(self, value:"HoverHeadingMode") -> None:
        """Get or set the heading mode for the lighter than air hover."""
        return self._intf.set_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._set_heading_mode_metadata, value)

    _get_relative_heading_metadata = { "offset" : _get_relative_heading_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def relative_heading(self) -> typing.Any:
        """Get or set the relative heading for the relative to start heading mode."""
        return self._intf.get_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._get_relative_heading_metadata)

    _set_relative_heading_metadata = { "offset" : _set_relative_heading_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @relative_heading.setter
    def relative_heading(self, value:typing.Any) -> None:
        """Get or set the relative heading for the relative to start heading mode."""
        return self._intf.set_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._set_relative_heading_metadata, value)

    _get_absolute_heading_metadata = { "offset" : _get_absolute_heading_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def absolute_heading(self) -> typing.Any:
        """Get or set the absolute heading for the absolute heading mode."""
        return self._intf.get_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._get_absolute_heading_metadata)

    _set_absolute_heading_metadata = { "offset" : _set_absolute_heading_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @absolute_heading.setter
    def absolute_heading(self, value:typing.Any) -> None:
        """Get or set the absolute heading for the absolute heading mode."""
        return self._intf.set_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._set_absolute_heading_metadata, value)

    _get_use_magnetic_heading_metadata = { "offset" : _get_use_magnetic_heading_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_magnetic_heading(self) -> bool:
        """Get or set the option to use a magentic heading for the absolute heading mode."""
        return self._intf.get_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._get_use_magnetic_heading_metadata)

    _set_use_magnetic_heading_metadata = { "offset" : _set_use_magnetic_heading_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_magnetic_heading.setter
    def use_magnetic_heading(self, value:bool) -> None:
        """Get or set the option to use a magentic heading for the absolute heading mode."""
        return self._intf.set_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._set_use_magnetic_heading_metadata, value)

    _get_heading_rate_metadata = { "offset" : _get_heading_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def heading_rate(self) -> typing.Any:
        """Get or set the maximum heading rate."""
        return self._intf.get_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._get_heading_rate_metadata)

    _set_heading_rate_metadata = { "offset" : _set_heading_rate_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @heading_rate.setter
    def heading_rate(self, value:typing.Any) -> None:
        """Get or set the maximum heading rate."""
        return self._intf.set_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._set_heading_rate_metadata, value)

    _get_altitude_mode_metadata = { "offset" : _get_altitude_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(HoverAltitudeMode),) }
    @property
    def altitude_mode(self) -> "HoverAltitudeMode":
        """Get or set the altitude mode for the lighter than air hover."""
        return self._intf.get_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._get_altitude_mode_metadata)

    _set_altitude_mode_metadata = { "offset" : _set_altitude_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(HoverAltitudeMode),) }
    @altitude_mode.setter
    def altitude_mode(self, value:"HoverAltitudeMode") -> None:
        """Get or set the altitude mode for the lighter than air hover."""
        return self._intf.set_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._set_altitude_mode_metadata, value)

    _get_absolute_altitude_metadata = { "offset" : _get_absolute_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def absolute_altitude(self) -> float:
        """Get or set the absolute altitude for the Specify Altitude mode."""
        return self._intf.get_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._get_absolute_altitude_metadata)

    _set_absolute_altitude_metadata = { "offset" : _set_absolute_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @absolute_altitude.setter
    def absolute_altitude(self, value:float) -> None:
        """Get or set the absolute altitude for the Specify Altitude mode."""
        return self._intf.set_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._set_absolute_altitude_metadata, value)

    _get_relative_altitude_change_metadata = { "offset" : _get_relative_altitude_change_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def relative_altitude_change(self) -> float:
        """Get or set the relative altitude change for the Specify Altitude Change mode."""
        return self._intf.get_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._get_relative_altitude_change_metadata)

    _set_relative_altitude_change_metadata = { "offset" : _set_relative_altitude_change_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @relative_altitude_change.setter
    def relative_altitude_change(self, value:float) -> None:
        """Get or set the relative altitude change for the Specify Altitude Change mode."""
        return self._intf.set_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._set_relative_altitude_change_metadata, value)

    _get_control_altitude_rate_metadata = { "offset" : _get_control_altitude_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def control_altitude_rate(self) -> float:
        """Get or set the controlled altitude rate for the Specify Altitude or Specify Altitude Change mode."""
        return self._intf.get_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._get_control_altitude_rate_metadata)

    _set_control_altitude_rate_metadata = { "offset" : _set_control_altitude_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @control_altitude_rate.setter
    def control_altitude_rate(self, value:float) -> None:
        """Get or set the controlled altitude rate for the Specify Altitude or Specify Altitude Change mode."""
        return self._intf.set_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._set_control_altitude_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 altitude rate for the Specify Altitude Rate mode."""
        return self._intf.get_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._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:
        """Get or set the altitude rate for the Specify Altitude Rate mode."""
        return self._intf.set_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._set_altitude_rate_metadata, value)

    _get_parachute_area_metadata = { "offset" : _get_parachute_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def parachute_area(self) -> float:
        """Get or set the parachute area for the Parachute mode."""
        return self._intf.get_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._get_parachute_area_metadata)

    _set_parachute_area_metadata = { "offset" : _set_parachute_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @parachute_area.setter
    def parachute_area(self, value:float) -> None:
        """Get or set the parachute area for the Parachute mode."""
        return self._intf.set_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._set_parachute_area_metadata, value)

    _get_parachute_cd_metadata = { "offset" : _get_parachute_cd_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def parachute_cd(self) -> float:
        """Get or set the parachute drag coefficient for the Parachute mode."""
        return self._intf.get_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._get_parachute_cd_metadata)

    _set_parachute_cd_metadata = { "offset" : _set_parachute_cd_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @parachute_cd.setter
    def parachute_cd(self, value:float) -> None:
        """Get or set the parachute drag coefficient for the Parachute mode."""
        return self._intf.set_property(BasicManeuverStrategyLTAHover._metadata, BasicManeuverStrategyLTAHover._set_parachute_cd_metadata, value)

    _property_names[heading_mode] = "heading_mode"
    _property_names[relative_heading] = "relative_heading"
    _property_names[absolute_heading] = "absolute_heading"
    _property_names[use_magnetic_heading] = "use_magnetic_heading"
    _property_names[heading_rate] = "heading_rate"
    _property_names[altitude_mode] = "altitude_mode"
    _property_names[absolute_altitude] = "absolute_altitude"
    _property_names[relative_altitude_change] = "relative_altitude_change"
    _property_names[control_altitude_rate] = "control_altitude_rate"
    _property_names[altitude_rate] = "altitude_rate"
    _property_names[parachute_area] = "parachute_area"
    _property_names[parachute_cd] = "parachute_cd"

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

agcls.AgClassCatalog.add_catalog_entry((5624469055344737798, 8341335282646269584), BasicManeuverStrategyLTAHover)
agcls.AgTypeNameMap["BasicManeuverStrategyLTAHover"] = BasicManeuverStrategyLTAHover

class BasicManeuverStrategyIntercept(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for an Intercept Strategy of a Basic Maneuver Procedure."""

    _num_methods = 34
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_target_name_method_offset = 1
    _set_target_name_method_offset = 2
    _get_valid_target_names_method_offset = 3
    _get_target_resolution_method_offset = 4
    _set_target_resolution_method_offset = 5
    _get_use_stop_time_to_go_method_offset = 6
    _get_stop_time_to_go_method_offset = 7
    _set_stop_time_to_go_method_offset = 8
    _get_use_stop_slant_range_method_offset = 9
    _get_stop_slant_range_method_offset = 10
    _set_stop_slant_range_method_offset = 11
    _get_intercept_mode_method_offset = 12
    _set_intercept_mode_method_offset = 13
    _get_target_aspect_method_offset = 14
    _set_target_aspect_method_offset = 15
    _get_lateral_separation_method_offset = 16
    _set_lateral_separation_method_offset = 17
    _get_maneuver_factor_method_offset = 18
    _set_maneuver_factor_method_offset = 19
    _get_control_limit_mode_method_offset = 20
    _get_control_limit_turn_radius_method_offset = 21
    _get_control_limit_turn_rate_method_offset = 22
    _get_control_limit_horizontal_acceleration_method_offset = 23
    _set_control_limit_method_offset = 24
    _get_closure_mode_method_offset = 25
    _set_closure_mode_method_offset = 26
    _get_hobs_max_angle_method_offset = 27
    _set_hobs_max_angle_method_offset = 28
    _get_hobs_angle_tol_method_offset = 29
    _set_hobs_angle_tol_method_offset = 30
    _get_compensate_for_coriolis_acceleration_method_offset = 31
    _set_compensate_for_coriolis_acceleration_method_offset = 32
    _get_position_velocity_strategies_method_offset = 33
    _cancel_target_position_velocity_method_offset = 34
    _metadata = {
        "iid_data" : (5313400505422947784, 17687416165806767533),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyIntercept)

    _get_target_name_metadata = { "offset" : _get_target_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def target_name(self) -> str:
        """Get or set the target name."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_target_name_metadata)

    _set_target_name_metadata = { "offset" : _set_target_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @target_name.setter
    def target_name(self, value:str) -> None:
        """Get or set the target name."""
        return self._intf.set_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._set_target_name_metadata, value)

    _get_valid_target_names_metadata = { "offset" : _get_valid_target_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def valid_target_names(self) -> list:
        """Return the valid target names."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_valid_target_names_metadata)

    _get_target_resolution_metadata = { "offset" : _get_target_resolution_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_resolution(self) -> float:
        """Get or set the target position/velocity sampling resolution."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_target_resolution_metadata)

    _set_target_resolution_metadata = { "offset" : _set_target_resolution_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_resolution.setter
    def target_resolution(self, value:float) -> None:
        """Get or set the target position/velocity sampling resolution."""
        return self._intf.set_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._set_target_resolution_metadata, value)

    _get_use_stop_time_to_go_metadata = { "offset" : _get_use_stop_time_to_go_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_stop_time_to_go(self) -> bool:
        """Get the option to specify a time to go stopping condition."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_use_stop_time_to_go_metadata)

    _get_stop_time_to_go_metadata = { "offset" : _get_stop_time_to_go_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stop_time_to_go(self) -> float:
        """Get the stop time from the target at which the maneuver will stop."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_stop_time_to_go_metadata)

    _set_stop_time_to_go_metadata = { "offset" : _set_stop_time_to_go_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.DoubleArg,) }
    def set_stop_time_to_go(self, enable:bool, time:float) -> None:
        """Set the option to use the stop time from target stopping condition and set the according value."""
        return self._intf.invoke(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._set_stop_time_to_go_metadata, enable, time)

    _get_use_stop_slant_range_metadata = { "offset" : _get_use_stop_slant_range_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_stop_slant_range(self) -> bool:
        """Get the option to specify a range from target stopping condition."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_use_stop_slant_range_metadata)

    _get_stop_slant_range_metadata = { "offset" : _get_stop_slant_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stop_slant_range(self) -> float:
        """Get the range from the target at which the maneuver will stop."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_stop_slant_range_metadata)

    _set_stop_slant_range_metadata = { "offset" : _set_stop_slant_range_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.DoubleArg,) }
    def set_stop_slant_range(self, enable:bool, range:float) -> None:
        """Set the option to use the stop slant range stopping condition and set the according value."""
        return self._intf.invoke(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._set_stop_slant_range_metadata, enable, range)

    _get_intercept_mode_metadata = { "offset" : _get_intercept_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(InterceptMode),) }
    @property
    def intercept_mode(self) -> "InterceptMode":
        """Get or set the intercept mode."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_intercept_mode_metadata)

    _set_intercept_mode_metadata = { "offset" : _set_intercept_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(InterceptMode),) }
    @intercept_mode.setter
    def intercept_mode(self, value:"InterceptMode") -> None:
        """Get or set the intercept mode."""
        return self._intf.set_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._set_intercept_mode_metadata, value)

    _get_target_aspect_metadata = { "offset" : _get_target_aspect_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def target_aspect(self) -> typing.Any:
        """Get or set the angle relative to the target that the aircraft should maintain until intercept."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_target_aspect_metadata)

    _set_target_aspect_metadata = { "offset" : _set_target_aspect_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @target_aspect.setter
    def target_aspect(self, value:typing.Any) -> None:
        """Get or set the angle relative to the target that the aircraft should maintain until intercept."""
        return self._intf.set_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._set_target_aspect_metadata, value)

    _get_lateral_separation_metadata = { "offset" : _get_lateral_separation_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def lateral_separation(self) -> float:
        """Get or set the distance from the target that the aircraft will guide to before intercepting."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_lateral_separation_metadata)

    _set_lateral_separation_metadata = { "offset" : _set_lateral_separation_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @lateral_separation.setter
    def lateral_separation(self, value:float) -> None:
        """Get or set the distance from the target that the aircraft will guide to before intercepting."""
        return self._intf.set_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._set_lateral_separation_metadata, value)

    _get_maneuver_factor_metadata = { "offset" : _get_maneuver_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def maneuver_factor(self) -> float:
        """Get or set the maneuver factor, a dimensionless factor that determines how tightly or gently the aircraft will maneuver."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_maneuver_factor_metadata)

    _set_maneuver_factor_metadata = { "offset" : _set_maneuver_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @maneuver_factor.setter
    def maneuver_factor(self, value:float) -> None:
        """Get or set the maneuver factor, a dimensionless factor that determines how tightly or gently the aircraft will maneuver."""
        return self._intf.set_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._set_maneuver_factor_metadata, value)

    _get_control_limit_mode_metadata = { "offset" : _get_control_limit_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyNavigationControlLimit),) }
    @property
    def control_limit_mode(self) -> "BasicManeuverStrategyNavigationControlLimit":
        """Get the method to define the control limits of the aircraft during the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_control_limit_mode_metadata)

    _get_control_limit_turn_radius_metadata = { "offset" : _get_control_limit_turn_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def control_limit_turn_radius(self) -> float:
        """Get the specified turn radius for a control limit mode of specify min turn radius."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_control_limit_turn_radius_metadata)

    _get_control_limit_turn_rate_metadata = { "offset" : _get_control_limit_turn_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def control_limit_turn_rate(self) -> typing.Any:
        """Get the specified turn rate for a control limit mode of specify max turn rate."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_control_limit_turn_rate_metadata)

    _get_control_limit_horizontal_acceleration_metadata = { "offset" : _get_control_limit_horizontal_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def control_limit_horizontal_acceleration(self) -> float:
        """Get the specified horizontal acceleration for a control limit mode of specify max horiz accel."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_control_limit_horizontal_acceleration_metadata)

    _set_control_limit_metadata = { "offset" : _set_control_limit_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyNavigationControlLimit), agmarshall.DoubleArg,) }
    def set_control_limit(self, control_limit_mode:"BasicManeuverStrategyNavigationControlLimit", control_limit_value:float) -> None:
        """Set the method and corresponding value to define the control limits of the aircraft during the maneuver."""
        return self._intf.invoke(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._set_control_limit_metadata, control_limit_mode, control_limit_value)

    _get_closure_mode_metadata = { "offset" : _get_closure_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ClosureMode),) }
    @property
    def closure_mode(self) -> "ClosureMode":
        """Get or set the closure mode for the guidance strategy."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_closure_mode_metadata)

    _set_closure_mode_metadata = { "offset" : _set_closure_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ClosureMode),) }
    @closure_mode.setter
    def closure_mode(self, value:"ClosureMode") -> None:
        """Get or set the closure mode for the guidance strategy."""
        return self._intf.set_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._set_closure_mode_metadata, value)

    _get_hobs_max_angle_metadata = { "offset" : _get_hobs_max_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def hobs_max_angle(self) -> typing.Any:
        """Get or set the closure high off boresight max angle."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_hobs_max_angle_metadata)

    _set_hobs_max_angle_metadata = { "offset" : _set_hobs_max_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @hobs_max_angle.setter
    def hobs_max_angle(self, value:typing.Any) -> None:
        """Get or set the closure high off boresight max angle."""
        return self._intf.set_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._set_hobs_max_angle_metadata, value)

    _get_hobs_angle_tol_metadata = { "offset" : _get_hobs_angle_tol_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def hobs_angle_tol(self) -> typing.Any:
        """Get or set the closure high off boresight angle tolerance."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_hobs_angle_tol_metadata)

    _set_hobs_angle_tol_metadata = { "offset" : _set_hobs_angle_tol_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @hobs_angle_tol.setter
    def hobs_angle_tol(self, value:typing.Any) -> None:
        """Get or set the closure high off boresight angle tolerance."""
        return self._intf.set_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._set_hobs_angle_tol_metadata, value)

    _get_compensate_for_coriolis_acceleration_metadata = { "offset" : _get_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def compensate_for_coriolis_acceleration(self) -> bool:
        """Get or set the option to compensate for the acceleration due to the Coriolis effect."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_compensate_for_coriolis_acceleration_metadata)

    _set_compensate_for_coriolis_acceleration_metadata = { "offset" : _set_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @compensate_for_coriolis_acceleration.setter
    def compensate_for_coriolis_acceleration(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._set_compensate_for_coriolis_acceleration_metadata, value)

    _get_position_velocity_strategies_metadata = { "offset" : _get_position_velocity_strategies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def position_velocity_strategies(self) -> "BasicManeuverTargetPositionVelocity":
        """Get the position velocity strategies for Intercept."""
        return self._intf.get_property(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._get_position_velocity_strategies_metadata)

    _cancel_target_position_velocity_metadata = { "offset" : _cancel_target_position_velocity_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def cancel_target_position_velocity(self) -> None:
        """Cancel the position velocity strategies for Intercept."""
        return self._intf.invoke(BasicManeuverStrategyIntercept._metadata, BasicManeuverStrategyIntercept._cancel_target_position_velocity_metadata, )

    _property_names[target_name] = "target_name"
    _property_names[valid_target_names] = "valid_target_names"
    _property_names[target_resolution] = "target_resolution"
    _property_names[use_stop_time_to_go] = "use_stop_time_to_go"
    _property_names[stop_time_to_go] = "stop_time_to_go"
    _property_names[use_stop_slant_range] = "use_stop_slant_range"
    _property_names[stop_slant_range] = "stop_slant_range"
    _property_names[intercept_mode] = "intercept_mode"
    _property_names[target_aspect] = "target_aspect"
    _property_names[lateral_separation] = "lateral_separation"
    _property_names[maneuver_factor] = "maneuver_factor"
    _property_names[control_limit_mode] = "control_limit_mode"
    _property_names[control_limit_turn_radius] = "control_limit_turn_radius"
    _property_names[control_limit_turn_rate] = "control_limit_turn_rate"
    _property_names[control_limit_horizontal_acceleration] = "control_limit_horizontal_acceleration"
    _property_names[closure_mode] = "closure_mode"
    _property_names[hobs_max_angle] = "hobs_max_angle"
    _property_names[hobs_angle_tol] = "hobs_angle_tol"
    _property_names[compensate_for_coriolis_acceleration] = "compensate_for_coriolis_acceleration"
    _property_names[position_velocity_strategies] = "position_velocity_strategies"

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

agcls.AgClassCatalog.add_catalog_entry((5159952174471101760, 4758727950404349881), BasicManeuverStrategyIntercept)
agcls.AgTypeNameMap["BasicManeuverStrategyIntercept"] = BasicManeuverStrategyIntercept

class BasicManeuverStrategyRelativeBearing(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Relative Bearing Strategy of a Basic Maneuver Procedure."""

    _num_methods = 18
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_target_name_method_offset = 1
    _set_target_name_method_offset = 2
    _get_valid_target_names_method_offset = 3
    _get_target_resolution_method_offset = 4
    _set_target_resolution_method_offset = 5
    _get_relative_bearing_method_offset = 6
    _set_relative_bearing_method_offset = 7
    _get_min_range_method_offset = 8
    _set_min_range_method_offset = 9
    _get_control_limit_mode_method_offset = 10
    _get_control_limit_turn_radius_method_offset = 11
    _get_control_limit_turn_rate_method_offset = 12
    _get_control_limit_horizontal_acceleration_method_offset = 13
    _set_control_limit_method_offset = 14
    _get_compensate_for_coriolis_acceleration_method_offset = 15
    _set_compensate_for_coriolis_acceleration_method_offset = 16
    _get_position_velocity_strategies_method_offset = 17
    _cancel_target_position_velocity_method_offset = 18
    _metadata = {
        "iid_data" : (4866238946930048015, 14417521249700002203),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyRelativeBearing)

    _get_target_name_metadata = { "offset" : _get_target_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def target_name(self) -> str:
        """Get or set the target name."""
        return self._intf.get_property(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._get_target_name_metadata)

    _set_target_name_metadata = { "offset" : _set_target_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @target_name.setter
    def target_name(self, value:str) -> None:
        """Get or set the target name."""
        return self._intf.set_property(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._set_target_name_metadata, value)

    _get_valid_target_names_metadata = { "offset" : _get_valid_target_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def valid_target_names(self) -> list:
        """Return the valid target names."""
        return self._intf.get_property(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._get_valid_target_names_metadata)

    _get_target_resolution_metadata = { "offset" : _get_target_resolution_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_resolution(self) -> float:
        """Get or set the target position/velocity sampling resolution."""
        return self._intf.get_property(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._get_target_resolution_metadata)

    _set_target_resolution_metadata = { "offset" : _set_target_resolution_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_resolution.setter
    def target_resolution(self, value:float) -> None:
        """Get or set the target position/velocity sampling resolution."""
        return self._intf.set_property(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._set_target_resolution_metadata, value)

    _get_relative_bearing_metadata = { "offset" : _get_relative_bearing_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def relative_bearing(self) -> typing.Any:
        """Get or set the relative bearing angle."""
        return self._intf.get_property(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._get_relative_bearing_metadata)

    _set_relative_bearing_metadata = { "offset" : _set_relative_bearing_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @relative_bearing.setter
    def relative_bearing(self, value:typing.Any) -> None:
        """Get or set the relative bearing angle."""
        return self._intf.set_property(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._set_relative_bearing_metadata, value)

    _get_min_range_metadata = { "offset" : _get_min_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_range(self) -> float:
        """Get or set the range from the target at which the aircraft will stop."""
        return self._intf.get_property(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._get_min_range_metadata)

    _set_min_range_metadata = { "offset" : _set_min_range_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_range.setter
    def min_range(self, value:float) -> None:
        """Get or set the range from the target at which the aircraft will stop."""
        return self._intf.set_property(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._set_min_range_metadata, value)

    _get_control_limit_mode_metadata = { "offset" : _get_control_limit_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyNavigationControlLimit),) }
    @property
    def control_limit_mode(self) -> "BasicManeuverStrategyNavigationControlLimit":
        """Get the method to define the control limits of the aircraft during the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._get_control_limit_mode_metadata)

    _get_control_limit_turn_radius_metadata = { "offset" : _get_control_limit_turn_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def control_limit_turn_radius(self) -> float:
        """Get the specified turn radius for a control limit mode of specify min turn radius."""
        return self._intf.get_property(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._get_control_limit_turn_radius_metadata)

    _get_control_limit_turn_rate_metadata = { "offset" : _get_control_limit_turn_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def control_limit_turn_rate(self) -> typing.Any:
        """Get the specified turn rate for a control limit mode of specify max turn rate."""
        return self._intf.get_property(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._get_control_limit_turn_rate_metadata)

    _get_control_limit_horizontal_acceleration_metadata = { "offset" : _get_control_limit_horizontal_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def control_limit_horizontal_acceleration(self) -> float:
        """Get the specified horizontal acceleration for a control limit mode of specify max horiz accel."""
        return self._intf.get_property(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._get_control_limit_horizontal_acceleration_metadata)

    _set_control_limit_metadata = { "offset" : _set_control_limit_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyNavigationControlLimit), agmarshall.DoubleArg,) }
    def set_control_limit(self, control_limit_mode:"BasicManeuverStrategyNavigationControlLimit", control_limit_value:float) -> None:
        """Set the method and corresponding value to define the control limits of the aircraft during the maneuver."""
        return self._intf.invoke(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._set_control_limit_metadata, control_limit_mode, control_limit_value)

    _get_compensate_for_coriolis_acceleration_metadata = { "offset" : _get_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def compensate_for_coriolis_acceleration(self) -> bool:
        """Get or set the option to compensate for the acceleration due to the Coriolis effect."""
        return self._intf.get_property(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._get_compensate_for_coriolis_acceleration_metadata)

    _set_compensate_for_coriolis_acceleration_metadata = { "offset" : _set_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @compensate_for_coriolis_acceleration.setter
    def compensate_for_coriolis_acceleration(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._set_compensate_for_coriolis_acceleration_metadata, value)

    _get_position_velocity_strategies_metadata = { "offset" : _get_position_velocity_strategies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def position_velocity_strategies(self) -> "BasicManeuverTargetPositionVelocity":
        """Get the position velocity strategies for Relative Bearing."""
        return self._intf.get_property(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._get_position_velocity_strategies_metadata)

    _cancel_target_position_velocity_metadata = { "offset" : _cancel_target_position_velocity_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def cancel_target_position_velocity(self) -> None:
        """Cancel the position velocity strategies for Relative Bearing."""
        return self._intf.invoke(BasicManeuverStrategyRelativeBearing._metadata, BasicManeuverStrategyRelativeBearing._cancel_target_position_velocity_metadata, )

    _property_names[target_name] = "target_name"
    _property_names[valid_target_names] = "valid_target_names"
    _property_names[target_resolution] = "target_resolution"
    _property_names[relative_bearing] = "relative_bearing"
    _property_names[min_range] = "min_range"
    _property_names[control_limit_mode] = "control_limit_mode"
    _property_names[control_limit_turn_radius] = "control_limit_turn_radius"
    _property_names[control_limit_turn_rate] = "control_limit_turn_rate"
    _property_names[control_limit_horizontal_acceleration] = "control_limit_horizontal_acceleration"
    _property_names[compensate_for_coriolis_acceleration] = "compensate_for_coriolis_acceleration"
    _property_names[position_velocity_strategies] = "position_velocity_strategies"

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

agcls.AgClassCatalog.add_catalog_entry((5655899589593519305, 304724110097198999), BasicManeuverStrategyRelativeBearing)
agcls.AgTypeNameMap["BasicManeuverStrategyRelativeBearing"] = BasicManeuverStrategyRelativeBearing

class BasicManeuverStrategyRelativeCourse(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Relative Course Strategy of a Basic Maneuver Procedure."""

    _num_methods = 34
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_target_name_method_offset = 1
    _set_target_name_method_offset = 2
    _get_valid_target_names_method_offset = 3
    _get_target_resolution_method_offset = 4
    _set_target_resolution_method_offset = 5
    _get_use_relative_course_method_offset = 6
    _set_use_relative_course_method_offset = 7
    _get_course_method_offset = 8
    _set_course_method_offset = 9
    _get_in_track_method_offset = 10
    _set_in_track_method_offset = 11
    _get_cross_track_method_offset = 12
    _set_cross_track_method_offset = 13
    _get_maneuver_factor_method_offset = 14
    _set_maneuver_factor_method_offset = 15
    _get_use_approach_turn_mode_method_offset = 16
    _set_use_approach_turn_mode_method_offset = 17
    _get_control_limit_mode_method_offset = 18
    _get_control_limit_turn_radius_method_offset = 19
    _get_control_limit_turn_rate_method_offset = 20
    _get_control_limit_horizontal_acceleration_method_offset = 21
    _set_control_limit_method_offset = 22
    _get_closure_mode_method_offset = 23
    _set_closure_mode_method_offset = 24
    _get_downrange_offset_method_offset = 25
    _set_downrange_offset_method_offset = 26
    _get_hobs_max_angle_method_offset = 27
    _set_hobs_max_angle_method_offset = 28
    _get_hobs_angle_tol_method_offset = 29
    _set_hobs_angle_tol_method_offset = 30
    _get_compensate_for_coriolis_acceleration_method_offset = 31
    _set_compensate_for_coriolis_acceleration_method_offset = 32
    _get_position_velocity_strategies_method_offset = 33
    _cancel_target_position_velocity_method_offset = 34
    _metadata = {
        "iid_data" : (5054084160759805633, 8063128821334535086),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyRelativeCourse)

    _get_target_name_metadata = { "offset" : _get_target_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def target_name(self) -> str:
        """Get or set the target name."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_target_name_metadata)

    _set_target_name_metadata = { "offset" : _set_target_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @target_name.setter
    def target_name(self, value:str) -> None:
        """Get or set the target name."""
        return self._intf.set_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._set_target_name_metadata, value)

    _get_valid_target_names_metadata = { "offset" : _get_valid_target_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def valid_target_names(self) -> list:
        """Return the valid target names."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_valid_target_names_metadata)

    _get_target_resolution_metadata = { "offset" : _get_target_resolution_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_resolution(self) -> float:
        """Get or set the target position/velocity sampling resolution."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_target_resolution_metadata)

    _set_target_resolution_metadata = { "offset" : _set_target_resolution_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_resolution.setter
    def target_resolution(self, value:float) -> None:
        """Get or set the target position/velocity sampling resolution."""
        return self._intf.set_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._set_target_resolution_metadata, value)

    _get_use_relative_course_metadata = { "offset" : _get_use_relative_course_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_relative_course(self) -> bool:
        """Get or set the option to specify a relative course as opposed to a true course."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_use_relative_course_metadata)

    _set_use_relative_course_metadata = { "offset" : _set_use_relative_course_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_relative_course.setter
    def use_relative_course(self, value:bool) -> None:
        """Get or set the option to specify a relative course as opposed to a true course."""
        return self._intf.set_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._set_use_relative_course_metadata, value)

    _get_course_metadata = { "offset" : _get_course_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def course(self) -> typing.Any:
        """Get or set the course value."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_course_metadata)

    _set_course_metadata = { "offset" : _set_course_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @course.setter
    def course(self, value:typing.Any) -> None:
        """Get or set the course value."""
        return self._intf.set_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._set_course_metadata, value)

    _get_in_track_metadata = { "offset" : _get_in_track_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def in_track(self) -> float:
        """Get or set the in track offset from the center of the target."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_in_track_metadata)

    _set_in_track_metadata = { "offset" : _set_in_track_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @in_track.setter
    def in_track(self, value:float) -> None:
        """Get or set the in track offset from the center of the target."""
        return self._intf.set_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._set_in_track_metadata, value)

    _get_cross_track_metadata = { "offset" : _get_cross_track_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cross_track(self) -> float:
        """Get or set the cross track offset from the center of the target."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_cross_track_metadata)

    _set_cross_track_metadata = { "offset" : _set_cross_track_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cross_track.setter
    def cross_track(self, value:float) -> None:
        """Get or set the cross track offset from the center of the target."""
        return self._intf.set_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._set_cross_track_metadata, value)

    _get_maneuver_factor_metadata = { "offset" : _get_maneuver_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def maneuver_factor(self) -> float:
        """Get or set the maneuver factor, a dimensionless factor that determines how tightly or gently the aircraft will maneuver."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_maneuver_factor_metadata)

    _set_maneuver_factor_metadata = { "offset" : _set_maneuver_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @maneuver_factor.setter
    def maneuver_factor(self, value:float) -> None:
        """Get or set the maneuver factor, a dimensionless factor that determines how tightly or gently the aircraft will maneuver."""
        return self._intf.set_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._set_maneuver_factor_metadata, value)

    _get_use_approach_turn_mode_metadata = { "offset" : _get_use_approach_turn_mode_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_approach_turn_mode(self) -> bool:
        """Get or set the option to fly the base leg of the maneuver with a constant radius turn."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_use_approach_turn_mode_metadata)

    _set_use_approach_turn_mode_metadata = { "offset" : _set_use_approach_turn_mode_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_approach_turn_mode.setter
    def use_approach_turn_mode(self, value:bool) -> None:
        """Get or set the option to fly the base leg of the maneuver with a constant radius turn."""
        return self._intf.set_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._set_use_approach_turn_mode_metadata, value)

    _get_control_limit_mode_metadata = { "offset" : _get_control_limit_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyNavigationControlLimit),) }
    @property
    def control_limit_mode(self) -> "BasicManeuverStrategyNavigationControlLimit":
        """Get the method to define the control limits of the aircraft during the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_control_limit_mode_metadata)

    _get_control_limit_turn_radius_metadata = { "offset" : _get_control_limit_turn_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def control_limit_turn_radius(self) -> float:
        """Get the specified turn radius for a control limit mode of specify min turn radius."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_control_limit_turn_radius_metadata)

    _get_control_limit_turn_rate_metadata = { "offset" : _get_control_limit_turn_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def control_limit_turn_rate(self) -> typing.Any:
        """Get the specified turn rate for a control limit mode of specify max turn rate."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_control_limit_turn_rate_metadata)

    _get_control_limit_horizontal_acceleration_metadata = { "offset" : _get_control_limit_horizontal_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def control_limit_horizontal_acceleration(self) -> float:
        """Get the specified horizontal acceleration for a control limit mode of specify max horiz accel."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_control_limit_horizontal_acceleration_metadata)

    _set_control_limit_metadata = { "offset" : _set_control_limit_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyNavigationControlLimit), agmarshall.DoubleArg,) }
    def set_control_limit(self, control_limit_mode:"BasicManeuverStrategyNavigationControlLimit", control_limit_value:float) -> None:
        """Set the method and corresponding value to define the control limits of the aircraft during the maneuver."""
        return self._intf.invoke(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._set_control_limit_metadata, control_limit_mode, control_limit_value)

    _get_closure_mode_metadata = { "offset" : _get_closure_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ClosureMode),) }
    @property
    def closure_mode(self) -> "ClosureMode":
        """Get or set the closure mode for the guidance strategy."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_closure_mode_metadata)

    _set_closure_mode_metadata = { "offset" : _set_closure_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ClosureMode),) }
    @closure_mode.setter
    def closure_mode(self, value:"ClosureMode") -> None:
        """Get or set the closure mode for the guidance strategy."""
        return self._intf.set_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._set_closure_mode_metadata, value)

    _get_downrange_offset_metadata = { "offset" : _get_downrange_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def downrange_offset(self) -> float:
        """Get or set the downrange offset for the closure options."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_downrange_offset_metadata)

    _set_downrange_offset_metadata = { "offset" : _set_downrange_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @downrange_offset.setter
    def downrange_offset(self, value:float) -> None:
        """Get or set the downrange offset for the closure options."""
        return self._intf.set_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._set_downrange_offset_metadata, value)

    _get_hobs_max_angle_metadata = { "offset" : _get_hobs_max_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def hobs_max_angle(self) -> typing.Any:
        """Get or set the closure high off boresight max angle."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_hobs_max_angle_metadata)

    _set_hobs_max_angle_metadata = { "offset" : _set_hobs_max_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @hobs_max_angle.setter
    def hobs_max_angle(self, value:typing.Any) -> None:
        """Get or set the closure high off boresight max angle."""
        return self._intf.set_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._set_hobs_max_angle_metadata, value)

    _get_hobs_angle_tol_metadata = { "offset" : _get_hobs_angle_tol_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def hobs_angle_tol(self) -> typing.Any:
        """Get or set the closure high off boresight angle tolerance."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_hobs_angle_tol_metadata)

    _set_hobs_angle_tol_metadata = { "offset" : _set_hobs_angle_tol_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @hobs_angle_tol.setter
    def hobs_angle_tol(self, value:typing.Any) -> None:
        """Get or set the closure high off boresight angle tolerance."""
        return self._intf.set_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._set_hobs_angle_tol_metadata, value)

    _get_compensate_for_coriolis_acceleration_metadata = { "offset" : _get_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def compensate_for_coriolis_acceleration(self) -> bool:
        """Get or set the option to compensate for the acceleration due to the Coriolis effect."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_compensate_for_coriolis_acceleration_metadata)

    _set_compensate_for_coriolis_acceleration_metadata = { "offset" : _set_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @compensate_for_coriolis_acceleration.setter
    def compensate_for_coriolis_acceleration(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._set_compensate_for_coriolis_acceleration_metadata, value)

    _get_position_velocity_strategies_metadata = { "offset" : _get_position_velocity_strategies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def position_velocity_strategies(self) -> "BasicManeuverTargetPositionVelocity":
        """Get the position velocity strategies for Relative Course."""
        return self._intf.get_property(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._get_position_velocity_strategies_metadata)

    _cancel_target_position_velocity_metadata = { "offset" : _cancel_target_position_velocity_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def cancel_target_position_velocity(self) -> None:
        """Cancel the position velocity strategies for Relative Course."""
        return self._intf.invoke(BasicManeuverStrategyRelativeCourse._metadata, BasicManeuverStrategyRelativeCourse._cancel_target_position_velocity_metadata, )

    _property_names[target_name] = "target_name"
    _property_names[valid_target_names] = "valid_target_names"
    _property_names[target_resolution] = "target_resolution"
    _property_names[use_relative_course] = "use_relative_course"
    _property_names[course] = "course"
    _property_names[in_track] = "in_track"
    _property_names[cross_track] = "cross_track"
    _property_names[maneuver_factor] = "maneuver_factor"
    _property_names[use_approach_turn_mode] = "use_approach_turn_mode"
    _property_names[control_limit_mode] = "control_limit_mode"
    _property_names[control_limit_turn_radius] = "control_limit_turn_radius"
    _property_names[control_limit_turn_rate] = "control_limit_turn_rate"
    _property_names[control_limit_horizontal_acceleration] = "control_limit_horizontal_acceleration"
    _property_names[closure_mode] = "closure_mode"
    _property_names[downrange_offset] = "downrange_offset"
    _property_names[hobs_max_angle] = "hobs_max_angle"
    _property_names[hobs_angle_tol] = "hobs_angle_tol"
    _property_names[compensate_for_coriolis_acceleration] = "compensate_for_coriolis_acceleration"
    _property_names[position_velocity_strategies] = "position_velocity_strategies"

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

agcls.AgClassCatalog.add_catalog_entry((5147571040876942273, 10395763520339013003), BasicManeuverStrategyRelativeCourse)
agcls.AgTypeNameMap["BasicManeuverStrategyRelativeCourse"] = BasicManeuverStrategyRelativeCourse

class BasicManeuverStrategyRendezvous(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Rendezvous Formation Strategy of a Basic Maneuver Procedure."""

    _num_methods = 39
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_target_name_method_offset = 1
    _set_target_name_method_offset = 2
    _get_valid_target_names_method_offset = 3
    _get_target_resolution_method_offset = 4
    _set_target_resolution_method_offset = 5
    _get_use_counter_turn_logic_method_offset = 6
    _set_use_counter_turn_logic_method_offset = 7
    _get_enable_collision_avoidance_method_offset = 8
    _get_cpa_method_offset = 9
    _set_cpa_method_offset = 10
    _get_relative_bearing_method_offset = 11
    _set_relative_bearing_method_offset = 12
    _get_relative_range_method_offset = 13
    _set_relative_range_method_offset = 14
    _get_altitude_split_method_offset = 15
    _set_altitude_split_method_offset = 16
    _get_maneuver_factor_method_offset = 17
    _set_maneuver_factor_method_offset = 18
    _get_use_performance_model_limits_method_offset = 19
    _set_use_performance_model_limits_method_offset = 20
    _get_altitude_rate_control_method_offset = 21
    _set_altitude_rate_control_method_offset = 22
    _get_min_load_factor_g_method_offset = 23
    _set_min_load_factor_g_method_offset = 24
    _get_max_load_factor_g_method_offset = 25
    _set_max_load_factor_g_method_offset = 26
    _get_max_speed_advantage_method_offset = 27
    _set_max_speed_advantage_method_offset = 28
    _get_airspeed_control_mode_method_offset = 29
    _set_airspeed_control_mode_method_offset = 30
    _get_acceleration_deceleration_g_method_offset = 31
    _set_acceleration_deceleration_g_method_offset = 32
    _get_use_separate_airspeed_control_method_offset = 33
    _get_airspeed_factor_method_offset = 34
    _set_airspeed_factor_method_offset = 35
    _get_stop_condition_method_offset = 36
    _set_stop_condition_method_offset = 37
    _get_position_velocity_strategies_method_offset = 38
    _cancel_target_position_velocity_method_offset = 39
    _metadata = {
        "iid_data" : (5284660652818080215, 12593108281635057289),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyRendezvous)

    _get_target_name_metadata = { "offset" : _get_target_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def target_name(self) -> str:
        """Get or set the target name."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_target_name_metadata)

    _set_target_name_metadata = { "offset" : _set_target_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @target_name.setter
    def target_name(self, value:str) -> None:
        """Get or set the target name."""
        return self._intf.set_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_target_name_metadata, value)

    _get_valid_target_names_metadata = { "offset" : _get_valid_target_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def valid_target_names(self) -> list:
        """Return the valid target names."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_valid_target_names_metadata)

    _get_target_resolution_metadata = { "offset" : _get_target_resolution_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_resolution(self) -> float:
        """Get or set the target position/velocity sampling resolution."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_target_resolution_metadata)

    _set_target_resolution_metadata = { "offset" : _set_target_resolution_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_resolution.setter
    def target_resolution(self, value:float) -> None:
        """Get or set the target position/velocity sampling resolution."""
        return self._intf.set_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_target_resolution_metadata, value)

    _get_use_counter_turn_logic_metadata = { "offset" : _get_use_counter_turn_logic_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_counter_turn_logic(self) -> bool:
        """Get or set the option to improve performance when flying with a target on a straight and level flight path."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_use_counter_turn_logic_metadata)

    _set_use_counter_turn_logic_metadata = { "offset" : _set_use_counter_turn_logic_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_counter_turn_logic.setter
    def use_counter_turn_logic(self, value:bool) -> None:
        """Get or set the option to improve performance when flying with a target on a straight and level flight path."""
        return self._intf.set_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_use_counter_turn_logic_metadata, value)

    _get_enable_collision_avoidance_metadata = { "offset" : _get_enable_collision_avoidance_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def enable_collision_avoidance(self) -> bool:
        """Get the option to enable collision avoidance."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_enable_collision_avoidance_metadata)

    _get_cpa_metadata = { "offset" : _get_cpa_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cpa(self) -> float:
        """Get the minimum distance between this aircraft and the target aircraft."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_cpa_metadata)

    _set_cpa_metadata = { "offset" : _set_cpa_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.DoubleArg,) }
    def set_cpa(self, enable:bool, collision_avoidance:float) -> None:
        """Set whether to enable collision avoidance and the corresponding minimum distance between this aircraft and the target aircraft."""
        return self._intf.invoke(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_cpa_metadata, enable, collision_avoidance)

    _get_relative_bearing_metadata = { "offset" : _get_relative_bearing_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def relative_bearing(self) -> typing.Any:
        """Get or set the bearing relative to the target the aircraft will achieve and maintain."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_relative_bearing_metadata)

    _set_relative_bearing_metadata = { "offset" : _set_relative_bearing_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @relative_bearing.setter
    def relative_bearing(self, value:typing.Any) -> None:
        """Get or set the bearing relative to the target the aircraft will achieve and maintain."""
        return self._intf.set_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_relative_bearing_metadata, value)

    _get_relative_range_metadata = { "offset" : _get_relative_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def relative_range(self) -> float:
        """Get or set the range to the target the aircraft will achieve and maintain."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_relative_range_metadata)

    _set_relative_range_metadata = { "offset" : _set_relative_range_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @relative_range.setter
    def relative_range(self, value:float) -> None:
        """Get or set the range to the target the aircraft will achieve and maintain."""
        return self._intf.set_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_relative_range_metadata, value)

    _get_altitude_split_metadata = { "offset" : _get_altitude_split_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude_split(self) -> float:
        """Get or set the altitude difference between the aircraft and target."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_altitude_split_metadata)

    _set_altitude_split_metadata = { "offset" : _set_altitude_split_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude_split.setter
    def altitude_split(self, value:float) -> None:
        """Get or set the altitude difference between the aircraft and target."""
        return self._intf.set_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_altitude_split_metadata, value)

    _get_maneuver_factor_metadata = { "offset" : _get_maneuver_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def maneuver_factor(self) -> float:
        """Get or set the maneuver factor, a dimensionless factor that determines how tightly or gently the aircraft will maneuver."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_maneuver_factor_metadata)

    _set_maneuver_factor_metadata = { "offset" : _set_maneuver_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @maneuver_factor.setter
    def maneuver_factor(self, value:float) -> None:
        """Get or set the maneuver factor, a dimensionless factor that determines how tightly or gently the aircraft will maneuver."""
        return self._intf.set_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_maneuver_factor_metadata, value)

    _get_use_performance_model_limits_metadata = { "offset" : _get_use_performance_model_limits_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_performance_model_limits(self) -> bool:
        """Get or set the option to derive the control limits of the aircraft from the applicable performance model."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_use_performance_model_limits_metadata)

    _set_use_performance_model_limits_metadata = { "offset" : _set_use_performance_model_limits_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_performance_model_limits.setter
    def use_performance_model_limits(self, value:bool) -> None:
        """Get or set the option to derive the control limits of the aircraft from the applicable performance model."""
        return self._intf.set_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_use_performance_model_limits_metadata, value)

    _get_altitude_rate_control_metadata = { "offset" : _get_altitude_rate_control_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude_rate_control(self) -> float:
        """Get or set the rate at which the aircraft will change altitude to achieve or maintain the ALtitude Split."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_altitude_rate_control_metadata)

    _set_altitude_rate_control_metadata = { "offset" : _set_altitude_rate_control_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude_rate_control.setter
    def altitude_rate_control(self, value:float) -> None:
        """Get or set the rate at which the aircraft will change altitude to achieve or maintain the ALtitude Split."""
        return self._intf.set_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_altitude_rate_control_metadata, value)

    _get_min_load_factor_g_metadata = { "offset" : _get_min_load_factor_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_load_factor_g(self) -> float:
        """Get or set the minimum load factor the aircraft can bear while maneuvering in formation."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_min_load_factor_g_metadata)

    _set_min_load_factor_g_metadata = { "offset" : _set_min_load_factor_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_load_factor_g.setter
    def min_load_factor_g(self, value:float) -> None:
        """Get or set the minimum load factor the aircraft can bear while maneuvering in formation."""
        return self._intf.set_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_min_load_factor_g_metadata, value)

    _get_max_load_factor_g_metadata = { "offset" : _get_max_load_factor_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_load_factor_g(self) -> float:
        """Get or set the maximum load factor the aircraft can bear while maneuvering in formation."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_max_load_factor_g_metadata)

    _set_max_load_factor_g_metadata = { "offset" : _set_max_load_factor_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_load_factor_g.setter
    def max_load_factor_g(self, value:float) -> None:
        """Get or set the maximum load factor the aircraft can bear while maneuvering in formation."""
        return self._intf.set_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_max_load_factor_g_metadata, value)

    _get_max_speed_advantage_metadata = { "offset" : _get_max_speed_advantage_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_speed_advantage(self) -> float:
        """Get or set the limit to the airspeed difference between the aircraft and target."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_max_speed_advantage_metadata)

    _set_max_speed_advantage_metadata = { "offset" : _set_max_speed_advantage_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_speed_advantage.setter
    def max_speed_advantage(self, value:float) -> None:
        """Get or set the limit to the airspeed difference between the aircraft and target."""
        return self._intf.set_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_max_speed_advantage_metadata, value)

    _get_airspeed_control_mode_metadata = { "offset" : _get_airspeed_control_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AccelerationPerformanceModelOverride),) }
    @property
    def airspeed_control_mode(self) -> "AccelerationPerformanceModelOverride":
        """Get or set the method to define the aircraft's acceleration performance in formation."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_airspeed_control_mode_metadata)

    _set_airspeed_control_mode_metadata = { "offset" : _set_airspeed_control_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AccelerationPerformanceModelOverride),) }
    @airspeed_control_mode.setter
    def airspeed_control_mode(self, value:"AccelerationPerformanceModelOverride") -> None:
        """Get or set the method to define the aircraft's acceleration performance in formation."""
        return self._intf.set_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_airspeed_control_mode_metadata, value)

    _get_acceleration_deceleration_g_metadata = { "offset" : _get_acceleration_deceleration_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def acceleration_deceleration_g(self) -> float:
        """Get or set the aircraft's specified acceleration rate for an airspeed control mode set to override."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_acceleration_deceleration_g_metadata)

    _set_acceleration_deceleration_g_metadata = { "offset" : _set_acceleration_deceleration_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @acceleration_deceleration_g.setter
    def acceleration_deceleration_g(self, value:float) -> None:
        """Get or set the aircraft's specified acceleration rate for an airspeed control mode set to override."""
        return self._intf.set_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_acceleration_deceleration_g_metadata, value)

    _get_use_separate_airspeed_control_metadata = { "offset" : _get_use_separate_airspeed_control_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_separate_airspeed_control(self) -> bool:
        """Get the option to control how fine the control is over the airspeed adjustments in formation flight."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_use_separate_airspeed_control_metadata)

    _get_airspeed_factor_metadata = { "offset" : _get_airspeed_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def airspeed_factor(self) -> float:
        """Get the maneuver factor, a dimensionless factor defining how fine the control is over airspeed adjustments in formation flight."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_airspeed_factor_metadata)

    _set_airspeed_factor_metadata = { "offset" : _set_airspeed_factor_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.DoubleArg,) }
    def set_airspeed_factor(self, enable:bool, airspeed_factor:float) -> None:
        """Set whether to enable the option to control how fine the control is and the corresponding dimensionless factor."""
        return self._intf.invoke(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_airspeed_factor_metadata, enable, airspeed_factor)

    _get_stop_condition_metadata = { "offset" : _get_stop_condition_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RendezvousStopCondition),) }
    @property
    def stop_condition(self) -> "RendezvousStopCondition":
        """Get or set the stopping condition for the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_stop_condition_metadata)

    _set_stop_condition_metadata = { "offset" : _set_stop_condition_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(RendezvousStopCondition),) }
    @stop_condition.setter
    def stop_condition(self, value:"RendezvousStopCondition") -> None:
        """Get or set the stopping condition for the maneuver."""
        return self._intf.set_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._set_stop_condition_metadata, value)

    _get_position_velocity_strategies_metadata = { "offset" : _get_position_velocity_strategies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def position_velocity_strategies(self) -> "BasicManeuverTargetPositionVelocity":
        """Get the position velocity strategies for Rendezvous."""
        return self._intf.get_property(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._get_position_velocity_strategies_metadata)

    _cancel_target_position_velocity_metadata = { "offset" : _cancel_target_position_velocity_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def cancel_target_position_velocity(self) -> None:
        """Cancel the position velocity strategies for Rendezvous."""
        return self._intf.invoke(BasicManeuverStrategyRendezvous._metadata, BasicManeuverStrategyRendezvous._cancel_target_position_velocity_metadata, )

    _property_names[target_name] = "target_name"
    _property_names[valid_target_names] = "valid_target_names"
    _property_names[target_resolution] = "target_resolution"
    _property_names[use_counter_turn_logic] = "use_counter_turn_logic"
    _property_names[enable_collision_avoidance] = "enable_collision_avoidance"
    _property_names[cpa] = "cpa"
    _property_names[relative_bearing] = "relative_bearing"
    _property_names[relative_range] = "relative_range"
    _property_names[altitude_split] = "altitude_split"
    _property_names[maneuver_factor] = "maneuver_factor"
    _property_names[use_performance_model_limits] = "use_performance_model_limits"
    _property_names[altitude_rate_control] = "altitude_rate_control"
    _property_names[min_load_factor_g] = "min_load_factor_g"
    _property_names[max_load_factor_g] = "max_load_factor_g"
    _property_names[max_speed_advantage] = "max_speed_advantage"
    _property_names[airspeed_control_mode] = "airspeed_control_mode"
    _property_names[acceleration_deceleration_g] = "acceleration_deceleration_g"
    _property_names[use_separate_airspeed_control] = "use_separate_airspeed_control"
    _property_names[airspeed_factor] = "airspeed_factor"
    _property_names[stop_condition] = "stop_condition"
    _property_names[position_velocity_strategies] = "position_velocity_strategies"

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

agcls.AgClassCatalog.add_catalog_entry((4675174661932178731, 17343095513377294464), BasicManeuverStrategyRendezvous)
agcls.AgTypeNameMap["BasicManeuverStrategyRendezvous"] = BasicManeuverStrategyRendezvous

class BasicManeuverStrategyStationkeeping(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Stationkeeping Strategy of a Basic Maneuver Procedure."""

    _num_methods = 38
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_target_name_method_offset = 1
    _set_target_name_method_offset = 2
    _get_valid_target_names_method_offset = 3
    _get_target_resolution_method_offset = 4
    _set_target_resolution_method_offset = 5
    _get_max_target_speed_fraction_method_offset = 6
    _set_max_target_speed_fraction_method_offset = 7
    _get_relative_bearing_method_offset = 8
    _set_relative_bearing_method_offset = 9
    _get_relative_range_method_offset = 10
    _set_relative_range_method_offset = 11
    _get_desired_radius_method_offset = 12
    _set_desired_radius_method_offset = 13
    _get_turn_direction_method_offset = 14
    _set_turn_direction_method_offset = 15
    _get_maneuver_factor_method_offset = 16
    _set_maneuver_factor_method_offset = 17
    _get_stop_condition_method_offset = 18
    _set_stop_condition_method_offset = 19
    _get_use_relative_course_method_offset = 20
    _set_use_relative_course_method_offset = 21
    _get_stop_course_method_offset = 22
    _set_stop_course_method_offset = 23
    _get_stop_after_turn_count_method_offset = 24
    _set_stop_after_turn_count_method_offset = 25
    _get_stop_after_duration_method_offset = 26
    _set_stop_after_duration_method_offset = 27
    _get_stop_after_time_method_offset = 28
    _set_stop_after_time_method_offset = 29
    _get_control_limit_mode_method_offset = 30
    _get_control_limit_turn_radius_method_offset = 31
    _get_control_limit_turn_rate_method_offset = 32
    _get_control_limit_horizontal_acceleration_method_offset = 33
    _set_control_limit_method_offset = 34
    _get_compensate_for_coriolis_acceleration_method_offset = 35
    _set_compensate_for_coriolis_acceleration_method_offset = 36
    _get_position_velocity_strategies_method_offset = 37
    _cancel_target_position_velocity_method_offset = 38
    _metadata = {
        "iid_data" : (5315651566696080808, 8511792787367462056),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyStationkeeping)

    _get_target_name_metadata = { "offset" : _get_target_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def target_name(self) -> str:
        """Get or set the target name."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_target_name_metadata)

    _set_target_name_metadata = { "offset" : _set_target_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @target_name.setter
    def target_name(self, value:str) -> None:
        """Get or set the target name."""
        return self._intf.set_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._set_target_name_metadata, value)

    _get_valid_target_names_metadata = { "offset" : _get_valid_target_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def valid_target_names(self) -> list:
        """Return the valid target names."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_valid_target_names_metadata)

    _get_target_resolution_metadata = { "offset" : _get_target_resolution_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_resolution(self) -> float:
        """Get or set the target position/velocity sampling resolution."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_target_resolution_metadata)

    _set_target_resolution_metadata = { "offset" : _set_target_resolution_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_resolution.setter
    def target_resolution(self, value:float) -> None:
        """Get or set the target position/velocity sampling resolution."""
        return self._intf.set_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._set_target_resolution_metadata, value)

    _get_max_target_speed_fraction_metadata = { "offset" : _get_max_target_speed_fraction_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_target_speed_fraction(self) -> float:
        """Get or set the maximum speed relative to the target."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_max_target_speed_fraction_metadata)

    _set_max_target_speed_fraction_metadata = { "offset" : _set_max_target_speed_fraction_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_target_speed_fraction.setter
    def max_target_speed_fraction(self, value:float) -> None:
        """Get or set the maximum speed relative to the target."""
        return self._intf.set_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._set_max_target_speed_fraction_metadata, value)

    _get_relative_bearing_metadata = { "offset" : _get_relative_bearing_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def relative_bearing(self) -> typing.Any:
        """Get or set the bearing relative to the target that the aircraft will hold."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_relative_bearing_metadata)

    _set_relative_bearing_metadata = { "offset" : _set_relative_bearing_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @relative_bearing.setter
    def relative_bearing(self, value:typing.Any) -> None:
        """Get or set the bearing relative to the target that the aircraft will hold."""
        return self._intf.set_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._set_relative_bearing_metadata, value)

    _get_relative_range_metadata = { "offset" : _get_relative_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def relative_range(self) -> float:
        """Get or set the range from the target where the aircraft will hold."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_relative_range_metadata)

    _set_relative_range_metadata = { "offset" : _set_relative_range_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @relative_range.setter
    def relative_range(self, value:float) -> None:
        """Get or set the range from the target where the aircraft will hold."""
        return self._intf.set_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._set_relative_range_metadata, value)

    _get_desired_radius_metadata = { "offset" : _get_desired_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def desired_radius(self) -> float:
        """Get or set the goal radius of the holding circle."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_desired_radius_metadata)

    _set_desired_radius_metadata = { "offset" : _set_desired_radius_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @desired_radius.setter
    def desired_radius(self, value:float) -> None:
        """Get or set the goal radius of the holding circle."""
        return self._intf.set_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._set_desired_radius_metadata, value)

    _get_turn_direction_metadata = { "offset" : _get_turn_direction_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(TurnDirection),) }
    @property
    def turn_direction(self) -> "TurnDirection":
        """Define if the aircraft turns left or right into the holding circle."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_turn_direction_metadata)

    _set_turn_direction_metadata = { "offset" : _set_turn_direction_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(TurnDirection),) }
    @turn_direction.setter
    def turn_direction(self, value:"TurnDirection") -> None:
        """Define if the aircraft turns left or right into the holding circle."""
        return self._intf.set_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._set_turn_direction_metadata, value)

    _get_maneuver_factor_metadata = { "offset" : _get_maneuver_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def maneuver_factor(self) -> float:
        """Get or set the maneuver factor, a dimensionless factor that determines how tightly or gently the aircraft will maneuver."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_maneuver_factor_metadata)

    _set_maneuver_factor_metadata = { "offset" : _set_maneuver_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @maneuver_factor.setter
    def maneuver_factor(self, value:float) -> None:
        """Get or set the maneuver factor, a dimensionless factor that determines how tightly or gently the aircraft will maneuver."""
        return self._intf.set_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._set_maneuver_factor_metadata, value)

    _get_stop_condition_metadata = { "offset" : _get_stop_condition_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(StationkeepingStopCondition),) }
    @property
    def stop_condition(self) -> "StationkeepingStopCondition":
        """Get or set the stopping condition for the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_stop_condition_metadata)

    _set_stop_condition_metadata = { "offset" : _set_stop_condition_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(StationkeepingStopCondition),) }
    @stop_condition.setter
    def stop_condition(self, value:"StationkeepingStopCondition") -> None:
        """Get or set the stopping condition for the maneuver."""
        return self._intf.set_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._set_stop_condition_metadata, value)

    _get_use_relative_course_metadata = { "offset" : _get_use_relative_course_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_relative_course(self) -> bool:
        """Option to use a relative course as opposed to an absolute course."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_use_relative_course_metadata)

    _set_use_relative_course_metadata = { "offset" : _set_use_relative_course_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_relative_course.setter
    def use_relative_course(self, value:bool) -> None:
        """Option to use a relative course as opposed to an absolute course."""
        return self._intf.set_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._set_use_relative_course_metadata, value)

    _get_stop_course_metadata = { "offset" : _get_stop_course_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def stop_course(self) -> typing.Any:
        """Get or set the course stop condition."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_stop_course_metadata)

    _set_stop_course_metadata = { "offset" : _set_stop_course_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @stop_course.setter
    def stop_course(self, value:typing.Any) -> None:
        """Get or set the course stop condition."""
        return self._intf.set_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._set_stop_course_metadata, value)

    _get_stop_after_turn_count_metadata = { "offset" : _get_stop_after_turn_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def stop_after_turn_count(self) -> int:
        """Get or set the number of turns stop condition."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_stop_after_turn_count_metadata)

    _set_stop_after_turn_count_metadata = { "offset" : _set_stop_after_turn_count_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @stop_after_turn_count.setter
    def stop_after_turn_count(self, value:int) -> None:
        """Get or set the number of turns stop condition."""
        return self._intf.set_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._set_stop_after_turn_count_metadata, value)

    _get_stop_after_duration_metadata = { "offset" : _get_stop_after_duration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stop_after_duration(self) -> float:
        """Get or set the duration stop condition."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_stop_after_duration_metadata)

    _set_stop_after_duration_metadata = { "offset" : _set_stop_after_duration_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @stop_after_duration.setter
    def stop_after_duration(self, value:float) -> None:
        """Get or set the duration stop condition."""
        return self._intf.set_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._set_stop_after_duration_metadata, value)

    _get_stop_after_time_metadata = { "offset" : _get_stop_after_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def stop_after_time(self) -> typing.Any:
        """Get or set the time stop condition."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_stop_after_time_metadata)

    _set_stop_after_time_metadata = { "offset" : _set_stop_after_time_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @stop_after_time.setter
    def stop_after_time(self, value:typing.Any) -> None:
        """Get or set the time stop condition."""
        return self._intf.set_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._set_stop_after_time_metadata, value)

    _get_control_limit_mode_metadata = { "offset" : _get_control_limit_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyNavigationControlLimit),) }
    @property
    def control_limit_mode(self) -> "BasicManeuverStrategyNavigationControlLimit":
        """Get the method to define the control limits of the aircraft during the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_control_limit_mode_metadata)

    _get_control_limit_turn_radius_metadata = { "offset" : _get_control_limit_turn_radius_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def control_limit_turn_radius(self) -> float:
        """Get the specified turn radius for a control limit mode of specify min turn radius."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_control_limit_turn_radius_metadata)

    _get_control_limit_turn_rate_metadata = { "offset" : _get_control_limit_turn_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def control_limit_turn_rate(self) -> typing.Any:
        """Get the specified turn rate for a control limit mode of specify max turn rate."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_control_limit_turn_rate_metadata)

    _get_control_limit_horizontal_acceleration_metadata = { "offset" : _get_control_limit_horizontal_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def control_limit_horizontal_acceleration(self) -> float:
        """Get the specified horizontal acceleration for a control limit mode of specify max horiz accel."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_control_limit_horizontal_acceleration_metadata)

    _set_control_limit_metadata = { "offset" : _set_control_limit_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverStrategyNavigationControlLimit), agmarshall.DoubleArg,) }
    def set_control_limit(self, control_limit_mode:"BasicManeuverStrategyNavigationControlLimit", control_limit_value:float) -> None:
        """Set the method and corresponding value to define the control limits of the aircraft during the maneuver."""
        return self._intf.invoke(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._set_control_limit_metadata, control_limit_mode, control_limit_value)

    _get_compensate_for_coriolis_acceleration_metadata = { "offset" : _get_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def compensate_for_coriolis_acceleration(self) -> bool:
        """Get or set the option to compensate for the acceleration due to the Coriolis effect."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_compensate_for_coriolis_acceleration_metadata)

    _set_compensate_for_coriolis_acceleration_metadata = { "offset" : _set_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @compensate_for_coriolis_acceleration.setter
    def compensate_for_coriolis_acceleration(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._set_compensate_for_coriolis_acceleration_metadata, value)

    _get_position_velocity_strategies_metadata = { "offset" : _get_position_velocity_strategies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def position_velocity_strategies(self) -> "BasicManeuverTargetPositionVelocity":
        """Get the position velocity strategies for Station Keeping."""
        return self._intf.get_property(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._get_position_velocity_strategies_metadata)

    _cancel_target_position_velocity_metadata = { "offset" : _cancel_target_position_velocity_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def cancel_target_position_velocity(self) -> None:
        """Cancel the position velocity strategies for Station Keeping."""
        return self._intf.invoke(BasicManeuverStrategyStationkeeping._metadata, BasicManeuverStrategyStationkeeping._cancel_target_position_velocity_metadata, )

    _property_names[target_name] = "target_name"
    _property_names[valid_target_names] = "valid_target_names"
    _property_names[target_resolution] = "target_resolution"
    _property_names[max_target_speed_fraction] = "max_target_speed_fraction"
    _property_names[relative_bearing] = "relative_bearing"
    _property_names[relative_range] = "relative_range"
    _property_names[desired_radius] = "desired_radius"
    _property_names[turn_direction] = "turn_direction"
    _property_names[maneuver_factor] = "maneuver_factor"
    _property_names[stop_condition] = "stop_condition"
    _property_names[use_relative_course] = "use_relative_course"
    _property_names[stop_course] = "stop_course"
    _property_names[stop_after_turn_count] = "stop_after_turn_count"
    _property_names[stop_after_duration] = "stop_after_duration"
    _property_names[stop_after_time] = "stop_after_time"
    _property_names[control_limit_mode] = "control_limit_mode"
    _property_names[control_limit_turn_radius] = "control_limit_turn_radius"
    _property_names[control_limit_turn_rate] = "control_limit_turn_rate"
    _property_names[control_limit_horizontal_acceleration] = "control_limit_horizontal_acceleration"
    _property_names[compensate_for_coriolis_acceleration] = "compensate_for_coriolis_acceleration"
    _property_names[position_velocity_strategies] = "position_velocity_strategies"

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

agcls.AgClassCatalog.add_catalog_entry((5702255453772112199, 1626181488337625527), BasicManeuverStrategyStationkeeping)
agcls.AgTypeNameMap["BasicManeuverStrategyStationkeeping"] = BasicManeuverStrategyStationkeeping

class BasicManeuverStrategyRelativeFlightPathAngle(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for the Relative Flight Path Angle Strategy of a Basic Maneuver Procedure."""

    _num_methods = 24
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_flight_path_angle_method_offset = 1
    _set_flight_path_angle_method_offset = 2
    _get_anchor_altitude_offset_method_offset = 3
    _set_anchor_altitude_offset_method_offset = 4
    _get_maneuver_factor_method_offset = 5
    _set_maneuver_factor_method_offset = 6
    _get_control_limit_mode_method_offset = 7
    _get_control_limit_pitch_rate_method_offset = 8
    _set_control_limit_method_offset = 9
    _get_airspeed_options_method_offset = 10
    _get_min_absolute_altitude_method_offset = 11
    _get_use_min_absolute_altitude_method_offset = 12
    _set_min_absolute_altitude_method_offset = 13
    _get_max_absolute_altitude_method_offset = 14
    _get_use_max_absolute_altitude_method_offset = 15
    _set_max_absolute_altitude_method_offset = 16
    _get_min_altitude_relative_anchor_method_offset = 17
    _get_use_min_altitude_relative_anchor_method_offset = 18
    _set_min_altitude_relative_anchor_method_offset = 19
    _get_max_altitude_relative_anchor_method_offset = 20
    _get_use_max_altitude_relative_anchor_method_offset = 21
    _set_max_altitude_relative_anchor_method_offset = 22
    _get_compensate_for_coriolis_acceleration_method_offset = 23
    _set_compensate_for_coriolis_acceleration_method_offset = 24
    _metadata = {
        "iid_data" : (5255887612627280946, 16294942005206168238),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyRelativeFlightPathAngle)

    _get_flight_path_angle_metadata = { "offset" : _get_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def flight_path_angle(self) -> typing.Any:
        """Get or set the flight path angle for the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._get_flight_path_angle_metadata)

    _set_flight_path_angle_metadata = { "offset" : _set_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @flight_path_angle.setter
    def flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the flight path angle for the maneuver."""
        return self._intf.set_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._set_flight_path_angle_metadata, value)

    _get_anchor_altitude_offset_metadata = { "offset" : _get_anchor_altitude_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def anchor_altitude_offset(self) -> float:
        """Get or set the goal height above or below the target."""
        return self._intf.get_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._get_anchor_altitude_offset_metadata)

    _set_anchor_altitude_offset_metadata = { "offset" : _set_anchor_altitude_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @anchor_altitude_offset.setter
    def anchor_altitude_offset(self, value:float) -> None:
        """Get or set the goal height above or below the target."""
        return self._intf.set_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._set_anchor_altitude_offset_metadata, value)

    _get_maneuver_factor_metadata = { "offset" : _get_maneuver_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def maneuver_factor(self) -> float:
        """Get or set the maneuver factor, a dimensionless factor that determines how tightly or gently the aircraft will maneuver."""
        return self._intf.get_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._get_maneuver_factor_metadata)

    _set_maneuver_factor_metadata = { "offset" : _set_maneuver_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @maneuver_factor.setter
    def maneuver_factor(self, value:float) -> None:
        """Get or set the maneuver factor, a dimensionless factor that determines how tightly or gently the aircraft will maneuver."""
        return self._intf.set_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._set_maneuver_factor_metadata, value)

    _get_control_limit_mode_metadata = { "offset" : _get_control_limit_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ProfileControlLimit),) }
    @property
    def control_limit_mode(self) -> "ProfileControlLimit":
        """Get the method to define the control limits of the aircraft during the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._get_control_limit_mode_metadata)

    _get_control_limit_pitch_rate_metadata = { "offset" : _get_control_limit_pitch_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def control_limit_pitch_rate(self) -> typing.Any:
        """Get the specified pitch rate for a control limit mode of specify max pitch rate."""
        return self._intf.get_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._get_control_limit_pitch_rate_metadata)

    _set_control_limit_metadata = { "offset" : _set_control_limit_method_offset,
            "arg_types" : (agcom.LONG, agcom.Variant,),
            "marshallers" : (agmarshall.EnumArg(ProfileControlLimit), agmarshall.VariantArg,) }
    def set_control_limit(self, control_limit_mode:"ProfileControlLimit", control_limit_value:typing.Any) -> None:
        """Set the method and corresponding value to define the control limits of the aircraft during the maneuver."""
        return self._intf.invoke(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._set_control_limit_metadata, control_limit_mode, control_limit_value)

    _get_airspeed_options_metadata = { "offset" : _get_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def airspeed_options(self) -> "BasicManeuverAirspeedOptions":
        """Get the airspeed options."""
        return self._intf.get_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._get_airspeed_options_metadata)

    _get_min_absolute_altitude_metadata = { "offset" : _get_min_absolute_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_absolute_altitude(self) -> float:
        """Get the minimum absolute altitude."""
        return self._intf.get_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._get_min_absolute_altitude_metadata)

    _get_use_min_absolute_altitude_metadata = { "offset" : _get_use_min_absolute_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_min_absolute_altitude(self) -> bool:
        """Get the option to specify a minimum absolute altitude."""
        return self._intf.get_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._get_use_min_absolute_altitude_metadata)

    _set_min_absolute_altitude_metadata = { "offset" : _set_min_absolute_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.DoubleArg,) }
    def set_min_absolute_altitude(self, enable:bool, altitude:float) -> None:
        """Set whether to enable and a value for the minimum absolute altitude."""
        return self._intf.invoke(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._set_min_absolute_altitude_metadata, enable, altitude)

    _get_max_absolute_altitude_metadata = { "offset" : _get_max_absolute_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_absolute_altitude(self) -> float:
        """Get the maximum absolute altitude."""
        return self._intf.get_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._get_max_absolute_altitude_metadata)

    _get_use_max_absolute_altitude_metadata = { "offset" : _get_use_max_absolute_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_max_absolute_altitude(self) -> bool:
        """Get the option to specify a maximum absolute altitude."""
        return self._intf.get_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._get_use_max_absolute_altitude_metadata)

    _set_max_absolute_altitude_metadata = { "offset" : _set_max_absolute_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.DoubleArg,) }
    def set_max_absolute_altitude(self, enable:bool, altitude:float) -> None:
        """Set whether to enable and a value for the maximum absolute altitude."""
        return self._intf.invoke(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._set_max_absolute_altitude_metadata, enable, altitude)

    _get_min_altitude_relative_anchor_metadata = { "offset" : _get_min_altitude_relative_anchor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_altitude_relative_anchor(self) -> float:
        """Get the minimum altitude offset from the target."""
        return self._intf.get_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._get_min_altitude_relative_anchor_metadata)

    _get_use_min_altitude_relative_anchor_metadata = { "offset" : _get_use_min_altitude_relative_anchor_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_min_altitude_relative_anchor(self) -> bool:
        """Get the option to specify a minimum altitude offset from the target."""
        return self._intf.get_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._get_use_min_altitude_relative_anchor_metadata)

    _set_min_altitude_relative_anchor_metadata = { "offset" : _set_min_altitude_relative_anchor_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.DoubleArg,) }
    def set_min_altitude_relative_anchor(self, enable:bool, altitude:float) -> None:
        """Set whether to enable and a value for the minimum altitude offset from the target."""
        return self._intf.invoke(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._set_min_altitude_relative_anchor_metadata, enable, altitude)

    _get_max_altitude_relative_anchor_metadata = { "offset" : _get_max_altitude_relative_anchor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_altitude_relative_anchor(self) -> float:
        """Get the maximum altitude offset from the target."""
        return self._intf.get_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._get_max_altitude_relative_anchor_metadata)

    _get_use_max_altitude_relative_anchor_metadata = { "offset" : _get_use_max_altitude_relative_anchor_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_max_altitude_relative_anchor(self) -> bool:
        """Get the option to specify a maximum altitude offset from the target."""
        return self._intf.get_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._get_use_max_altitude_relative_anchor_metadata)

    _set_max_altitude_relative_anchor_metadata = { "offset" : _set_max_altitude_relative_anchor_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.DoubleArg,) }
    def set_max_altitude_relative_anchor(self, enable:bool, altitude:float) -> None:
        """Set whether to enable and a value for the maximum altitude offset from the target."""
        return self._intf.invoke(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._set_max_altitude_relative_anchor_metadata, enable, altitude)

    _get_compensate_for_coriolis_acceleration_metadata = { "offset" : _get_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def compensate_for_coriolis_acceleration(self) -> bool:
        """Get or set the option to compensate for the acceleration due to the Coriolis effect."""
        return self._intf.get_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._get_compensate_for_coriolis_acceleration_metadata)

    _set_compensate_for_coriolis_acceleration_metadata = { "offset" : _set_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @compensate_for_coriolis_acceleration.setter
    def compensate_for_coriolis_acceleration(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyRelativeFlightPathAngle._metadata, BasicManeuverStrategyRelativeFlightPathAngle._set_compensate_for_coriolis_acceleration_metadata, value)

    _property_names[flight_path_angle] = "flight_path_angle"
    _property_names[anchor_altitude_offset] = "anchor_altitude_offset"
    _property_names[maneuver_factor] = "maneuver_factor"
    _property_names[control_limit_mode] = "control_limit_mode"
    _property_names[control_limit_pitch_rate] = "control_limit_pitch_rate"
    _property_names[airspeed_options] = "airspeed_options"
    _property_names[min_absolute_altitude] = "min_absolute_altitude"
    _property_names[use_min_absolute_altitude] = "use_min_absolute_altitude"
    _property_names[max_absolute_altitude] = "max_absolute_altitude"
    _property_names[use_max_absolute_altitude] = "use_max_absolute_altitude"
    _property_names[min_altitude_relative_anchor] = "min_altitude_relative_anchor"
    _property_names[use_min_altitude_relative_anchor] = "use_min_altitude_relative_anchor"
    _property_names[max_altitude_relative_anchor] = "max_altitude_relative_anchor"
    _property_names[use_max_altitude_relative_anchor] = "use_max_altitude_relative_anchor"
    _property_names[compensate_for_coriolis_acceleration] = "compensate_for_coriolis_acceleration"

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

agcls.AgClassCatalog.add_catalog_entry((5235810298562675973, 15451148610208858280), BasicManeuverStrategyRelativeFlightPathAngle)
agcls.AgTypeNameMap["BasicManeuverStrategyRelativeFlightPathAngle"] = BasicManeuverStrategyRelativeFlightPathAngle

class BasicManeuverStrategyRelativeSpeedAltitude(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Relative Speed/Altitude Strategy of a Basic Maneuver Procedure."""

    _num_methods = 38
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_target_name_method_offset = 1
    _set_target_name_method_offset = 2
    _get_valid_target_names_method_offset = 3
    _get_target_resolution_method_offset = 4
    _set_target_resolution_method_offset = 5
    _get_relative_altitude_mode_method_offset = 6
    _set_relative_altitude_mode_method_offset = 7
    _get_elevation_angle_method_offset = 8
    _set_elevation_angle_method_offset = 9
    _get_altitude_offset_method_offset = 10
    _set_altitude_offset_method_offset = 11
    _get_airspeed_offset_type_method_offset = 12
    _get_airspeed_offset_method_offset = 13
    _set_airspeed_offset_method_offset = 14
    _get_use_target_aspect_for_airspeed_method_offset = 15
    _set_use_target_aspect_for_airspeed_method_offset = 16
    _get_use_performance_model_limits_method_offset = 17
    _set_use_performance_model_limits_method_offset = 18
    _get_range_for_equal_speed_method_offset = 19
    _set_range_for_equal_speed_method_offset = 20
    _get_range_to_transition_speed_method_offset = 21
    _set_range_to_transition_speed_method_offset = 22
    _get_min_altitude_method_offset = 23
    _set_min_altitude_method_offset = 24
    _get_max_altitude_method_offset = 25
    _set_max_altitude_method_offset = 26
    _get_min_airspeed_method_offset = 27
    _get_min_airspeed_type_method_offset = 28
    _set_min_airspeed_method_offset = 29
    _get_max_airspeed_method_offset = 30
    _get_max_airspeed_type_method_offset = 31
    _set_max_airspeed_method_offset = 32
    _get_stop_condition_method_offset = 33
    _set_stop_condition_method_offset = 34
    _get_compensate_for_coriolis_acceleration_method_offset = 35
    _set_compensate_for_coriolis_acceleration_method_offset = 36
    _get_position_velocity_strategies_method_offset = 37
    _cancel_target_position_velocity_method_offset = 38
    _metadata = {
        "iid_data" : (5691163621320581131, 205069969700959880),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyRelativeSpeedAltitude)

    _get_target_name_metadata = { "offset" : _get_target_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def target_name(self) -> str:
        """Get or set the target name."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_target_name_metadata)

    _set_target_name_metadata = { "offset" : _set_target_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @target_name.setter
    def target_name(self, value:str) -> None:
        """Get or set the target name."""
        return self._intf.set_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._set_target_name_metadata, value)

    _get_valid_target_names_metadata = { "offset" : _get_valid_target_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def valid_target_names(self) -> list:
        """Return the valid target names."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_valid_target_names_metadata)

    _get_target_resolution_metadata = { "offset" : _get_target_resolution_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def target_resolution(self) -> float:
        """Get or set the target position/velocity sampling resolution."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_target_resolution_metadata)

    _set_target_resolution_metadata = { "offset" : _set_target_resolution_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @target_resolution.setter
    def target_resolution(self, value:float) -> None:
        """Get or set the target position/velocity sampling resolution."""
        return self._intf.set_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._set_target_resolution_metadata, value)

    _get_relative_altitude_mode_metadata = { "offset" : _get_relative_altitude_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RelativeAltitudeMode),) }
    @property
    def relative_altitude_mode(self) -> "RelativeAltitudeMode":
        """Get or set the mode to define the hold objective for the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_relative_altitude_mode_metadata)

    _set_relative_altitude_mode_metadata = { "offset" : _set_relative_altitude_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(RelativeAltitudeMode),) }
    @relative_altitude_mode.setter
    def relative_altitude_mode(self, value:"RelativeAltitudeMode") -> None:
        """Get or set the mode to define the hold objective for the maneuver."""
        return self._intf.set_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._set_relative_altitude_mode_metadata, value)

    _get_elevation_angle_metadata = { "offset" : _get_elevation_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def elevation_angle(self) -> typing.Any:
        """Get or set the goal elevation angle from the target to the aircraft."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_elevation_angle_metadata)

    _set_elevation_angle_metadata = { "offset" : _set_elevation_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @elevation_angle.setter
    def elevation_angle(self, value:typing.Any) -> None:
        """Get or set the goal elevation angle from the target to the aircraft."""
        return self._intf.set_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._set_elevation_angle_metadata, value)

    _get_altitude_offset_metadata = { "offset" : _get_altitude_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude_offset(self) -> float:
        """Get or set the goal altitude offset from the target to the aircraft."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_altitude_offset_metadata)

    _set_altitude_offset_metadata = { "offset" : _set_altitude_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude_offset.setter
    def altitude_offset(self, value:float) -> None:
        """Get or set the goal altitude offset from the target to the aircraft."""
        return self._intf.set_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._set_altitude_offset_metadata, value)

    _get_airspeed_offset_type_metadata = { "offset" : _get_airspeed_offset_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_offset_type(self) -> "AirspeedType":
        """Get the airspeed type."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_airspeed_offset_type_metadata)

    _get_airspeed_offset_metadata = { "offset" : _get_airspeed_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def airspeed_offset(self) -> float:
        """Get the airspeed offset from the target."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_airspeed_offset_metadata)

    _set_airspeed_offset_metadata = { "offset" : _set_airspeed_offset_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_airspeed_offset(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the airspeed offset value and type."""
        return self._intf.invoke(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._set_airspeed_offset_metadata, airspeed_type, airspeed)

    _get_use_target_aspect_for_airspeed_metadata = { "offset" : _get_use_target_aspect_for_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_target_aspect_for_airspeed(self) -> bool:
        """Get or set the option to use the target aspect to compute the enforced airspeed difference."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_use_target_aspect_for_airspeed_metadata)

    _set_use_target_aspect_for_airspeed_metadata = { "offset" : _set_use_target_aspect_for_airspeed_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_target_aspect_for_airspeed.setter
    def use_target_aspect_for_airspeed(self, value:bool) -> None:
        """Get or set the option to use the target aspect to compute the enforced airspeed difference."""
        return self._intf.set_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._set_use_target_aspect_for_airspeed_metadata, value)

    _get_use_performance_model_limits_metadata = { "offset" : _get_use_performance_model_limits_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_performance_model_limits(self) -> bool:
        """Get or set the option to use the performance model limits for the aircraft."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_use_performance_model_limits_metadata)

    _set_use_performance_model_limits_metadata = { "offset" : _set_use_performance_model_limits_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_performance_model_limits.setter
    def use_performance_model_limits(self, value:bool) -> None:
        """Get or set the option to use the performance model limits for the aircraft."""
        return self._intf.set_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._set_use_performance_model_limits_metadata, value)

    _get_range_for_equal_speed_metadata = { "offset" : _get_range_for_equal_speed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def range_for_equal_speed(self) -> float:
        """Get or set the range at which the aircraft will achieve the same airspeed as the target."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_range_for_equal_speed_metadata)

    _set_range_for_equal_speed_metadata = { "offset" : _set_range_for_equal_speed_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @range_for_equal_speed.setter
    def range_for_equal_speed(self, value:float) -> None:
        """Get or set the range at which the aircraft will achieve the same airspeed as the target."""
        return self._intf.set_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._set_range_for_equal_speed_metadata, value)

    _get_range_to_transition_speed_metadata = { "offset" : _get_range_to_transition_speed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def range_to_transition_speed(self) -> float:
        """Get or set the range at which the aircraft will begin to slow down to match the speed of the target."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_range_to_transition_speed_metadata)

    _set_range_to_transition_speed_metadata = { "offset" : _set_range_to_transition_speed_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @range_to_transition_speed.setter
    def range_to_transition_speed(self, value:float) -> None:
        """Get or set the range at which the aircraft will begin to slow down to match the speed of the target."""
        return self._intf.set_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._set_range_to_transition_speed_metadata, value)

    _get_min_altitude_metadata = { "offset" : _get_min_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_altitude(self) -> float:
        """Get or set the minimum altitude boundary for the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_min_altitude_metadata)

    _set_min_altitude_metadata = { "offset" : _set_min_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_altitude.setter
    def min_altitude(self, value:float) -> None:
        """Get or set the minimum altitude boundary for the maneuver."""
        return self._intf.set_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._set_min_altitude_metadata, value)

    _get_max_altitude_metadata = { "offset" : _get_max_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_altitude(self) -> float:
        """Get or set the maximum altitude boundary for the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_max_altitude_metadata)

    _set_max_altitude_metadata = { "offset" : _set_max_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_altitude.setter
    def max_altitude(self, value:float) -> None:
        """Get or set the maximum altitude boundary for the maneuver."""
        return self._intf.set_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._set_max_altitude_metadata, value)

    _get_min_airspeed_metadata = { "offset" : _get_min_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_airspeed(self) -> float:
        """Get the minimum airspeed limit for the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_min_airspeed_metadata)

    _get_min_airspeed_type_metadata = { "offset" : _get_min_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def min_airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_min_airspeed_type_metadata)

    _set_min_airspeed_metadata = { "offset" : _set_min_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_min_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the minimum airspeed value and type."""
        return self._intf.invoke(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._set_min_airspeed_metadata, airspeed_type, airspeed)

    _get_max_airspeed_metadata = { "offset" : _get_max_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_airspeed(self) -> float:
        """Get the maximum airspeed limit for the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_max_airspeed_metadata)

    _get_max_airspeed_type_metadata = { "offset" : _get_max_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def max_airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_max_airspeed_type_metadata)

    _set_max_airspeed_metadata = { "offset" : _set_max_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_max_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the maximum airspeed value and type."""
        return self._intf.invoke(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._set_max_airspeed_metadata, airspeed_type, airspeed)

    _get_stop_condition_metadata = { "offset" : _get_stop_condition_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RelativeSpeedAltitudeStopCondition),) }
    @property
    def stop_condition(self) -> "RelativeSpeedAltitudeStopCondition":
        """Get or set the stopping condition for the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_stop_condition_metadata)

    _set_stop_condition_metadata = { "offset" : _set_stop_condition_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(RelativeSpeedAltitudeStopCondition),) }
    @stop_condition.setter
    def stop_condition(self, value:"RelativeSpeedAltitudeStopCondition") -> None:
        """Get or set the stopping condition for the maneuver."""
        return self._intf.set_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._set_stop_condition_metadata, value)

    _get_compensate_for_coriolis_acceleration_metadata = { "offset" : _get_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def compensate_for_coriolis_acceleration(self) -> bool:
        """Get or set the option to compensate for the acceleration due to the Coriolis effect."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_compensate_for_coriolis_acceleration_metadata)

    _set_compensate_for_coriolis_acceleration_metadata = { "offset" : _set_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @compensate_for_coriolis_acceleration.setter
    def compensate_for_coriolis_acceleration(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._set_compensate_for_coriolis_acceleration_metadata, value)

    _get_position_velocity_strategies_metadata = { "offset" : _get_position_velocity_strategies_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def position_velocity_strategies(self) -> "BasicManeuverTargetPositionVelocity":
        """Get the position velocity strategies for Rel Speed Alt."""
        return self._intf.get_property(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._get_position_velocity_strategies_metadata)

    _cancel_target_position_velocity_metadata = { "offset" : _cancel_target_position_velocity_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def cancel_target_position_velocity(self) -> None:
        """Cancel the position velocity strategies for Rel Speed Alt."""
        return self._intf.invoke(BasicManeuverStrategyRelativeSpeedAltitude._metadata, BasicManeuverStrategyRelativeSpeedAltitude._cancel_target_position_velocity_metadata, )

    _property_names[target_name] = "target_name"
    _property_names[valid_target_names] = "valid_target_names"
    _property_names[target_resolution] = "target_resolution"
    _property_names[relative_altitude_mode] = "relative_altitude_mode"
    _property_names[elevation_angle] = "elevation_angle"
    _property_names[altitude_offset] = "altitude_offset"
    _property_names[airspeed_offset_type] = "airspeed_offset_type"
    _property_names[airspeed_offset] = "airspeed_offset"
    _property_names[use_target_aspect_for_airspeed] = "use_target_aspect_for_airspeed"
    _property_names[use_performance_model_limits] = "use_performance_model_limits"
    _property_names[range_for_equal_speed] = "range_for_equal_speed"
    _property_names[range_to_transition_speed] = "range_to_transition_speed"
    _property_names[min_altitude] = "min_altitude"
    _property_names[max_altitude] = "max_altitude"
    _property_names[min_airspeed] = "min_airspeed"
    _property_names[min_airspeed_type] = "min_airspeed_type"
    _property_names[max_airspeed] = "max_airspeed"
    _property_names[max_airspeed_type] = "max_airspeed_type"
    _property_names[stop_condition] = "stop_condition"
    _property_names[compensate_for_coriolis_acceleration] = "compensate_for_coriolis_acceleration"
    _property_names[position_velocity_strategies] = "position_velocity_strategies"

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

agcls.AgClassCatalog.add_catalog_entry((4894758819387771869, 8683178293969344168), BasicManeuverStrategyRelativeSpeedAltitude)
agcls.AgTypeNameMap["BasicManeuverStrategyRelativeSpeedAltitude"] = BasicManeuverStrategyRelativeSpeedAltitude

class BasicManeuverStrategyBezier(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Bezier Strategy of a Basic Maneuver Procedure."""

    _num_methods = 22
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_reference_frame_method_offset = 1
    _set_reference_frame_method_offset = 2
    _get_altitude_method_offset = 3
    _set_altitude_method_offset = 4
    _get_downrange_method_offset = 5
    _set_downrange_method_offset = 6
    _get_airspeed_method_offset = 7
    _get_airspeed_type_method_offset = 8
    _set_airspeed_method_offset = 9
    _get_vertical_velocity_mode_method_offset = 10
    _get_flight_path_angle_method_offset = 11
    _get_altitude_rate_method_offset = 12
    _set_vertical_velocity_method_offset = 13
    _get_use_stop_at_altitude_rate_method_offset = 14
    _get_stop_altitude_rate_method_offset = 15
    _set_stop_altitude_rate_method_offset = 16
    _get_use_stop_at_airspeed_method_offset = 17
    _get_stop_airspeed_method_offset = 18
    _get_stop_airspeed_type_method_offset = 19
    _set_stop_airspeed_method_offset = 20
    _get_compensate_for_coriolis_acceleration_method_offset = 21
    _set_compensate_for_coriolis_acceleration_method_offset = 22
    _metadata = {
        "iid_data" : (5595669399647378963, 17571238138391423883),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyBezier)

    _get_reference_frame_metadata = { "offset" : _get_reference_frame_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverReferenceFrame),) }
    @property
    def reference_frame(self) -> "BasicManeuverReferenceFrame":
        """Get or set the reference frame the aircraft will use."""
        return self._intf.get_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._get_reference_frame_metadata)

    _set_reference_frame_metadata = { "offset" : _set_reference_frame_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverReferenceFrame),) }
    @reference_frame.setter
    def reference_frame(self, value:"BasicManeuverReferenceFrame") -> None:
        """Get or set the reference frame the aircraft will use."""
        return self._intf.set_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._set_reference_frame_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 aircraft's altitude."""
        return self._intf.get_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._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:
        """Get or set the aircraft's altitude."""
        return self._intf.set_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._set_altitude_metadata, value)

    _get_downrange_metadata = { "offset" : _get_downrange_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def downrange(self) -> float:
        """Get or set the ground distance from the beginning of the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._get_downrange_metadata)

    _set_downrange_metadata = { "offset" : _set_downrange_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @downrange.setter
    def downrange(self, value:float) -> None:
        """Get or set the ground distance from the beginning of the maneuver."""
        return self._intf.set_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._set_downrange_metadata, value)

    _get_airspeed_metadata = { "offset" : _get_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def airspeed(self) -> float:
        """Get or set the aircraft's airspeed."""
        return self._intf.get_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._get_airspeed_metadata)

    _get_airspeed_type_metadata = { "offset" : _get_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type."""
        return self._intf.get_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._get_airspeed_type_metadata)

    _set_airspeed_metadata = { "offset" : _set_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the fly to airspeed value and type."""
        return self._intf.invoke(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._set_airspeed_metadata, airspeed_type, airspeed)

    _get_vertical_velocity_mode_metadata = { "offset" : _get_vertical_velocity_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(FlyToFlightPathAngleMode),) }
    @property
    def vertical_velocity_mode(self) -> "FlyToFlightPathAngleMode":
        """Get the option to specify the flight path angle or the altitude rate."""
        return self._intf.get_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._get_vertical_velocity_mode_metadata)

    _get_flight_path_angle_metadata = { "offset" : _get_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def flight_path_angle(self) -> typing.Any:
        """Get the initial pitch angle of the flight path."""
        return self._intf.get_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._get_flight_path_angle_metadata)

    _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 the constant rate at which the aircraft will climb or descend."""
        return self._intf.get_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._get_altitude_rate_metadata)

    _set_vertical_velocity_metadata = { "offset" : _set_vertical_velocity_method_offset,
            "arg_types" : (agcom.LONG, agcom.Variant,),
            "marshallers" : (agmarshall.EnumArg(FlyToFlightPathAngleMode), agmarshall.VariantArg,) }
    def set_vertical_velocity(self, mode:"FlyToFlightPathAngleMode", value:typing.Any) -> None:
        """Set the flight path angle or altitude rate."""
        return self._intf.invoke(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._set_vertical_velocity_metadata, mode, value)

    _get_use_stop_at_altitude_rate_metadata = { "offset" : _get_use_stop_at_altitude_rate_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_stop_at_altitude_rate(self) -> bool:
        """Get the option to stop the maneuver if a specified altitude rate is achieved."""
        return self._intf.get_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._get_use_stop_at_altitude_rate_metadata)

    _get_stop_altitude_rate_metadata = { "offset" : _get_stop_altitude_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stop_altitude_rate(self) -> float:
        """Get the altitude rate stopping condition."""
        return self._intf.get_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._get_stop_altitude_rate_metadata)

    _set_stop_altitude_rate_metadata = { "offset" : _set_stop_altitude_rate_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.DoubleArg,) }
    def set_stop_altitude_rate(self, enable:bool, altitude_rate:float) -> None:
        """Set whether to enable the altitude rate stopping condition and the corresponding value."""
        return self._intf.invoke(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._set_stop_altitude_rate_metadata, enable, altitude_rate)

    _get_use_stop_at_airspeed_metadata = { "offset" : _get_use_stop_at_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_stop_at_airspeed(self) -> bool:
        """Get the option to stop the maneuver if a specified airspeed is achieved."""
        return self._intf.get_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._get_use_stop_at_airspeed_metadata)

    _get_stop_airspeed_metadata = { "offset" : _get_stop_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stop_airspeed(self) -> float:
        """Get the airspeed stopping condition."""
        return self._intf.get_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._get_stop_airspeed_metadata)

    _get_stop_airspeed_type_metadata = { "offset" : _get_stop_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def stop_airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type for the airspeed stopping condition."""
        return self._intf.get_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._get_stop_airspeed_type_metadata)

    _set_stop_airspeed_metadata = { "offset" : _set_stop_airspeed_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_stop_airspeed(self, enable:bool, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set whether to enable the airspeed stopping condition and the corresponding value."""
        return self._intf.invoke(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._set_stop_airspeed_metadata, enable, airspeed_type, airspeed)

    _get_compensate_for_coriolis_acceleration_metadata = { "offset" : _get_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def compensate_for_coriolis_acceleration(self) -> bool:
        """Get or set the option to compensate for the acceleration due to the Coriolis effect."""
        return self._intf.get_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._get_compensate_for_coriolis_acceleration_metadata)

    _set_compensate_for_coriolis_acceleration_metadata = { "offset" : _set_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @compensate_for_coriolis_acceleration.setter
    def compensate_for_coriolis_acceleration(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyBezier._metadata, BasicManeuverStrategyBezier._set_compensate_for_coriolis_acceleration_metadata, value)

    _property_names[reference_frame] = "reference_frame"
    _property_names[altitude] = "altitude"
    _property_names[downrange] = "downrange"
    _property_names[airspeed] = "airspeed"
    _property_names[airspeed_type] = "airspeed_type"
    _property_names[vertical_velocity_mode] = "vertical_velocity_mode"
    _property_names[flight_path_angle] = "flight_path_angle"
    _property_names[altitude_rate] = "altitude_rate"
    _property_names[use_stop_at_altitude_rate] = "use_stop_at_altitude_rate"
    _property_names[stop_altitude_rate] = "stop_altitude_rate"
    _property_names[use_stop_at_airspeed] = "use_stop_at_airspeed"
    _property_names[stop_airspeed] = "stop_airspeed"
    _property_names[stop_airspeed_type] = "stop_airspeed_type"
    _property_names[compensate_for_coriolis_acceleration] = "compensate_for_coriolis_acceleration"

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

agcls.AgClassCatalog.add_catalog_entry((5222291178848850719, 6629227373768158352), BasicManeuverStrategyBezier)
agcls.AgTypeNameMap["BasicManeuverStrategyBezier"] = BasicManeuverStrategyBezier

class BasicManeuverStrategyPushPull(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a Push/Pull Strategy of a Basic Maneuver Procedure."""

    _num_methods = 27
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_reference_frame_method_offset = 1
    _set_reference_frame_method_offset = 2
    _get_push_pull_method_offset = 3
    _set_push_pull_method_offset = 4
    _get_push_pull_g_method_offset = 5
    _set_push_pull_g_method_offset = 6
    _get_acceleration_mode_method_offset = 7
    _set_acceleration_mode_method_offset = 8
    _get_acceleration_deceleration_g_method_offset = 9
    _set_acceleration_deceleration_g_method_offset = 10
    _get_maintain_airspeed_type_method_offset = 11
    _set_maintain_airspeed_type_method_offset = 12
    _get_maintain_airspeed_method_offset = 13
    _get_stop_flight_path_angle_method_offset = 14
    _set_stop_flight_path_angle_method_offset = 15
    _get_use_stop_at_altitude_method_offset = 16
    _get_stop_altitude_method_offset = 17
    _set_stop_altitude_method_offset = 18
    _get_use_stop_at_altitude_rate_method_offset = 19
    _get_stop_altitude_rate_method_offset = 20
    _set_stop_altitude_rate_method_offset = 21
    _get_use_stop_at_airspeed_method_offset = 22
    _get_stop_airspeed_method_offset = 23
    _get_stop_airspeed_type_method_offset = 24
    _set_stop_airspeed_method_offset = 25
    _get_compensate_for_coriolis_acceleration_method_offset = 26
    _set_compensate_for_coriolis_acceleration_method_offset = 27
    _metadata = {
        "iid_data" : (5379525353037390362, 8450611450859654847),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyPushPull)

    _get_reference_frame_metadata = { "offset" : _get_reference_frame_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverReferenceFrame),) }
    @property
    def reference_frame(self) -> "BasicManeuverReferenceFrame":
        """Get or set the reference frame the aircraft will use."""
        return self._intf.get_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._get_reference_frame_metadata)

    _set_reference_frame_metadata = { "offset" : _set_reference_frame_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverReferenceFrame),) }
    @reference_frame.setter
    def reference_frame(self, value:"BasicManeuverReferenceFrame") -> None:
        """Get or set the reference frame the aircraft will use."""
        return self._intf.set_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._set_reference_frame_metadata, value)

    _get_push_pull_metadata = { "offset" : _get_push_pull_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PushPull),) }
    @property
    def push_pull(self) -> "PushPull":
        """Get or set the option to push over or pull up."""
        return self._intf.get_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._get_push_pull_metadata)

    _set_push_pull_metadata = { "offset" : _set_push_pull_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PushPull),) }
    @push_pull.setter
    def push_pull(self, value:"PushPull") -> None:
        """Get or set the option to push over or pull up."""
        return self._intf.set_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._set_push_pull_metadata, value)

    _get_push_pull_g_metadata = { "offset" : _get_push_pull_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def push_pull_g(self) -> float:
        """Get or set the G force of the maneuver."""
        return self._intf.get_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._get_push_pull_g_metadata)

    _set_push_pull_g_metadata = { "offset" : _set_push_pull_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @push_pull_g.setter
    def push_pull_g(self, value:float) -> None:
        """Get or set the G force of the maneuver."""
        return self._intf.set_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._set_push_pull_g_metadata, value)

    _get_acceleration_mode_metadata = { "offset" : _get_acceleration_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AccelerationMode),) }
    @property
    def acceleration_mode(self) -> "AccelerationMode":
        """Get or set the option to accelerate, decelerate, or maintain the current airspeed."""
        return self._intf.get_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._get_acceleration_mode_metadata)

    _set_acceleration_mode_metadata = { "offset" : _set_acceleration_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AccelerationMode),) }
    @acceleration_mode.setter
    def acceleration_mode(self, value:"AccelerationMode") -> None:
        """Get or set the option to accelerate, decelerate, or maintain the current airspeed."""
        return self._intf.set_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._set_acceleration_mode_metadata, value)

    _get_acceleration_deceleration_g_metadata = { "offset" : _get_acceleration_deceleration_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def acceleration_deceleration_g(self) -> float:
        """Get or set the specific G force rate to accelerate/decelerate at."""
        return self._intf.get_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._get_acceleration_deceleration_g_metadata)

    _set_acceleration_deceleration_g_metadata = { "offset" : _set_acceleration_deceleration_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @acceleration_deceleration_g.setter
    def acceleration_deceleration_g(self, value:float) -> None:
        """Get or set the specific G force rate to accelerate/decelerate at."""
        return self._intf.set_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._set_acceleration_deceleration_g_metadata, value)

    _get_maintain_airspeed_type_metadata = { "offset" : _get_maintain_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def maintain_airspeed_type(self) -> "AirspeedType":
        """Get or set the airspeed type for the maintain airspeed."""
        return self._intf.get_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._get_maintain_airspeed_type_metadata)

    _set_maintain_airspeed_type_metadata = { "offset" : _set_maintain_airspeed_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @maintain_airspeed_type.setter
    def maintain_airspeed_type(self, value:"AirspeedType") -> None:
        """Get or set the airspeed type for the maintain airspeed."""
        return self._intf.set_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._set_maintain_airspeed_type_metadata, value)

    _get_maintain_airspeed_metadata = { "offset" : _get_maintain_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def maintain_airspeed(self) -> float:
        """Get the airspeed to maintain."""
        return self._intf.get_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._get_maintain_airspeed_metadata)

    _get_stop_flight_path_angle_metadata = { "offset" : _get_stop_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def stop_flight_path_angle(self) -> typing.Any:
        """Get or set the flight path angle the maneuver will stop at if achieved."""
        return self._intf.get_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._get_stop_flight_path_angle_metadata)

    _set_stop_flight_path_angle_metadata = { "offset" : _set_stop_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @stop_flight_path_angle.setter
    def stop_flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the flight path angle the maneuver will stop at if achieved."""
        return self._intf.set_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._set_stop_flight_path_angle_metadata, value)

    _get_use_stop_at_altitude_metadata = { "offset" : _get_use_stop_at_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_stop_at_altitude(self) -> bool:
        """Get the option to stop the maneuver if a specified altitude is achieved."""
        return self._intf.get_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._get_use_stop_at_altitude_metadata)

    _get_stop_altitude_metadata = { "offset" : _get_stop_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stop_altitude(self) -> float:
        """Get the altitude stopping condition."""
        return self._intf.get_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._get_stop_altitude_metadata)

    _set_stop_altitude_metadata = { "offset" : _set_stop_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.DoubleArg,) }
    def set_stop_altitude(self, enable:bool, altitude_rate:float) -> None:
        """Set whether to enable the altitude stopping condition and the corresponding value."""
        return self._intf.invoke(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._set_stop_altitude_metadata, enable, altitude_rate)

    _get_use_stop_at_altitude_rate_metadata = { "offset" : _get_use_stop_at_altitude_rate_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_stop_at_altitude_rate(self) -> bool:
        """Get the option to stop the maneuver if a specified altitude rate is achieved."""
        return self._intf.get_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._get_use_stop_at_altitude_rate_metadata)

    _get_stop_altitude_rate_metadata = { "offset" : _get_stop_altitude_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stop_altitude_rate(self) -> float:
        """Get the altitude rate stopping condition."""
        return self._intf.get_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._get_stop_altitude_rate_metadata)

    _set_stop_altitude_rate_metadata = { "offset" : _set_stop_altitude_rate_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.DoubleArg,) }
    def set_stop_altitude_rate(self, enable:bool, altitude_rate:float) -> None:
        """Set whether to enable the altitude rate stopping condition and the corresponding value."""
        return self._intf.invoke(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._set_stop_altitude_rate_metadata, enable, altitude_rate)

    _get_use_stop_at_airspeed_metadata = { "offset" : _get_use_stop_at_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_stop_at_airspeed(self) -> bool:
        """Get the option to stop the maneuver if a specified airspeed is achieved."""
        return self._intf.get_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._get_use_stop_at_airspeed_metadata)

    _get_stop_airspeed_metadata = { "offset" : _get_stop_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stop_airspeed(self) -> float:
        """Get the airspeed stopping condition."""
        return self._intf.get_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._get_stop_airspeed_metadata)

    _get_stop_airspeed_type_metadata = { "offset" : _get_stop_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def stop_airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type for the airspeed stopping condition."""
        return self._intf.get_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._get_stop_airspeed_type_metadata)

    _set_stop_airspeed_metadata = { "offset" : _set_stop_airspeed_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_stop_airspeed(self, enable:bool, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set whether to enable the airspeed stopping condition and the corresponding value."""
        return self._intf.invoke(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._set_stop_airspeed_metadata, enable, airspeed_type, airspeed)

    _get_compensate_for_coriolis_acceleration_metadata = { "offset" : _get_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def compensate_for_coriolis_acceleration(self) -> bool:
        """Get or set the option to compensate for the acceleration due to the Coriolis effect."""
        return self._intf.get_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._get_compensate_for_coriolis_acceleration_metadata)

    _set_compensate_for_coriolis_acceleration_metadata = { "offset" : _set_compensate_for_coriolis_acceleration_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @compensate_for_coriolis_acceleration.setter
    def compensate_for_coriolis_acceleration(self, value:bool) -> None:
        return self._intf.set_property(BasicManeuverStrategyPushPull._metadata, BasicManeuverStrategyPushPull._set_compensate_for_coriolis_acceleration_metadata, value)

    _property_names[reference_frame] = "reference_frame"
    _property_names[push_pull] = "push_pull"
    _property_names[push_pull_g] = "push_pull_g"
    _property_names[acceleration_mode] = "acceleration_mode"
    _property_names[acceleration_deceleration_g] = "acceleration_deceleration_g"
    _property_names[maintain_airspeed_type] = "maintain_airspeed_type"
    _property_names[maintain_airspeed] = "maintain_airspeed"
    _property_names[stop_flight_path_angle] = "stop_flight_path_angle"
    _property_names[use_stop_at_altitude] = "use_stop_at_altitude"
    _property_names[stop_altitude] = "stop_altitude"
    _property_names[use_stop_at_altitude_rate] = "use_stop_at_altitude_rate"
    _property_names[stop_altitude_rate] = "stop_altitude_rate"
    _property_names[use_stop_at_airspeed] = "use_stop_at_airspeed"
    _property_names[stop_airspeed] = "stop_airspeed"
    _property_names[stop_airspeed_type] = "stop_airspeed_type"
    _property_names[compensate_for_coriolis_acceleration] = "compensate_for_coriolis_acceleration"

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

agcls.AgClassCatalog.add_catalog_entry((5657445006848612225, 10751136478487384450), BasicManeuverStrategyPushPull)
agcls.AgTypeNameMap["BasicManeuverStrategyPushPull"] = BasicManeuverStrategyPushPull

class ProcedureHoldingCircular(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a holding circular procedure."""

    _num_methods = 27
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_options_method_offset = 1
    _get_profile_mode_method_offset = 2
    _set_profile_mode_method_offset = 3
    _get_level_off_mode_method_offset = 4
    _set_level_off_mode_method_offset = 5
    _get_bearing_method_offset = 6
    _set_bearing_method_offset = 7
    _get_use_magnetic_heading_method_offset = 8
    _set_use_magnetic_heading_method_offset = 9
    _get_range_method_offset = 10
    _set_range_method_offset = 11
    _get_diameter_method_offset = 12
    _set_diameter_method_offset = 13
    _get_use_alternate_entry_points_method_offset = 14
    _set_use_alternate_entry_points_method_offset = 15
    _get_turn_direction_method_offset = 16
    _set_turn_direction_method_offset = 17
    _get_turns_method_offset = 18
    _set_turns_method_offset = 19
    _get_refuel_dump_mode_method_offset = 20
    _set_refuel_dump_mode_method_offset = 21
    _get_hold_cruise_airspeed_options_method_offset = 22
    _get_enroute_options_method_offset = 23
    _get_enroute_cruise_airspeed_options_method_offset = 24
    _get_enroute_turn_direction_options_method_offset = 25
    _get_minimum_diameter_method_offset = 26
    _get_as_procedure_method_offset = 27
    _metadata = {
        "iid_data" : (5040350194063280561, 12538380298232867459),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureHoldingCircular)

    _get_altitude_options_metadata = { "offset" : _get_altitude_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def altitude_options(self) -> "AltitudeMSLOptions":
        """Get the altitude options."""
        return self._intf.get_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._get_altitude_options_metadata)

    _get_profile_mode_metadata = { "offset" : _get_profile_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(HoldingProfileMode),) }
    @property
    def profile_mode(self) -> "HoldingProfileMode":
        """Get or set the mode defines how the aircraft will perform the holding pattern."""
        return self._intf.get_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._get_profile_mode_metadata)

    _set_profile_mode_metadata = { "offset" : _set_profile_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(HoldingProfileMode),) }
    @profile_mode.setter
    def profile_mode(self, value:"HoldingProfileMode") -> None:
        """Get or set the mode defines how the aircraft will perform the holding pattern."""
        return self._intf.set_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._set_profile_mode_metadata, value)

    _get_level_off_mode_metadata = { "offset" : _get_level_off_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AltitudeConstraintManeuverMode),) }
    @property
    def level_off_mode(self) -> "AltitudeConstraintManeuverMode":
        """Get or set the mode for the level off maneuver."""
        return self._intf.get_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._get_level_off_mode_metadata)

    _set_level_off_mode_metadata = { "offset" : _set_level_off_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AltitudeConstraintManeuverMode),) }
    @level_off_mode.setter
    def level_off_mode(self, value:"AltitudeConstraintManeuverMode") -> None:
        """Get or set the mode for the level off maneuver."""
        return self._intf.set_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._set_level_off_mode_metadata, value)

    _get_bearing_metadata = { "offset" : _get_bearing_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def bearing(self) -> typing.Any:
        """Get or set the bearing of the holding point from the site."""
        return self._intf.get_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._get_bearing_metadata)

    _set_bearing_metadata = { "offset" : _set_bearing_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @bearing.setter
    def bearing(self, value:typing.Any) -> None:
        """Get or set the bearing of the holding point from the site."""
        return self._intf.set_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._set_bearing_metadata, value)

    _get_use_magnetic_heading_metadata = { "offset" : _get_use_magnetic_heading_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_magnetic_heading(self) -> bool:
        """Get or set the option to use a magnetic heading."""
        return self._intf.get_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._get_use_magnetic_heading_metadata)

    _set_use_magnetic_heading_metadata = { "offset" : _set_use_magnetic_heading_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_magnetic_heading.setter
    def use_magnetic_heading(self, value:bool) -> None:
        """Get or set the option to use a magnetic heading."""
        return self._intf.set_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._set_use_magnetic_heading_metadata, value)

    _get_range_metadata = { "offset" : _get_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def range(self) -> float:
        """Get or set the distance to the holding point from the site."""
        return self._intf.get_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._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:
        """Get or set the distance to the holding point from the site."""
        return self._intf.set_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._set_range_metadata, value)

    _get_diameter_metadata = { "offset" : _get_diameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def diameter(self) -> float:
        """Get or set the diameter of the holding pattern."""
        return self._intf.get_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._get_diameter_metadata)

    _set_diameter_metadata = { "offset" : _set_diameter_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @diameter.setter
    def diameter(self, value:float) -> None:
        """Get or set the diameter of the holding pattern."""
        return self._intf.set_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._set_diameter_metadata, value)

    _get_use_alternate_entry_points_metadata = { "offset" : _get_use_alternate_entry_points_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_alternate_entry_points(self) -> bool:
        """Get or set the option to enter the holding pattern from an alternate point."""
        return self._intf.get_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._get_use_alternate_entry_points_metadata)

    _set_use_alternate_entry_points_metadata = { "offset" : _set_use_alternate_entry_points_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_alternate_entry_points.setter
    def use_alternate_entry_points(self, value:bool) -> None:
        """Get or set the option to enter the holding pattern from an alternate point."""
        return self._intf.set_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._set_use_alternate_entry_points_metadata, value)

    _get_turn_direction_metadata = { "offset" : _get_turn_direction_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(HoldingDirection),) }
    @property
    def turn_direction(self) -> "HoldingDirection":
        """Get or set the turn direction to enter the holding pattern."""
        return self._intf.get_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._get_turn_direction_metadata)

    _set_turn_direction_metadata = { "offset" : _set_turn_direction_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(HoldingDirection),) }
    @turn_direction.setter
    def turn_direction(self, value:"HoldingDirection") -> None:
        """Get or set the turn direction to enter the holding pattern."""
        return self._intf.set_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._set_turn_direction_metadata, value)

    _get_turns_metadata = { "offset" : _get_turns_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def turns(self) -> int:
        """Get or set the number of full turns."""
        return self._intf.get_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._get_turns_metadata)

    _set_turns_metadata = { "offset" : _set_turns_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @turns.setter
    def turns(self, value:int) -> None:
        """Get or set the number of full turns."""
        return self._intf.set_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._set_turns_metadata, value)

    _get_refuel_dump_mode_metadata = { "offset" : _get_refuel_dump_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(HoldRefuelDumpMode),) }
    @property
    def refuel_dump_mode(self) -> "HoldRefuelDumpMode":
        """Get or set the mode that defines when the aircraft will leave the holding pattern for a Refuel/Dump operation."""
        return self._intf.get_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._get_refuel_dump_mode_metadata)

    _set_refuel_dump_mode_metadata = { "offset" : _set_refuel_dump_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(HoldRefuelDumpMode),) }
    @refuel_dump_mode.setter
    def refuel_dump_mode(self, value:"HoldRefuelDumpMode") -> None:
        """Get or set the mode that defines when the aircraft will leave the holding pattern for a Refuel/Dump operation."""
        return self._intf.set_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._set_refuel_dump_mode_metadata, value)

    _get_hold_cruise_airspeed_options_metadata = { "offset" : _get_hold_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def hold_cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the hold cruise airspeed options."""
        return self._intf.get_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._get_hold_cruise_airspeed_options_metadata)

    _get_enroute_options_metadata = { "offset" : _get_enroute_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_options(self) -> "IEnrouteAndDelayOptions":
        """Get the enroute options."""
        return self._intf.get_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._get_enroute_options_metadata)

    _get_enroute_cruise_airspeed_options_metadata = { "offset" : _get_enroute_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the enroute cruise airspeed options."""
        return self._intf.get_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._get_enroute_cruise_airspeed_options_metadata)

    _get_enroute_turn_direction_options_metadata = { "offset" : _get_enroute_turn_direction_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_turn_direction_options(self) -> "EnrouteTurnDirectionOptions":
        """Get the enroute turn direction options."""
        return self._intf.get_property(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._get_enroute_turn_direction_options_metadata)

    _get_minimum_diameter_metadata = { "offset" : _get_minimum_diameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    def get_minimum_diameter(self) -> float:
        """Get the aircraft's minimum diameter at this altitude."""
        return self._intf.invoke(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._get_minimum_diameter_metadata, OutArg())

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureHoldingCircular._metadata, ProcedureHoldingCircular._get_as_procedure_metadata, OutArg())

    _property_names[altitude_options] = "altitude_options"
    _property_names[profile_mode] = "profile_mode"
    _property_names[level_off_mode] = "level_off_mode"
    _property_names[bearing] = "bearing"
    _property_names[use_magnetic_heading] = "use_magnetic_heading"
    _property_names[range] = "range"
    _property_names[diameter] = "diameter"
    _property_names[use_alternate_entry_points] = "use_alternate_entry_points"
    _property_names[turn_direction] = "turn_direction"
    _property_names[turns] = "turns"
    _property_names[refuel_dump_mode] = "refuel_dump_mode"
    _property_names[hold_cruise_airspeed_options] = "hold_cruise_airspeed_options"
    _property_names[enroute_options] = "enroute_options"
    _property_names[enroute_cruise_airspeed_options] = "enroute_cruise_airspeed_options"
    _property_names[enroute_turn_direction_options] = "enroute_turn_direction_options"

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

agcls.AgClassCatalog.add_catalog_entry((5374995383901064165, 6409085697245498811), ProcedureHoldingCircular)
agcls.AgTypeNameMap["ProcedureHoldingCircular"] = ProcedureHoldingCircular

class ProcedureHoldingFigure8(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a holding figure 8 procedure."""

    _num_methods = 27
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_options_method_offset = 1
    _get_profile_mode_method_offset = 2
    _set_profile_mode_method_offset = 3
    _get_level_off_mode_method_offset = 4
    _set_level_off_mode_method_offset = 5
    _get_bearing_method_offset = 6
    _set_bearing_method_offset = 7
    _get_use_magnetic_heading_method_offset = 8
    _set_use_magnetic_heading_method_offset = 9
    _get_range_method_offset = 10
    _set_range_method_offset = 11
    _get_length_method_offset = 12
    _set_length_method_offset = 13
    _get_width_method_offset = 14
    _set_width_method_offset = 15
    _get_use_alternate_entry_points_method_offset = 16
    _set_use_alternate_entry_points_method_offset = 17
    _get_turns_method_offset = 18
    _set_turns_method_offset = 19
    _get_refuel_dump_mode_method_offset = 20
    _set_refuel_dump_mode_method_offset = 21
    _get_hold_cruise_airspeed_options_method_offset = 22
    _get_enroute_options_method_offset = 23
    _get_enroute_cruise_airspeed_options_method_offset = 24
    _get_enroute_turn_direction_options_method_offset = 25
    _get_minimum_width_method_offset = 26
    _get_as_procedure_method_offset = 27
    _metadata = {
        "iid_data" : (5057504402673113506, 16387967675821578932),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureHoldingFigure8)

    _get_altitude_options_metadata = { "offset" : _get_altitude_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def altitude_options(self) -> "AltitudeMSLOptions":
        """Get the altitude options."""
        return self._intf.get_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._get_altitude_options_metadata)

    _get_profile_mode_metadata = { "offset" : _get_profile_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(HoldingProfileMode),) }
    @property
    def profile_mode(self) -> "HoldingProfileMode":
        """Get or set the mode defines how the aircraft will perform the holding pattern."""
        return self._intf.get_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._get_profile_mode_metadata)

    _set_profile_mode_metadata = { "offset" : _set_profile_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(HoldingProfileMode),) }
    @profile_mode.setter
    def profile_mode(self, value:"HoldingProfileMode") -> None:
        """Get or set the mode defines how the aircraft will perform the holding pattern."""
        return self._intf.set_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._set_profile_mode_metadata, value)

    _get_level_off_mode_metadata = { "offset" : _get_level_off_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AltitudeConstraintManeuverMode),) }
    @property
    def level_off_mode(self) -> "AltitudeConstraintManeuverMode":
        """Get or set the mode for the level off maneuver."""
        return self._intf.get_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._get_level_off_mode_metadata)

    _set_level_off_mode_metadata = { "offset" : _set_level_off_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AltitudeConstraintManeuverMode),) }
    @level_off_mode.setter
    def level_off_mode(self, value:"AltitudeConstraintManeuverMode") -> None:
        """Get or set the mode for the level off maneuver."""
        return self._intf.set_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._set_level_off_mode_metadata, value)

    _get_bearing_metadata = { "offset" : _get_bearing_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def bearing(self) -> typing.Any:
        """Get or set the bearing of the holding point from the site."""
        return self._intf.get_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._get_bearing_metadata)

    _set_bearing_metadata = { "offset" : _set_bearing_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @bearing.setter
    def bearing(self, value:typing.Any) -> None:
        """Get or set the bearing of the holding point from the site."""
        return self._intf.set_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._set_bearing_metadata, value)

    _get_use_magnetic_heading_metadata = { "offset" : _get_use_magnetic_heading_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_magnetic_heading(self) -> bool:
        """Get or set the option to use a magnetic heading."""
        return self._intf.get_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._get_use_magnetic_heading_metadata)

    _set_use_magnetic_heading_metadata = { "offset" : _set_use_magnetic_heading_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_magnetic_heading.setter
    def use_magnetic_heading(self, value:bool) -> None:
        """Get or set the option to use a magnetic heading."""
        return self._intf.set_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._set_use_magnetic_heading_metadata, value)

    _get_range_metadata = { "offset" : _get_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def range(self) -> float:
        """Get or set the distance to the holding point from the site."""
        return self._intf.get_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._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:
        """Get or set the distance to the holding point from the site."""
        return self._intf.set_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._set_range_metadata, value)

    _get_length_metadata = { "offset" : _get_length_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def length(self) -> float:
        """Get or set the distance between the centers of the pattern's arcs."""
        return self._intf.get_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._get_length_metadata)

    _set_length_metadata = { "offset" : _set_length_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @length.setter
    def length(self, value:float) -> None:
        """Get or set the distance between the centers of the pattern's arcs."""
        return self._intf.set_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._set_length_metadata, value)

    _get_width_metadata = { "offset" : _get_width_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def width(self) -> float:
        """Get or set the width of the holding pattern."""
        return self._intf.get_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._get_width_metadata)

    _set_width_metadata = { "offset" : _set_width_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @width.setter
    def width(self, value:float) -> None:
        """Get or set the width of the holding pattern."""
        return self._intf.set_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._set_width_metadata, value)

    _get_use_alternate_entry_points_metadata = { "offset" : _get_use_alternate_entry_points_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_alternate_entry_points(self) -> bool:
        """Get or set the option to enter the holding pattern from an alternate point."""
        return self._intf.get_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._get_use_alternate_entry_points_metadata)

    _set_use_alternate_entry_points_metadata = { "offset" : _set_use_alternate_entry_points_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_alternate_entry_points.setter
    def use_alternate_entry_points(self, value:bool) -> None:
        """Get or set the option to enter the holding pattern from an alternate point."""
        return self._intf.set_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._set_use_alternate_entry_points_metadata, value)

    _get_turns_metadata = { "offset" : _get_turns_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def turns(self) -> int:
        """Get or set the number of full turns."""
        return self._intf.get_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._get_turns_metadata)

    _set_turns_metadata = { "offset" : _set_turns_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @turns.setter
    def turns(self, value:int) -> None:
        """Get or set the number of full turns."""
        return self._intf.set_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._set_turns_metadata, value)

    _get_refuel_dump_mode_metadata = { "offset" : _get_refuel_dump_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(HoldRefuelDumpMode),) }
    @property
    def refuel_dump_mode(self) -> "HoldRefuelDumpMode":
        """Get or set the mode that defines when the aircraft will leave the holding pattern for a Refuel/Dump operation."""
        return self._intf.get_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._get_refuel_dump_mode_metadata)

    _set_refuel_dump_mode_metadata = { "offset" : _set_refuel_dump_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(HoldRefuelDumpMode),) }
    @refuel_dump_mode.setter
    def refuel_dump_mode(self, value:"HoldRefuelDumpMode") -> None:
        """Get or set the mode that defines when the aircraft will leave the holding pattern for a Refuel/Dump operation."""
        return self._intf.set_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._set_refuel_dump_mode_metadata, value)

    _get_hold_cruise_airspeed_options_metadata = { "offset" : _get_hold_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def hold_cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the hold cruise airspeed options."""
        return self._intf.get_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._get_hold_cruise_airspeed_options_metadata)

    _get_enroute_options_metadata = { "offset" : _get_enroute_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_options(self) -> "IEnrouteAndDelayOptions":
        """Get the enroute options."""
        return self._intf.get_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._get_enroute_options_metadata)

    _get_enroute_cruise_airspeed_options_metadata = { "offset" : _get_enroute_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the enroute cruise airspeed options."""
        return self._intf.get_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._get_enroute_cruise_airspeed_options_metadata)

    _get_enroute_turn_direction_options_metadata = { "offset" : _get_enroute_turn_direction_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_turn_direction_options(self) -> "EnrouteTurnDirectionOptions":
        """Get the enroute turn direction options."""
        return self._intf.get_property(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._get_enroute_turn_direction_options_metadata)

    _get_minimum_width_metadata = { "offset" : _get_minimum_width_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    def get_minimum_width(self) -> float:
        """Get the minimum allowable width based on the aircraft's minimum diameter at this altitude."""
        return self._intf.invoke(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._get_minimum_width_metadata, OutArg())

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureHoldingFigure8._metadata, ProcedureHoldingFigure8._get_as_procedure_metadata, OutArg())

    _property_names[altitude_options] = "altitude_options"
    _property_names[profile_mode] = "profile_mode"
    _property_names[level_off_mode] = "level_off_mode"
    _property_names[bearing] = "bearing"
    _property_names[use_magnetic_heading] = "use_magnetic_heading"
    _property_names[range] = "range"
    _property_names[length] = "length"
    _property_names[width] = "width"
    _property_names[use_alternate_entry_points] = "use_alternate_entry_points"
    _property_names[turns] = "turns"
    _property_names[refuel_dump_mode] = "refuel_dump_mode"
    _property_names[hold_cruise_airspeed_options] = "hold_cruise_airspeed_options"
    _property_names[enroute_options] = "enroute_options"
    _property_names[enroute_cruise_airspeed_options] = "enroute_cruise_airspeed_options"
    _property_names[enroute_turn_direction_options] = "enroute_turn_direction_options"

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

agcls.AgClassCatalog.add_catalog_entry((5040902702432878542, 2657564633102253195), ProcedureHoldingFigure8)
agcls.AgTypeNameMap["ProcedureHoldingFigure8"] = ProcedureHoldingFigure8

class ProcedureHoldingRacetrack(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a holding racetrack procedure."""

    _num_methods = 27
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_options_method_offset = 1
    _get_profile_mode_method_offset = 2
    _set_profile_mode_method_offset = 3
    _get_level_off_mode_method_offset = 4
    _set_level_off_mode_method_offset = 5
    _get_bearing_method_offset = 6
    _set_bearing_method_offset = 7
    _get_use_magnetic_heading_method_offset = 8
    _set_use_magnetic_heading_method_offset = 9
    _get_range_method_offset = 10
    _set_range_method_offset = 11
    _get_length_method_offset = 12
    _set_length_method_offset = 13
    _get_width_method_offset = 14
    _set_width_method_offset = 15
    _get_entry_maneuver_method_offset = 16
    _set_entry_maneuver_method_offset = 17
    _get_turns_method_offset = 18
    _set_turns_method_offset = 19
    _get_refuel_dump_mode_method_offset = 20
    _set_refuel_dump_mode_method_offset = 21
    _get_hold_cruise_airspeed_options_method_offset = 22
    _get_enroute_options_method_offset = 23
    _get_enroute_cruise_airspeed_options_method_offset = 24
    _get_enroute_turn_direction_options_method_offset = 25
    _get_minimum_width_method_offset = 26
    _get_as_procedure_method_offset = 27
    _metadata = {
        "iid_data" : (4842277984816642990, 12984619644259900564),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureHoldingRacetrack)

    _get_altitude_options_metadata = { "offset" : _get_altitude_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def altitude_options(self) -> "AltitudeMSLOptions":
        """Get the altitude options."""
        return self._intf.get_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._get_altitude_options_metadata)

    _get_profile_mode_metadata = { "offset" : _get_profile_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(HoldingProfileMode),) }
    @property
    def profile_mode(self) -> "HoldingProfileMode":
        """Get or set the mode defines how the aircraft will perform the holding pattern."""
        return self._intf.get_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._get_profile_mode_metadata)

    _set_profile_mode_metadata = { "offset" : _set_profile_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(HoldingProfileMode),) }
    @profile_mode.setter
    def profile_mode(self, value:"HoldingProfileMode") -> None:
        """Get or set the mode defines how the aircraft will perform the holding pattern."""
        return self._intf.set_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._set_profile_mode_metadata, value)

    _get_level_off_mode_metadata = { "offset" : _get_level_off_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AltitudeConstraintManeuverMode),) }
    @property
    def level_off_mode(self) -> "AltitudeConstraintManeuverMode":
        """Get or set the mode for the level off maneuver."""
        return self._intf.get_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._get_level_off_mode_metadata)

    _set_level_off_mode_metadata = { "offset" : _set_level_off_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AltitudeConstraintManeuverMode),) }
    @level_off_mode.setter
    def level_off_mode(self, value:"AltitudeConstraintManeuverMode") -> None:
        """Get or set the mode for the level off maneuver."""
        return self._intf.set_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._set_level_off_mode_metadata, value)

    _get_bearing_metadata = { "offset" : _get_bearing_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def bearing(self) -> typing.Any:
        """Get or set the bearing of the holding point from the site."""
        return self._intf.get_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._get_bearing_metadata)

    _set_bearing_metadata = { "offset" : _set_bearing_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @bearing.setter
    def bearing(self, value:typing.Any) -> None:
        """Get or set the bearing of the holding point from the site."""
        return self._intf.set_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._set_bearing_metadata, value)

    _get_use_magnetic_heading_metadata = { "offset" : _get_use_magnetic_heading_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_magnetic_heading(self) -> bool:
        """Get or set the option to use a magnetic heading."""
        return self._intf.get_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._get_use_magnetic_heading_metadata)

    _set_use_magnetic_heading_metadata = { "offset" : _set_use_magnetic_heading_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_magnetic_heading.setter
    def use_magnetic_heading(self, value:bool) -> None:
        """Get or set the option to use a magnetic heading."""
        return self._intf.set_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._set_use_magnetic_heading_metadata, value)

    _get_range_metadata = { "offset" : _get_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def range(self) -> float:
        """Get or set the distance to the holding point from the site."""
        return self._intf.get_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._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:
        """Get or set the distance to the holding point from the site."""
        return self._intf.set_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._set_range_metadata, value)

    _get_length_metadata = { "offset" : _get_length_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def length(self) -> float:
        """Get or set the distance between the centers of the pattern's arcs."""
        return self._intf.get_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._get_length_metadata)

    _set_length_metadata = { "offset" : _set_length_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @length.setter
    def length(self, value:float) -> None:
        """Get or set the distance between the centers of the pattern's arcs."""
        return self._intf.set_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._set_length_metadata, value)

    _get_width_metadata = { "offset" : _get_width_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def width(self) -> float:
        """Get or set the width of the holding pattern."""
        return self._intf.get_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._get_width_metadata)

    _set_width_metadata = { "offset" : _set_width_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @width.setter
    def width(self, value:float) -> None:
        """Get or set the width of the holding pattern."""
        return self._intf.set_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._set_width_metadata, value)

    _get_entry_maneuver_metadata = { "offset" : _get_entry_maneuver_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(HoldingEntryManeuver),) }
    @property
    def entry_maneuver(self) -> "HoldingEntryManeuver":
        """Define how the aircraft will enter the holding pattern."""
        return self._intf.get_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._get_entry_maneuver_metadata)

    _set_entry_maneuver_metadata = { "offset" : _set_entry_maneuver_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(HoldingEntryManeuver),) }
    @entry_maneuver.setter
    def entry_maneuver(self, value:"HoldingEntryManeuver") -> None:
        """Define how the aircraft will enter the holding pattern."""
        return self._intf.set_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._set_entry_maneuver_metadata, value)

    _get_turns_metadata = { "offset" : _get_turns_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def turns(self) -> int:
        """Get or set the number of full turns."""
        return self._intf.get_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._get_turns_metadata)

    _set_turns_metadata = { "offset" : _set_turns_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @turns.setter
    def turns(self, value:int) -> None:
        """Get or set the number of full turns."""
        return self._intf.set_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._set_turns_metadata, value)

    _get_refuel_dump_mode_metadata = { "offset" : _get_refuel_dump_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(HoldRefuelDumpMode),) }
    @property
    def refuel_dump_mode(self) -> "HoldRefuelDumpMode":
        """Get or set the mode that defines when the aircraft will leave the holding pattern for a Refuel/Dump operation."""
        return self._intf.get_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._get_refuel_dump_mode_metadata)

    _set_refuel_dump_mode_metadata = { "offset" : _set_refuel_dump_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(HoldRefuelDumpMode),) }
    @refuel_dump_mode.setter
    def refuel_dump_mode(self, value:"HoldRefuelDumpMode") -> None:
        """Get or set the mode that defines when the aircraft will leave the holding pattern for a Refuel/Dump operation."""
        return self._intf.set_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._set_refuel_dump_mode_metadata, value)

    _get_hold_cruise_airspeed_options_metadata = { "offset" : _get_hold_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def hold_cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the hold cruise airspeed options."""
        return self._intf.get_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._get_hold_cruise_airspeed_options_metadata)

    _get_enroute_options_metadata = { "offset" : _get_enroute_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_options(self) -> "IEnrouteAndDelayOptions":
        """Get the enroute options."""
        return self._intf.get_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._get_enroute_options_metadata)

    _get_enroute_cruise_airspeed_options_metadata = { "offset" : _get_enroute_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the enroute cruise airspeed options."""
        return self._intf.get_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._get_enroute_cruise_airspeed_options_metadata)

    _get_enroute_turn_direction_options_metadata = { "offset" : _get_enroute_turn_direction_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_turn_direction_options(self) -> "EnrouteTurnDirectionOptions":
        """Get the enroute turn direction options."""
        return self._intf.get_property(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._get_enroute_turn_direction_options_metadata)

    _get_minimum_width_metadata = { "offset" : _get_minimum_width_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    def get_minimum_width(self) -> float:
        """Get the minimum allowable width based on the aircraft's minimum diameter at this altitude."""
        return self._intf.invoke(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._get_minimum_width_metadata, OutArg())

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureHoldingRacetrack._metadata, ProcedureHoldingRacetrack._get_as_procedure_metadata, OutArg())

    _property_names[altitude_options] = "altitude_options"
    _property_names[profile_mode] = "profile_mode"
    _property_names[level_off_mode] = "level_off_mode"
    _property_names[bearing] = "bearing"
    _property_names[use_magnetic_heading] = "use_magnetic_heading"
    _property_names[range] = "range"
    _property_names[length] = "length"
    _property_names[width] = "width"
    _property_names[entry_maneuver] = "entry_maneuver"
    _property_names[turns] = "turns"
    _property_names[refuel_dump_mode] = "refuel_dump_mode"
    _property_names[hold_cruise_airspeed_options] = "hold_cruise_airspeed_options"
    _property_names[enroute_options] = "enroute_options"
    _property_names[enroute_cruise_airspeed_options] = "enroute_cruise_airspeed_options"
    _property_names[enroute_turn_direction_options] = "enroute_turn_direction_options"

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

agcls.AgClassCatalog.add_catalog_entry((5686552538982805981, 15746507684010401214), ProcedureHoldingRacetrack)
agcls.AgTypeNameMap["ProcedureHoldingRacetrack"] = ProcedureHoldingRacetrack

class ProcedureTransitionToHover(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a transition to hover procedure."""

    _num_methods = 15
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_reference_method_offset = 1
    _set_altitude_reference_method_offset = 2
    _get_altitude_method_offset = 3
    _set_altitude_method_offset = 4
    _get_use_magnetic_heading_method_offset = 5
    _get_course_method_offset = 6
    _get_transition_into_wind_method_offset = 7
    _set_transition_course_method_offset = 8
    _set_transition_into_wind_method_offset = 9
    _get_enroute_options_method_offset = 10
    _get_enroute_turn_direction_options_method_offset = 11
    _get_vertical_plane_options_method_offset = 12
    _get_smooth_transition_mode_method_offset = 13
    _set_smooth_transition_mode_method_offset = 14
    _get_as_procedure_method_offset = 15
    _metadata = {
        "iid_data" : (5350110137894207342, 13890695915349771698),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureTransitionToHover)

    _get_altitude_reference_metadata = { "offset" : _get_altitude_reference_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AGLMSL),) }
    @property
    def altitude_reference(self) -> "AGLMSL":
        """Get or set the altitude reference."""
        return self._intf.get_property(ProcedureTransitionToHover._metadata, ProcedureTransitionToHover._get_altitude_reference_metadata)

    _set_altitude_reference_metadata = { "offset" : _set_altitude_reference_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AGLMSL),) }
    @altitude_reference.setter
    def altitude_reference(self, value:"AGLMSL") -> None:
        """Get or set the altitude reference."""
        return self._intf.set_property(ProcedureTransitionToHover._metadata, ProcedureTransitionToHover._set_altitude_reference_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 for the procedure."""
        return self._intf.get_property(ProcedureTransitionToHover._metadata, ProcedureTransitionToHover._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:
        """Get or set the altitude for the procedure."""
        return self._intf.set_property(ProcedureTransitionToHover._metadata, ProcedureTransitionToHover._set_altitude_metadata, value)

    _get_use_magnetic_heading_metadata = { "offset" : _get_use_magnetic_heading_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_magnetic_heading(self) -> bool:
        """Get or set the option to use a magnetic heading for the course."""
        return self._intf.get_property(ProcedureTransitionToHover._metadata, ProcedureTransitionToHover._get_use_magnetic_heading_metadata)

    _get_course_metadata = { "offset" : _get_course_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def course(self) -> typing.Any:
        """Get or set the course for the procedure."""
        return self._intf.get_property(ProcedureTransitionToHover._metadata, ProcedureTransitionToHover._get_course_metadata)

    _get_transition_into_wind_metadata = { "offset" : _get_transition_into_wind_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def transition_into_wind(self) -> bool:
        """Get or set the option to transition into the wind."""
        return self._intf.get_property(ProcedureTransitionToHover._metadata, ProcedureTransitionToHover._get_transition_into_wind_metadata)

    _set_transition_course_metadata = { "offset" : _set_transition_course_method_offset,
            "arg_types" : (agcom.Variant, agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantArg, agmarshall.VariantBoolArg,) }
    def set_transition_course(self, course:typing.Any, use_magnetic_course:bool) -> None:
        """Set the course and heading reference."""
        return self._intf.invoke(ProcedureTransitionToHover._metadata, ProcedureTransitionToHover._set_transition_course_metadata, course, use_magnetic_course)

    _set_transition_into_wind_metadata = { "offset" : _set_transition_into_wind_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def set_transition_into_wind(self) -> None:
        """Set the option to transition into the wind to true."""
        return self._intf.invoke(ProcedureTransitionToHover._metadata, ProcedureTransitionToHover._set_transition_into_wind_metadata, )

    _get_enroute_options_metadata = { "offset" : _get_enroute_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_options(self) -> "EnrouteOptions":
        """Get the enroute options."""
        return self._intf.get_property(ProcedureTransitionToHover._metadata, ProcedureTransitionToHover._get_enroute_options_metadata)

    _get_enroute_turn_direction_options_metadata = { "offset" : _get_enroute_turn_direction_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_turn_direction_options(self) -> "EnrouteTurnDirectionOptions":
        """Get the enroute turn direction options."""
        return self._intf.get_property(ProcedureTransitionToHover._metadata, ProcedureTransitionToHover._get_enroute_turn_direction_options_metadata)

    _get_vertical_plane_options_metadata = { "offset" : _get_vertical_plane_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def vertical_plane_options(self) -> "VerticalPlaneAndFlightPathOptions":
        """Get the vertical plane options."""
        return self._intf.get_property(ProcedureTransitionToHover._metadata, ProcedureTransitionToHover._get_vertical_plane_options_metadata)

    _get_smooth_transition_mode_metadata = { "offset" : _get_smooth_transition_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(TransitionToHoverMode),) }
    @property
    def smooth_transition_mode(self) -> "TransitionToHoverMode":
        """Get or set the transition mode of the aircraft at the end of the procedure."""
        return self._intf.get_property(ProcedureTransitionToHover._metadata, ProcedureTransitionToHover._get_smooth_transition_mode_metadata)

    _set_smooth_transition_mode_metadata = { "offset" : _set_smooth_transition_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(TransitionToHoverMode),) }
    @smooth_transition_mode.setter
    def smooth_transition_mode(self, value:"TransitionToHoverMode") -> None:
        """Get or set the transition mode of the aircraft at the end of the procedure."""
        return self._intf.set_property(ProcedureTransitionToHover._metadata, ProcedureTransitionToHover._set_smooth_transition_mode_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureTransitionToHover._metadata, ProcedureTransitionToHover._get_as_procedure_metadata, OutArg())

    _property_names[altitude_reference] = "altitude_reference"
    _property_names[altitude] = "altitude"
    _property_names[use_magnetic_heading] = "use_magnetic_heading"
    _property_names[course] = "course"
    _property_names[transition_into_wind] = "transition_into_wind"
    _property_names[enroute_options] = "enroute_options"
    _property_names[enroute_turn_direction_options] = "enroute_turn_direction_options"
    _property_names[vertical_plane_options] = "vertical_plane_options"
    _property_names[smooth_transition_mode] = "smooth_transition_mode"

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

agcls.AgClassCatalog.add_catalog_entry((5499213008247255937, 18176109542300513441), ProcedureTransitionToHover)
agcls.AgTypeNameMap["ProcedureTransitionToHover"] = ProcedureTransitionToHover

class ProcedureTerrainFollow(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a terrain following procedure."""

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_agl_method_offset = 1
    _set_altitude_agl_method_offset = 2
    _get_navigation_options_method_offset = 3
    _get_terrain_following_airspeed_options_method_offset = 4
    _get_reduce_turn_radii_method_offset = 5
    _set_reduce_turn_radii_method_offset = 6
    _get_turn_factor_method_offset = 7
    _set_turn_factor_method_offset = 8
    _get_as_procedure_method_offset = 9
    _metadata = {
        "iid_data" : (5088963624823228270, 17025317602044178563),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureTerrainFollow)

    _get_altitude_agl_metadata = { "offset" : _get_altitude_agl_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude_agl(self) -> float:
        """Get or set the altitude above ground level the aircraft will fly."""
        return self._intf.get_property(ProcedureTerrainFollow._metadata, ProcedureTerrainFollow._get_altitude_agl_metadata)

    _set_altitude_agl_metadata = { "offset" : _set_altitude_agl_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude_agl.setter
    def altitude_agl(self, value:float) -> None:
        """Get or set the altitude above ground level the aircraft will fly."""
        return self._intf.set_property(ProcedureTerrainFollow._metadata, ProcedureTerrainFollow._set_altitude_agl_metadata, value)

    _get_navigation_options_metadata = { "offset" : _get_navigation_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def navigation_options(self) -> "NavigationOptions":
        """Get the navigation options."""
        return self._intf.get_property(ProcedureTerrainFollow._metadata, ProcedureTerrainFollow._get_navigation_options_metadata)

    _get_terrain_following_airspeed_options_metadata = { "offset" : _get_terrain_following_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def terrain_following_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the terrain following airspeed options."""
        return self._intf.get_property(ProcedureTerrainFollow._metadata, ProcedureTerrainFollow._get_terrain_following_airspeed_options_metadata)

    _get_reduce_turn_radii_metadata = { "offset" : _get_reduce_turn_radii_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def reduce_turn_radii(self) -> bool:
        """Option to use the minimum speed to compute the turn radius."""
        return self._intf.get_property(ProcedureTerrainFollow._metadata, ProcedureTerrainFollow._get_reduce_turn_radii_metadata)

    _set_reduce_turn_radii_metadata = { "offset" : _set_reduce_turn_radii_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @reduce_turn_radii.setter
    def reduce_turn_radii(self, value:bool) -> None:
        """Option to use the minimum speed to compute the turn radius."""
        return self._intf.set_property(ProcedureTerrainFollow._metadata, ProcedureTerrainFollow._set_reduce_turn_radii_metadata, value)

    _get_turn_factor_metadata = { "offset" : _get_turn_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def turn_factor(self) -> float:
        """Get or set the maximum turn radius factor."""
        return self._intf.get_property(ProcedureTerrainFollow._metadata, ProcedureTerrainFollow._get_turn_factor_metadata)

    _set_turn_factor_metadata = { "offset" : _set_turn_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @turn_factor.setter
    def turn_factor(self, value:float) -> None:
        """Get or set the maximum turn radius factor."""
        return self._intf.set_property(ProcedureTerrainFollow._metadata, ProcedureTerrainFollow._set_turn_factor_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureTerrainFollow._metadata, ProcedureTerrainFollow._get_as_procedure_metadata, OutArg())

    _property_names[altitude_agl] = "altitude_agl"
    _property_names[navigation_options] = "navigation_options"
    _property_names[terrain_following_airspeed_options] = "terrain_following_airspeed_options"
    _property_names[reduce_turn_radii] = "reduce_turn_radii"
    _property_names[turn_factor] = "turn_factor"

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

agcls.AgClassCatalog.add_catalog_entry((4637705811759712830, 3762655096574013604), ProcedureTerrainFollow)
agcls.AgTypeNameMap["ProcedureTerrainFollow"] = ProcedureTerrainFollow

class ProcedureHover(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a hover procedure."""

    _num_methods = 31
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_options_method_offset = 1
    _get_hover_mode_method_offset = 2
    _set_hover_mode_method_offset = 3
    _get_fixed_time_method_offset = 4
    _set_fixed_time_method_offset = 5
    _get_heading_mode_method_offset = 6
    _set_heading_mode_method_offset = 7
    _get_final_heading_mode_method_offset = 8
    _set_relative_course_method_offset = 9
    _set_absolute_course_method_offset = 10
    _set_final_translation_course_method_offset = 11
    _get_absolute_course_method_offset = 12
    _get_relative_course_method_offset = 13
    _get_use_magnetic_heading_method_offset = 14
    _get_final_heading_rate_method_offset = 15
    _set_final_heading_rate_method_offset = 16
    _get_translation_mode_method_offset = 17
    _set_translation_mode_method_offset = 18
    _get_bearing_method_offset = 19
    _set_bearing_method_offset = 20
    _get_use_magnetic_bearing_method_offset = 21
    _set_use_magnetic_bearing_method_offset = 22
    _get_range_method_offset = 23
    _set_range_method_offset = 24
    _get_final_course_mode_method_offset = 25
    _set_final_course_mode_method_offset = 26
    _get_smooth_translation_mode_method_offset = 27
    _set_smooth_translation_mode_method_offset = 28
    _get_radius_factor_method_offset = 29
    _set_radius_factor_method_offset = 30
    _get_as_procedure_method_offset = 31
    _metadata = {
        "iid_data" : (4746140938652922276, 18383641478313139114),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureHover)

    _get_altitude_options_metadata = { "offset" : _get_altitude_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def altitude_options(self) -> "HoverAltitudeOptions":
        """Get the altitude options."""
        return self._intf.get_property(ProcedureHover._metadata, ProcedureHover._get_altitude_options_metadata)

    _get_hover_mode_metadata = { "offset" : _get_hover_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(HoverMode),) }
    @property
    def hover_mode(self) -> "HoverMode":
        """Get or set the option to have the aircraft hover in place for a fixed time or to perform a hovering maneuver."""
        return self._intf.get_property(ProcedureHover._metadata, ProcedureHover._get_hover_mode_metadata)

    _set_hover_mode_metadata = { "offset" : _set_hover_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(HoverMode),) }
    @hover_mode.setter
    def hover_mode(self, value:"HoverMode") -> None:
        """Get or set the option to have the aircraft hover in place for a fixed time or to perform a hovering maneuver."""
        return self._intf.set_property(ProcedureHover._metadata, ProcedureHover._set_hover_mode_metadata, value)

    _get_fixed_time_metadata = { "offset" : _get_fixed_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def fixed_time(self) -> typing.Any:
        """Get or set the time to hover in place."""
        return self._intf.get_property(ProcedureHover._metadata, ProcedureHover._get_fixed_time_metadata)

    _set_fixed_time_metadata = { "offset" : _set_fixed_time_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @fixed_time.setter
    def fixed_time(self, value:typing.Any) -> None:
        """Get or set the time to hover in place."""
        return self._intf.set_property(ProcedureHover._metadata, ProcedureHover._set_fixed_time_metadata, value)

    _get_heading_mode_metadata = { "offset" : _get_heading_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VTOLHeadingMode),) }
    @property
    def heading_mode(self) -> "VTOLHeadingMode":
        """Get or set the heading mode for the aircraft."""
        return self._intf.get_property(ProcedureHover._metadata, ProcedureHover._get_heading_mode_metadata)

    _set_heading_mode_metadata = { "offset" : _set_heading_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(VTOLHeadingMode),) }
    @heading_mode.setter
    def heading_mode(self, value:"VTOLHeadingMode") -> None:
        """Get or set the heading mode for the aircraft."""
        return self._intf.set_property(ProcedureHover._metadata, ProcedureHover._set_heading_mode_metadata, value)

    _get_final_heading_mode_metadata = { "offset" : _get_final_heading_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VTOLFinalHeadingMode),) }
    @property
    def final_heading_mode(self) -> "VTOLFinalHeadingMode":
        """Get the mode to define the heading at the end of the hover."""
        return self._intf.get_property(ProcedureHover._metadata, ProcedureHover._get_final_heading_mode_metadata)

    _set_relative_course_metadata = { "offset" : _set_relative_course_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def set_relative_course(self, heading_change:typing.Any) -> None:
        """Set the relative heading change."""
        return self._intf.invoke(ProcedureHover._metadata, ProcedureHover._set_relative_course_metadata, heading_change)

    _set_absolute_course_metadata = { "offset" : _set_absolute_course_method_offset,
            "arg_types" : (agcom.Variant, agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantArg, agmarshall.VariantBoolArg,) }
    def set_absolute_course(self, course:typing.Any, is_magnetic:bool) -> None:
        """Set the absolute heading and reference."""
        return self._intf.invoke(ProcedureHover._metadata, ProcedureHover._set_absolute_course_metadata, course, is_magnetic)

    _set_final_translation_course_metadata = { "offset" : _set_final_translation_course_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def set_final_translation_course(self) -> None:
        """Set the option to have the final heading to match the translation bearing."""
        return self._intf.invoke(ProcedureHover._metadata, ProcedureHover._set_final_translation_course_metadata, )

    _get_absolute_course_metadata = { "offset" : _get_absolute_course_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def absolute_course(self) -> typing.Any:
        """Get the absolute course for the heading."""
        return self._intf.get_property(ProcedureHover._metadata, ProcedureHover._get_absolute_course_metadata)

    _get_relative_course_metadata = { "offset" : _get_relative_course_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def relative_course(self) -> typing.Any:
        """Get the relative heading change."""
        return self._intf.get_property(ProcedureHover._metadata, ProcedureHover._get_relative_course_metadata)

    _get_use_magnetic_heading_metadata = { "offset" : _get_use_magnetic_heading_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_magnetic_heading(self) -> bool:
        """Get the option to use a magnetic heading for the heading course."""
        return self._intf.get_property(ProcedureHover._metadata, ProcedureHover._get_use_magnetic_heading_metadata)

    _get_final_heading_rate_metadata = { "offset" : _get_final_heading_rate_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VTOLRateMode),) }
    @property
    def final_heading_rate(self) -> "VTOLRateMode":
        """Get or set the options to define the heading rate of the aircraft at the end of the procedure."""
        return self._intf.get_property(ProcedureHover._metadata, ProcedureHover._get_final_heading_rate_metadata)

    _set_final_heading_rate_metadata = { "offset" : _set_final_heading_rate_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(VTOLRateMode),) }
    @final_heading_rate.setter
    def final_heading_rate(self, value:"VTOLRateMode") -> None:
        """Get or set the options to define the heading rate of the aircraft at the end of the procedure."""
        return self._intf.set_property(ProcedureHover._metadata, ProcedureHover._set_final_heading_rate_metadata, value)

    _get_translation_mode_metadata = { "offset" : _get_translation_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VTOLTranslationMode),) }
    @property
    def translation_mode(self) -> "VTOLTranslationMode":
        """Define how the aircraft will translate during the hover."""
        return self._intf.get_property(ProcedureHover._metadata, ProcedureHover._get_translation_mode_metadata)

    _set_translation_mode_metadata = { "offset" : _set_translation_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(VTOLTranslationMode),) }
    @translation_mode.setter
    def translation_mode(self, value:"VTOLTranslationMode") -> None:
        """Define how the aircraft will translate during the hover."""
        return self._intf.set_property(ProcedureHover._metadata, ProcedureHover._set_translation_mode_metadata, value)

    _get_bearing_metadata = { "offset" : _get_bearing_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def bearing(self) -> typing.Any:
        """Get or set the bearing of the translation during the hover."""
        return self._intf.get_property(ProcedureHover._metadata, ProcedureHover._get_bearing_metadata)

    _set_bearing_metadata = { "offset" : _set_bearing_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @bearing.setter
    def bearing(self, value:typing.Any) -> None:
        """Get or set the bearing of the translation during the hover."""
        return self._intf.set_property(ProcedureHover._metadata, ProcedureHover._set_bearing_metadata, value)

    _get_use_magnetic_bearing_metadata = { "offset" : _get_use_magnetic_bearing_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_magnetic_bearing(self) -> bool:
        """Get or set the option to use a magnetic heading for the translation bearing."""
        return self._intf.get_property(ProcedureHover._metadata, ProcedureHover._get_use_magnetic_bearing_metadata)

    _set_use_magnetic_bearing_metadata = { "offset" : _set_use_magnetic_bearing_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_magnetic_bearing.setter
    def use_magnetic_bearing(self, value:bool) -> None:
        """Get or set the option to use a magnetic heading for the translation bearing."""
        return self._intf.set_property(ProcedureHover._metadata, ProcedureHover._set_use_magnetic_bearing_metadata, value)

    _get_range_metadata = { "offset" : _get_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def range(self) -> float:
        """Get or set the range to translate during the hover."""
        return self._intf.get_property(ProcedureHover._metadata, ProcedureHover._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:
        """Get or set the range to translate during the hover."""
        return self._intf.set_property(ProcedureHover._metadata, ProcedureHover._set_range_metadata, value)

    _get_final_course_mode_metadata = { "offset" : _get_final_course_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VTOLTranslationFinalCourseMode),) }
    @property
    def final_course_mode(self) -> "VTOLTranslationFinalCourseMode":
        """Get or set the mode to specify the final course at the end of the hover."""
        return self._intf.get_property(ProcedureHover._metadata, ProcedureHover._get_final_course_mode_metadata)

    _set_final_course_mode_metadata = { "offset" : _set_final_course_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(VTOLTranslationFinalCourseMode),) }
    @final_course_mode.setter
    def final_course_mode(self, value:"VTOLTranslationFinalCourseMode") -> None:
        """Get or set the mode to specify the final course at the end of the hover."""
        return self._intf.set_property(ProcedureHover._metadata, ProcedureHover._set_final_course_mode_metadata, value)

    _get_smooth_translation_mode_metadata = { "offset" : _get_smooth_translation_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VTOLRateMode),) }
    @property
    def smooth_translation_mode(self) -> "VTOLRateMode":
        """Get or set the translation mode of the aircraft at the end of the procedure."""
        return self._intf.get_property(ProcedureHover._metadata, ProcedureHover._get_smooth_translation_mode_metadata)

    _set_smooth_translation_mode_metadata = { "offset" : _set_smooth_translation_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(VTOLRateMode),) }
    @smooth_translation_mode.setter
    def smooth_translation_mode(self, value:"VTOLRateMode") -> None:
        """Get or set the translation mode of the aircraft at the end of the procedure."""
        return self._intf.set_property(ProcedureHover._metadata, ProcedureHover._set_smooth_translation_mode_metadata, value)

    _get_radius_factor_metadata = { "offset" : _get_radius_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radius_factor(self) -> float:
        """Get or set the turn radius factor."""
        return self._intf.get_property(ProcedureHover._metadata, ProcedureHover._get_radius_factor_metadata)

    _set_radius_factor_metadata = { "offset" : _set_radius_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radius_factor.setter
    def radius_factor(self, value:float) -> None:
        """Get or set the turn radius factor."""
        return self._intf.set_property(ProcedureHover._metadata, ProcedureHover._set_radius_factor_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureHover._metadata, ProcedureHover._get_as_procedure_metadata, OutArg())

    _property_names[altitude_options] = "altitude_options"
    _property_names[hover_mode] = "hover_mode"
    _property_names[fixed_time] = "fixed_time"
    _property_names[heading_mode] = "heading_mode"
    _property_names[final_heading_mode] = "final_heading_mode"
    _property_names[absolute_course] = "absolute_course"
    _property_names[relative_course] = "relative_course"
    _property_names[use_magnetic_heading] = "use_magnetic_heading"
    _property_names[final_heading_rate] = "final_heading_rate"
    _property_names[translation_mode] = "translation_mode"
    _property_names[bearing] = "bearing"
    _property_names[use_magnetic_bearing] = "use_magnetic_bearing"
    _property_names[range] = "range"
    _property_names[final_course_mode] = "final_course_mode"
    _property_names[smooth_translation_mode] = "smooth_translation_mode"
    _property_names[radius_factor] = "radius_factor"

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

agcls.AgClassCatalog.add_catalog_entry((4637757686110696229, 14943083538204818584), ProcedureHover)
agcls.AgTypeNameMap["ProcedureHover"] = ProcedureHover

class ProcedureHoverTranslate(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a hover translate procedure."""

    _num_methods = 19
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_options_method_offset = 1
    _get_heading_mode_method_offset = 2
    _set_heading_mode_method_offset = 3
    _get_final_heading_mode_method_offset = 4
    _set_relative_course_method_offset = 5
    _set_absolute_course_method_offset = 6
    _set_final_translation_course_method_offset = 7
    _get_absolute_course_method_offset = 8
    _get_relative_course_method_offset = 9
    _get_use_magnetic_heading_method_offset = 10
    _get_final_heading_rate_method_offset = 11
    _set_final_heading_rate_method_offset = 12
    _get_final_course_mode_method_offset = 13
    _set_final_course_mode_method_offset = 14
    _get_smooth_translation_mode_method_offset = 15
    _set_smooth_translation_mode_method_offset = 16
    _get_radius_factor_method_offset = 17
    _set_radius_factor_method_offset = 18
    _get_as_procedure_method_offset = 19
    _metadata = {
        "iid_data" : (5662964070338846544, 4864949394049088699),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureHoverTranslate)

    _get_altitude_options_metadata = { "offset" : _get_altitude_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def altitude_options(self) -> "HoverAltitudeOptions":
        """Get the altitude options."""
        return self._intf.get_property(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._get_altitude_options_metadata)

    _get_heading_mode_metadata = { "offset" : _get_heading_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VTOLHeadingMode),) }
    @property
    def heading_mode(self) -> "VTOLHeadingMode":
        """Get or set the heading mode for the aircraft."""
        return self._intf.get_property(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._get_heading_mode_metadata)

    _set_heading_mode_metadata = { "offset" : _set_heading_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(VTOLHeadingMode),) }
    @heading_mode.setter
    def heading_mode(self, value:"VTOLHeadingMode") -> None:
        """Get or set the heading mode for the aircraft."""
        return self._intf.set_property(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._set_heading_mode_metadata, value)

    _get_final_heading_mode_metadata = { "offset" : _get_final_heading_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VTOLFinalHeadingMode),) }
    @property
    def final_heading_mode(self) -> "VTOLFinalHeadingMode":
        """Get the mode to define the heading at the end of the hover."""
        return self._intf.get_property(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._get_final_heading_mode_metadata)

    _set_relative_course_metadata = { "offset" : _set_relative_course_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def set_relative_course(self, heading_change:typing.Any) -> None:
        """Set the relative heading change."""
        return self._intf.invoke(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._set_relative_course_metadata, heading_change)

    _set_absolute_course_metadata = { "offset" : _set_absolute_course_method_offset,
            "arg_types" : (agcom.Variant, agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantArg, agmarshall.VariantBoolArg,) }
    def set_absolute_course(self, course:typing.Any, is_magnetic:bool) -> None:
        """Set the absolute heading and reference."""
        return self._intf.invoke(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._set_absolute_course_metadata, course, is_magnetic)

    _set_final_translation_course_metadata = { "offset" : _set_final_translation_course_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def set_final_translation_course(self) -> None:
        """Set the option to have the final heading to match the translation bearing."""
        return self._intf.invoke(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._set_final_translation_course_metadata, )

    _get_absolute_course_metadata = { "offset" : _get_absolute_course_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def absolute_course(self) -> typing.Any:
        """Get the absolute course for the heading."""
        return self._intf.get_property(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._get_absolute_course_metadata)

    _get_relative_course_metadata = { "offset" : _get_relative_course_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def relative_course(self) -> typing.Any:
        """Get the relative heading change."""
        return self._intf.get_property(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._get_relative_course_metadata)

    _get_use_magnetic_heading_metadata = { "offset" : _get_use_magnetic_heading_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_magnetic_heading(self) -> bool:
        """Get the option to use a magnetic heading for the heading course."""
        return self._intf.get_property(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._get_use_magnetic_heading_metadata)

    _get_final_heading_rate_metadata = { "offset" : _get_final_heading_rate_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VTOLRateMode),) }
    @property
    def final_heading_rate(self) -> "VTOLRateMode":
        """Get or set the options to define the heading rate of the aircraft at the end of the procedure."""
        return self._intf.get_property(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._get_final_heading_rate_metadata)

    _set_final_heading_rate_metadata = { "offset" : _set_final_heading_rate_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(VTOLRateMode),) }
    @final_heading_rate.setter
    def final_heading_rate(self, value:"VTOLRateMode") -> None:
        """Get or set the options to define the heading rate of the aircraft at the end of the procedure."""
        return self._intf.set_property(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._set_final_heading_rate_metadata, value)

    _get_final_course_mode_metadata = { "offset" : _get_final_course_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VTOLTranslationFinalCourseMode),) }
    @property
    def final_course_mode(self) -> "VTOLTranslationFinalCourseMode":
        """Get or set the mode to specify the final course at the end of the hover."""
        return self._intf.get_property(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._get_final_course_mode_metadata)

    _set_final_course_mode_metadata = { "offset" : _set_final_course_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(VTOLTranslationFinalCourseMode),) }
    @final_course_mode.setter
    def final_course_mode(self, value:"VTOLTranslationFinalCourseMode") -> None:
        """Get or set the mode to specify the final course at the end of the hover."""
        return self._intf.set_property(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._set_final_course_mode_metadata, value)

    _get_smooth_translation_mode_metadata = { "offset" : _get_smooth_translation_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VTOLRateMode),) }
    @property
    def smooth_translation_mode(self) -> "VTOLRateMode":
        """Get or set the translation mode of the aircraft at the end of the procedure."""
        return self._intf.get_property(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._get_smooth_translation_mode_metadata)

    _set_smooth_translation_mode_metadata = { "offset" : _set_smooth_translation_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(VTOLRateMode),) }
    @smooth_translation_mode.setter
    def smooth_translation_mode(self, value:"VTOLRateMode") -> None:
        """Get or set the translation mode of the aircraft at the end of the procedure."""
        return self._intf.set_property(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._set_smooth_translation_mode_metadata, value)

    _get_radius_factor_metadata = { "offset" : _get_radius_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radius_factor(self) -> float:
        """Get or set the turn radius factor."""
        return self._intf.get_property(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._get_radius_factor_metadata)

    _set_radius_factor_metadata = { "offset" : _set_radius_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radius_factor.setter
    def radius_factor(self, value:float) -> None:
        """Get or set the turn radius factor."""
        return self._intf.set_property(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._set_radius_factor_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureHoverTranslate._metadata, ProcedureHoverTranslate._get_as_procedure_metadata, OutArg())

    _property_names[altitude_options] = "altitude_options"
    _property_names[heading_mode] = "heading_mode"
    _property_names[final_heading_mode] = "final_heading_mode"
    _property_names[absolute_course] = "absolute_course"
    _property_names[relative_course] = "relative_course"
    _property_names[use_magnetic_heading] = "use_magnetic_heading"
    _property_names[final_heading_rate] = "final_heading_rate"
    _property_names[final_course_mode] = "final_course_mode"
    _property_names[smooth_translation_mode] = "smooth_translation_mode"
    _property_names[radius_factor] = "radius_factor"

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

agcls.AgClassCatalog.add_catalog_entry((5420214741440535853, 18125981861350198176), ProcedureHoverTranslate)
agcls.AgTypeNameMap["ProcedureHoverTranslate"] = ProcedureHoverTranslate

class ProcedureTransitionToForwardFlight(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a transition to forward flight procedure."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_transition_course_mode_method_offset = 1
    _set_transition_into_wind_method_offset = 2
    _set_absolute_course_method_offset = 3
    _set_relative_course_method_offset = 4
    _get_use_magnetic_heading_method_offset = 5
    _get_absolute_course_method_offset = 6
    _get_relative_course_method_offset = 7
    _get_flight_path_angle_method_offset = 8
    _set_flight_path_angle_method_offset = 9
    _get_as_procedure_method_offset = 10
    _metadata = {
        "iid_data" : (5172158911162988128, 12605206831299636140),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureTransitionToForwardFlight)

    _get_transition_course_mode_metadata = { "offset" : _get_transition_course_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VTOLTransitionMode),) }
    @property
    def transition_course_mode(self) -> "VTOLTransitionMode":
        """Get the mode to specify the course of the transition maneuver."""
        return self._intf.get_property(ProcedureTransitionToForwardFlight._metadata, ProcedureTransitionToForwardFlight._get_transition_course_mode_metadata)

    _set_transition_into_wind_metadata = { "offset" : _set_transition_into_wind_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def set_transition_into_wind(self) -> None:
        """Set the option to transition into the wind to true."""
        return self._intf.invoke(ProcedureTransitionToForwardFlight._metadata, ProcedureTransitionToForwardFlight._set_transition_into_wind_metadata, )

    _set_absolute_course_metadata = { "offset" : _set_absolute_course_method_offset,
            "arg_types" : (agcom.Variant, agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantArg, agmarshall.VariantBoolArg,) }
    def set_absolute_course(self, course:typing.Any, use_magnetic_course:bool) -> None:
        """Set the mode to absolute and specify the course and heading reference."""
        return self._intf.invoke(ProcedureTransitionToForwardFlight._metadata, ProcedureTransitionToForwardFlight._set_absolute_course_metadata, course, use_magnetic_course)

    _set_relative_course_metadata = { "offset" : _set_relative_course_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def set_relative_course(self, heading_change:typing.Any) -> None:
        """Set the mode to relative and specify the heading change."""
        return self._intf.invoke(ProcedureTransitionToForwardFlight._metadata, ProcedureTransitionToForwardFlight._set_relative_course_metadata, heading_change)

    _get_use_magnetic_heading_metadata = { "offset" : _get_use_magnetic_heading_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_magnetic_heading(self) -> bool:
        """Get the option to use a magnetic heading for the course."""
        return self._intf.get_property(ProcedureTransitionToForwardFlight._metadata, ProcedureTransitionToForwardFlight._get_use_magnetic_heading_metadata)

    _get_absolute_course_metadata = { "offset" : _get_absolute_course_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def absolute_course(self) -> typing.Any:
        """Get the absolute course for the procedure."""
        return self._intf.get_property(ProcedureTransitionToForwardFlight._metadata, ProcedureTransitionToForwardFlight._get_absolute_course_metadata)

    _get_relative_course_metadata = { "offset" : _get_relative_course_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def relative_course(self) -> typing.Any:
        """Get the relative course for the procedure."""
        return self._intf.get_property(ProcedureTransitionToForwardFlight._metadata, ProcedureTransitionToForwardFlight._get_relative_course_metadata)

    _get_flight_path_angle_metadata = { "offset" : _get_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def flight_path_angle(self) -> typing.Any:
        """Get or set the pitch angle of the flight path at the end of the procedure."""
        return self._intf.get_property(ProcedureTransitionToForwardFlight._metadata, ProcedureTransitionToForwardFlight._get_flight_path_angle_metadata)

    _set_flight_path_angle_metadata = { "offset" : _set_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @flight_path_angle.setter
    def flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the pitch angle of the flight path at the end of the procedure."""
        return self._intf.set_property(ProcedureTransitionToForwardFlight._metadata, ProcedureTransitionToForwardFlight._set_flight_path_angle_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureTransitionToForwardFlight._metadata, ProcedureTransitionToForwardFlight._get_as_procedure_metadata, OutArg())

    _property_names[transition_course_mode] = "transition_course_mode"
    _property_names[use_magnetic_heading] = "use_magnetic_heading"
    _property_names[absolute_course] = "absolute_course"
    _property_names[relative_course] = "relative_course"
    _property_names[flight_path_angle] = "flight_path_angle"

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

agcls.AgClassCatalog.add_catalog_entry((5262760007562529134, 8656628601888141195), ProcedureTransitionToForwardFlight)
agcls.AgTypeNameMap["ProcedureTransitionToForwardFlight"] = ProcedureTransitionToForwardFlight

class HoverAltitudeOptions(SupportsDeleteCallback):
    """Interface used to access the altitude options for VTOL procedure."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_reference_method_offset = 1
    _set_altitude_reference_method_offset = 2
    _get_altitude_method_offset = 3
    _set_altitude_method_offset = 4
    _get_final_altitude_rate_method_offset = 5
    _set_final_altitude_rate_method_offset = 6
    _metadata = {
        "iid_data" : (4635993456199635708, 13678738623190303391),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, HoverAltitudeOptions)

    _get_altitude_reference_metadata = { "offset" : _get_altitude_reference_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AGLMSL),) }
    @property
    def altitude_reference(self) -> "AGLMSL":
        """Get or set the altitude reference."""
        return self._intf.get_property(HoverAltitudeOptions._metadata, HoverAltitudeOptions._get_altitude_reference_metadata)

    _set_altitude_reference_metadata = { "offset" : _set_altitude_reference_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AGLMSL),) }
    @altitude_reference.setter
    def altitude_reference(self, value:"AGLMSL") -> None:
        """Get or set the altitude reference."""
        return self._intf.set_property(HoverAltitudeOptions._metadata, HoverAltitudeOptions._set_altitude_reference_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 for the procedure."""
        return self._intf.get_property(HoverAltitudeOptions._metadata, HoverAltitudeOptions._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:
        """Get or set the altitude for the procedure."""
        return self._intf.set_property(HoverAltitudeOptions._metadata, HoverAltitudeOptions._set_altitude_metadata, value)

    _get_final_altitude_rate_metadata = { "offset" : _get_final_altitude_rate_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VTOLRateMode),) }
    @property
    def final_altitude_rate(self) -> "VTOLRateMode":
        """Get or set the altitude rate of the aircraft at the end of the procedure."""
        return self._intf.get_property(HoverAltitudeOptions._metadata, HoverAltitudeOptions._get_final_altitude_rate_metadata)

    _set_final_altitude_rate_metadata = { "offset" : _set_final_altitude_rate_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(VTOLRateMode),) }
    @final_altitude_rate.setter
    def final_altitude_rate(self, value:"VTOLRateMode") -> None:
        """Get or set the altitude rate of the aircraft at the end of the procedure."""
        return self._intf.set_property(HoverAltitudeOptions._metadata, HoverAltitudeOptions._set_final_altitude_rate_metadata, value)

    _property_names[altitude_reference] = "altitude_reference"
    _property_names[altitude] = "altitude"
    _property_names[final_altitude_rate] = "final_altitude_rate"

    def __init__(self, source_object=None):
        """Construct an object of type HoverAltitudeOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, HoverAltitudeOptions)
    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, HoverAltitudeOptions, [HoverAltitudeOptions, ])

agcls.AgClassCatalog.add_catalog_entry((5129030188012039213, 13778514413080775075), HoverAltitudeOptions)
agcls.AgTypeNameMap["HoverAltitudeOptions"] = HoverAltitudeOptions

class ProcedureVerticalTakeoff(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a vertical takeoff procedure."""

    _num_methods = 14
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_above_point_method_offset = 1
    _set_altitude_above_point_method_offset = 2
    _get_final_altitude_rate_method_offset = 3
    _set_final_altitude_rate_method_offset = 4
    _get_altitude_offset_method_offset = 5
    _set_altitude_offset_method_offset = 6
    _set_heading_method_offset = 7
    _get_heading_method_offset = 8
    _get_use_magnetic_heading_method_offset = 9
    _get_heading_into_wind_method_offset = 10
    _set_heading_into_wind_method_offset = 11
    _get_hold_on_deck_method_offset = 12
    _set_hold_on_deck_method_offset = 13
    _get_as_procedure_method_offset = 14
    _metadata = {
        "iid_data" : (5748758660416097725, 5478054864104337286),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureVerticalTakeoff)

    _get_altitude_above_point_metadata = { "offset" : _get_altitude_above_point_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude_above_point(self) -> float:
        """Get or set the altitude the aircraft will takeoff to."""
        return self._intf.get_property(ProcedureVerticalTakeoff._metadata, ProcedureVerticalTakeoff._get_altitude_above_point_metadata)

    _set_altitude_above_point_metadata = { "offset" : _set_altitude_above_point_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude_above_point.setter
    def altitude_above_point(self, value:float) -> None:
        """Get or set the altitude the aircraft will takeoff to."""
        return self._intf.set_property(ProcedureVerticalTakeoff._metadata, ProcedureVerticalTakeoff._set_altitude_above_point_metadata, value)

    _get_final_altitude_rate_metadata = { "offset" : _get_final_altitude_rate_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VTOLRateMode),) }
    @property
    def final_altitude_rate(self) -> "VTOLRateMode":
        """Get or set the altitude rate at the end of the procedure."""
        return self._intf.get_property(ProcedureVerticalTakeoff._metadata, ProcedureVerticalTakeoff._get_final_altitude_rate_metadata)

    _set_final_altitude_rate_metadata = { "offset" : _set_final_altitude_rate_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(VTOLRateMode),) }
    @final_altitude_rate.setter
    def final_altitude_rate(self, value:"VTOLRateMode") -> None:
        """Get or set the altitude rate at the end of the procedure."""
        return self._intf.set_property(ProcedureVerticalTakeoff._metadata, ProcedureVerticalTakeoff._set_final_altitude_rate_metadata, value)

    _get_altitude_offset_metadata = { "offset" : _get_altitude_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude_offset(self) -> float:
        """Get or set the altitude offset from the site to begin the vertical takeoff."""
        return self._intf.get_property(ProcedureVerticalTakeoff._metadata, ProcedureVerticalTakeoff._get_altitude_offset_metadata)

    _set_altitude_offset_metadata = { "offset" : _set_altitude_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude_offset.setter
    def altitude_offset(self, value:float) -> None:
        """Get or set the altitude offset from the site to begin the vertical takeoff."""
        return self._intf.set_property(ProcedureVerticalTakeoff._metadata, ProcedureVerticalTakeoff._set_altitude_offset_metadata, value)

    _set_heading_metadata = { "offset" : _set_heading_method_offset,
            "arg_types" : (agcom.Variant, agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantArg, agmarshall.VariantBoolArg,) }
    def set_heading(self, heading:typing.Any, is_magnetic:bool) -> None:
        """Set the heading and heading reference."""
        return self._intf.invoke(ProcedureVerticalTakeoff._metadata, ProcedureVerticalTakeoff._set_heading_metadata, heading, is_magnetic)

    _get_heading_metadata = { "offset" : _get_heading_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def heading(self) -> typing.Any:
        """Get the heading for the procedure."""
        return self._intf.get_property(ProcedureVerticalTakeoff._metadata, ProcedureVerticalTakeoff._get_heading_metadata)

    _get_use_magnetic_heading_metadata = { "offset" : _get_use_magnetic_heading_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_magnetic_heading(self) -> bool:
        """Get the option to use a magnetic heading."""
        return self._intf.get_property(ProcedureVerticalTakeoff._metadata, ProcedureVerticalTakeoff._get_use_magnetic_heading_metadata)

    _get_heading_into_wind_metadata = { "offset" : _get_heading_into_wind_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def heading_into_wind(self) -> bool:
        """Get or set the option to define the heading according to the wind direction."""
        return self._intf.get_property(ProcedureVerticalTakeoff._metadata, ProcedureVerticalTakeoff._get_heading_into_wind_metadata)

    _set_heading_into_wind_metadata = { "offset" : _set_heading_into_wind_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @heading_into_wind.setter
    def heading_into_wind(self, value:bool) -> None:
        """Get or set the option to define the heading according to the wind direction."""
        return self._intf.set_property(ProcedureVerticalTakeoff._metadata, ProcedureVerticalTakeoff._set_heading_into_wind_metadata, value)

    _get_hold_on_deck_metadata = { "offset" : _get_hold_on_deck_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def hold_on_deck(self) -> typing.Any:
        """Get or set the duration the aircraft will wait before beginning the takeoff."""
        return self._intf.get_property(ProcedureVerticalTakeoff._metadata, ProcedureVerticalTakeoff._get_hold_on_deck_metadata)

    _set_hold_on_deck_metadata = { "offset" : _set_hold_on_deck_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @hold_on_deck.setter
    def hold_on_deck(self, value:typing.Any) -> None:
        """Get or set the duration the aircraft will wait before beginning the takeoff."""
        return self._intf.set_property(ProcedureVerticalTakeoff._metadata, ProcedureVerticalTakeoff._set_hold_on_deck_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureVerticalTakeoff._metadata, ProcedureVerticalTakeoff._get_as_procedure_metadata, OutArg())

    _property_names[altitude_above_point] = "altitude_above_point"
    _property_names[final_altitude_rate] = "final_altitude_rate"
    _property_names[altitude_offset] = "altitude_offset"
    _property_names[heading] = "heading"
    _property_names[use_magnetic_heading] = "use_magnetic_heading"
    _property_names[heading_into_wind] = "heading_into_wind"
    _property_names[hold_on_deck] = "hold_on_deck"

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

agcls.AgClassCatalog.add_catalog_entry((4791321845834673536, 13367423232266428341), ProcedureVerticalTakeoff)
agcls.AgTypeNameMap["ProcedureVerticalTakeoff"] = ProcedureVerticalTakeoff

class ProcedureVerticalLanding(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a vertical landing procedure."""

    _num_methods = 14
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_above_point_method_offset = 1
    _set_altitude_above_point_method_offset = 2
    _get_final_altitude_rate_method_offset = 3
    _set_final_altitude_rate_method_offset = 4
    _get_altitude_offset_method_offset = 5
    _set_altitude_offset_method_offset = 6
    _get_heading_mode_method_offset = 7
    _set_heading_mode_method_offset = 8
    _set_heading_method_offset = 9
    _get_heading_method_offset = 10
    _get_use_magnetic_heading_method_offset = 11
    _get_radius_factor_method_offset = 12
    _set_radius_factor_method_offset = 13
    _get_as_procedure_method_offset = 14
    _metadata = {
        "iid_data" : (5077635317155011109, 11487885256739439786),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureVerticalLanding)

    _get_altitude_above_point_metadata = { "offset" : _get_altitude_above_point_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude_above_point(self) -> float:
        """Get or set the altitude the aircraft will takeoff to."""
        return self._intf.get_property(ProcedureVerticalLanding._metadata, ProcedureVerticalLanding._get_altitude_above_point_metadata)

    _set_altitude_above_point_metadata = { "offset" : _set_altitude_above_point_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude_above_point.setter
    def altitude_above_point(self, value:float) -> None:
        """Get or set the altitude the aircraft will takeoff to."""
        return self._intf.set_property(ProcedureVerticalLanding._metadata, ProcedureVerticalLanding._set_altitude_above_point_metadata, value)

    _get_final_altitude_rate_metadata = { "offset" : _get_final_altitude_rate_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VTOLRateMode),) }
    @property
    def final_altitude_rate(self) -> "VTOLRateMode":
        """Get or set the altitude rate at the end of the procedure."""
        return self._intf.get_property(ProcedureVerticalLanding._metadata, ProcedureVerticalLanding._get_final_altitude_rate_metadata)

    _set_final_altitude_rate_metadata = { "offset" : _set_final_altitude_rate_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(VTOLRateMode),) }
    @final_altitude_rate.setter
    def final_altitude_rate(self, value:"VTOLRateMode") -> None:
        """Get or set the altitude rate at the end of the procedure."""
        return self._intf.set_property(ProcedureVerticalLanding._metadata, ProcedureVerticalLanding._set_final_altitude_rate_metadata, value)

    _get_altitude_offset_metadata = { "offset" : _get_altitude_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude_offset(self) -> float:
        """Get or set the altitude offset from the site to begin the vertical takeoff."""
        return self._intf.get_property(ProcedureVerticalLanding._metadata, ProcedureVerticalLanding._get_altitude_offset_metadata)

    _set_altitude_offset_metadata = { "offset" : _set_altitude_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude_offset.setter
    def altitude_offset(self, value:float) -> None:
        """Get or set the altitude offset from the site to begin the vertical takeoff."""
        return self._intf.set_property(ProcedureVerticalLanding._metadata, ProcedureVerticalLanding._set_altitude_offset_metadata, value)

    _get_heading_mode_metadata = { "offset" : _get_heading_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(VertLandingMode),) }
    @property
    def heading_mode(self) -> "VertLandingMode":
        """Get or set the mode to define the heading during the landing."""
        return self._intf.get_property(ProcedureVerticalLanding._metadata, ProcedureVerticalLanding._get_heading_mode_metadata)

    _set_heading_mode_metadata = { "offset" : _set_heading_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(VertLandingMode),) }
    @heading_mode.setter
    def heading_mode(self, value:"VertLandingMode") -> None:
        """Get or set the mode to define the heading during the landing."""
        return self._intf.set_property(ProcedureVerticalLanding._metadata, ProcedureVerticalLanding._set_heading_mode_metadata, value)

    _set_heading_metadata = { "offset" : _set_heading_method_offset,
            "arg_types" : (agcom.Variant, agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantArg, agmarshall.VariantBoolArg,) }
    def set_heading(self, heading:typing.Any, is_magnetic:bool) -> None:
        """Set the heading and heading reference."""
        return self._intf.invoke(ProcedureVerticalLanding._metadata, ProcedureVerticalLanding._set_heading_metadata, heading, is_magnetic)

    _get_heading_metadata = { "offset" : _get_heading_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def heading(self) -> typing.Any:
        """Get the heading for the procedure."""
        return self._intf.get_property(ProcedureVerticalLanding._metadata, ProcedureVerticalLanding._get_heading_metadata)

    _get_use_magnetic_heading_metadata = { "offset" : _get_use_magnetic_heading_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_magnetic_heading(self) -> bool:
        """Get the option to use a magnetic heading."""
        return self._intf.get_property(ProcedureVerticalLanding._metadata, ProcedureVerticalLanding._get_use_magnetic_heading_metadata)

    _get_radius_factor_metadata = { "offset" : _get_radius_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radius_factor(self) -> float:
        """Get or set the radius factor for turns performed while translating to the hover point."""
        return self._intf.get_property(ProcedureVerticalLanding._metadata, ProcedureVerticalLanding._get_radius_factor_metadata)

    _set_radius_factor_metadata = { "offset" : _set_radius_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radius_factor.setter
    def radius_factor(self, value:float) -> None:
        """Get or set the radius factor for turns performed while translating to the hover point."""
        return self._intf.set_property(ProcedureVerticalLanding._metadata, ProcedureVerticalLanding._set_radius_factor_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureVerticalLanding._metadata, ProcedureVerticalLanding._get_as_procedure_metadata, OutArg())

    _property_names[altitude_above_point] = "altitude_above_point"
    _property_names[final_altitude_rate] = "final_altitude_rate"
    _property_names[altitude_offset] = "altitude_offset"
    _property_names[heading_mode] = "heading_mode"
    _property_names[heading] = "heading"
    _property_names[use_magnetic_heading] = "use_magnetic_heading"
    _property_names[radius_factor] = "radius_factor"

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

agcls.AgClassCatalog.add_catalog_entry((5365072422615651427, 462059424097126035), ProcedureVerticalLanding)
agcls.AgTypeNameMap["ProcedureVerticalLanding"] = ProcedureVerticalLanding

class ProcedureReferenceState(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a reference state procedure."""

    _num_methods = 21
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_start_time_method_offset = 1
    _set_start_time_method_offset = 2
    _get_as_procedure_method_offset = 3
    _get_latitude_method_offset = 4
    _set_latitude_method_offset = 5
    _get_longitude_method_offset = 6
    _set_longitude_method_offset = 7
    _get_use_default_cruise_altitude_method_offset = 8
    _set_use_default_cruise_altitude_method_offset = 9
    _get_msl_altitude_method_offset = 10
    _set_msl_altitude_method_offset = 11
    _get_performance_mode_method_offset = 12
    _set_performance_mode_method_offset = 13
    _get_reference_frame_method_offset = 14
    _set_reference_frame_method_offset = 15
    _get_fuel_flow_method_offset = 16
    _set_fuel_flow_method_offset = 17
    _get_mode_as_forward_flight_method_offset = 18
    _get_mode_as_takeoff_landing_method_offset = 19
    _get_mode_as_hover_method_offset = 20
    _get_mode_as_weight_on_wheels_method_offset = 21
    _metadata = {
        "iid_data" : (5635558193097324645, 13481034554753658046),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureReferenceState)

    _get_start_time_metadata = { "offset" : _get_start_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def start_time(self) -> typing.Any:
        """Get or set the start time of the reference state."""
        return self._intf.get_property(ProcedureReferenceState._metadata, ProcedureReferenceState._get_start_time_metadata)

    _set_start_time_metadata = { "offset" : _set_start_time_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @start_time.setter
    def start_time(self, value:typing.Any) -> None:
        """Get or set the start time of the reference state."""
        return self._intf.set_property(ProcedureReferenceState._metadata, ProcedureReferenceState._set_start_time_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureReferenceState._metadata, ProcedureReferenceState._get_as_procedure_metadata, OutArg())

    _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 waypoint latitude."""
        return self._intf.get_property(ProcedureReferenceState._metadata, ProcedureReferenceState._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:
        """Get or set the waypoint latitude."""
        return self._intf.set_property(ProcedureReferenceState._metadata, ProcedureReferenceState._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 waypoint longitude."""
        return self._intf.get_property(ProcedureReferenceState._metadata, ProcedureReferenceState._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:
        """Get or set the waypoint longitude."""
        return self._intf.set_property(ProcedureReferenceState._metadata, ProcedureReferenceState._set_longitude_metadata, value)

    _get_use_default_cruise_altitude_metadata = { "offset" : _get_use_default_cruise_altitude_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_default_cruise_altitude(self) -> bool:
        """Opt whether to use the default cruise altitude."""
        return self._intf.get_property(ProcedureReferenceState._metadata, ProcedureReferenceState._get_use_default_cruise_altitude_metadata)

    _set_use_default_cruise_altitude_metadata = { "offset" : _set_use_default_cruise_altitude_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_default_cruise_altitude.setter
    def use_default_cruise_altitude(self, value:bool) -> None:
        """Opt whether to use the default cruise altitude."""
        return self._intf.set_property(ProcedureReferenceState._metadata, ProcedureReferenceState._set_use_default_cruise_altitude_metadata, value)

    _get_msl_altitude_metadata = { "offset" : _get_msl_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def msl_altitude(self) -> float:
        """Get the MSL altitude. Can only be used when the option to use the default cruise altitude is off."""
        return self._intf.get_property(ProcedureReferenceState._metadata, ProcedureReferenceState._get_msl_altitude_metadata)

    _set_msl_altitude_metadata = { "offset" : _set_msl_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @msl_altitude.setter
    def msl_altitude(self, value:float) -> None:
        """Set the MSLAltitude."""
        return self._intf.set_property(ProcedureReferenceState._metadata, ProcedureReferenceState._set_msl_altitude_metadata, value)

    _get_performance_mode_metadata = { "offset" : _get_performance_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ReferenceStatePerformanceMode),) }
    @property
    def performance_mode(self) -> "ReferenceStatePerformanceMode":
        """Get or set the type of motion the aircraft is engaged in."""
        return self._intf.get_property(ProcedureReferenceState._metadata, ProcedureReferenceState._get_performance_mode_metadata)

    _set_performance_mode_metadata = { "offset" : _set_performance_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ReferenceStatePerformanceMode),) }
    @performance_mode.setter
    def performance_mode(self, value:"ReferenceStatePerformanceMode") -> None:
        """Get or set the type of motion the aircraft is engaged in."""
        return self._intf.set_property(ProcedureReferenceState._metadata, ProcedureReferenceState._set_performance_mode_metadata, value)

    _get_reference_frame_metadata = { "offset" : _get_reference_frame_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverReferenceFrame),) }
    @property
    def reference_frame(self) -> "BasicManeuverReferenceFrame":
        """Get or set the reference frame the aircraft will use."""
        return self._intf.get_property(ProcedureReferenceState._metadata, ProcedureReferenceState._get_reference_frame_metadata)

    _set_reference_frame_metadata = { "offset" : _set_reference_frame_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(BasicManeuverReferenceFrame),) }
    @reference_frame.setter
    def reference_frame(self, value:"BasicManeuverReferenceFrame") -> None:
        """Get or set the reference frame the aircraft will use."""
        return self._intf.set_property(ProcedureReferenceState._metadata, ProcedureReferenceState._set_reference_frame_metadata, value)

    _get_fuel_flow_metadata = { "offset" : _get_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fuel_flow(self) -> float:
        """Get or set the rate of fuel consumption."""
        return self._intf.get_property(ProcedureReferenceState._metadata, ProcedureReferenceState._get_fuel_flow_metadata)

    _set_fuel_flow_metadata = { "offset" : _set_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fuel_flow.setter
    def fuel_flow(self, value:float) -> None:
        """Get or set the rate of fuel consumption."""
        return self._intf.set_property(ProcedureReferenceState._metadata, ProcedureReferenceState._set_fuel_flow_metadata, value)

    _get_mode_as_forward_flight_metadata = { "offset" : _get_mode_as_forward_flight_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_forward_flight(self) -> "ReferenceStateForwardFlightOptions":
        """Get the forward flight options."""
        return self._intf.get_property(ProcedureReferenceState._metadata, ProcedureReferenceState._get_mode_as_forward_flight_metadata)

    _get_mode_as_takeoff_landing_metadata = { "offset" : _get_mode_as_takeoff_landing_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_takeoff_landing(self) -> "ReferenceStateTakeoffLandingOptions":
        """Get the takeoff and landing options."""
        return self._intf.get_property(ProcedureReferenceState._metadata, ProcedureReferenceState._get_mode_as_takeoff_landing_metadata)

    _get_mode_as_hover_metadata = { "offset" : _get_mode_as_hover_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_hover(self) -> "ReferenceStateHoverOptions":
        """Get the hover options."""
        return self._intf.get_property(ProcedureReferenceState._metadata, ProcedureReferenceState._get_mode_as_hover_metadata)

    _get_mode_as_weight_on_wheels_metadata = { "offset" : _get_mode_as_weight_on_wheels_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_weight_on_wheels(self) -> "ReferenceStateWeightOnWheelsOptions":
        """Get the weight on wheels options."""
        return self._intf.get_property(ProcedureReferenceState._metadata, ProcedureReferenceState._get_mode_as_weight_on_wheels_metadata)

    _property_names[start_time] = "start_time"
    _property_names[latitude] = "latitude"
    _property_names[longitude] = "longitude"
    _property_names[use_default_cruise_altitude] = "use_default_cruise_altitude"
    _property_names[msl_altitude] = "msl_altitude"
    _property_names[performance_mode] = "performance_mode"
    _property_names[reference_frame] = "reference_frame"
    _property_names[fuel_flow] = "fuel_flow"
    _property_names[mode_as_forward_flight] = "mode_as_forward_flight"
    _property_names[mode_as_takeoff_landing] = "mode_as_takeoff_landing"
    _property_names[mode_as_hover] = "mode_as_hover"
    _property_names[mode_as_weight_on_wheels] = "mode_as_weight_on_wheels"

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

agcls.AgClassCatalog.add_catalog_entry((4812781112846854856, 13811130182470939556), ProcedureReferenceState)
agcls.AgTypeNameMap["ProcedureReferenceState"] = ProcedureReferenceState

class ProcedureSuperProcedure(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a super procedure."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_as_procedure_method_offset = 1
    _load_procedures_from_clipboard_method_offset = 2
    _load_procedures_from_file_method_offset = 3
    _metadata = {
        "iid_data" : (4976634188254865349, 4662999449300962743),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureSuperProcedure)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureSuperProcedure._metadata, ProcedureSuperProcedure._get_as_procedure_metadata, OutArg())

    _load_procedures_from_clipboard_metadata = { "offset" : _load_procedures_from_clipboard_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def load_procedures_from_clipboard(self) -> None:
        """Load procedures from the clipboard."""
        return self._intf.invoke(ProcedureSuperProcedure._metadata, ProcedureSuperProcedure._load_procedures_from_clipboard_metadata, )

    _load_procedures_from_file_metadata = { "offset" : _load_procedures_from_file_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def load_procedures_from_file(self, filepath:str) -> None:
        """Load procedures from a file."""
        return self._intf.invoke(ProcedureSuperProcedure._metadata, ProcedureSuperProcedure._load_procedures_from_file_metadata, filepath)


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

agcls.AgClassCatalog.add_catalog_entry((5251086126458868149, 1670994784482352541), ProcedureSuperProcedure)
agcls.AgTypeNameMap["ProcedureSuperProcedure"] = ProcedureSuperProcedure

class ProcedureLaunch(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a launch procedure."""

    _num_methods = 22
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_launch_time_method_offset = 1
    _set_launch_time_method_offset = 2
    _get_position_point_name_method_offset = 3
    _set_position_point_name_method_offset = 4
    _get_direction_vec_name_method_offset = 5
    _set_direction_vec_name_method_offset = 6
    _get_attitude_mode_method_offset = 7
    _set_attitude_mode_method_offset = 8
    _get_specify_launch_airspeed_method_offset = 9
    _set_specify_launch_airspeed_method_offset = 10
    _get_acceleration_g_method_offset = 11
    _set_acceleration_g_method_offset = 12
    _get_airspeed_type_method_offset = 13
    _get_airspeed_method_offset = 14
    _set_airspeed_method_offset = 15
    _get_fuel_flow_type_method_offset = 16
    _set_fuel_flow_type_method_offset = 17
    _get_override_fuel_flow_method_offset = 18
    _set_override_fuel_flow_method_offset = 19
    _get_as_procedure_method_offset = 20
    _get_true_course_hint_method_offset = 21
    _set_true_course_hint_method_offset = 22
    _metadata = {
        "iid_data" : (4997115185128623189, 1319403736513253293),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureLaunch)

    _get_launch_time_metadata = { "offset" : _get_launch_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def launch_time(self) -> typing.Any:
        """Get or set the launch time of the aircraft."""
        return self._intf.get_property(ProcedureLaunch._metadata, ProcedureLaunch._get_launch_time_metadata)

    _set_launch_time_metadata = { "offset" : _set_launch_time_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @launch_time.setter
    def launch_time(self, value:typing.Any) -> None:
        """Get or set the launch time of the aircraft."""
        return self._intf.set_property(ProcedureLaunch._metadata, ProcedureLaunch._set_launch_time_metadata, value)

    _get_position_point_name_metadata = { "offset" : _get_position_point_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def position_point_name(self) -> str:
        """Get or set the name of the point used for the launch position."""
        return self._intf.get_property(ProcedureLaunch._metadata, ProcedureLaunch._get_position_point_name_metadata)

    _set_position_point_name_metadata = { "offset" : _set_position_point_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @position_point_name.setter
    def position_point_name(self, value:str) -> None:
        """Get or set the name of the point used for the launch position."""
        return self._intf.set_property(ProcedureLaunch._metadata, ProcedureLaunch._set_position_point_name_metadata, value)

    _get_direction_vec_name_metadata = { "offset" : _get_direction_vec_name_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def direction_vec_name(self) -> str:
        """Get or set the name of the vector used for the launch direction."""
        return self._intf.get_property(ProcedureLaunch._metadata, ProcedureLaunch._get_direction_vec_name_metadata)

    _set_direction_vec_name_metadata = { "offset" : _set_direction_vec_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @direction_vec_name.setter
    def direction_vec_name(self, value:str) -> None:
        """Get or set the name of the vector used for the launch direction."""
        return self._intf.set_property(ProcedureLaunch._metadata, ProcedureLaunch._set_direction_vec_name_metadata, value)

    _get_attitude_mode_metadata = { "offset" : _get_attitude_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(LaunchAttitudeMode),) }
    @property
    def attitude_mode(self) -> "LaunchAttitudeMode":
        """Get or set the attitude mode during the launch."""
        return self._intf.get_property(ProcedureLaunch._metadata, ProcedureLaunch._get_attitude_mode_metadata)

    _set_attitude_mode_metadata = { "offset" : _set_attitude_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(LaunchAttitudeMode),) }
    @attitude_mode.setter
    def attitude_mode(self, value:"LaunchAttitudeMode") -> None:
        """Get or set the attitude mode during the launch."""
        return self._intf.set_property(ProcedureLaunch._metadata, ProcedureLaunch._set_attitude_mode_metadata, value)

    _get_specify_launch_airspeed_metadata = { "offset" : _get_specify_launch_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def specify_launch_airspeed(self) -> bool:
        """Opt to specify a minimum launch speed the aircraft will accelerate to."""
        return self._intf.get_property(ProcedureLaunch._metadata, ProcedureLaunch._get_specify_launch_airspeed_metadata)

    _set_specify_launch_airspeed_metadata = { "offset" : _set_specify_launch_airspeed_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @specify_launch_airspeed.setter
    def specify_launch_airspeed(self, value:bool) -> None:
        """Opt to specify a minimum launch speed the aircraft will accelerate to."""
        return self._intf.set_property(ProcedureLaunch._metadata, ProcedureLaunch._set_specify_launch_airspeed_metadata, value)

    _get_acceleration_g_metadata = { "offset" : _get_acceleration_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def acceleration_g(self) -> float:
        """Get or set the acceleration of the aircraft during the launch."""
        return self._intf.get_property(ProcedureLaunch._metadata, ProcedureLaunch._get_acceleration_g_metadata)

    _set_acceleration_g_metadata = { "offset" : _set_acceleration_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @acceleration_g.setter
    def acceleration_g(self, value:float) -> None:
        """Get or set the acceleration of the aircraft during the launch."""
        return self._intf.set_property(ProcedureLaunch._metadata, ProcedureLaunch._set_acceleration_g_metadata, value)

    _get_airspeed_type_metadata = { "offset" : _get_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type."""
        return self._intf.get_property(ProcedureLaunch._metadata, ProcedureLaunch._get_airspeed_type_metadata)

    _get_airspeed_metadata = { "offset" : _get_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def airspeed(self) -> float:
        """Get the goal airspeed for the launch."""
        return self._intf.get_property(ProcedureLaunch._metadata, ProcedureLaunch._get_airspeed_metadata)

    _set_airspeed_metadata = { "offset" : _set_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the launch airspeed."""
        return self._intf.invoke(ProcedureLaunch._metadata, ProcedureLaunch._set_airspeed_metadata, airspeed_type, airspeed)

    _get_fuel_flow_type_metadata = { "offset" : _get_fuel_flow_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(FuelFlowType),) }
    @property
    def fuel_flow_type(self) -> "FuelFlowType":
        """Get or set the fuel flow type of the aircraft during the launch."""
        return self._intf.get_property(ProcedureLaunch._metadata, ProcedureLaunch._get_fuel_flow_type_metadata)

    _set_fuel_flow_type_metadata = { "offset" : _set_fuel_flow_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(FuelFlowType),) }
    @fuel_flow_type.setter
    def fuel_flow_type(self, value:"FuelFlowType") -> None:
        """Get or set the fuel flow type of the aircraft during the launch."""
        return self._intf.set_property(ProcedureLaunch._metadata, ProcedureLaunch._set_fuel_flow_type_metadata, value)

    _get_override_fuel_flow_metadata = { "offset" : _get_override_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def override_fuel_flow(self) -> float:
        """Get or set the fuel flow value for a fuel flow type set to Override."""
        return self._intf.get_property(ProcedureLaunch._metadata, ProcedureLaunch._get_override_fuel_flow_metadata)

    _set_override_fuel_flow_metadata = { "offset" : _set_override_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @override_fuel_flow.setter
    def override_fuel_flow(self, value:float) -> None:
        """Get or set the fuel flow value for a fuel flow type set to Override."""
        return self._intf.set_property(ProcedureLaunch._metadata, ProcedureLaunch._set_override_fuel_flow_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureLaunch._metadata, ProcedureLaunch._get_as_procedure_metadata, OutArg())

    _get_true_course_hint_metadata = { "offset" : _get_true_course_hint_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def true_course_hint(self) -> typing.Any:
        """Get or set the true course used when the vehicle's direction vector is set to Zenith."""
        return self._intf.get_property(ProcedureLaunch._metadata, ProcedureLaunch._get_true_course_hint_metadata)

    _set_true_course_hint_metadata = { "offset" : _set_true_course_hint_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @true_course_hint.setter
    def true_course_hint(self, value:typing.Any) -> None:
        """Get or set the true course used when the vehicle's direction vector is set to Zenith."""
        return self._intf.set_property(ProcedureLaunch._metadata, ProcedureLaunch._set_true_course_hint_metadata, value)

    _property_names[launch_time] = "launch_time"
    _property_names[position_point_name] = "position_point_name"
    _property_names[direction_vec_name] = "direction_vec_name"
    _property_names[attitude_mode] = "attitude_mode"
    _property_names[specify_launch_airspeed] = "specify_launch_airspeed"
    _property_names[acceleration_g] = "acceleration_g"
    _property_names[airspeed_type] = "airspeed_type"
    _property_names[airspeed] = "airspeed"
    _property_names[fuel_flow_type] = "fuel_flow_type"
    _property_names[override_fuel_flow] = "override_fuel_flow"
    _property_names[true_course_hint] = "true_course_hint"

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

agcls.AgClassCatalog.add_catalog_entry((4915172643493226120, 10856906451169746841), ProcedureLaunch)
agcls.AgTypeNameMap["ProcedureLaunch"] = ProcedureLaunch

class ProcedureAirway(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for an Airway procedure."""

    _num_methods = 18
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_as_procedure_method_offset = 1
    _get_altitude_options_method_offset = 2
    _get_enroute_options_method_offset = 3
    _get_enroute_cruise_airspeed_options_method_offset = 4
    _get_router_method_offset = 5
    _set_router_method_offset = 6
    _get_airway_id_method_offset = 7
    _set_airway_id_method_offset = 8
    _get_airway_names_method_offset = 9
    _get_sequence_method_offset = 10
    _set_sequence_method_offset = 11
    _get_sequences_method_offset = 12
    _get_entry_id_method_offset = 13
    _set_entry_id_method_offset = 14
    _get_exit_id_method_offset = 15
    _set_exit_id_method_offset = 16
    _get_waypoints_method_offset = 17
    _copy_procedures_method_offset = 18
    _metadata = {
        "iid_data" : (5113338053800770439, 8104523135851895734),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureAirway)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureAirway._metadata, ProcedureAirway._get_as_procedure_metadata, OutArg())

    _get_altitude_options_metadata = { "offset" : _get_altitude_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def altitude_options(self) -> "AltitudeMSLOptions":
        """Get the altitude options."""
        return self._intf.get_property(ProcedureAirway._metadata, ProcedureAirway._get_altitude_options_metadata)

    _get_enroute_options_metadata = { "offset" : _get_enroute_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_options(self) -> "EnrouteOptions":
        """Get the enroute options."""
        return self._intf.get_property(ProcedureAirway._metadata, ProcedureAirway._get_enroute_options_metadata)

    _get_enroute_cruise_airspeed_options_metadata = { "offset" : _get_enroute_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the enroute cruise airspeed options."""
        return self._intf.get_property(ProcedureAirway._metadata, ProcedureAirway._get_enroute_cruise_airspeed_options_metadata)

    _get_router_metadata = { "offset" : _get_router_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def router(self) -> str:
        """Get or set the router used to provide available airways."""
        return self._intf.get_property(ProcedureAirway._metadata, ProcedureAirway._get_router_metadata)

    _set_router_metadata = { "offset" : _set_router_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @router.setter
    def router(self, value:str) -> None:
        """Get or set the router used to provide available airways."""
        return self._intf.set_property(ProcedureAirway._metadata, ProcedureAirway._set_router_metadata, value)

    _get_airway_id_metadata = { "offset" : _get_airway_id_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def airway_id(self) -> str:
        """Get or set the airway ID."""
        return self._intf.get_property(ProcedureAirway._metadata, ProcedureAirway._get_airway_id_metadata)

    _set_airway_id_metadata = { "offset" : _set_airway_id_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @airway_id.setter
    def airway_id(self, value:str) -> None:
        """Get or set the airway ID."""
        return self._intf.set_property(ProcedureAirway._metadata, ProcedureAirway._set_airway_id_metadata, value)

    _get_airway_names_metadata = { "offset" : _get_airway_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    def get_airway_names(self) -> list:
        """Get the a list of names of the available airways."""
        return self._intf.invoke(ProcedureAirway._metadata, ProcedureAirway._get_airway_names_metadata, OutArg())

    _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 direction the aircraft will fly the route."""
        return self._intf.get_property(ProcedureAirway._metadata, ProcedureAirway._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:
        """Get or set the direction the aircraft will fly the route."""
        return self._intf.set_property(ProcedureAirway._metadata, ProcedureAirway._set_sequence_metadata, value)

    _get_sequences_metadata = { "offset" : _get_sequences_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    def get_sequences(self) -> list:
        """Get a list of sequence options."""
        return self._intf.invoke(ProcedureAirway._metadata, ProcedureAirway._get_sequences_metadata, OutArg())

    _get_entry_id_metadata = { "offset" : _get_entry_id_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def entry_id(self) -> str:
        """Get or set the ID of the entry waypoint."""
        return self._intf.get_property(ProcedureAirway._metadata, ProcedureAirway._get_entry_id_metadata)

    _set_entry_id_metadata = { "offset" : _set_entry_id_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @entry_id.setter
    def entry_id(self, value:str) -> None:
        """Get or set the ID of the entry waypoint."""
        return self._intf.set_property(ProcedureAirway._metadata, ProcedureAirway._set_entry_id_metadata, value)

    _get_exit_id_metadata = { "offset" : _get_exit_id_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def exit_id(self) -> str:
        """Get or set the ID of the exit waypoint."""
        return self._intf.get_property(ProcedureAirway._metadata, ProcedureAirway._get_exit_id_metadata)

    _set_exit_id_metadata = { "offset" : _set_exit_id_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @exit_id.setter
    def exit_id(self, value:str) -> None:
        """Get or set the ID of the exit waypoint."""
        return self._intf.set_property(ProcedureAirway._metadata, ProcedureAirway._set_exit_id_metadata, value)

    _get_waypoints_metadata = { "offset" : _get_waypoints_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    def get_waypoints(self) -> list:
        """Get a list of available waypoints for the airway."""
        return self._intf.invoke(ProcedureAirway._metadata, ProcedureAirway._get_waypoints_metadata, OutArg())

    _copy_procedures_metadata = { "offset" : _copy_procedures_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def copy_procedures(self) -> None:
        """Copy the airway route as a set of procedures to the clipboard."""
        return self._intf.invoke(ProcedureAirway._metadata, ProcedureAirway._copy_procedures_metadata, )

    _property_names[altitude_options] = "altitude_options"
    _property_names[enroute_options] = "enroute_options"
    _property_names[enroute_cruise_airspeed_options] = "enroute_cruise_airspeed_options"
    _property_names[router] = "router"
    _property_names[airway_id] = "airway_id"
    _property_names[sequence] = "sequence"
    _property_names[entry_id] = "entry_id"
    _property_names[exit_id] = "exit_id"

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

agcls.AgClassCatalog.add_catalog_entry((5692509012567053828, 17361800954042551713), ProcedureAirway)
agcls.AgTypeNameMap["ProcedureAirway"] = ProcedureAirway

class ProcedureAirwayRouter(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for an Airway Router procedure."""

    _num_methods = 19
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_as_procedure_method_offset = 1
    _get_altitude_options_method_offset = 2
    _get_enroute_options_method_offset = 3
    _get_enroute_cruise_airspeed_options_method_offset = 4
    _get_router_method_offset = 5
    _get_optimize_for_wind_method_offset = 6
    _set_optimize_for_wind_method_offset = 7
    _get_bounding_box_pad_method_offset = 8
    _set_bounding_box_pad_method_offset = 9
    _get_max_waypoint_range_method_offset = 10
    _set_max_waypoint_range_method_offset = 11
    _get_entry_exit_and_or_method_offset = 12
    _set_entry_exit_and_or_method_offset = 13
    _get_max_waypoint_count_method_offset = 14
    _set_max_waypoint_count_method_offset = 15
    _update_route_method_offset = 16
    _get_waypoints_method_offset = 17
    _get_segments_method_offset = 18
    _copy_procedures_method_offset = 19
    _metadata = {
        "iid_data" : (5008084498985926846, 600814285428910999),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureAirwayRouter)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._get_as_procedure_metadata, OutArg())

    _get_altitude_options_metadata = { "offset" : _get_altitude_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def altitude_options(self) -> "AltitudeMSLOptions":
        """Get the altitude options."""
        return self._intf.get_property(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._get_altitude_options_metadata)

    _get_enroute_options_metadata = { "offset" : _get_enroute_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_options(self) -> "EnrouteOptions":
        """Get the enroute options."""
        return self._intf.get_property(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._get_enroute_options_metadata)

    _get_enroute_cruise_airspeed_options_metadata = { "offset" : _get_enroute_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the enroute cruise airspeed options."""
        return self._intf.get_property(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._get_enroute_cruise_airspeed_options_metadata)

    _get_router_metadata = { "offset" : _get_router_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def router(self) -> str:
        """Get or set the router used to provide available airways."""
        return self._intf.get_property(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._get_router_metadata)

    _get_optimize_for_wind_metadata = { "offset" : _get_optimize_for_wind_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def optimize_for_wind(self) -> bool:
        """Opt to account for the wind when calculating the most efficient route."""
        return self._intf.get_property(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._get_optimize_for_wind_metadata)

    _set_optimize_for_wind_metadata = { "offset" : _set_optimize_for_wind_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @optimize_for_wind.setter
    def optimize_for_wind(self, value:bool) -> None:
        """Opt to account for the wind when calculating the most efficient route."""
        return self._intf.set_property(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._set_optimize_for_wind_metadata, value)

    _get_bounding_box_pad_metadata = { "offset" : _get_bounding_box_pad_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def bounding_box_pad(self) -> float:
        """Get or set the maximum distance beyond the bounding box that a waypoint will be considered for the final route."""
        return self._intf.get_property(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._get_bounding_box_pad_metadata)

    _set_bounding_box_pad_metadata = { "offset" : _set_bounding_box_pad_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @bounding_box_pad.setter
    def bounding_box_pad(self, value:float) -> None:
        """Get or set the maximum distance beyond the bounding box that a waypoint will be considered for the final route."""
        return self._intf.set_property(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._set_bounding_box_pad_metadata, value)

    _get_max_waypoint_range_metadata = { "offset" : _get_max_waypoint_range_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_waypoint_range(self) -> float:
        """Get or set the maximum distance from the end of the previous procedure that an airway waypoint will be considered."""
        return self._intf.get_property(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._get_max_waypoint_range_metadata)

    _set_max_waypoint_range_metadata = { "offset" : _set_max_waypoint_range_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_waypoint_range.setter
    def max_waypoint_range(self, value:float) -> None:
        """Get or set the maximum distance from the end of the previous procedure that an airway waypoint will be considered."""
        return self._intf.set_property(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._set_max_waypoint_range_metadata, value)

    _get_entry_exit_and_or_metadata = { "offset" : _get_entry_exit_and_or_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AndOr),) }
    @property
    def entry_exit_and_or(self) -> "AndOr":
        """Define how the two Entry/Exit Waypoint constraints will be considered."""
        return self._intf.get_property(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._get_entry_exit_and_or_metadata)

    _set_entry_exit_and_or_metadata = { "offset" : _set_entry_exit_and_or_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AndOr),) }
    @entry_exit_and_or.setter
    def entry_exit_and_or(self, value:"AndOr") -> None:
        """Define how the two Entry/Exit Waypoint constraints will be considered."""
        return self._intf.set_property(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._set_entry_exit_and_or_metadata, value)

    _get_max_waypoint_count_metadata = { "offset" : _get_max_waypoint_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def max_waypoint_count(self) -> int:
        """Get or set the maximum number of airway waypoints that the procedure will consider for each segment."""
        return self._intf.get_property(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._get_max_waypoint_count_metadata)

    _set_max_waypoint_count_metadata = { "offset" : _set_max_waypoint_count_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @max_waypoint_count.setter
    def max_waypoint_count(self, value:int) -> None:
        """Get or set the maximum number of airway waypoints that the procedure will consider for each segment."""
        return self._intf.set_property(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._set_max_waypoint_count_metadata, value)

    _update_route_metadata = { "offset" : _update_route_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def update_route(self) -> None:
        """Recalculate the route."""
        return self._intf.invoke(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._update_route_metadata, )

    _get_waypoints_metadata = { "offset" : _get_waypoints_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    def get_waypoints(self) -> list:
        """Get a list of the current route's waypoints."""
        return self._intf.invoke(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._get_waypoints_metadata, OutArg())

    _get_segments_metadata = { "offset" : _get_segments_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    def get_segments(self) -> list:
        """Get a list of the current route's individual procedures."""
        return self._intf.invoke(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._get_segments_metadata, OutArg())

    _copy_procedures_metadata = { "offset" : _copy_procedures_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def copy_procedures(self) -> None:
        """Copy the route as a set of procedures to the clipboard."""
        return self._intf.invoke(ProcedureAirwayRouter._metadata, ProcedureAirwayRouter._copy_procedures_metadata, )

    _property_names[altitude_options] = "altitude_options"
    _property_names[enroute_options] = "enroute_options"
    _property_names[enroute_cruise_airspeed_options] = "enroute_cruise_airspeed_options"
    _property_names[router] = "router"
    _property_names[optimize_for_wind] = "optimize_for_wind"
    _property_names[bounding_box_pad] = "bounding_box_pad"
    _property_names[max_waypoint_range] = "max_waypoint_range"
    _property_names[entry_exit_and_or] = "entry_exit_and_or"
    _property_names[max_waypoint_count] = "max_waypoint_count"

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

agcls.AgClassCatalog.add_catalog_entry((4819096666789441106, 4134135321931006376), ProcedureAirwayRouter)
agcls.AgTypeNameMap["ProcedureAirwayRouter"] = ProcedureAirwayRouter

class ProcedureAreaTargetSearch(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for an Area Target Search procedure."""

    _num_methods = 21
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_as_procedure_method_offset = 1
    _get_altitude_options_method_offset = 2
    _get_enroute_options_method_offset = 3
    _get_enroute_cruise_airspeed_options_method_offset = 4
    _get_procedure_type_method_offset = 5
    _set_procedure_type_method_offset = 6
    _get_max_separation_method_offset = 7
    _set_max_separation_method_offset = 8
    _get_course_mode_method_offset = 9
    _set_course_mode_method_offset = 10
    _get_first_leg_retrograde_method_offset = 11
    _set_first_leg_retrograde_method_offset = 12
    _get_centroid_true_course_method_offset = 13
    _set_centroid_true_course_method_offset = 14
    _get_fly_cruise_airspeed_profile_method_offset = 15
    _set_fly_cruise_airspeed_profile_method_offset = 16
    _get_must_level_off_method_offset = 17
    _set_must_level_off_method_offset = 18
    _get_level_off_mode_method_offset = 19
    _set_level_off_mode_method_offset = 20
    _copy_procedures_method_offset = 21
    _metadata = {
        "iid_data" : (5304016268201673934, 12422724768842932378),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureAreaTargetSearch)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._get_as_procedure_metadata, OutArg())

    _get_altitude_options_metadata = { "offset" : _get_altitude_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def altitude_options(self) -> "AltitudeOptions":
        """Get the altitude options."""
        return self._intf.get_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._get_altitude_options_metadata)

    _get_enroute_options_metadata = { "offset" : _get_enroute_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_options(self) -> "EnrouteOptions":
        """Get the enroute options."""
        return self._intf.get_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._get_enroute_options_metadata)

    _get_enroute_cruise_airspeed_options_metadata = { "offset" : _get_enroute_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the enroute cruise airspeed options."""
        return self._intf.get_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._get_enroute_cruise_airspeed_options_metadata)

    _get_procedure_type_metadata = { "offset" : _get_procedure_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(FlightLineProcedureType),) }
    @property
    def procedure_type(self) -> "FlightLineProcedureType":
        """Get or set the procedure methodology used to calculate the flight line."""
        return self._intf.get_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._get_procedure_type_metadata)

    _set_procedure_type_metadata = { "offset" : _set_procedure_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(FlightLineProcedureType),) }
    @procedure_type.setter
    def procedure_type(self, value:"FlightLineProcedureType") -> None:
        """Get or set the procedure methodology used to calculate the flight line."""
        return self._intf.set_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._set_procedure_type_metadata, value)

    _get_max_separation_metadata = { "offset" : _get_max_separation_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_separation(self) -> float:
        """Get or set the maximum distance between the parallel flight lines of the search pattern."""
        return self._intf.get_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._get_max_separation_metadata)

    _set_max_separation_metadata = { "offset" : _set_max_separation_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_separation.setter
    def max_separation(self, value:float) -> None:
        """Get or set the maximum distance between the parallel flight lines of the search pattern."""
        return self._intf.set_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._set_max_separation_metadata, value)

    _get_course_mode_metadata = { "offset" : _get_course_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(SearchPatternCourseMode),) }
    @property
    def course_mode(self) -> "SearchPatternCourseMode":
        """Get or set the mode to determine the course of the search pattern."""
        return self._intf.get_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._get_course_mode_metadata)

    _set_course_mode_metadata = { "offset" : _set_course_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(SearchPatternCourseMode),) }
    @course_mode.setter
    def course_mode(self, value:"SearchPatternCourseMode") -> None:
        """Get or set the mode to determine the course of the search pattern."""
        return self._intf.set_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._set_course_mode_metadata, value)

    _get_first_leg_retrograde_metadata = { "offset" : _get_first_leg_retrograde_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def first_leg_retrograde(self) -> bool:
        """Get or set the option to fly the first leg of the search pattern on the reverse heading."""
        return self._intf.get_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._get_first_leg_retrograde_metadata)

    _set_first_leg_retrograde_metadata = { "offset" : _set_first_leg_retrograde_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @first_leg_retrograde.setter
    def first_leg_retrograde(self, value:bool) -> None:
        """Get or set the option to fly the first leg of the search pattern on the reverse heading."""
        return self._intf.set_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._set_first_leg_retrograde_metadata, value)

    _get_centroid_true_course_metadata = { "offset" : _get_centroid_true_course_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def centroid_true_course(self) -> typing.Any:
        """Get or set the specific course of the search pattern."""
        return self._intf.get_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._get_centroid_true_course_metadata)

    _set_centroid_true_course_metadata = { "offset" : _set_centroid_true_course_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @centroid_true_course.setter
    def centroid_true_course(self, value:typing.Any) -> None:
        """Get or set the specific course of the search pattern."""
        return self._intf.set_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._set_centroid_true_course_metadata, value)

    _get_fly_cruise_airspeed_profile_metadata = { "offset" : _get_fly_cruise_airspeed_profile_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def fly_cruise_airspeed_profile(self) -> bool:
        """Opt whether the aircraft immediately adopts the selected cruise airspeed or gradually begins accelerating/decelerating in the previous procedure."""
        return self._intf.get_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._get_fly_cruise_airspeed_profile_metadata)

    _set_fly_cruise_airspeed_profile_metadata = { "offset" : _set_fly_cruise_airspeed_profile_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @fly_cruise_airspeed_profile.setter
    def fly_cruise_airspeed_profile(self, value:bool) -> None:
        """Opt whether the aircraft immediately adopts the selected cruise airspeed or gradually begins accelerating/decelerating in the previous procedure."""
        return self._intf.set_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._set_fly_cruise_airspeed_profile_metadata, value)

    _get_must_level_off_metadata = { "offset" : _get_must_level_off_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def must_level_off(self) -> bool:
        """Opt whether the procedure must level off."""
        return self._intf.get_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._get_must_level_off_metadata)

    _set_must_level_off_metadata = { "offset" : _set_must_level_off_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @must_level_off.setter
    def must_level_off(self, value:bool) -> None:
        """Opt whether the procedure must level off."""
        return self._intf.set_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._set_must_level_off_metadata, value)

    _get_level_off_mode_metadata = { "offset" : _get_level_off_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AltitudeConstraintManeuverMode),) }
    @property
    def level_off_mode(self) -> "AltitudeConstraintManeuverMode":
        """Get or set the level off mode. This is only used when the must level off option is on."""
        return self._intf.get_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._get_level_off_mode_metadata)

    _set_level_off_mode_metadata = { "offset" : _set_level_off_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AltitudeConstraintManeuverMode),) }
    @level_off_mode.setter
    def level_off_mode(self, value:"AltitudeConstraintManeuverMode") -> None:
        """Get or set the level off mode. This is only used when the must level off option is on."""
        return self._intf.set_property(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._set_level_off_mode_metadata, value)

    _copy_procedures_metadata = { "offset" : _copy_procedures_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def copy_procedures(self) -> None:
        """Copy the search pattern maneuvers as a set of procedures to the clipboard."""
        return self._intf.invoke(ProcedureAreaTargetSearch._metadata, ProcedureAreaTargetSearch._copy_procedures_metadata, )

    _property_names[altitude_options] = "altitude_options"
    _property_names[enroute_options] = "enroute_options"
    _property_names[enroute_cruise_airspeed_options] = "enroute_cruise_airspeed_options"
    _property_names[procedure_type] = "procedure_type"
    _property_names[max_separation] = "max_separation"
    _property_names[course_mode] = "course_mode"
    _property_names[first_leg_retrograde] = "first_leg_retrograde"
    _property_names[centroid_true_course] = "centroid_true_course"
    _property_names[fly_cruise_airspeed_profile] = "fly_cruise_airspeed_profile"
    _property_names[must_level_off] = "must_level_off"
    _property_names[level_off_mode] = "level_off_mode"

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

agcls.AgClassCatalog.add_catalog_entry((5703169694398522635, 8200198528211558019), ProcedureAreaTargetSearch)
agcls.AgTypeNameMap["ProcedureAreaTargetSearch"] = ProcedureAreaTargetSearch

class ProcedureFormationRecover(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a Formation Recover procedure."""

    _num_methods = 38
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_as_procedure_method_offset = 1
    _get_enroute_options_method_offset = 2
    _get_delay_cruise_airspeed_options_method_offset = 3
    _get_minimum_time_method_offset = 4
    _get_start_time_method_offset = 5
    _set_start_time_method_offset = 6
    _find_first_valid_start_time_method_offset = 7
    _get_maximum_time_method_offset = 8
    _get_formation_point_method_offset = 9
    _set_formation_point_method_offset = 10
    _get_interpolate_point_position_velocity_method_offset = 11
    _set_interpolate_point_position_velocity_method_offset = 12
    _get_altitude_offset_method_offset = 13
    _set_altitude_offset_method_offset = 14
    _get_fuel_flow_type_method_offset = 15
    _set_fuel_flow_type_method_offset = 16
    _get_override_fuel_flow_value_method_offset = 17
    _set_override_fuel_flow_value_method_offset = 18
    _get_consider_acceleration_for_fuel_flow_method_offset = 19
    _set_consider_acceleration_for_fuel_flow_method_offset = 20
    _get_first_pause_method_offset = 21
    _set_first_pause_method_offset = 22
    _get_transition_time_method_offset = 23
    _set_transition_time_method_offset = 24
    _get_second_pause_method_offset = 25
    _set_second_pause_method_offset = 26
    _get_display_step_time_method_offset = 27
    _set_display_step_time_method_offset = 28
    _get_flight_mode_method_offset = 29
    _set_flight_mode_method_offset = 30
    _get_flight_path_angle_method_offset = 31
    _set_flight_path_angle_method_offset = 32
    _get_radius_factor_method_offset = 33
    _set_radius_factor_method_offset = 34
    _get_use_delay_method_offset = 35
    _set_use_delay_method_offset = 36
    _get_delay_turn_direction_method_offset = 37
    _set_delay_turn_direction_method_offset = 38
    _metadata = {
        "iid_data" : (4870593204797535676, 9491535379450674305),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureFormationRecover)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_as_procedure_metadata, OutArg())

    _get_enroute_options_metadata = { "offset" : _get_enroute_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_options(self) -> "EnrouteOptions":
        """Get the enroute options."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_enroute_options_metadata)

    _get_delay_cruise_airspeed_options_metadata = { "offset" : _get_delay_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def delay_cruise_airspeed_options(self) -> "CruiseAirspeedOptions":
        """Get the delay cruise airspeed options."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_delay_cruise_airspeed_options_metadata)

    _get_minimum_time_metadata = { "offset" : _get_minimum_time_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.VariantArg,) }
    def get_minimum_time(self, consider_prev_proc:bool) -> typing.Any:
        """Get the minimum time at which formation might be possible. Opt whether to consider previous procedure(s) for the minimum time."""
        return self._intf.invoke(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_minimum_time_metadata, consider_prev_proc, OutArg())

    _get_start_time_metadata = { "offset" : _get_start_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def start_time(self) -> typing.Any:
        """Get or set the time at which the formation begins."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_start_time_metadata)

    _set_start_time_metadata = { "offset" : _set_start_time_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @start_time.setter
    def start_time(self, value:typing.Any) -> None:
        """Get or set the time at which the formation begins."""
        return self._intf.set_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._set_start_time_metadata, value)

    _find_first_valid_start_time_metadata = { "offset" : _find_first_valid_start_time_method_offset,
            "arg_types" : (agcom.Variant, agcom.Variant, agcom.DOUBLE, POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg, agmarshall.VariantArg, agmarshall.DoubleArg, agmarshall.VariantArg,) }
    def find_first_valid_start_time(self, min_time:typing.Any, max_time:typing.Any, step_time:float) -> typing.Any:
        """Have Aviator calculate the earliest valid formation time."""
        return self._intf.invoke(ProcedureFormationRecover._metadata, ProcedureFormationRecover._find_first_valid_start_time_metadata, min_time, max_time, step_time, OutArg())

    _get_maximum_time_metadata = { "offset" : _get_maximum_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def maximum_time(self) -> typing.Any:
        """Get the maximum time at which formation might be possible."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_maximum_time_metadata)

    _get_formation_point_metadata = { "offset" : _get_formation_point_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def formation_point(self) -> str:
        """Get or set the position that the aircraft will be locked onto while in formation."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_formation_point_metadata)

    _set_formation_point_metadata = { "offset" : _set_formation_point_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @formation_point.setter
    def formation_point(self, value:str) -> None:
        """Get or set the position that the aircraft will be locked onto while in formation."""
        return self._intf.set_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._set_formation_point_metadata, value)

    _get_interpolate_point_position_velocity_metadata = { "offset" : _get_interpolate_point_position_velocity_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def interpolate_point_position_velocity(self) -> bool:
        """Get or set the option to use interpolation to determine the formation point's speed and position."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_interpolate_point_position_velocity_metadata)

    _set_interpolate_point_position_velocity_metadata = { "offset" : _set_interpolate_point_position_velocity_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @interpolate_point_position_velocity.setter
    def interpolate_point_position_velocity(self, value:bool) -> None:
        """Get or set the option to use interpolation to determine the formation point's speed and position."""
        return self._intf.set_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._set_interpolate_point_position_velocity_metadata, value)

    _get_altitude_offset_metadata = { "offset" : _get_altitude_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def altitude_offset(self) -> float:
        """Get or set the altitude distance between the aircraft and the formation point during the first or second pause."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_altitude_offset_metadata)

    _set_altitude_offset_metadata = { "offset" : _set_altitude_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @altitude_offset.setter
    def altitude_offset(self, value:float) -> None:
        """Get or set the altitude distance between the aircraft and the formation point during the first or second pause."""
        return self._intf.set_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._set_altitude_offset_metadata, value)

    _get_fuel_flow_type_metadata = { "offset" : _get_fuel_flow_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(FuelFlowType),) }
    @property
    def fuel_flow_type(self) -> "FuelFlowType":
        """Get or set the source used to calculate the fuel flow for the maneuver."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_fuel_flow_type_metadata)

    _set_fuel_flow_type_metadata = { "offset" : _set_fuel_flow_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(FuelFlowType),) }
    @fuel_flow_type.setter
    def fuel_flow_type(self, value:"FuelFlowType") -> None:
        """Get or set the source used to calculate the fuel flow for the maneuver."""
        return self._intf.set_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._set_fuel_flow_type_metadata, value)

    _get_override_fuel_flow_value_metadata = { "offset" : _get_override_fuel_flow_value_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def override_fuel_flow_value(self) -> float:
        """Get or set the value used for the Override Fuel Flow type. The fuel flow type must be set to Override to access this value."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_override_fuel_flow_value_metadata)

    _set_override_fuel_flow_value_metadata = { "offset" : _set_override_fuel_flow_value_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @override_fuel_flow_value.setter
    def override_fuel_flow_value(self, value:float) -> None:
        """Get or set the value used for the Override Fuel Flow type. The fuel flow type must be set to Override to access this value."""
        return self._intf.set_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._set_override_fuel_flow_value_metadata, value)

    _get_consider_acceleration_for_fuel_flow_metadata = { "offset" : _get_consider_acceleration_for_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def consider_acceleration_for_fuel_flow(self) -> bool:
        """Get or set the option to calculate the fuel flow rate according to the acceleration of the aircraft."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_consider_acceleration_for_fuel_flow_metadata)

    _set_consider_acceleration_for_fuel_flow_metadata = { "offset" : _set_consider_acceleration_for_fuel_flow_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @consider_acceleration_for_fuel_flow.setter
    def consider_acceleration_for_fuel_flow(self, value:bool) -> None:
        """Get or set the option to calculate the fuel flow rate according to the acceleration of the aircraft."""
        return self._intf.set_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._set_consider_acceleration_for_fuel_flow_metadata, value)

    _get_first_pause_metadata = { "offset" : _get_first_pause_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def first_pause(self) -> typing.Any:
        """Get or set the amount of time that the aircraft will pause at the specified altitude offset."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_first_pause_metadata)

    _set_first_pause_metadata = { "offset" : _set_first_pause_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @first_pause.setter
    def first_pause(self, value:typing.Any) -> None:
        """Get or set the amount of time that the aircraft will pause at the specified altitude offset."""
        return self._intf.set_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._set_first_pause_metadata, value)

    _get_transition_time_metadata = { "offset" : _get_transition_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def transition_time(self) -> float:
        """Get or set the amount of time that the aircraft will spend transitioning from the specified altitude offset to a zero altitude offset."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_transition_time_metadata)

    _set_transition_time_metadata = { "offset" : _set_transition_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @transition_time.setter
    def transition_time(self, value:float) -> None:
        """Get or set the amount of time that the aircraft will spend transitioning from the specified altitude offset to a zero altitude offset."""
        return self._intf.set_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._set_transition_time_metadata, value)

    _get_second_pause_metadata = { "offset" : _get_second_pause_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def second_pause(self) -> typing.Any:
        """Get or set the amount of time that the aircraft will pause at a zero altitude offset."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_second_pause_metadata)

    _set_second_pause_metadata = { "offset" : _set_second_pause_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @second_pause.setter
    def second_pause(self, value:typing.Any) -> None:
        """Get or set the amount of time that the aircraft will pause at a zero altitude offset."""
        return self._intf.set_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._set_second_pause_metadata, value)

    _get_display_step_time_metadata = { "offset" : _get_display_step_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def display_step_time(self) -> float:
        """Get or set the time interval at which ephemeris is generated for display purposes."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_display_step_time_metadata)

    _set_display_step_time_metadata = { "offset" : _set_display_step_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @display_step_time.setter
    def display_step_time(self, value:float) -> None:
        """Get or set the time interval at which ephemeris is generated for display purposes."""
        return self._intf.set_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._set_display_step_time_metadata, value)

    _get_flight_mode_metadata = { "offset" : _get_flight_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PhaseOfFlight),) }
    @property
    def flight_mode(self) -> "PhaseOfFlight":
        """Get or set the type of performance model that the aircraft will use to fly the maneuver."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_flight_mode_metadata)

    _set_flight_mode_metadata = { "offset" : _set_flight_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PhaseOfFlight),) }
    @flight_mode.setter
    def flight_mode(self, value:"PhaseOfFlight") -> None:
        """Get or set the type of performance model that the aircraft will use to fly the maneuver."""
        return self._intf.set_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._set_flight_mode_metadata, value)

    _get_flight_path_angle_metadata = { "offset" : _get_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def flight_path_angle(self) -> typing.Any:
        """Get or set the flight path angle at the beginning of the first pause."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_flight_path_angle_metadata)

    _set_flight_path_angle_metadata = { "offset" : _set_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @flight_path_angle.setter
    def flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the flight path angle at the beginning of the first pause."""
        return self._intf.set_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._set_flight_path_angle_metadata, value)

    _get_radius_factor_metadata = { "offset" : _get_radius_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def radius_factor(self) -> float:
        """Get or set the maximum amount the radius of vertical curve will be increased to minimize the flight path angle required to complete it."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_radius_factor_metadata)

    _set_radius_factor_metadata = { "offset" : _set_radius_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @radius_factor.setter
    def radius_factor(self, value:float) -> None:
        """Get or set the maximum amount the radius of vertical curve will be increased to minimize the flight path angle required to complete it."""
        return self._intf.set_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._set_radius_factor_metadata, value)

    _get_use_delay_metadata = { "offset" : _get_use_delay_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_delay(self) -> bool:
        """Get or set the option to insert a delay at the beginning of the procedure."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_use_delay_metadata)

    _set_use_delay_metadata = { "offset" : _set_use_delay_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_delay.setter
    def use_delay(self, value:bool) -> None:
        """Get or set the option to insert a delay at the beginning of the procedure."""
        return self._intf.set_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._set_use_delay_metadata, value)

    _get_delay_turn_direction_metadata = { "offset" : _get_delay_turn_direction_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(DelayTurnDirection),) }
    @property
    def delay_turn_direction(self) -> "DelayTurnDirection":
        """Get or set the turn direction of the delay."""
        return self._intf.get_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._get_delay_turn_direction_metadata)

    _set_delay_turn_direction_metadata = { "offset" : _set_delay_turn_direction_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(DelayTurnDirection),) }
    @delay_turn_direction.setter
    def delay_turn_direction(self, value:"DelayTurnDirection") -> None:
        """Get or set the turn direction of the delay."""
        return self._intf.set_property(ProcedureFormationRecover._metadata, ProcedureFormationRecover._set_delay_turn_direction_metadata, value)

    _property_names[enroute_options] = "enroute_options"
    _property_names[delay_cruise_airspeed_options] = "delay_cruise_airspeed_options"
    _property_names[start_time] = "start_time"
    _property_names[maximum_time] = "maximum_time"
    _property_names[formation_point] = "formation_point"
    _property_names[interpolate_point_position_velocity] = "interpolate_point_position_velocity"
    _property_names[altitude_offset] = "altitude_offset"
    _property_names[fuel_flow_type] = "fuel_flow_type"
    _property_names[override_fuel_flow_value] = "override_fuel_flow_value"
    _property_names[consider_acceleration_for_fuel_flow] = "consider_acceleration_for_fuel_flow"
    _property_names[first_pause] = "first_pause"
    _property_names[transition_time] = "transition_time"
    _property_names[second_pause] = "second_pause"
    _property_names[display_step_time] = "display_step_time"
    _property_names[flight_mode] = "flight_mode"
    _property_names[flight_path_angle] = "flight_path_angle"
    _property_names[radius_factor] = "radius_factor"
    _property_names[use_delay] = "use_delay"
    _property_names[delay_turn_direction] = "delay_turn_direction"

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

agcls.AgClassCatalog.add_catalog_entry((4646585276692074522, 9641621253891545000), ProcedureFormationRecover)
agcls.AgTypeNameMap["ProcedureFormationRecover"] = ProcedureFormationRecover

class ProcedureInFormation(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for an In Formation procedure."""

    _num_methods = 19
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_as_procedure_method_offset = 1
    _get_flight_mode_method_offset = 2
    _set_flight_mode_method_offset = 3
    _get_formation_point_method_offset = 4
    _set_formation_point_method_offset = 5
    _get_transition_time_method_offset = 6
    _set_transition_time_method_offset = 7
    _get_hold_time_method_offset = 8
    _set_hold_time_method_offset = 9
    _get_display_step_time_method_offset = 10
    _set_display_step_time_method_offset = 11
    _get_trajectory_blending_method_offset = 12
    _set_trajectory_blending_method_offset = 13
    _get_fuel_flow_type_method_offset = 14
    _set_fuel_flow_type_method_offset = 15
    _get_override_fuel_flow_value_method_offset = 16
    _set_override_fuel_flow_value_method_offset = 17
    _get_consider_acceleration_for_fuel_flow_method_offset = 18
    _set_consider_acceleration_for_fuel_flow_method_offset = 19
    _metadata = {
        "iid_data" : (5297555687400448155, 1815741588290416825),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureInFormation)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureInFormation._metadata, ProcedureInFormation._get_as_procedure_metadata, OutArg())

    _get_flight_mode_metadata = { "offset" : _get_flight_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PhaseOfFlight),) }
    @property
    def flight_mode(self) -> "PhaseOfFlight":
        """Get or set the type of performance model that the aircraft will use to fly the maneuver."""
        return self._intf.get_property(ProcedureInFormation._metadata, ProcedureInFormation._get_flight_mode_metadata)

    _set_flight_mode_metadata = { "offset" : _set_flight_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PhaseOfFlight),) }
    @flight_mode.setter
    def flight_mode(self, value:"PhaseOfFlight") -> None:
        """Get or set the type of performance model that the aircraft will use to fly the maneuver."""
        return self._intf.set_property(ProcedureInFormation._metadata, ProcedureInFormation._set_flight_mode_metadata, value)

    _get_formation_point_metadata = { "offset" : _get_formation_point_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def formation_point(self) -> str:
        """Get or set the position that the aircraft will be locked onto while in formation."""
        return self._intf.get_property(ProcedureInFormation._metadata, ProcedureInFormation._get_formation_point_metadata)

    _set_formation_point_metadata = { "offset" : _set_formation_point_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @formation_point.setter
    def formation_point(self, value:str) -> None:
        """Get or set the position that the aircraft will be locked onto while in formation."""
        return self._intf.set_property(ProcedureInFormation._metadata, ProcedureInFormation._set_formation_point_metadata, value)

    _get_transition_time_metadata = { "offset" : _get_transition_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def transition_time(self) -> float:
        """Get or set the amount of time that the aircraft will spend transitioning from the altitude offset to a zero altitude offset."""
        return self._intf.get_property(ProcedureInFormation._metadata, ProcedureInFormation._get_transition_time_metadata)

    _set_transition_time_metadata = { "offset" : _set_transition_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @transition_time.setter
    def transition_time(self, value:float) -> None:
        """Get or set the amount of time that the aircraft will spend transitioning from the altitude offset to a zero altitude offset."""
        return self._intf.set_property(ProcedureInFormation._metadata, ProcedureInFormation._set_transition_time_metadata, value)

    _get_hold_time_metadata = { "offset" : _get_hold_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def hold_time(self) -> typing.Any:
        """Get or set the amount of time that the aircraft will pause at a zero altitude offset."""
        return self._intf.get_property(ProcedureInFormation._metadata, ProcedureInFormation._get_hold_time_metadata)

    _set_hold_time_metadata = { "offset" : _set_hold_time_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @hold_time.setter
    def hold_time(self, value:typing.Any) -> None:
        """Get or set the amount of time that the aircraft will pause at a zero altitude offset."""
        return self._intf.set_property(ProcedureInFormation._metadata, ProcedureInFormation._set_hold_time_metadata, value)

    _get_display_step_time_metadata = { "offset" : _get_display_step_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def display_step_time(self) -> float:
        """Get or set the time interval at which ephemeris is generated for display purposes."""
        return self._intf.get_property(ProcedureInFormation._metadata, ProcedureInFormation._get_display_step_time_metadata)

    _set_display_step_time_metadata = { "offset" : _set_display_step_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @display_step_time.setter
    def display_step_time(self, value:float) -> None:
        """Get or set the time interval at which ephemeris is generated for display purposes."""
        return self._intf.set_property(ProcedureInFormation._metadata, ProcedureInFormation._set_display_step_time_metadata, value)

    _get_trajectory_blending_metadata = { "offset" : _get_trajectory_blending_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(TrajectoryBlendMode),) }
    @property
    def trajectory_blending(self) -> "TrajectoryBlendMode":
        """Get or set the interpolation mode to determine the aircraft's position and velocity."""
        return self._intf.get_property(ProcedureInFormation._metadata, ProcedureInFormation._get_trajectory_blending_metadata)

    _set_trajectory_blending_metadata = { "offset" : _set_trajectory_blending_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(TrajectoryBlendMode),) }
    @trajectory_blending.setter
    def trajectory_blending(self, value:"TrajectoryBlendMode") -> None:
        """Get or set the interpolation mode to determine the aircraft's position and velocity."""
        return self._intf.set_property(ProcedureInFormation._metadata, ProcedureInFormation._set_trajectory_blending_metadata, value)

    _get_fuel_flow_type_metadata = { "offset" : _get_fuel_flow_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(FuelFlowType),) }
    @property
    def fuel_flow_type(self) -> "FuelFlowType":
        """Get or set the source used to calculate the fuel flow for the maneuver."""
        return self._intf.get_property(ProcedureInFormation._metadata, ProcedureInFormation._get_fuel_flow_type_metadata)

    _set_fuel_flow_type_metadata = { "offset" : _set_fuel_flow_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(FuelFlowType),) }
    @fuel_flow_type.setter
    def fuel_flow_type(self, value:"FuelFlowType") -> None:
        """Get or set the source used to calculate the fuel flow for the maneuver."""
        return self._intf.set_property(ProcedureInFormation._metadata, ProcedureInFormation._set_fuel_flow_type_metadata, value)

    _get_override_fuel_flow_value_metadata = { "offset" : _get_override_fuel_flow_value_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def override_fuel_flow_value(self) -> float:
        """Get or set the value used for the Override Fuel Flow type. The fuel flow type must be set to Override to access this value."""
        return self._intf.get_property(ProcedureInFormation._metadata, ProcedureInFormation._get_override_fuel_flow_value_metadata)

    _set_override_fuel_flow_value_metadata = { "offset" : _set_override_fuel_flow_value_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @override_fuel_flow_value.setter
    def override_fuel_flow_value(self, value:float) -> None:
        """Get or set the value used for the Override Fuel Flow type. The fuel flow type must be set to Override to access this value."""
        return self._intf.set_property(ProcedureInFormation._metadata, ProcedureInFormation._set_override_fuel_flow_value_metadata, value)

    _get_consider_acceleration_for_fuel_flow_metadata = { "offset" : _get_consider_acceleration_for_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def consider_acceleration_for_fuel_flow(self) -> bool:
        """Get or set the option to calculate the fuel flow rate according to the acceleration of the aircraft."""
        return self._intf.get_property(ProcedureInFormation._metadata, ProcedureInFormation._get_consider_acceleration_for_fuel_flow_metadata)

    _set_consider_acceleration_for_fuel_flow_metadata = { "offset" : _set_consider_acceleration_for_fuel_flow_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @consider_acceleration_for_fuel_flow.setter
    def consider_acceleration_for_fuel_flow(self, value:bool) -> None:
        """Get or set the option to calculate the fuel flow rate according to the acceleration of the aircraft."""
        return self._intf.set_property(ProcedureInFormation._metadata, ProcedureInFormation._set_consider_acceleration_for_fuel_flow_metadata, value)

    _property_names[flight_mode] = "flight_mode"
    _property_names[formation_point] = "formation_point"
    _property_names[transition_time] = "transition_time"
    _property_names[hold_time] = "hold_time"
    _property_names[display_step_time] = "display_step_time"
    _property_names[trajectory_blending] = "trajectory_blending"
    _property_names[fuel_flow_type] = "fuel_flow_type"
    _property_names[override_fuel_flow_value] = "override_fuel_flow_value"
    _property_names[consider_acceleration_for_fuel_flow] = "consider_acceleration_for_fuel_flow"

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

agcls.AgClassCatalog.add_catalog_entry((5532593623227038087, 13258620445025064627), ProcedureInFormation)
agcls.AgTypeNameMap["ProcedureInFormation"] = ProcedureInFormation

class ProcedureParallelFlightLine(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a Parallel Flight Line procedure."""

    _num_methods = 19
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_options_method_offset = 1
    _get_enroute_options_method_offset = 2
    _get_enroute_cruise_airspeed_options_method_offset = 3
    _get_enroute_turn_direction_options_method_offset = 4
    _get_procedure_type_method_offset = 5
    _set_procedure_type_method_offset = 6
    _get_orientation_method_offset = 7
    _set_orientation_method_offset = 8
    _get_separation_method_offset = 9
    _set_separation_method_offset = 10
    _get_offset_method_offset = 11
    _set_offset_method_offset = 12
    _get_leg_length_method_offset = 13
    _set_leg_length_method_offset = 14
    _get_must_level_off_method_offset = 15
    _set_must_level_off_method_offset = 16
    _get_level_off_mode_method_offset = 17
    _set_level_off_mode_method_offset = 18
    _get_as_procedure_method_offset = 19
    _metadata = {
        "iid_data" : (5007645273842850441, 258664155243137693),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureParallelFlightLine)

    _get_altitude_options_metadata = { "offset" : _get_altitude_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def altitude_options(self) -> "AltitudeOptions":
        """Get the altitude options."""
        return self._intf.get_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._get_altitude_options_metadata)

    _get_enroute_options_metadata = { "offset" : _get_enroute_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_options(self) -> "EnrouteOptions":
        """Get the enroute options."""
        return self._intf.get_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._get_enroute_options_metadata)

    _get_enroute_cruise_airspeed_options_metadata = { "offset" : _get_enroute_cruise_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_cruise_airspeed_options(self) -> "ICruiseAirspeedAndProfileOptions":
        """Get the enroute cruise airspeed options."""
        return self._intf.get_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._get_enroute_cruise_airspeed_options_metadata)

    _get_enroute_turn_direction_options_metadata = { "offset" : _get_enroute_turn_direction_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def enroute_turn_direction_options(self) -> "EnrouteTurnDirectionOptions":
        """Get the enroute turn direction options."""
        return self._intf.get_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._get_enroute_turn_direction_options_metadata)

    _get_procedure_type_metadata = { "offset" : _get_procedure_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(FlightLineProcedureType),) }
    @property
    def procedure_type(self) -> "FlightLineProcedureType":
        """Get or set the procedure methodology used to calculate the flight line."""
        return self._intf.get_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._get_procedure_type_metadata)

    _set_procedure_type_metadata = { "offset" : _set_procedure_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(FlightLineProcedureType),) }
    @procedure_type.setter
    def procedure_type(self, value:"FlightLineProcedureType") -> None:
        """Get or set the procedure methodology used to calculate the flight line."""
        return self._intf.set_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._set_procedure_type_metadata, value)

    _get_orientation_metadata = { "offset" : _get_orientation_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(LineOrientation),) }
    @property
    def orientation(self) -> "LineOrientation":
        """Get or set the placement of the procedure with respect to the previous flight line."""
        return self._intf.get_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._get_orientation_metadata)

    _set_orientation_metadata = { "offset" : _set_orientation_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(LineOrientation),) }
    @orientation.setter
    def orientation(self, value:"LineOrientation") -> None:
        """Get or set the placement of the procedure with respect to the previous flight line."""
        return self._intf.set_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._set_orientation_metadata, value)

    _get_separation_metadata = { "offset" : _get_separation_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def separation(self) -> float:
        """Get or set the distance between the flight line and the previous flight line."""
        return self._intf.get_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._get_separation_metadata)

    _set_separation_metadata = { "offset" : _set_separation_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @separation.setter
    def separation(self, value:float) -> None:
        """Get or set the distance between the flight line and the previous flight line."""
        return self._intf.set_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._set_separation_metadata, value)

    _get_offset_metadata = { "offset" : _get_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def offset(self) -> float:
        """Get or set the distance from the end of the previous procedure to the beginning of the flight line."""
        return self._intf.get_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._get_offset_metadata)

    _set_offset_metadata = { "offset" : _set_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @offset.setter
    def offset(self, value:float) -> None:
        """Get or set the distance from the end of the previous procedure to the beginning of the flight line."""
        return self._intf.set_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._set_offset_metadata, value)

    _get_leg_length_metadata = { "offset" : _get_leg_length_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def leg_length(self) -> float:
        """Get or set the length of the flight line."""
        return self._intf.get_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._get_leg_length_metadata)

    _set_leg_length_metadata = { "offset" : _set_leg_length_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @leg_length.setter
    def leg_length(self, value:float) -> None:
        """Get or set the length of the flight line."""
        return self._intf.set_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._set_leg_length_metadata, value)

    _get_must_level_off_metadata = { "offset" : _get_must_level_off_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def must_level_off(self) -> bool:
        """Opt whether the procedure must level off."""
        return self._intf.get_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._get_must_level_off_metadata)

    _set_must_level_off_metadata = { "offset" : _set_must_level_off_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @must_level_off.setter
    def must_level_off(self, value:bool) -> None:
        """Opt whether the procedure must level off."""
        return self._intf.set_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._set_must_level_off_metadata, value)

    _get_level_off_mode_metadata = { "offset" : _get_level_off_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AltitudeConstraintManeuverMode),) }
    @property
    def level_off_mode(self) -> "AltitudeConstraintManeuverMode":
        """Get or set the level off mode. This is only used when the must level off option is on."""
        return self._intf.get_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._get_level_off_mode_metadata)

    _set_level_off_mode_metadata = { "offset" : _set_level_off_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AltitudeConstraintManeuverMode),) }
    @level_off_mode.setter
    def level_off_mode(self, value:"AltitudeConstraintManeuverMode") -> None:
        """Get or set the level off mode. This is only used when the must level off option is on."""
        return self._intf.set_property(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._set_level_off_mode_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureParallelFlightLine._metadata, ProcedureParallelFlightLine._get_as_procedure_metadata, OutArg())

    _property_names[altitude_options] = "altitude_options"
    _property_names[enroute_options] = "enroute_options"
    _property_names[enroute_cruise_airspeed_options] = "enroute_cruise_airspeed_options"
    _property_names[enroute_turn_direction_options] = "enroute_turn_direction_options"
    _property_names[procedure_type] = "procedure_type"
    _property_names[orientation] = "orientation"
    _property_names[separation] = "separation"
    _property_names[offset] = "offset"
    _property_names[leg_length] = "leg_length"
    _property_names[must_level_off] = "must_level_off"
    _property_names[level_off_mode] = "level_off_mode"

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

agcls.AgClassCatalog.add_catalog_entry((5109471054028572559, 5414478772883439545), ProcedureParallelFlightLine)
agcls.AgTypeNameMap["ProcedureParallelFlightLine"] = ProcedureParallelFlightLine

class ProcedureVGTPoint(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a VGT Point procedure."""

    _num_methods = 23
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_as_procedure_method_offset = 1
    _get_minimum_time_method_offset = 2
    _get_start_time_method_offset = 3
    _set_start_time_method_offset = 4
    _get_maximum_time_method_offset = 5
    _get_formation_point_method_offset = 6
    _set_formation_point_method_offset = 7
    _get_interpolate_point_position_velocity_method_offset = 8
    _set_interpolate_point_position_velocity_method_offset = 9
    _get_duration_method_offset = 10
    _set_duration_method_offset = 11
    _get_use_max_point_stop_time_method_offset = 12
    _set_use_max_point_stop_time_method_offset = 13
    _get_fuel_flow_type_method_offset = 14
    _set_fuel_flow_type_method_offset = 15
    _get_override_fuel_flow_value_method_offset = 16
    _set_override_fuel_flow_value_method_offset = 17
    _get_consider_acceleration_for_fuel_flow_method_offset = 18
    _set_consider_acceleration_for_fuel_flow_method_offset = 19
    _get_flight_mode_method_offset = 20
    _set_flight_mode_method_offset = 21
    _get_display_step_time_method_offset = 22
    _set_display_step_time_method_offset = 23
    _metadata = {
        "iid_data" : (5352911337839501133, 797182055070628029),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureVGTPoint)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureVGTPoint._metadata, ProcedureVGTPoint._get_as_procedure_metadata, OutArg())

    _get_minimum_time_metadata = { "offset" : _get_minimum_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def minimum_time(self) -> typing.Any:
        """Get the minimum time at which formation might be possible."""
        return self._intf.get_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._get_minimum_time_metadata)

    _get_start_time_metadata = { "offset" : _get_start_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def start_time(self) -> typing.Any:
        """Get or set the time at which the formation begins."""
        return self._intf.get_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._get_start_time_metadata)

    _set_start_time_metadata = { "offset" : _set_start_time_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @start_time.setter
    def start_time(self, value:typing.Any) -> None:
        """Get or set the time at which the formation begins."""
        return self._intf.set_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._set_start_time_metadata, value)

    _get_maximum_time_metadata = { "offset" : _get_maximum_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def maximum_time(self) -> typing.Any:
        """Get the maximum time at which formation might be possible."""
        return self._intf.get_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._get_maximum_time_metadata)

    _get_formation_point_metadata = { "offset" : _get_formation_point_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def formation_point(self) -> str:
        """Get or set the position that the aircraft will be locked onto while in formation."""
        return self._intf.get_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._get_formation_point_metadata)

    _set_formation_point_metadata = { "offset" : _set_formation_point_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @formation_point.setter
    def formation_point(self, value:str) -> None:
        """Get or set the position that the aircraft will be locked onto while in formation."""
        return self._intf.set_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._set_formation_point_metadata, value)

    _get_interpolate_point_position_velocity_metadata = { "offset" : _get_interpolate_point_position_velocity_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def interpolate_point_position_velocity(self) -> bool:
        """Get or set the option to use interpolation to determine the formation point's speed and position."""
        return self._intf.get_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._get_interpolate_point_position_velocity_metadata)

    _set_interpolate_point_position_velocity_metadata = { "offset" : _set_interpolate_point_position_velocity_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @interpolate_point_position_velocity.setter
    def interpolate_point_position_velocity(self, value:bool) -> None:
        """Get or set the option to use interpolation to determine the formation point's speed and position."""
        return self._intf.set_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._set_interpolate_point_position_velocity_metadata, value)

    _get_duration_metadata = { "offset" : _get_duration_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def duration(self) -> float:
        """Get or set the duration of the procedure."""
        return self._intf.get_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._get_duration_metadata)

    _set_duration_metadata = { "offset" : _set_duration_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @duration.setter
    def duration(self, value:float) -> None:
        """Get or set the duration of the procedure."""
        return self._intf.set_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._set_duration_metadata, value)

    _get_use_max_point_stop_time_metadata = { "offset" : _get_use_max_point_stop_time_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_max_point_stop_time(self) -> bool:
        """Opt to limit the duration to the maximum possible time if the duration exceeds the time limit."""
        return self._intf.get_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._get_use_max_point_stop_time_metadata)

    _set_use_max_point_stop_time_metadata = { "offset" : _set_use_max_point_stop_time_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_max_point_stop_time.setter
    def use_max_point_stop_time(self, value:bool) -> None:
        """Opt to limit the duration to the maximum possible time if the duration exceeds the time limit."""
        return self._intf.set_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._set_use_max_point_stop_time_metadata, value)

    _get_fuel_flow_type_metadata = { "offset" : _get_fuel_flow_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(FuelFlowType),) }
    @property
    def fuel_flow_type(self) -> "FuelFlowType":
        """Get or set the source used to calculate the fuel flow for the maneuver."""
        return self._intf.get_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._get_fuel_flow_type_metadata)

    _set_fuel_flow_type_metadata = { "offset" : _set_fuel_flow_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(FuelFlowType),) }
    @fuel_flow_type.setter
    def fuel_flow_type(self, value:"FuelFlowType") -> None:
        """Get or set the source used to calculate the fuel flow for the maneuver."""
        return self._intf.set_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._set_fuel_flow_type_metadata, value)

    _get_override_fuel_flow_value_metadata = { "offset" : _get_override_fuel_flow_value_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def override_fuel_flow_value(self) -> float:
        """Get or set the value used for the Override Fuel Flow type. The fuel flow type must be set to Override to access this value."""
        return self._intf.get_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._get_override_fuel_flow_value_metadata)

    _set_override_fuel_flow_value_metadata = { "offset" : _set_override_fuel_flow_value_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @override_fuel_flow_value.setter
    def override_fuel_flow_value(self, value:float) -> None:
        """Get or set the value used for the Override Fuel Flow type. The fuel flow type must be set to Override to access this value."""
        return self._intf.set_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._set_override_fuel_flow_value_metadata, value)

    _get_consider_acceleration_for_fuel_flow_metadata = { "offset" : _get_consider_acceleration_for_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def consider_acceleration_for_fuel_flow(self) -> bool:
        """Get or set the option to calculate the fuel flow rate according to the acceleration of the aircraft."""
        return self._intf.get_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._get_consider_acceleration_for_fuel_flow_metadata)

    _set_consider_acceleration_for_fuel_flow_metadata = { "offset" : _set_consider_acceleration_for_fuel_flow_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @consider_acceleration_for_fuel_flow.setter
    def consider_acceleration_for_fuel_flow(self, value:bool) -> None:
        """Get or set the option to calculate the fuel flow rate according to the acceleration of the aircraft."""
        return self._intf.set_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._set_consider_acceleration_for_fuel_flow_metadata, value)

    _get_flight_mode_metadata = { "offset" : _get_flight_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(PhaseOfFlight),) }
    @property
    def flight_mode(self) -> "PhaseOfFlight":
        """Get or set the type of performance model that the aircraft will use to fly the maneuver."""
        return self._intf.get_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._get_flight_mode_metadata)

    _set_flight_mode_metadata = { "offset" : _set_flight_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(PhaseOfFlight),) }
    @flight_mode.setter
    def flight_mode(self, value:"PhaseOfFlight") -> None:
        """Get or set the type of performance model that the aircraft will use to fly the maneuver."""
        return self._intf.set_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._set_flight_mode_metadata, value)

    _get_display_step_time_metadata = { "offset" : _get_display_step_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def display_step_time(self) -> float:
        """Get or set the time interval at which ephemeris is generated for display purposes."""
        return self._intf.get_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._get_display_step_time_metadata)

    _set_display_step_time_metadata = { "offset" : _set_display_step_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @display_step_time.setter
    def display_step_time(self, value:float) -> None:
        """Get or set the time interval at which ephemeris is generated for display purposes."""
        return self._intf.set_property(ProcedureVGTPoint._metadata, ProcedureVGTPoint._set_display_step_time_metadata, value)

    _property_names[minimum_time] = "minimum_time"
    _property_names[start_time] = "start_time"
    _property_names[maximum_time] = "maximum_time"
    _property_names[formation_point] = "formation_point"
    _property_names[interpolate_point_position_velocity] = "interpolate_point_position_velocity"
    _property_names[duration] = "duration"
    _property_names[use_max_point_stop_time] = "use_max_point_stop_time"
    _property_names[fuel_flow_type] = "fuel_flow_type"
    _property_names[override_fuel_flow_value] = "override_fuel_flow_value"
    _property_names[consider_acceleration_for_fuel_flow] = "consider_acceleration_for_fuel_flow"
    _property_names[flight_mode] = "flight_mode"
    _property_names[display_step_time] = "display_step_time"

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

agcls.AgClassCatalog.add_catalog_entry((5185311090544048998, 8831984788416391870), ProcedureVGTPoint)
agcls.AgTypeNameMap["ProcedureVGTPoint"] = ProcedureVGTPoint

class PerformanceModelOptions(SupportsDeleteCallback):
    """
    Interface used to change the active performance model in a phase for a given model type.

    Examples
    --------
    Configure the performance models to be used in the phase:
    >>> # Phase phase: Phase object
    >>> # Get the acceleration performance model used for the current phase
    >>> acceleration = phase.get_performance_model_by_type("Acceleration")
    >>> # Check if it is linked to the catalog
    >>> isLinkedToCatalog = acceleration.is_linked_to_catalog
    >>> # Use the performance model in the catalog named "Built-In Model"
    >>> acceleration.link_to_catalog("Built-In Model")
    >>>
    >>> # Get the VTOL performance model
    >>> vtol = phase.get_performance_model_by_type("VTOL")
    >>> # Create a new vtol model of type AGI VTOL Model. Note that this new model does not exist in the catalog and only exists in the phase.
    >>> vtol.create_new("AGI VTOL Model")
    >>> # Rename the performance model
    >>> vtol.rename("Temporary VTOL Model")
    """

    _num_methods = 8
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _link_to_catalog_method_offset = 1
    _copy_from_catalog_method_offset = 2
    _create_new_method_offset = 3
    _rename_method_offset = 4
    _delete_method_offset = 5
    _get_name_method_offset = 6
    _get_is_linked_to_catalog_method_offset = 7
    _get_properties_method_offset = 8
    _metadata = {
        "iid_data" : (5482067015907007282, 18267973121590324881),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, PerformanceModelOptions)

    _link_to_catalog_metadata = { "offset" : _link_to_catalog_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def link_to_catalog(self, name:str) -> None:
        """Link to the performance model in the catalog with the given name."""
        return self._intf.invoke(PerformanceModelOptions._metadata, PerformanceModelOptions._link_to_catalog_metadata, name)

    _copy_from_catalog_metadata = { "offset" : _copy_from_catalog_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def copy_from_catalog(self, name:str) -> None:
        """Create a copy of the performance model in the catalog with the given name."""
        return self._intf.invoke(PerformanceModelOptions._metadata, PerformanceModelOptions._copy_from_catalog_metadata, name)

    _create_new_metadata = { "offset" : _create_new_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def create_new(self, type:str) -> None:
        """Create a new performance model of the given type."""
        return self._intf.invoke(PerformanceModelOptions._metadata, PerformanceModelOptions._create_new_metadata, type)

    _rename_metadata = { "offset" : _rename_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def rename(self, type:str) -> None:
        """Rename the performance model."""
        return self._intf.invoke(PerformanceModelOptions._metadata, PerformanceModelOptions._rename_metadata, type)

    _delete_metadata = { "offset" : _delete_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def delete(self) -> None:
        """Delete the performance model."""
        return self._intf.invoke(PerformanceModelOptions._metadata, PerformanceModelOptions._delete_metadata, )

    _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 performance model."""
        return self._intf.get_property(PerformanceModelOptions._metadata, PerformanceModelOptions._get_name_metadata)

    _get_is_linked_to_catalog_metadata = { "offset" : _get_is_linked_to_catalog_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def is_linked_to_catalog(self) -> bool:
        """Get whether the performance model is linked to the catalog."""
        return self._intf.get_property(PerformanceModelOptions._metadata, PerformanceModelOptions._get_is_linked_to_catalog_metadata)

    _get_properties_metadata = { "offset" : _get_properties_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def properties(self) -> "IPerformanceModel":
        """Get the properties of the performance model."""
        return self._intf.get_property(PerformanceModelOptions._metadata, PerformanceModelOptions._get_properties_metadata)

    _property_names[name] = "name"
    _property_names[is_linked_to_catalog] = "is_linked_to_catalog"
    _property_names[properties] = "properties"

    def __init__(self, source_object=None):
        """Construct an object of type PerformanceModelOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, PerformanceModelOptions)
    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, PerformanceModelOptions, [PerformanceModelOptions, ])

agcls.AgClassCatalog.add_catalog_entry((5564371800440964119, 7517434752528760714), PerformanceModelOptions)
agcls.AgTypeNameMap["PerformanceModelOptions"] = PerformanceModelOptions

class AdvancedFixedWingTool(SupportsDeleteCallback):
    """
    Interface used to access the options for the Advanced Fixed Wing Tool of an aircraft.

    Examples
    --------
    Configure the Advanced Fixed Wing Tool and set the aircraft to use the resulting performance models:
    >>> # AircraftModel aviatorAircraft: Aviator Aircraft object
    >>> # Get the advanced fixed wing tool
    >>> advFixedWingTool = aviatorAircraft.advanced_fixed_wing_tool
    >>> # Set the basic geometry
    >>> advFixedWingTool.wing_area = 300
    >>> advFixedWingTool.flaps_area = 50
    >>> advFixedWingTool.speedbrakes_area = 10
    >>> # Set the structural and human factor limits
    >>> advFixedWingTool.max_altitude = 65000
    >>> advFixedWingTool.max_mach = 0.98
    >>> advFixedWingTool.max_eas = 460
    >>> advFixedWingTool.min_load_factor = -2.5
    >>> advFixedWingTool.max_load_factor = 4.5
    >>>
    >>> # Opt to enforce the max temperature limit
    >>> advFixedWingTool.use_max_temperature_limit = True
    >>> advFixedWingTool.max_temperature = 900
    >>>
    >>> # Use a subsonic aerodynamic strategy
    >>> advFixedWingTool.aerodynamic_strategy = AdvancedFixedWingAerodynamicStrategy.SUBSONIC_AERODYNAMIC
    >>> # Cache the aerodynamic data to improve calculation speed
    >>> advFixedWingTool.cache_aerodynamic_data = True
    >>> # Use a high bypass turbofan
    >>> advFixedWingTool.powerplant_strategy = AdvancedFixedWingPowerplantStrategy.TURBOFAN_HIGH_BYPASS
    >>> # Cache the fuel flow data to improve calculation speed
    >>> advFixedWingTool.cache_fuel_flow = True
    >>>
    >>> # Create the corresponding performance models that reference the advanced fixed wing tool
    >>> # Specify the name, whether to override any existing models with the same name, and whether to set the new models as the default performance models
    >>> advFixedWingTool.create_all_performance_models("AdvancedModels", True, True)
    >>>
    >>> # Save the changes in the catalog
    >>> aviatorAircraft.save()
    """

    _num_methods = 42
    _vtable_offset = IDispatch._vtable_offset + IDispatch._num_methods
    _get_wing_area_method_offset = 1
    _set_wing_area_method_offset = 2
    _get_flaps_area_method_offset = 3
    _set_flaps_area_method_offset = 4
    _get_speedbrakes_area_method_offset = 5
    _set_speedbrakes_area_method_offset = 6
    _get_max_altitude_method_offset = 7
    _set_max_altitude_method_offset = 8
    _get_max_mach_method_offset = 9
    _set_max_mach_method_offset = 10
    _get_max_eas_method_offset = 11
    _set_max_eas_method_offset = 12
    _get_min_load_factor_method_offset = 13
    _set_min_load_factor_method_offset = 14
    _get_max_load_factor_method_offset = 15
    _set_max_load_factor_method_offset = 16
    _get_use_max_temperature_limit_method_offset = 17
    _set_use_max_temperature_limit_method_offset = 18
    _get_max_temperature_method_offset = 19
    _set_max_temperature_method_offset = 20
    _get_cache_aerodynamic_data_method_offset = 21
    _set_cache_aerodynamic_data_method_offset = 22
    _get_cache_fuel_flow_method_offset = 23
    _set_cache_fuel_flow_method_offset = 24
    _get_aerodynamic_strategy_method_offset = 25
    _set_aerodynamic_strategy_method_offset = 26
    _get_aerodynamic_mode_as_external_method_offset = 27
    _get_aerodynamic_mode_as_subsonic_method_offset = 28
    _get_aerodynamic_mode_as_sub_super_hypersonic_method_offset = 29
    _get_aerodynamic_mode_as_supersonic_method_offset = 30
    _get_powerplant_strategy_method_offset = 31
    _set_powerplant_strategy_method_offset = 32
    _get_powerplant_mode_as_electric_method_offset = 33
    _get_powerplant_mode_as_external_method_offset = 34
    _get_powerplant_mode_as_piston_method_offset = 35
    _get_powerplant_mode_as_turboprop_method_offset = 36
    _get_powerplant_mode_as_empirical_jet_engine_method_offset = 37
    _create_all_performance_models_method_offset = 38
    _get_powerplant_mode_as_basic_turbofan_method_offset = 39
    _get_powerplant_mode_as_basic_turbojet_method_offset = 40
    _get_powerplant_mode_as_sub_super_hypersonic_method_offset = 41
    _get_aerodynamic_mode_as_four_point_method_offset = 42
    _metadata = {
        "iid_data" : (5237019780042636595, 13473390248537517999),
        "vtable_reference" : IDispatch._vtable_offset + IDispatch._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingTool)

    _get_wing_area_metadata = { "offset" : _get_wing_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def wing_area(self) -> float:
        """Get or set the total surface area of the wing."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_wing_area_metadata)

    _set_wing_area_metadata = { "offset" : _set_wing_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @wing_area.setter
    def wing_area(self, value:float) -> None:
        """Get or set the total surface area of the wing."""
        return self._intf.set_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._set_wing_area_metadata, value)

    _get_flaps_area_metadata = { "offset" : _get_flaps_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def flaps_area(self) -> float:
        """Get or set the total surface area of the flaps."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_flaps_area_metadata)

    _set_flaps_area_metadata = { "offset" : _set_flaps_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @flaps_area.setter
    def flaps_area(self, value:float) -> None:
        """Get or set the total surface area of the flaps."""
        return self._intf.set_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._set_flaps_area_metadata, value)

    _get_speedbrakes_area_metadata = { "offset" : _get_speedbrakes_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def speedbrakes_area(self) -> float:
        """Get or set the total surface area of the speedbrakes."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_speedbrakes_area_metadata)

    _set_speedbrakes_area_metadata = { "offset" : _set_speedbrakes_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @speedbrakes_area.setter
    def speedbrakes_area(self, value:float) -> None:
        """Get or set the total surface area of the speedbrakes."""
        return self._intf.set_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._set_speedbrakes_area_metadata, value)

    _get_max_altitude_metadata = { "offset" : _get_max_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_altitude(self) -> float:
        """Get or set the maximum altitude of the aircraft."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_max_altitude_metadata)

    _set_max_altitude_metadata = { "offset" : _set_max_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_altitude.setter
    def max_altitude(self, value:float) -> None:
        """Get or set the maximum altitude of the aircraft."""
        return self._intf.set_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._set_max_altitude_metadata, value)

    _get_max_mach_metadata = { "offset" : _get_max_mach_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_mach(self) -> float:
        """Get or set the maximum mach number of the aircraft."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_max_mach_metadata)

    _set_max_mach_metadata = { "offset" : _set_max_mach_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_mach.setter
    def max_mach(self, value:float) -> None:
        """Get or set the maximum mach number of the aircraft."""
        return self._intf.set_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._set_max_mach_metadata, value)

    _get_max_eas_metadata = { "offset" : _get_max_eas_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_eas(self) -> float:
        """Get or set the maximum equivalent airspeed of the aircraft."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_max_eas_metadata)

    _set_max_eas_metadata = { "offset" : _set_max_eas_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_eas.setter
    def max_eas(self, value:float) -> None:
        """Get or set the maximum equivalent airspeed of the aircraft."""
        return self._intf.set_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._set_max_eas_metadata, value)

    _get_min_load_factor_metadata = { "offset" : _get_min_load_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_load_factor(self) -> float:
        """Get or set the minimum load factor the aircraft can bear."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_min_load_factor_metadata)

    _set_min_load_factor_metadata = { "offset" : _set_min_load_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_load_factor.setter
    def min_load_factor(self, value:float) -> None:
        """Get or set the minimum load factor the aircraft can bear."""
        return self._intf.set_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._set_min_load_factor_metadata, value)

    _get_max_load_factor_metadata = { "offset" : _get_max_load_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_load_factor(self) -> float:
        """Get or set the maximum load factor the aircraft can bear."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_max_load_factor_metadata)

    _set_max_load_factor_metadata = { "offset" : _set_max_load_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_load_factor.setter
    def max_load_factor(self, value:float) -> None:
        """Get or set the maximum load factor the aircraft can bear."""
        return self._intf.set_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._set_max_load_factor_metadata, value)

    _get_use_max_temperature_limit_metadata = { "offset" : _get_use_max_temperature_limit_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_max_temperature_limit(self) -> bool:
        """Get or set the option to limit the maximum speed of the aircraft so the specified temperature is not exceeded."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_use_max_temperature_limit_metadata)

    _set_use_max_temperature_limit_metadata = { "offset" : _set_use_max_temperature_limit_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_max_temperature_limit.setter
    def use_max_temperature_limit(self, value:bool) -> None:
        """Get or set the option to limit the maximum speed of the aircraft so the specified temperature is not exceeded."""
        return self._intf.set_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._set_use_max_temperature_limit_metadata, value)

    _get_max_temperature_metadata = { "offset" : _get_max_temperature_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_temperature(self) -> float:
        """Get or set the maximum total temperature limit of the aircraft."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_max_temperature_metadata)

    _set_max_temperature_metadata = { "offset" : _set_max_temperature_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_temperature.setter
    def max_temperature(self, value:float) -> None:
        """Get or set the maximum total temperature limit of the aircraft."""
        return self._intf.set_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._set_max_temperature_metadata, value)

    _get_cache_aerodynamic_data_metadata = { "offset" : _get_cache_aerodynamic_data_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def cache_aerodynamic_data(self) -> bool:
        """Get or set the option to store intermediate results for aerodynamics calculations."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_cache_aerodynamic_data_metadata)

    _set_cache_aerodynamic_data_metadata = { "offset" : _set_cache_aerodynamic_data_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @cache_aerodynamic_data.setter
    def cache_aerodynamic_data(self, value:bool) -> None:
        """Get or set the option to store intermediate results for aerodynamics calculations."""
        return self._intf.set_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._set_cache_aerodynamic_data_metadata, value)

    _get_cache_fuel_flow_metadata = { "offset" : _get_cache_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def cache_fuel_flow(self) -> bool:
        """Get or set the option to store intermediate results for fuel flow calculations."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_cache_fuel_flow_metadata)

    _set_cache_fuel_flow_metadata = { "offset" : _set_cache_fuel_flow_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @cache_fuel_flow.setter
    def cache_fuel_flow(self, value:bool) -> None:
        """Get or set the option to store intermediate results for fuel flow calculations."""
        return self._intf.set_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._set_cache_fuel_flow_metadata, value)

    _get_aerodynamic_strategy_metadata = { "offset" : _get_aerodynamic_strategy_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AdvancedFixedWingAerodynamicStrategy),) }
    @property
    def aerodynamic_strategy(self) -> "AdvancedFixedWingAerodynamicStrategy":
        """Get or set the aerodynamic strategy type."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_aerodynamic_strategy_metadata)

    _set_aerodynamic_strategy_metadata = { "offset" : _set_aerodynamic_strategy_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AdvancedFixedWingAerodynamicStrategy),) }
    @aerodynamic_strategy.setter
    def aerodynamic_strategy(self, value:"AdvancedFixedWingAerodynamicStrategy") -> None:
        """Get or set the aerodynamic strategy type."""
        return self._intf.set_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._set_aerodynamic_strategy_metadata, value)

    _get_aerodynamic_mode_as_external_metadata = { "offset" : _get_aerodynamic_mode_as_external_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def aerodynamic_mode_as_external(self) -> "AdvancedFixedWingExternalAerodynamic":
        """Get the interface for an Extern File Aerodynamics strategy."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_aerodynamic_mode_as_external_metadata)

    _get_aerodynamic_mode_as_subsonic_metadata = { "offset" : _get_aerodynamic_mode_as_subsonic_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def aerodynamic_mode_as_subsonic(self) -> "AdvancedFixedWingSubsonicAerodynamic":
        """Get the interface for a Subsonic Aerodynamics strategy."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_aerodynamic_mode_as_subsonic_metadata)

    _get_aerodynamic_mode_as_sub_super_hypersonic_metadata = { "offset" : _get_aerodynamic_mode_as_sub_super_hypersonic_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def aerodynamic_mode_as_sub_super_hypersonic(self) -> "AdvancedFixedWingSubSuperHypersonicAerodynamic":
        """Get the interface for a Sub/Super/Hypersonic Aerodynamics strategy."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_aerodynamic_mode_as_sub_super_hypersonic_metadata)

    _get_aerodynamic_mode_as_supersonic_metadata = { "offset" : _get_aerodynamic_mode_as_supersonic_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def aerodynamic_mode_as_supersonic(self) -> "AdvancedFixedWingSupersonicAerodynamic":
        """Get the interface for a Supersonic Aerodynamics strategy."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_aerodynamic_mode_as_supersonic_metadata)

    _get_powerplant_strategy_metadata = { "offset" : _get_powerplant_strategy_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AdvancedFixedWingPowerplantStrategy),) }
    @property
    def powerplant_strategy(self) -> "AdvancedFixedWingPowerplantStrategy":
        """Get or set the powerplant strategy type."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_powerplant_strategy_metadata)

    _set_powerplant_strategy_metadata = { "offset" : _set_powerplant_strategy_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AdvancedFixedWingPowerplantStrategy),) }
    @powerplant_strategy.setter
    def powerplant_strategy(self, value:"AdvancedFixedWingPowerplantStrategy") -> None:
        """Get or set the powerplant  strategy type."""
        return self._intf.set_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._set_powerplant_strategy_metadata, value)

    _get_powerplant_mode_as_electric_metadata = { "offset" : _get_powerplant_mode_as_electric_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def powerplant_mode_as_electric(self) -> "AdvancedFixedWingElectricPowerplant":
        """Get the interface for an Electric Powerplant strategy."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_powerplant_mode_as_electric_metadata)

    _get_powerplant_mode_as_external_metadata = { "offset" : _get_powerplant_mode_as_external_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def powerplant_mode_as_external(self) -> "AdvancedFixedWingExternalPropulsion":
        """Get the interface for an External Prop File Powerplant strategy."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_powerplant_mode_as_external_metadata)

    _get_powerplant_mode_as_piston_metadata = { "offset" : _get_powerplant_mode_as_piston_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def powerplant_mode_as_piston(self) -> "AdvancedFixedWingPistonPowerplant":
        """Get the interface for a Piston Powerplant strategy."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_powerplant_mode_as_piston_metadata)

    _get_powerplant_mode_as_turboprop_metadata = { "offset" : _get_powerplant_mode_as_turboprop_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def powerplant_mode_as_turboprop(self) -> "AdvancedFixedWingTurbopropPowerplant":
        """Get the interface for a Turboprop Powerplant strategy."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_powerplant_mode_as_turboprop_metadata)

    _get_powerplant_mode_as_empirical_jet_engine_metadata = { "offset" : _get_powerplant_mode_as_empirical_jet_engine_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def powerplant_mode_as_empirical_jet_engine(self) -> "AdvancedFixedWingEmpiricalJetEngine":
        """Get the interface for an Empirical Jet Engine Powerplant strategy."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_powerplant_mode_as_empirical_jet_engine_metadata)

    _create_all_performance_models_metadata = { "offset" : _create_all_performance_models_method_offset,
            "arg_types" : (agcom.BSTR, agcom.VARIANT_BOOL, agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.BStrArg, agmarshall.VariantBoolArg, agmarshall.VariantBoolArg,) }
    def create_all_performance_models(self, name:str, overwrite:bool, make_default:bool) -> None:
        """Create a set of advanced performance models for the aircraft with the given name."""
        return self._intf.invoke(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._create_all_performance_models_metadata, name, overwrite, make_default)

    _get_powerplant_mode_as_basic_turbofan_metadata = { "offset" : _get_powerplant_mode_as_basic_turbofan_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def powerplant_mode_as_basic_turbofan(self) -> "AdvancedFixedWingTurbofanBasicABPropulsion":
        """Get the interface for a Turbofan - Basic w/ AB Powerplant strategy."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_powerplant_mode_as_basic_turbofan_metadata)

    _get_powerplant_mode_as_basic_turbojet_metadata = { "offset" : _get_powerplant_mode_as_basic_turbojet_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def powerplant_mode_as_basic_turbojet(self) -> "AdvancedFixedWingTurbojetBasicABPropulsion":
        """Get the interface for a Turbojet - Basic w/ AB Powerplant strategy."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_powerplant_mode_as_basic_turbojet_metadata)

    _get_powerplant_mode_as_sub_super_hypersonic_metadata = { "offset" : _get_powerplant_mode_as_sub_super_hypersonic_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def powerplant_mode_as_sub_super_hypersonic(self) -> "AdvancedFixedWingSubSuperHypersonicPropulsion":
        """Get the interface for a Sub/Super/Hypersoinc Powerplant strategy."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_powerplant_mode_as_sub_super_hypersonic_metadata)

    _get_aerodynamic_mode_as_four_point_metadata = { "offset" : _get_aerodynamic_mode_as_four_point_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def aerodynamic_mode_as_four_point(self) -> "AdvancedFixedWingFourPointAerodynamic":
        """Get the interface for a Four Point Aerodynamics strategy."""
        return self._intf.get_property(AdvancedFixedWingTool._metadata, AdvancedFixedWingTool._get_aerodynamic_mode_as_four_point_metadata)

    _property_names[wing_area] = "wing_area"
    _property_names[flaps_area] = "flaps_area"
    _property_names[speedbrakes_area] = "speedbrakes_area"
    _property_names[max_altitude] = "max_altitude"
    _property_names[max_mach] = "max_mach"
    _property_names[max_eas] = "max_eas"
    _property_names[min_load_factor] = "min_load_factor"
    _property_names[max_load_factor] = "max_load_factor"
    _property_names[use_max_temperature_limit] = "use_max_temperature_limit"
    _property_names[max_temperature] = "max_temperature"
    _property_names[cache_aerodynamic_data] = "cache_aerodynamic_data"
    _property_names[cache_fuel_flow] = "cache_fuel_flow"
    _property_names[aerodynamic_strategy] = "aerodynamic_strategy"
    _property_names[aerodynamic_mode_as_external] = "aerodynamic_mode_as_external"
    _property_names[aerodynamic_mode_as_subsonic] = "aerodynamic_mode_as_subsonic"
    _property_names[aerodynamic_mode_as_sub_super_hypersonic] = "aerodynamic_mode_as_sub_super_hypersonic"
    _property_names[aerodynamic_mode_as_supersonic] = "aerodynamic_mode_as_supersonic"
    _property_names[powerplant_strategy] = "powerplant_strategy"
    _property_names[powerplant_mode_as_electric] = "powerplant_mode_as_electric"
    _property_names[powerplant_mode_as_external] = "powerplant_mode_as_external"
    _property_names[powerplant_mode_as_piston] = "powerplant_mode_as_piston"
    _property_names[powerplant_mode_as_turboprop] = "powerplant_mode_as_turboprop"
    _property_names[powerplant_mode_as_empirical_jet_engine] = "powerplant_mode_as_empirical_jet_engine"
    _property_names[powerplant_mode_as_basic_turbofan] = "powerplant_mode_as_basic_turbofan"
    _property_names[powerplant_mode_as_basic_turbojet] = "powerplant_mode_as_basic_turbojet"
    _property_names[powerplant_mode_as_sub_super_hypersonic] = "powerplant_mode_as_sub_super_hypersonic"
    _property_names[aerodynamic_mode_as_four_point] = "aerodynamic_mode_as_four_point"

    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingTool."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingTool)
    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, AdvancedFixedWingTool, [AdvancedFixedWingTool, ])

agcls.AgClassCatalog.add_catalog_entry((4959167576758306460, 5150777901270384053), AdvancedFixedWingTool)
agcls.AgTypeNameMap["AdvancedFixedWingTool"] = AdvancedFixedWingTool

class AdvancedFixedWingExternalAerodynamic(SupportsDeleteCallback):
    """Interface used to access the options for an external file aerodynamic strategy in the advanced fixed wing tool."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_filepath_method_offset = 1
    _set_filepath_method_offset = 2
    _get_is_valid_method_offset = 3
    _metadata = {
        "iid_data" : (4718562149881086212, 5213103095226551192),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingExternalAerodynamic)

    _get_filepath_metadata = { "offset" : _get_filepath_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def filepath(self) -> str:
        """Get the filepath for the external aero file."""
        return self._intf.get_property(AdvancedFixedWingExternalAerodynamic._metadata, AdvancedFixedWingExternalAerodynamic._get_filepath_metadata)

    _set_filepath_metadata = { "offset" : _set_filepath_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg,) }
    def set_filepath(self, filepath:str) -> str:
        """Set the filepath for the external aero file."""
        return self._intf.invoke(AdvancedFixedWingExternalAerodynamic._metadata, AdvancedFixedWingExternalAerodynamic._set_filepath_metadata, filepath, OutArg())

    _get_is_valid_metadata = { "offset" : _get_is_valid_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def is_valid(self) -> bool:
        """Check whether the filepath is valid."""
        return self._intf.get_property(AdvancedFixedWingExternalAerodynamic._metadata, AdvancedFixedWingExternalAerodynamic._get_is_valid_metadata)

    _property_names[filepath] = "filepath"
    _property_names[is_valid] = "is_valid"

    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingExternalAerodynamic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingExternalAerodynamic)
    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, AdvancedFixedWingExternalAerodynamic, [AdvancedFixedWingExternalAerodynamic, ])

agcls.AgClassCatalog.add_catalog_entry((4930872444534161422, 10999827858917784511), AdvancedFixedWingExternalAerodynamic)
agcls.AgTypeNameMap["AdvancedFixedWingExternalAerodynamic"] = AdvancedFixedWingExternalAerodynamic

class AdvancedFixedWingSubsonicAerodynamic(SupportsDeleteCallback):
    """Interface used to access the options for the subsonic aerodynamic strategy in the advanced fixed wing tool."""

    _num_methods = 12
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_geometry_type_method_offset = 1
    _set_geometry_type_method_offset = 2
    _get_geometry_mode_as_basic_method_offset = 3
    _get_geometry_mode_as_variable_method_offset = 4
    _get_max_aoa_method_offset = 5
    _set_max_aoa_method_offset = 6
    _get_cd0_method_offset = 7
    _set_cd0_method_offset = 8
    _get_mach_divergence_method_offset = 9
    _set_mach_divergence_method_offset = 10
    _get_transonic_mach_drag_factor_method_offset = 11
    _set_transonic_mach_drag_factor_method_offset = 12
    _metadata = {
        "iid_data" : (4697303484004482935, 3130684680515483791),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingSubsonicAerodynamic)

    _get_geometry_type_metadata = { "offset" : _get_geometry_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AdvancedFixedWingGeometry),) }
    @property
    def geometry_type(self) -> "AdvancedFixedWingGeometry":
        """Get or set the type of wing geometry for the aircraft."""
        return self._intf.get_property(AdvancedFixedWingSubsonicAerodynamic._metadata, AdvancedFixedWingSubsonicAerodynamic._get_geometry_type_metadata)

    _set_geometry_type_metadata = { "offset" : _set_geometry_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AdvancedFixedWingGeometry),) }
    @geometry_type.setter
    def geometry_type(self, value:"AdvancedFixedWingGeometry") -> None:
        """Get or set the type of wing geometry for the aircraft."""
        return self._intf.set_property(AdvancedFixedWingSubsonicAerodynamic._metadata, AdvancedFixedWingSubsonicAerodynamic._set_geometry_type_metadata, value)

    _get_geometry_mode_as_basic_metadata = { "offset" : _get_geometry_mode_as_basic_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def geometry_mode_as_basic(self) -> "AdvancedFixedWingGeometryBasic":
        """Get the options for a basic geometry wing."""
        return self._intf.get_property(AdvancedFixedWingSubsonicAerodynamic._metadata, AdvancedFixedWingSubsonicAerodynamic._get_geometry_mode_as_basic_metadata)

    _get_geometry_mode_as_variable_metadata = { "offset" : _get_geometry_mode_as_variable_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def geometry_mode_as_variable(self) -> "AdvancedFixedWingGeometryVariable":
        """Get the options for a variable geometry wing."""
        return self._intf.get_property(AdvancedFixedWingSubsonicAerodynamic._metadata, AdvancedFixedWingSubsonicAerodynamic._get_geometry_mode_as_variable_metadata)

    _get_max_aoa_metadata = { "offset" : _get_max_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_aoa(self) -> typing.Any:
        """Get or set the maximum angle of attack possible."""
        return self._intf.get_property(AdvancedFixedWingSubsonicAerodynamic._metadata, AdvancedFixedWingSubsonicAerodynamic._get_max_aoa_metadata)

    _set_max_aoa_metadata = { "offset" : _set_max_aoa_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_aoa.setter
    def max_aoa(self, value:typing.Any) -> None:
        """Get or set the maximum angle of attack possible."""
        return self._intf.set_property(AdvancedFixedWingSubsonicAerodynamic._metadata, AdvancedFixedWingSubsonicAerodynamic._set_max_aoa_metadata, value)

    _get_cd0_metadata = { "offset" : _get_cd0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cd0(self) -> float:
        """Get or set the parasitic drag coefficient of the aircraft when flying at a speed less than the Mach Divergence."""
        return self._intf.get_property(AdvancedFixedWingSubsonicAerodynamic._metadata, AdvancedFixedWingSubsonicAerodynamic._get_cd0_metadata)

    _set_cd0_metadata = { "offset" : _set_cd0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cd0.setter
    def cd0(self, value:float) -> None:
        """Get or set the parasitic drag coefficient of the aircraft when flying at a speed less than the Mach Divergence."""
        return self._intf.set_property(AdvancedFixedWingSubsonicAerodynamic._metadata, AdvancedFixedWingSubsonicAerodynamic._set_cd0_metadata, value)

    _get_mach_divergence_metadata = { "offset" : _get_mach_divergence_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mach_divergence(self) -> float:
        """Get or set the speed at which the aircraft begins to experience air compression."""
        return self._intf.get_property(AdvancedFixedWingSubsonicAerodynamic._metadata, AdvancedFixedWingSubsonicAerodynamic._get_mach_divergence_metadata)

    _set_mach_divergence_metadata = { "offset" : _set_mach_divergence_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mach_divergence.setter
    def mach_divergence(self, value:float) -> None:
        """Get or set the speed at which the aircraft begins to experience air compression."""
        return self._intf.set_property(AdvancedFixedWingSubsonicAerodynamic._metadata, AdvancedFixedWingSubsonicAerodynamic._set_mach_divergence_metadata, value)

    _get_transonic_mach_drag_factor_metadata = { "offset" : _get_transonic_mach_drag_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def transonic_mach_drag_factor(self) -> float:
        """Get or set the factor applied to the aircraft's parasitic drag coefficient when it is flying faster than the Mach Divergence."""
        return self._intf.get_property(AdvancedFixedWingSubsonicAerodynamic._metadata, AdvancedFixedWingSubsonicAerodynamic._get_transonic_mach_drag_factor_metadata)

    _set_transonic_mach_drag_factor_metadata = { "offset" : _set_transonic_mach_drag_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @transonic_mach_drag_factor.setter
    def transonic_mach_drag_factor(self, value:float) -> None:
        """Get or set the factor applied to the aircraft's parasitic drag coefficient when it is flying faster than the Mach Divergence."""
        return self._intf.set_property(AdvancedFixedWingSubsonicAerodynamic._metadata, AdvancedFixedWingSubsonicAerodynamic._set_transonic_mach_drag_factor_metadata, value)

    _property_names[geometry_type] = "geometry_type"
    _property_names[geometry_mode_as_basic] = "geometry_mode_as_basic"
    _property_names[geometry_mode_as_variable] = "geometry_mode_as_variable"
    _property_names[max_aoa] = "max_aoa"
    _property_names[cd0] = "cd0"
    _property_names[mach_divergence] = "mach_divergence"
    _property_names[transonic_mach_drag_factor] = "transonic_mach_drag_factor"

    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingSubsonicAerodynamic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingSubsonicAerodynamic)
    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, AdvancedFixedWingSubsonicAerodynamic, [AdvancedFixedWingSubsonicAerodynamic, ])

agcls.AgClassCatalog.add_catalog_entry((5062145481846871754, 6094659154782220179), AdvancedFixedWingSubsonicAerodynamic)
agcls.AgTypeNameMap["AdvancedFixedWingSubsonicAerodynamic"] = AdvancedFixedWingSubsonicAerodynamic

class AdvancedFixedWingSubSuperHypersonicAerodynamic(SupportsDeleteCallback):
    """Interface used to access the options for the Sub/Super/Hypersonic aerodynamic strategy in the advanced fixed wing tool."""

    _num_methods = 16
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_max_aoa_method_offset = 1
    _set_max_aoa_method_offset = 2
    _get_transonic_min_mach_method_offset = 3
    _set_transonic_min_mach_method_offset = 4
    _get_transonic_max_mach_method_offset = 5
    _set_transonic_max_mach_method_offset = 6
    _get_super_hyper_mach_transition_method_offset = 7
    _set_super_hyper_mach_transition_method_offset = 8
    _get_leading_edge_frontal_area_ratio_method_offset = 9
    _set_leading_edge_frontal_area_ratio_method_offset = 10
    _get_subsonic_aspect_ratio_method_offset = 11
    _set_subsonic_aspect_ratio_method_offset = 12
    _get_transonic_mach_drag_factor_method_offset = 13
    _set_transonic_mach_drag_factor_method_offset = 14
    _get_wave_drag_factor_method_offset = 15
    _set_wave_drag_factor_method_offset = 16
    _metadata = {
        "iid_data" : (5006549268881285727, 2704518954570612897),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingSubSuperHypersonicAerodynamic)

    _get_max_aoa_metadata = { "offset" : _get_max_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_aoa(self) -> typing.Any:
        """Get or set the maximum angle of attack possible."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicAerodynamic._metadata, AdvancedFixedWingSubSuperHypersonicAerodynamic._get_max_aoa_metadata)

    _set_max_aoa_metadata = { "offset" : _set_max_aoa_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_aoa.setter
    def max_aoa(self, value:typing.Any) -> None:
        """Get or set the maximum angle of attack possible."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicAerodynamic._metadata, AdvancedFixedWingSubSuperHypersonicAerodynamic._set_max_aoa_metadata, value)

    _get_transonic_min_mach_metadata = { "offset" : _get_transonic_min_mach_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def transonic_min_mach(self) -> float:
        """Get or set the minimum speed at which the aircraft begins to experience air compression."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicAerodynamic._metadata, AdvancedFixedWingSubSuperHypersonicAerodynamic._get_transonic_min_mach_metadata)

    _set_transonic_min_mach_metadata = { "offset" : _set_transonic_min_mach_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @transonic_min_mach.setter
    def transonic_min_mach(self, value:float) -> None:
        """Get or set the minimum speed at which the aircraft begins to experience air compression."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicAerodynamic._metadata, AdvancedFixedWingSubSuperHypersonicAerodynamic._set_transonic_min_mach_metadata, value)

    _get_transonic_max_mach_metadata = { "offset" : _get_transonic_max_mach_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def transonic_max_mach(self) -> float:
        """Get or set the maximum speed, below supersonic, at which the aircraft begins to experience air compression."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicAerodynamic._metadata, AdvancedFixedWingSubSuperHypersonicAerodynamic._get_transonic_max_mach_metadata)

    _set_transonic_max_mach_metadata = { "offset" : _set_transonic_max_mach_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @transonic_max_mach.setter
    def transonic_max_mach(self, value:float) -> None:
        """Get or set the maximum speed, below supersonic, at which the aircraft begins to experience air compression."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicAerodynamic._metadata, AdvancedFixedWingSubSuperHypersonicAerodynamic._set_transonic_max_mach_metadata, value)

    _get_super_hyper_mach_transition_metadata = { "offset" : _get_super_hyper_mach_transition_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def super_hyper_mach_transition(self) -> float:
        """Get or set the minimum speed at which the air flow will be treated as hypersonic."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicAerodynamic._metadata, AdvancedFixedWingSubSuperHypersonicAerodynamic._get_super_hyper_mach_transition_metadata)

    _set_super_hyper_mach_transition_metadata = { "offset" : _set_super_hyper_mach_transition_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @super_hyper_mach_transition.setter
    def super_hyper_mach_transition(self, value:float) -> None:
        """Get or set the minimum speed at which the air flow will be treated as hypersonic."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicAerodynamic._metadata, AdvancedFixedWingSubSuperHypersonicAerodynamic._set_super_hyper_mach_transition_metadata, value)

    _get_leading_edge_frontal_area_ratio_metadata = { "offset" : _get_leading_edge_frontal_area_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def leading_edge_frontal_area_ratio(self) -> float:
        """Get or set the frontal face thickness of the aircraft's wings at their leading edge."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicAerodynamic._metadata, AdvancedFixedWingSubSuperHypersonicAerodynamic._get_leading_edge_frontal_area_ratio_metadata)

    _set_leading_edge_frontal_area_ratio_metadata = { "offset" : _set_leading_edge_frontal_area_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @leading_edge_frontal_area_ratio.setter
    def leading_edge_frontal_area_ratio(self, value:float) -> None:
        """Get or set the frontal face thickness of the aircraft's wings at their leading edge."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicAerodynamic._metadata, AdvancedFixedWingSubSuperHypersonicAerodynamic._set_leading_edge_frontal_area_ratio_metadata, value)

    _get_subsonic_aspect_ratio_metadata = { "offset" : _get_subsonic_aspect_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def subsonic_aspect_ratio(self) -> float:
        """Get or set the aircraft's wingspan squared divided by the wing area."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicAerodynamic._metadata, AdvancedFixedWingSubSuperHypersonicAerodynamic._get_subsonic_aspect_ratio_metadata)

    _set_subsonic_aspect_ratio_metadata = { "offset" : _set_subsonic_aspect_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @subsonic_aspect_ratio.setter
    def subsonic_aspect_ratio(self, value:float) -> None:
        """Get or set the aircraft's wingspan squared divided by the wing area."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicAerodynamic._metadata, AdvancedFixedWingSubSuperHypersonicAerodynamic._set_subsonic_aspect_ratio_metadata, value)

    _get_transonic_mach_drag_factor_metadata = { "offset" : _get_transonic_mach_drag_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def transonic_mach_drag_factor(self) -> float:
        """Get or set the factor applied to the aircraft's parasitic drag coefficient when it is flying between the Transonic Min Mach and Transonic Mach Drag Factor speeds."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicAerodynamic._metadata, AdvancedFixedWingSubSuperHypersonicAerodynamic._get_transonic_mach_drag_factor_metadata)

    _set_transonic_mach_drag_factor_metadata = { "offset" : _set_transonic_mach_drag_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @transonic_mach_drag_factor.setter
    def transonic_mach_drag_factor(self, value:float) -> None:
        """Get or set the factor applied to the aircraft's parasitic drag coefficient when it is flying between the Transonic Min Mach and Transonic Mach Drag Factor speeds."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicAerodynamic._metadata, AdvancedFixedWingSubSuperHypersonicAerodynamic._set_transonic_mach_drag_factor_metadata, value)

    _get_wave_drag_factor_metadata = { "offset" : _get_wave_drag_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def wave_drag_factor(self) -> float:
        """Get or set the scalar value that models drag produced by shock waves at or near the aircraft's critical Mach number."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicAerodynamic._metadata, AdvancedFixedWingSubSuperHypersonicAerodynamic._get_wave_drag_factor_metadata)

    _set_wave_drag_factor_metadata = { "offset" : _set_wave_drag_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @wave_drag_factor.setter
    def wave_drag_factor(self, value:float) -> None:
        """Get or set the scalar value that models drag produced by shock waves at or near the aircraft's critical Mach number."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicAerodynamic._metadata, AdvancedFixedWingSubSuperHypersonicAerodynamic._set_wave_drag_factor_metadata, value)

    _property_names[max_aoa] = "max_aoa"
    _property_names[transonic_min_mach] = "transonic_min_mach"
    _property_names[transonic_max_mach] = "transonic_max_mach"
    _property_names[super_hyper_mach_transition] = "super_hyper_mach_transition"
    _property_names[leading_edge_frontal_area_ratio] = "leading_edge_frontal_area_ratio"
    _property_names[subsonic_aspect_ratio] = "subsonic_aspect_ratio"
    _property_names[transonic_mach_drag_factor] = "transonic_mach_drag_factor"
    _property_names[wave_drag_factor] = "wave_drag_factor"

    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingSubSuperHypersonicAerodynamic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingSubSuperHypersonicAerodynamic)
    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, AdvancedFixedWingSubSuperHypersonicAerodynamic, [AdvancedFixedWingSubSuperHypersonicAerodynamic, ])

agcls.AgClassCatalog.add_catalog_entry((4952686633379458317, 2294599711029805235), AdvancedFixedWingSubSuperHypersonicAerodynamic)
agcls.AgTypeNameMap["AdvancedFixedWingSubSuperHypersonicAerodynamic"] = AdvancedFixedWingSubSuperHypersonicAerodynamic

class AdvancedFixedWingSupersonicAerodynamic(SupportsDeleteCallback):
    """Interface used to access the options for the supersonic aerodynamic strategy in the advanced fixed wing tool."""

    _num_methods = 20
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_geometry_type_method_offset = 1
    _set_geometry_type_method_offset = 2
    _get_geometry_mode_as_basic_method_offset = 3
    _get_geometry_mode_as_variable_method_offset = 4
    _get_max_aoa_method_offset = 5
    _set_max_aoa_method_offset = 6
    _get_subsonic_cd0_method_offset = 7
    _set_subsonic_cd0_method_offset = 8
    _get_transonic_min_mach_method_offset = 9
    _set_transonic_min_mach_method_offset = 10
    _get_transonic_max_mach_method_offset = 11
    _set_transonic_max_mach_method_offset = 12
    _get_supersonic_max_mach_method_offset = 13
    _set_supersonic_max_mach_method_offset = 14
    _get_transonic_mach_drag_factor_method_offset = 15
    _set_transonic_mach_drag_factor_method_offset = 16
    _get_supersonic_mach_drag_factor_method_offset = 17
    _set_supersonic_mach_drag_factor_method_offset = 18
    _get_leading_edge_suction_efficiency_method_offset = 19
    _set_leading_edge_suction_efficiency_method_offset = 20
    _metadata = {
        "iid_data" : (4670617610581468956, 16867775200645798805),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingSupersonicAerodynamic)

    _get_geometry_type_metadata = { "offset" : _get_geometry_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AdvancedFixedWingGeometry),) }
    @property
    def geometry_type(self) -> "AdvancedFixedWingGeometry":
        """Get or set the type of wing geometry for the aircraft."""
        return self._intf.get_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._get_geometry_type_metadata)

    _set_geometry_type_metadata = { "offset" : _set_geometry_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AdvancedFixedWingGeometry),) }
    @geometry_type.setter
    def geometry_type(self, value:"AdvancedFixedWingGeometry") -> None:
        """Get or set the type of wing geometry for the aircraft."""
        return self._intf.set_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._set_geometry_type_metadata, value)

    _get_geometry_mode_as_basic_metadata = { "offset" : _get_geometry_mode_as_basic_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def geometry_mode_as_basic(self) -> "AdvancedFixedWingGeometryBasic":
        """Get the options for a basic geometry wing."""
        return self._intf.get_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._get_geometry_mode_as_basic_metadata)

    _get_geometry_mode_as_variable_metadata = { "offset" : _get_geometry_mode_as_variable_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def geometry_mode_as_variable(self) -> "AdvancedFixedWingGeometryVariable":
        """Get the options for a variable geometry wing."""
        return self._intf.get_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._get_geometry_mode_as_variable_metadata)

    _get_max_aoa_metadata = { "offset" : _get_max_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_aoa(self) -> typing.Any:
        """Get or set the maximum angle of attack possible."""
        return self._intf.get_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._get_max_aoa_metadata)

    _set_max_aoa_metadata = { "offset" : _set_max_aoa_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_aoa.setter
    def max_aoa(self, value:typing.Any) -> None:
        """Get or set the maximum angle of attack possible."""
        return self._intf.set_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._set_max_aoa_metadata, value)

    _get_subsonic_cd0_metadata = { "offset" : _get_subsonic_cd0_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def subsonic_cd0(self) -> float:
        """Get or set the parasitic drag coefficient of the aircraft when flying at a speed less than the Mach Divergence."""
        return self._intf.get_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._get_subsonic_cd0_metadata)

    _set_subsonic_cd0_metadata = { "offset" : _set_subsonic_cd0_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @subsonic_cd0.setter
    def subsonic_cd0(self, value:float) -> None:
        """Get or set the parasitic drag coefficient of the aircraft when flying at a speed less than the Mach Divergence."""
        return self._intf.set_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._set_subsonic_cd0_metadata, value)

    _get_transonic_min_mach_metadata = { "offset" : _get_transonic_min_mach_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def transonic_min_mach(self) -> float:
        """Get or set the minimum speed at which the aircraft begins to experience air compression."""
        return self._intf.get_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._get_transonic_min_mach_metadata)

    _set_transonic_min_mach_metadata = { "offset" : _set_transonic_min_mach_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @transonic_min_mach.setter
    def transonic_min_mach(self, value:float) -> None:
        """Get or set the minimum speed at which the aircraft begins to experience air compression."""
        return self._intf.set_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._set_transonic_min_mach_metadata, value)

    _get_transonic_max_mach_metadata = { "offset" : _get_transonic_max_mach_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def transonic_max_mach(self) -> float:
        """Get or set the maximum speed, below supersonic, at which the aircraft begins to experience air compression."""
        return self._intf.get_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._get_transonic_max_mach_metadata)

    _set_transonic_max_mach_metadata = { "offset" : _set_transonic_max_mach_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @transonic_max_mach.setter
    def transonic_max_mach(self, value:float) -> None:
        """Get or set the maximum speed, below supersonic, at which the aircraft begins to experience air compression."""
        return self._intf.set_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._set_transonic_max_mach_metadata, value)

    _get_supersonic_max_mach_metadata = { "offset" : _get_supersonic_max_mach_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def supersonic_max_mach(self) -> float:
        """Get or set the speed at which the Supersonic Mach Drag Factor is applied."""
        return self._intf.get_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._get_supersonic_max_mach_metadata)

    _set_supersonic_max_mach_metadata = { "offset" : _set_supersonic_max_mach_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @supersonic_max_mach.setter
    def supersonic_max_mach(self, value:float) -> None:
        """Get or set the speed at which the Supersonic Mach Drag Factor is applied."""
        return self._intf.set_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._set_supersonic_max_mach_metadata, value)

    _get_transonic_mach_drag_factor_metadata = { "offset" : _get_transonic_mach_drag_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def transonic_mach_drag_factor(self) -> float:
        """Get or set the factor applied to the aircraft's parasitic drag coefficient when it is flying between the Transonic Min Mach and Transonic Mach Drag Factor speeds."""
        return self._intf.get_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._get_transonic_mach_drag_factor_metadata)

    _set_transonic_mach_drag_factor_metadata = { "offset" : _set_transonic_mach_drag_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @transonic_mach_drag_factor.setter
    def transonic_mach_drag_factor(self, value:float) -> None:
        """Get or set the factor applied to the aircraft's parasitic drag coefficient when it is flying between the Transonic Min Mach and Transonic Mach Drag Factor speeds."""
        return self._intf.set_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._set_transonic_mach_drag_factor_metadata, value)

    _get_supersonic_mach_drag_factor_metadata = { "offset" : _get_supersonic_mach_drag_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def supersonic_mach_drag_factor(self) -> float:
        """Get or set the scalar value applied to the aircraft's parasitic drag coefficient when it is flying faster than the Supersonic Max Mach."""
        return self._intf.get_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._get_supersonic_mach_drag_factor_metadata)

    _set_supersonic_mach_drag_factor_metadata = { "offset" : _set_supersonic_mach_drag_factor_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @supersonic_mach_drag_factor.setter
    def supersonic_mach_drag_factor(self, value:float) -> None:
        """Get or set the scalar value applied to the aircraft's parasitic drag coefficient when it is flying faster than the Supersonic Max Mach."""
        return self._intf.set_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._set_supersonic_mach_drag_factor_metadata, value)

    _get_leading_edge_suction_efficiency_metadata = { "offset" : _get_leading_edge_suction_efficiency_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def leading_edge_suction_efficiency(self) -> float:
        """Get or set the ability of the wing's leading edge to ingest turbulent airflow and thereby reduce induced drag."""
        return self._intf.get_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._get_leading_edge_suction_efficiency_metadata)

    _set_leading_edge_suction_efficiency_metadata = { "offset" : _set_leading_edge_suction_efficiency_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @leading_edge_suction_efficiency.setter
    def leading_edge_suction_efficiency(self, value:float) -> None:
        """Get or set the ability of the wing's leading edge to ingest turbulent airflow and thereby reduce induced drag."""
        return self._intf.set_property(AdvancedFixedWingSupersonicAerodynamic._metadata, AdvancedFixedWingSupersonicAerodynamic._set_leading_edge_suction_efficiency_metadata, value)

    _property_names[geometry_type] = "geometry_type"
    _property_names[geometry_mode_as_basic] = "geometry_mode_as_basic"
    _property_names[geometry_mode_as_variable] = "geometry_mode_as_variable"
    _property_names[max_aoa] = "max_aoa"
    _property_names[subsonic_cd0] = "subsonic_cd0"
    _property_names[transonic_min_mach] = "transonic_min_mach"
    _property_names[transonic_max_mach] = "transonic_max_mach"
    _property_names[supersonic_max_mach] = "supersonic_max_mach"
    _property_names[transonic_mach_drag_factor] = "transonic_mach_drag_factor"
    _property_names[supersonic_mach_drag_factor] = "supersonic_mach_drag_factor"
    _property_names[leading_edge_suction_efficiency] = "leading_edge_suction_efficiency"

    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingSupersonicAerodynamic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingSupersonicAerodynamic)
    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, AdvancedFixedWingSupersonicAerodynamic, [AdvancedFixedWingSupersonicAerodynamic, ])

agcls.AgClassCatalog.add_catalog_entry((5450196044160187843, 1674866698247736221), AdvancedFixedWingSupersonicAerodynamic)
agcls.AgTypeNameMap["AdvancedFixedWingSupersonicAerodynamic"] = AdvancedFixedWingSupersonicAerodynamic

class PerformanceModel(IPerformanceModel, ICatalogItem, SupportsDeleteCallback):
    """Class defining an unknown performance model."""
    def __init__(self, source_object=None):
        """Construct an object of type PerformanceModel."""
        SupportsDeleteCallback.__init__(self)
        IPerformanceModel.__init__(self, source_object)
        ICatalogItem.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IPerformanceModel._private_init(self, intf)
        ICatalogItem._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, PerformanceModel, [IPerformanceModel, ICatalogItem])

agcls.AgClassCatalog.add_catalog_entry((4906634384985166370, 1876213520004692359), PerformanceModel)
agcls.AgTypeNameMap["PerformanceModel"] = PerformanceModel

class AdvancedFixedWingGeometryBasic(IAdvancedFixedWingGeometry, SupportsDeleteCallback):
    """Interface used to access the options for a basic geometry wing in the advanced fixed wing tool."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_aspect_ratio_method_offset = 1
    _set_aspect_ratio_method_offset = 2
    _get_wing_sweep_method_offset = 3
    _set_wing_sweep_method_offset = 4
    _metadata = {
        "iid_data" : (5059005218786994271, 963439622374066585),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingGeometryBasic)

    _get_aspect_ratio_metadata = { "offset" : _get_aspect_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def aspect_ratio(self) -> float:
        """Get the aspect ratio of the aircraft."""
        return self._intf.get_property(AdvancedFixedWingGeometryBasic._metadata, AdvancedFixedWingGeometryBasic._get_aspect_ratio_metadata)

    _set_aspect_ratio_metadata = { "offset" : _set_aspect_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    def set_aspect_ratio(self, aspect_ratio:float) -> None:
        """Set the aspect ratio of the aircraft."""
        return self._intf.invoke(AdvancedFixedWingGeometryBasic._metadata, AdvancedFixedWingGeometryBasic._set_aspect_ratio_metadata, aspect_ratio)

    _get_wing_sweep_metadata = { "offset" : _get_wing_sweep_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def wing_sweep(self) -> typing.Any:
        """Get or set the wing sweep of the aircraft."""
        return self._intf.get_property(AdvancedFixedWingGeometryBasic._metadata, AdvancedFixedWingGeometryBasic._get_wing_sweep_metadata)

    _set_wing_sweep_metadata = { "offset" : _set_wing_sweep_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @wing_sweep.setter
    def wing_sweep(self, value:typing.Any) -> None:
        """Get or set the wing sweep of the aircraft."""
        return self._intf.set_property(AdvancedFixedWingGeometryBasic._metadata, AdvancedFixedWingGeometryBasic._set_wing_sweep_metadata, value)

    _property_names[aspect_ratio] = "aspect_ratio"
    _property_names[wing_sweep] = "wing_sweep"

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

agcls.AgClassCatalog.add_catalog_entry((4777932001523849137, 741639022048858530), AdvancedFixedWingGeometryBasic)
agcls.AgTypeNameMap["AdvancedFixedWingGeometryBasic"] = AdvancedFixedWingGeometryBasic

class AdvancedFixedWingGeometryVariable(IAdvancedFixedWingGeometry, SupportsDeleteCallback):
    """Interface used to access the options for a variable geometry wing in the advanced fixed wing tool."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_aspect_ratio_method_offset = 1
    _set_aspect_ratio_method_offset = 2
    _get_start_sweep_mach_method_offset = 3
    _set_start_sweep_mach_method_offset = 4
    _get_stop_sweep_mach_method_offset = 5
    _set_stop_sweep_mach_method_offset = 6
    _get_min_sweep_angle_method_offset = 7
    _set_min_sweep_angle_method_offset = 8
    _get_max_sweep_angle_method_offset = 9
    _set_max_sweep_angle_method_offset = 10
    _metadata = {
        "iid_data" : (5135497072626624642, 14268566815327029893),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingGeometryVariable)

    _get_aspect_ratio_metadata = { "offset" : _get_aspect_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def aspect_ratio(self) -> float:
        """Get the aspect ratio of the aircraft."""
        return self._intf.get_property(AdvancedFixedWingGeometryVariable._metadata, AdvancedFixedWingGeometryVariable._get_aspect_ratio_metadata)

    _set_aspect_ratio_metadata = { "offset" : _set_aspect_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    def set_aspect_ratio(self, aspect_ratio:float) -> None:
        """Set the aspect ratio of the aircraft."""
        return self._intf.invoke(AdvancedFixedWingGeometryVariable._metadata, AdvancedFixedWingGeometryVariable._set_aspect_ratio_metadata, aspect_ratio)

    _get_start_sweep_mach_metadata = { "offset" : _get_start_sweep_mach_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def start_sweep_mach(self) -> float:
        """Get or set the mach number at which the wings start to sweep from the min sweep angle."""
        return self._intf.get_property(AdvancedFixedWingGeometryVariable._metadata, AdvancedFixedWingGeometryVariable._get_start_sweep_mach_metadata)

    _set_start_sweep_mach_metadata = { "offset" : _set_start_sweep_mach_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @start_sweep_mach.setter
    def start_sweep_mach(self, value:float) -> None:
        """Get or set the mach number at which the wings start to sweep from the min sweep angle."""
        return self._intf.set_property(AdvancedFixedWingGeometryVariable._metadata, AdvancedFixedWingGeometryVariable._set_start_sweep_mach_metadata, value)

    _get_stop_sweep_mach_metadata = { "offset" : _get_stop_sweep_mach_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def stop_sweep_mach(self) -> float:
        """Get or set the mach number at which the wings are swept to the max sweep angle."""
        return self._intf.get_property(AdvancedFixedWingGeometryVariable._metadata, AdvancedFixedWingGeometryVariable._get_stop_sweep_mach_metadata)

    _set_stop_sweep_mach_metadata = { "offset" : _set_stop_sweep_mach_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @stop_sweep_mach.setter
    def stop_sweep_mach(self, value:float) -> None:
        """Get or set the mach number at which the wings are swept to the max sweep angle."""
        return self._intf.set_property(AdvancedFixedWingGeometryVariable._metadata, AdvancedFixedWingGeometryVariable._set_stop_sweep_mach_metadata, value)

    _get_min_sweep_angle_metadata = { "offset" : _get_min_sweep_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def min_sweep_angle(self) -> typing.Any:
        """Get or set the minimum sweep angle of the wings."""
        return self._intf.get_property(AdvancedFixedWingGeometryVariable._metadata, AdvancedFixedWingGeometryVariable._get_min_sweep_angle_metadata)

    _set_min_sweep_angle_metadata = { "offset" : _set_min_sweep_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @min_sweep_angle.setter
    def min_sweep_angle(self, value:typing.Any) -> None:
        """Get or set the minimum sweep angle of the wings."""
        return self._intf.set_property(AdvancedFixedWingGeometryVariable._metadata, AdvancedFixedWingGeometryVariable._set_min_sweep_angle_metadata, value)

    _get_max_sweep_angle_metadata = { "offset" : _get_max_sweep_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_sweep_angle(self) -> typing.Any:
        """Get or set the maximum sweep angle of the wings."""
        return self._intf.get_property(AdvancedFixedWingGeometryVariable._metadata, AdvancedFixedWingGeometryVariable._get_max_sweep_angle_metadata)

    _set_max_sweep_angle_metadata = { "offset" : _set_max_sweep_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_sweep_angle.setter
    def max_sweep_angle(self, value:typing.Any) -> None:
        """Get or set the maximum sweep angle of the wings."""
        return self._intf.set_property(AdvancedFixedWingGeometryVariable._metadata, AdvancedFixedWingGeometryVariable._set_max_sweep_angle_metadata, value)

    _property_names[aspect_ratio] = "aspect_ratio"
    _property_names[start_sweep_mach] = "start_sweep_mach"
    _property_names[stop_sweep_mach] = "stop_sweep_mach"
    _property_names[min_sweep_angle] = "min_sweep_angle"
    _property_names[max_sweep_angle] = "max_sweep_angle"

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

agcls.AgClassCatalog.add_catalog_entry((4714699656490854060, 4645343672878635960), AdvancedFixedWingGeometryVariable)
agcls.AgTypeNameMap["AdvancedFixedWingGeometryVariable"] = AdvancedFixedWingGeometryVariable

class AdvancedFixedWingElectricPowerplant(SupportsDeleteCallback):
    """Interface used to access the options for the Electric powerplant strategy in the advanced fixed wing tool."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_max_power_method_offset = 1
    _set_max_power_method_offset = 2
    _get_propeller_count_method_offset = 3
    _set_propeller_count_method_offset = 4
    _get_propeller_diameter_method_offset = 5
    _set_propeller_diameter_method_offset = 6
    _metadata = {
        "iid_data" : (5323567609941829628, 9517624223825083288),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingElectricPowerplant)

    _get_max_power_metadata = { "offset" : _get_max_power_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_power(self) -> float:
        """Get or set the maximum power of the engine."""
        return self._intf.get_property(AdvancedFixedWingElectricPowerplant._metadata, AdvancedFixedWingElectricPowerplant._get_max_power_metadata)

    _set_max_power_metadata = { "offset" : _set_max_power_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_power.setter
    def max_power(self, value:float) -> None:
        """Get or set the maximum power of the engine."""
        return self._intf.set_property(AdvancedFixedWingElectricPowerplant._metadata, AdvancedFixedWingElectricPowerplant._set_max_power_metadata, value)

    _get_propeller_count_metadata = { "offset" : _get_propeller_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def propeller_count(self) -> int:
        """Get or set the number of propellers."""
        return self._intf.get_property(AdvancedFixedWingElectricPowerplant._metadata, AdvancedFixedWingElectricPowerplant._get_propeller_count_metadata)

    _set_propeller_count_metadata = { "offset" : _set_propeller_count_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @propeller_count.setter
    def propeller_count(self, value:int) -> None:
        """Get or set the number of propellers."""
        return self._intf.set_property(AdvancedFixedWingElectricPowerplant._metadata, AdvancedFixedWingElectricPowerplant._set_propeller_count_metadata, value)

    _get_propeller_diameter_metadata = { "offset" : _get_propeller_diameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def propeller_diameter(self) -> float:
        """Get or set the propeller diameter."""
        return self._intf.get_property(AdvancedFixedWingElectricPowerplant._metadata, AdvancedFixedWingElectricPowerplant._get_propeller_diameter_metadata)

    _set_propeller_diameter_metadata = { "offset" : _set_propeller_diameter_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @propeller_diameter.setter
    def propeller_diameter(self, value:float) -> None:
        """Get or set the propeller diameter."""
        return self._intf.set_property(AdvancedFixedWingElectricPowerplant._metadata, AdvancedFixedWingElectricPowerplant._set_propeller_diameter_metadata, value)

    _property_names[max_power] = "max_power"
    _property_names[propeller_count] = "propeller_count"
    _property_names[propeller_diameter] = "propeller_diameter"

    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingElectricPowerplant."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingElectricPowerplant)
    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, AdvancedFixedWingElectricPowerplant, [AdvancedFixedWingElectricPowerplant, ])

agcls.AgClassCatalog.add_catalog_entry((5409750622288828148, 653894210607339956), AdvancedFixedWingElectricPowerplant)
agcls.AgTypeNameMap["AdvancedFixedWingElectricPowerplant"] = AdvancedFixedWingElectricPowerplant

class AdvancedFixedWingExternalPropulsion(SupportsDeleteCallback):
    """Interface used to access the options for the External Prop File powerplant strategy in the advanced fixed wing tool."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_filepath_method_offset = 1
    _set_filepath_method_offset = 2
    _get_is_valid_method_offset = 3
    _metadata = {
        "iid_data" : (4997979588924974553, 2131361272405219996),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingExternalPropulsion)

    _get_filepath_metadata = { "offset" : _get_filepath_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def filepath(self) -> str:
        """Get the filepath for the external aero file."""
        return self._intf.get_property(AdvancedFixedWingExternalPropulsion._metadata, AdvancedFixedWingExternalPropulsion._get_filepath_metadata)

    _set_filepath_metadata = { "offset" : _set_filepath_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg,) }
    def set_filepath(self, filepath:str) -> str:
        """Set the filepath for the external aero file."""
        return self._intf.invoke(AdvancedFixedWingExternalPropulsion._metadata, AdvancedFixedWingExternalPropulsion._set_filepath_metadata, filepath, OutArg())

    _get_is_valid_metadata = { "offset" : _get_is_valid_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def is_valid(self) -> bool:
        """Check whether the filepath is valid."""
        return self._intf.get_property(AdvancedFixedWingExternalPropulsion._metadata, AdvancedFixedWingExternalPropulsion._get_is_valid_metadata)

    _property_names[filepath] = "filepath"
    _property_names[is_valid] = "is_valid"

    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingExternalPropulsion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingExternalPropulsion)
    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, AdvancedFixedWingExternalPropulsion, [AdvancedFixedWingExternalPropulsion, ])

agcls.AgClassCatalog.add_catalog_entry((5248810364255474372, 10276250267386325905), AdvancedFixedWingExternalPropulsion)
agcls.AgTypeNameMap["AdvancedFixedWingExternalPropulsion"] = AdvancedFixedWingExternalPropulsion

class AdvancedFixedWingSubSuperHypersonicPropulsion(SupportsDeleteCallback):
    """Interface used to access the options for the Sub/Super/Hypersonic powerplant strategy in the advanced fixed wing tool."""

    _num_methods = 25
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_turbine_mode_method_offset = 1
    _set_turbine_mode_method_offset = 2
    _get_turbine_mode_as_turbojet_method_offset = 3
    _get_turbine_mode_as_turbofan_method_offset = 4
    _get_ramjet_mode_method_offset = 5
    _set_ramjet_mode_method_offset = 6
    _get_ramjet_mode_as_basic_method_offset = 7
    _get_scramjet_mode_method_offset = 8
    _set_scramjet_mode_method_offset = 9
    _get_scramjet_mode_as_basic_method_offset = 10
    _get_turbine_reference_area_method_offset = 11
    _get_ramjet_reference_area_method_offset = 12
    _get_scramjet_reference_area_method_offset = 13
    _get_max_turbine_compression_temp_method_offset = 14
    _set_max_turbine_compression_temp_method_offset = 15
    _get_max_turbine_burner_temp_method_offset = 16
    _set_max_turbine_burner_temp_method_offset = 17
    _get_can_ram_compressor_pressure_ratio_method_offset = 18
    _set_can_ram_compressor_pressure_ratio_method_offset = 19
    _get_must_ram_compressor_pressure_ratio_method_offset = 20
    _set_must_ram_compressor_pressure_ratio_method_offset = 21
    _get_max_ram_scram_compression_temperature_method_offset = 22
    _set_max_ram_scram_compression_temperature_method_offset = 23
    _get_max_ram_scram_burner_total_temperature_method_offset = 24
    _set_max_ram_scram_burner_total_temperature_method_offset = 25
    _metadata = {
        "iid_data" : (5230764198344016963, 5005012326381662389),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingSubSuperHypersonicPropulsion)

    _get_turbine_mode_metadata = { "offset" : _get_turbine_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(TurbineMode),) }
    @property
    def turbine_mode(self) -> "TurbineMode":
        """Get or set the turbine operating mode."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._get_turbine_mode_metadata)

    _set_turbine_mode_metadata = { "offset" : _set_turbine_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(TurbineMode),) }
    @turbine_mode.setter
    def turbine_mode(self, value:"TurbineMode") -> None:
        """Get or set the turbine operating mode."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._set_turbine_mode_metadata, value)

    _get_turbine_mode_as_turbojet_metadata = { "offset" : _get_turbine_mode_as_turbojet_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def turbine_mode_as_turbojet(self) -> "AdvancedFixedWingTurbojetBasicABPropulsion":
        """Get or set the interface for a Turbojet Basic w/ AB tubrine mode."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._get_turbine_mode_as_turbojet_metadata)

    _get_turbine_mode_as_turbofan_metadata = { "offset" : _get_turbine_mode_as_turbofan_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def turbine_mode_as_turbofan(self) -> "AdvancedFixedWingTurbofanBasicABPropulsion":
        """Get or set the interface for a Turbojet Basic w/ AB tubrine mode."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._get_turbine_mode_as_turbofan_metadata)

    _get_ramjet_mode_metadata = { "offset" : _get_ramjet_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RamjetMode),) }
    @property
    def ramjet_mode(self) -> "RamjetMode":
        """Get or set the ramjet operating mode."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._get_ramjet_mode_metadata)

    _set_ramjet_mode_metadata = { "offset" : _set_ramjet_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(RamjetMode),) }
    @ramjet_mode.setter
    def ramjet_mode(self, value:"RamjetMode") -> None:
        """Get or set the ramjet operating mode."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._set_ramjet_mode_metadata, value)

    _get_ramjet_mode_as_basic_metadata = { "offset" : _get_ramjet_mode_as_basic_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def ramjet_mode_as_basic(self) -> "AdvancedFixedWingRamjetBasic":
        """Get the interface for a Ramjet - Basic."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._get_ramjet_mode_as_basic_metadata)

    _get_scramjet_mode_metadata = { "offset" : _get_scramjet_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ScramjetMode),) }
    @property
    def scramjet_mode(self) -> "ScramjetMode":
        """Get or set the scramjet operating mode."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._get_scramjet_mode_metadata)

    _set_scramjet_mode_metadata = { "offset" : _set_scramjet_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(ScramjetMode),) }
    @scramjet_mode.setter
    def scramjet_mode(self, value:"ScramjetMode") -> None:
        """Get or set the scramjet operating mode."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._set_scramjet_mode_metadata, value)

    _get_scramjet_mode_as_basic_metadata = { "offset" : _get_scramjet_mode_as_basic_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def scramjet_mode_as_basic(self) -> "AdvancedFixedWingScramjetBasic":
        """Get the interface for a Scramjet - Basic."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._get_scramjet_mode_as_basic_metadata)

    _get_turbine_reference_area_metadata = { "offset" : _get_turbine_reference_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def turbine_reference_area(self) -> float:
        """Get the reference area used for the turbine operating mode."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._get_turbine_reference_area_metadata)

    _get_ramjet_reference_area_metadata = { "offset" : _get_ramjet_reference_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def ramjet_reference_area(self) -> float:
        """Get the reference area used for the ramjet operating mode."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._get_ramjet_reference_area_metadata)

    _get_scramjet_reference_area_metadata = { "offset" : _get_scramjet_reference_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def scramjet_reference_area(self) -> float:
        """Get the reference area used for the scramjet operating mode."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._get_scramjet_reference_area_metadata)

    _get_max_turbine_compression_temp_metadata = { "offset" : _get_max_turbine_compression_temp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_turbine_compression_temp(self) -> float:
        """Get or set the maximum temperature at the compressor stage in the turbine operating mode."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._get_max_turbine_compression_temp_metadata)

    _set_max_turbine_compression_temp_metadata = { "offset" : _set_max_turbine_compression_temp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_turbine_compression_temp.setter
    def max_turbine_compression_temp(self, value:float) -> None:
        """Get or set the maximum temperature at the compressor stage in the turbine operating mode."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._set_max_turbine_compression_temp_metadata, value)

    _get_max_turbine_burner_temp_metadata = { "offset" : _get_max_turbine_burner_temp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_turbine_burner_temp(self) -> float:
        """Get or set the maximum temperature at the combustion stage in the turbine operating mode."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._get_max_turbine_burner_temp_metadata)

    _set_max_turbine_burner_temp_metadata = { "offset" : _set_max_turbine_burner_temp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_turbine_burner_temp.setter
    def max_turbine_burner_temp(self, value:float) -> None:
        """Get or set the maximum temperature at the combustion stage in the turbine operating mode."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._set_max_turbine_burner_temp_metadata, value)

    _get_can_ram_compressor_pressure_ratio_metadata = { "offset" : _get_can_ram_compressor_pressure_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def can_ram_compressor_pressure_ratio(self) -> float:
        """Can Ram compressor pressure ratio."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._get_can_ram_compressor_pressure_ratio_metadata)

    _set_can_ram_compressor_pressure_ratio_metadata = { "offset" : _set_can_ram_compressor_pressure_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @can_ram_compressor_pressure_ratio.setter
    def can_ram_compressor_pressure_ratio(self, value:float) -> None:
        """Can Ram compressor pressure ratio."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._set_can_ram_compressor_pressure_ratio_metadata, value)

    _get_must_ram_compressor_pressure_ratio_metadata = { "offset" : _get_must_ram_compressor_pressure_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def must_ram_compressor_pressure_ratio(self) -> float:
        """Must Ram compressor pressure ratio."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._get_must_ram_compressor_pressure_ratio_metadata)

    _set_must_ram_compressor_pressure_ratio_metadata = { "offset" : _set_must_ram_compressor_pressure_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @must_ram_compressor_pressure_ratio.setter
    def must_ram_compressor_pressure_ratio(self, value:float) -> None:
        """Must Ram compressor pressure ratio."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._set_must_ram_compressor_pressure_ratio_metadata, value)

    _get_max_ram_scram_compression_temperature_metadata = { "offset" : _get_max_ram_scram_compression_temperature_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_ram_scram_compression_temperature(self) -> float:
        """Get or set the maximum temperature at the compressor stage in the Ramjet or Scramjet operating mode."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._get_max_ram_scram_compression_temperature_metadata)

    _set_max_ram_scram_compression_temperature_metadata = { "offset" : _set_max_ram_scram_compression_temperature_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_ram_scram_compression_temperature.setter
    def max_ram_scram_compression_temperature(self, value:float) -> None:
        """Get or set the maximum temperature at the compressor stage in the Ramjet or Scramjet operating mode."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._set_max_ram_scram_compression_temperature_metadata, value)

    _get_max_ram_scram_burner_total_temperature_metadata = { "offset" : _get_max_ram_scram_burner_total_temperature_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_ram_scram_burner_total_temperature(self) -> float:
        """Get or set the maximum temperature at the combustion stage in the Ramjet or Scramjet operating mode."""
        return self._intf.get_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._get_max_ram_scram_burner_total_temperature_metadata)

    _set_max_ram_scram_burner_total_temperature_metadata = { "offset" : _set_max_ram_scram_burner_total_temperature_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_ram_scram_burner_total_temperature.setter
    def max_ram_scram_burner_total_temperature(self, value:float) -> None:
        """Get or set the maximum temperature at the combustion stage in the Ramjet or Scramjet operating mode."""
        return self._intf.set_property(AdvancedFixedWingSubSuperHypersonicPropulsion._metadata, AdvancedFixedWingSubSuperHypersonicPropulsion._set_max_ram_scram_burner_total_temperature_metadata, value)

    _property_names[turbine_mode] = "turbine_mode"
    _property_names[turbine_mode_as_turbojet] = "turbine_mode_as_turbojet"
    _property_names[turbine_mode_as_turbofan] = "turbine_mode_as_turbofan"
    _property_names[ramjet_mode] = "ramjet_mode"
    _property_names[ramjet_mode_as_basic] = "ramjet_mode_as_basic"
    _property_names[scramjet_mode] = "scramjet_mode"
    _property_names[scramjet_mode_as_basic] = "scramjet_mode_as_basic"
    _property_names[turbine_reference_area] = "turbine_reference_area"
    _property_names[ramjet_reference_area] = "ramjet_reference_area"
    _property_names[scramjet_reference_area] = "scramjet_reference_area"
    _property_names[max_turbine_compression_temp] = "max_turbine_compression_temp"
    _property_names[max_turbine_burner_temp] = "max_turbine_burner_temp"
    _property_names[can_ram_compressor_pressure_ratio] = "can_ram_compressor_pressure_ratio"
    _property_names[must_ram_compressor_pressure_ratio] = "must_ram_compressor_pressure_ratio"
    _property_names[max_ram_scram_compression_temperature] = "max_ram_scram_compression_temperature"
    _property_names[max_ram_scram_burner_total_temperature] = "max_ram_scram_burner_total_temperature"

    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingSubSuperHypersonicPropulsion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingSubSuperHypersonicPropulsion)
    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, AdvancedFixedWingSubSuperHypersonicPropulsion, [AdvancedFixedWingSubSuperHypersonicPropulsion, ])

agcls.AgClassCatalog.add_catalog_entry((5011678706765634819, 12159855238285393045), AdvancedFixedWingSubSuperHypersonicPropulsion)
agcls.AgTypeNameMap["AdvancedFixedWingSubSuperHypersonicPropulsion"] = AdvancedFixedWingSubSuperHypersonicPropulsion

class AdvancedFixedWingPistonPowerplant(SupportsDeleteCallback):
    """Interface used to access the options for the Piston powerplant strategy in the advanced fixed wing tool."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_max_sea_level_static_power_method_offset = 1
    _set_max_sea_level_static_power_method_offset = 2
    _get_critical_altitude_method_offset = 3
    _set_critical_altitude_method_offset = 4
    _get_propeller_count_method_offset = 5
    _set_propeller_count_method_offset = 6
    _get_propeller_diameter_method_offset = 7
    _set_propeller_diameter_method_offset = 8
    _get_fuel_flow_method_offset = 9
    _set_fuel_flow_method_offset = 10
    _metadata = {
        "iid_data" : (4935298023931483912, 9470029545764234654),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingPistonPowerplant)

    _get_max_sea_level_static_power_metadata = { "offset" : _get_max_sea_level_static_power_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_sea_level_static_power(self) -> float:
        """Get or set the maximum static power of the engine at sea level."""
        return self._intf.get_property(AdvancedFixedWingPistonPowerplant._metadata, AdvancedFixedWingPistonPowerplant._get_max_sea_level_static_power_metadata)

    _set_max_sea_level_static_power_metadata = { "offset" : _set_max_sea_level_static_power_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_sea_level_static_power.setter
    def max_sea_level_static_power(self, value:float) -> None:
        """Get or set the maximum static power of the engine at sea level."""
        return self._intf.set_property(AdvancedFixedWingPistonPowerplant._metadata, AdvancedFixedWingPistonPowerplant._set_max_sea_level_static_power_metadata, value)

    _get_critical_altitude_metadata = { "offset" : _get_critical_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def critical_altitude(self) -> float:
        """Get or set the engine's critical altitude."""
        return self._intf.get_property(AdvancedFixedWingPistonPowerplant._metadata, AdvancedFixedWingPistonPowerplant._get_critical_altitude_metadata)

    _set_critical_altitude_metadata = { "offset" : _set_critical_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @critical_altitude.setter
    def critical_altitude(self, value:float) -> None:
        """Get or set the engine's critical altitude."""
        return self._intf.set_property(AdvancedFixedWingPistonPowerplant._metadata, AdvancedFixedWingPistonPowerplant._set_critical_altitude_metadata, value)

    _get_propeller_count_metadata = { "offset" : _get_propeller_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def propeller_count(self) -> int:
        """Get or set the number of propellers."""
        return self._intf.get_property(AdvancedFixedWingPistonPowerplant._metadata, AdvancedFixedWingPistonPowerplant._get_propeller_count_metadata)

    _set_propeller_count_metadata = { "offset" : _set_propeller_count_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @propeller_count.setter
    def propeller_count(self, value:int) -> None:
        """Get or set the number of propellers."""
        return self._intf.set_property(AdvancedFixedWingPistonPowerplant._metadata, AdvancedFixedWingPistonPowerplant._set_propeller_count_metadata, value)

    _get_propeller_diameter_metadata = { "offset" : _get_propeller_diameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def propeller_diameter(self) -> float:
        """Get or set the propeller diameter."""
        return self._intf.get_property(AdvancedFixedWingPistonPowerplant._metadata, AdvancedFixedWingPistonPowerplant._get_propeller_diameter_metadata)

    _set_propeller_diameter_metadata = { "offset" : _set_propeller_diameter_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @propeller_diameter.setter
    def propeller_diameter(self, value:float) -> None:
        """Get or set the propeller diameter."""
        return self._intf.set_property(AdvancedFixedWingPistonPowerplant._metadata, AdvancedFixedWingPistonPowerplant._set_propeller_diameter_metadata, value)

    _get_fuel_flow_metadata = { "offset" : _get_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fuel_flow(self) -> float:
        """Get or set the engine's fuel flow at max power."""
        return self._intf.get_property(AdvancedFixedWingPistonPowerplant._metadata, AdvancedFixedWingPistonPowerplant._get_fuel_flow_metadata)

    _set_fuel_flow_metadata = { "offset" : _set_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fuel_flow.setter
    def fuel_flow(self, value:float) -> None:
        """Get or set the engine's fuel flow at max power."""
        return self._intf.set_property(AdvancedFixedWingPistonPowerplant._metadata, AdvancedFixedWingPistonPowerplant._set_fuel_flow_metadata, value)

    _property_names[max_sea_level_static_power] = "max_sea_level_static_power"
    _property_names[critical_altitude] = "critical_altitude"
    _property_names[propeller_count] = "propeller_count"
    _property_names[propeller_diameter] = "propeller_diameter"
    _property_names[fuel_flow] = "fuel_flow"

    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingPistonPowerplant."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingPistonPowerplant)
    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, AdvancedFixedWingPistonPowerplant, [AdvancedFixedWingPistonPowerplant, ])

agcls.AgClassCatalog.add_catalog_entry((5404022589632298539, 3796637743485632914), AdvancedFixedWingPistonPowerplant)
agcls.AgTypeNameMap["AdvancedFixedWingPistonPowerplant"] = AdvancedFixedWingPistonPowerplant

class AdvancedFixedWingEmpiricalJetEngine(SupportsDeleteCallback):
    """Interface used to access the options for the Sub/Super/Hypersonic powerplant strategy in the advanced fixed wing tool."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_max_sea_level_static_thrust_method_offset = 1
    _set_max_sea_level_static_thrust_method_offset = 2
    _get_design_point_altitude_method_offset = 3
    _set_design_point_altitude_method_offset = 4
    _get_design_point_mach_number_method_offset = 5
    _set_design_point_mach_number_method_offset = 6
    _get_fuel_flow_method_offset = 7
    _set_fuel_flow_method_offset = 8
    _metadata = {
        "iid_data" : (5442029511614548464, 3220950130539061420),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingEmpiricalJetEngine)

    _get_max_sea_level_static_thrust_metadata = { "offset" : _get_max_sea_level_static_thrust_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_sea_level_static_thrust(self) -> float:
        """Get or set the maximum static thrust of the engine at sea level."""
        return self._intf.get_property(AdvancedFixedWingEmpiricalJetEngine._metadata, AdvancedFixedWingEmpiricalJetEngine._get_max_sea_level_static_thrust_metadata)

    _set_max_sea_level_static_thrust_metadata = { "offset" : _set_max_sea_level_static_thrust_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_sea_level_static_thrust.setter
    def max_sea_level_static_thrust(self, value:float) -> None:
        """Get or set the maximum static thrust of the engine at sea level."""
        return self._intf.set_property(AdvancedFixedWingEmpiricalJetEngine._metadata, AdvancedFixedWingEmpiricalJetEngine._set_max_sea_level_static_thrust_metadata, value)

    _get_design_point_altitude_metadata = { "offset" : _get_design_point_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_point_altitude(self) -> float:
        """Get or set the altitude design point of the engine."""
        return self._intf.get_property(AdvancedFixedWingEmpiricalJetEngine._metadata, AdvancedFixedWingEmpiricalJetEngine._get_design_point_altitude_metadata)

    _set_design_point_altitude_metadata = { "offset" : _set_design_point_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_point_altitude.setter
    def design_point_altitude(self, value:float) -> None:
        """Get or set the altitude design point of the engine."""
        return self._intf.set_property(AdvancedFixedWingEmpiricalJetEngine._metadata, AdvancedFixedWingEmpiricalJetEngine._set_design_point_altitude_metadata, value)

    _get_design_point_mach_number_metadata = { "offset" : _get_design_point_mach_number_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_point_mach_number(self) -> float:
        """Get or set the mach number design point of the engine."""
        return self._intf.get_property(AdvancedFixedWingEmpiricalJetEngine._metadata, AdvancedFixedWingEmpiricalJetEngine._get_design_point_mach_number_metadata)

    _set_design_point_mach_number_metadata = { "offset" : _set_design_point_mach_number_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_point_mach_number.setter
    def design_point_mach_number(self, value:float) -> None:
        """Get or set the mach number design point of the engine."""
        return self._intf.set_property(AdvancedFixedWingEmpiricalJetEngine._metadata, AdvancedFixedWingEmpiricalJetEngine._set_design_point_mach_number_metadata, value)

    _get_fuel_flow_metadata = { "offset" : _get_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fuel_flow(self) -> float:
        """Get or set the engine's fuel flow at max power."""
        return self._intf.get_property(AdvancedFixedWingEmpiricalJetEngine._metadata, AdvancedFixedWingEmpiricalJetEngine._get_fuel_flow_metadata)

    _set_fuel_flow_metadata = { "offset" : _set_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fuel_flow.setter
    def fuel_flow(self, value:float) -> None:
        """Get or set the engine's fuel flow at max power."""
        return self._intf.set_property(AdvancedFixedWingEmpiricalJetEngine._metadata, AdvancedFixedWingEmpiricalJetEngine._set_fuel_flow_metadata, value)

    _property_names[max_sea_level_static_thrust] = "max_sea_level_static_thrust"
    _property_names[design_point_altitude] = "design_point_altitude"
    _property_names[design_point_mach_number] = "design_point_mach_number"
    _property_names[fuel_flow] = "fuel_flow"

    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingEmpiricalJetEngine."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingEmpiricalJetEngine)
    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, AdvancedFixedWingEmpiricalJetEngine, [AdvancedFixedWingEmpiricalJetEngine, ])

agcls.AgClassCatalog.add_catalog_entry((5173205300249269855, 3414284464176281766), AdvancedFixedWingEmpiricalJetEngine)
agcls.AgTypeNameMap["AdvancedFixedWingEmpiricalJetEngine"] = AdvancedFixedWingEmpiricalJetEngine

class AdvancedFixedWingTurbofanBasicABPowerplant(SupportsDeleteCallback):
    """Do not use this interface, as it is deprecated. Use AdvancedFixedWingTurbofanBasicABPropulsion instead."""

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


    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingTurbofanBasicABPowerplant."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingTurbofanBasicABPowerplant)
    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, AdvancedFixedWingTurbofanBasicABPowerplant, [AdvancedFixedWingTurbofanBasicABPowerplant, ])

agcls.AgClassCatalog.add_catalog_entry((5401994752137022731, 14788126705060767635), AdvancedFixedWingTurbofanBasicABPowerplant)
agcls.AgTypeNameMap["AdvancedFixedWingTurbofanBasicABPowerplant"] = AdvancedFixedWingTurbofanBasicABPowerplant

class AdvancedFixedWingTurbojetBasicABPowerplant(SupportsDeleteCallback):
    """Do not use this interface, as it is deprecated. Use AdvancedFixedWingTurbojetBasicABPropulsion instead."""

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


    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingTurbojetBasicABPowerplant."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingTurbojetBasicABPowerplant)
    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, AdvancedFixedWingTurbojetBasicABPowerplant, [AdvancedFixedWingTurbojetBasicABPowerplant, ])

agcls.AgClassCatalog.add_catalog_entry((5440608781197312823, 13762363781635156626), AdvancedFixedWingTurbojetBasicABPowerplant)
agcls.AgTypeNameMap["AdvancedFixedWingTurbojetBasicABPowerplant"] = AdvancedFixedWingTurbojetBasicABPowerplant

class AdvancedFixedWingTurbofanBasicABPropulsion(SupportsDeleteCallback):
    """Interface used to access the options for the Turbofan - Basic w/AB (Thermodynamic) powerplant strategy in the advanced fixed wing tool."""

    _num_methods = 27
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_can_use_afterburner_method_offset = 1
    _set_can_use_afterburner_method_offset = 2
    _get_design_altitude_method_offset = 3
    _set_design_altitude_method_offset = 4
    _get_design_mach_method_offset = 5
    _set_design_mach_method_offset = 6
    _get_design_thrust_method_offset = 7
    _set_design_thrust_method_offset = 8
    _get_afterburner_on_method_offset = 9
    _set_afterburner_on_method_offset = 10
    _get_max_compression_temp_method_offset = 11
    _set_max_compression_temp_method_offset = 12
    _get_max_burner_temp_method_offset = 13
    _set_max_burner_temp_method_offset = 14
    _get_max_afterburner_temp_method_offset = 15
    _set_max_afterburner_temp_method_offset = 16
    _get_hpc_pressure_ratio_method_offset = 17
    _set_hpc_pressure_ratio_method_offset = 18
    _get_lpc_pressure_ratio_method_offset = 19
    _set_lpc_pressure_ratio_method_offset = 20
    _get_fan_pressure_ratio_method_offset = 21
    _set_fan_pressure_ratio_method_offset = 22
    _get_efficiencies_and_losses_method_offset = 23
    _get_fuel_type_method_offset = 24
    _set_fuel_type_method_offset = 25
    _get_fuel_mode_as_afprop_method_offset = 26
    _get_fuel_mode_as_cea_method_offset = 27
    _metadata = {
        "iid_data" : (5166061279867733857, 6770102323018610328),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingTurbofanBasicABPropulsion)

    _get_can_use_afterburner_metadata = { "offset" : _get_can_use_afterburner_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def can_use_afterburner(self) -> bool:
        """Opt whether the engine has an afterburner."""
        return self._intf.get_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._get_can_use_afterburner_metadata)

    _set_can_use_afterburner_metadata = { "offset" : _set_can_use_afterburner_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @can_use_afterburner.setter
    def can_use_afterburner(self, value:bool) -> None:
        """Opt whether the engine has an afterburner."""
        return self._intf.set_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._set_can_use_afterburner_metadata, value)

    _get_design_altitude_metadata = { "offset" : _get_design_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_altitude(self) -> float:
        """Get or set the altitude design point of the engine."""
        return self._intf.get_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._get_design_altitude_metadata)

    _set_design_altitude_metadata = { "offset" : _set_design_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_altitude.setter
    def design_altitude(self, value:float) -> None:
        """Get or set the altitude design point of the engine."""
        return self._intf.set_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._set_design_altitude_metadata, value)

    _get_design_mach_metadata = { "offset" : _get_design_mach_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_mach(self) -> float:
        """Get or set the mach number design point of the engine."""
        return self._intf.get_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._get_design_mach_metadata)

    _set_design_mach_metadata = { "offset" : _set_design_mach_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_mach.setter
    def design_mach(self, value:float) -> None:
        """Get or set the mach number design point of the engine."""
        return self._intf.set_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._set_design_mach_metadata, value)

    _get_design_thrust_metadata = { "offset" : _get_design_thrust_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_thrust(self) -> float:
        """Get or set the thrust design point of the engine."""
        return self._intf.get_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._get_design_thrust_metadata)

    _set_design_thrust_metadata = { "offset" : _set_design_thrust_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_thrust.setter
    def design_thrust(self, value:float) -> None:
        """Get or set the thrust design point of the engine."""
        return self._intf.set_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._set_design_thrust_metadata, value)

    _get_afterburner_on_metadata = { "offset" : _get_afterburner_on_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def afterburner_on(self) -> bool:
        """Opt whether to specify the design point with the afterburner on."""
        return self._intf.get_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._get_afterburner_on_metadata)

    _set_afterburner_on_metadata = { "offset" : _set_afterburner_on_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @afterburner_on.setter
    def afterburner_on(self, value:bool) -> None:
        """Opt whether to specify the design point with the afterburner on."""
        return self._intf.set_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._set_afterburner_on_metadata, value)

    _get_max_compression_temp_metadata = { "offset" : _get_max_compression_temp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_compression_temp(self) -> float:
        """Get or set the maximum temperature at the compressor stage."""
        return self._intf.get_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._get_max_compression_temp_metadata)

    _set_max_compression_temp_metadata = { "offset" : _set_max_compression_temp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_compression_temp.setter
    def max_compression_temp(self, value:float) -> None:
        """Get or set the maximum temperature at the compressor stage."""
        return self._intf.set_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._set_max_compression_temp_metadata, value)

    _get_max_burner_temp_metadata = { "offset" : _get_max_burner_temp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_burner_temp(self) -> float:
        """Get or set the maximum temperature at the combustion stage."""
        return self._intf.get_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._get_max_burner_temp_metadata)

    _set_max_burner_temp_metadata = { "offset" : _set_max_burner_temp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_burner_temp.setter
    def max_burner_temp(self, value:float) -> None:
        """Get or set the maximum temperature at the combustion stage."""
        return self._intf.set_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._set_max_burner_temp_metadata, value)

    _get_max_afterburner_temp_metadata = { "offset" : _get_max_afterburner_temp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_afterburner_temp(self) -> float:
        """Get or set the maximum temperature at the afterburner."""
        return self._intf.get_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._get_max_afterburner_temp_metadata)

    _set_max_afterburner_temp_metadata = { "offset" : _set_max_afterburner_temp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_afterburner_temp.setter
    def max_afterburner_temp(self, value:float) -> None:
        """Get or set the maximum temperature at the afterburner."""
        return self._intf.set_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._set_max_afterburner_temp_metadata, value)

    _get_hpc_pressure_ratio_metadata = { "offset" : _get_hpc_pressure_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def hpc_pressure_ratio(self) -> float:
        """Get or set the pressure ratio of the high-pressure compressor."""
        return self._intf.get_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._get_hpc_pressure_ratio_metadata)

    _set_hpc_pressure_ratio_metadata = { "offset" : _set_hpc_pressure_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @hpc_pressure_ratio.setter
    def hpc_pressure_ratio(self, value:float) -> None:
        """Get or set the pressure ratio of the high-pressure compressor."""
        return self._intf.set_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._set_hpc_pressure_ratio_metadata, value)

    _get_lpc_pressure_ratio_metadata = { "offset" : _get_lpc_pressure_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def lpc_pressure_ratio(self) -> float:
        """Get or set the pressure ratio of the low-pressure compressor."""
        return self._intf.get_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._get_lpc_pressure_ratio_metadata)

    _set_lpc_pressure_ratio_metadata = { "offset" : _set_lpc_pressure_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @lpc_pressure_ratio.setter
    def lpc_pressure_ratio(self, value:float) -> None:
        """Get or set the pressure ratio of the low-pressure compressor."""
        return self._intf.set_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._set_lpc_pressure_ratio_metadata, value)

    _get_fan_pressure_ratio_metadata = { "offset" : _get_fan_pressure_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fan_pressure_ratio(self) -> float:
        """Get or set the pressure ratio of the fan."""
        return self._intf.get_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._get_fan_pressure_ratio_metadata)

    _set_fan_pressure_ratio_metadata = { "offset" : _set_fan_pressure_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fan_pressure_ratio.setter
    def fan_pressure_ratio(self, value:float) -> None:
        """Get or set the pressure ratio of the fan."""
        return self._intf.set_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._set_fan_pressure_ratio_metadata, value)

    _get_efficiencies_and_losses_metadata = { "offset" : _get_efficiencies_and_losses_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def efficiencies_and_losses(self) -> "PropulsionEfficiencies":
        """Get the jet engine's propulsion efficiencies and losses."""
        return self._intf.get_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._get_efficiencies_and_losses_metadata)

    _get_fuel_type_metadata = { "offset" : _get_fuel_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(JetFuelType),) }
    @property
    def fuel_type(self) -> "JetFuelType":
        """Get or set the jet engine's fuel type."""
        return self._intf.get_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._get_fuel_type_metadata)

    _set_fuel_type_metadata = { "offset" : _set_fuel_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(JetFuelType),) }
    @fuel_type.setter
    def fuel_type(self, value:"JetFuelType") -> None:
        """Get or set the jet engine's fuel type."""
        return self._intf.set_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._set_fuel_type_metadata, value)

    _get_fuel_mode_as_afprop_metadata = { "offset" : _get_fuel_mode_as_afprop_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def fuel_mode_as_afprop(self) -> "FuelModelKeroseneAFPROP":
        """Get the interface for a Kerosene - AFPROP fuel mode."""
        return self._intf.get_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._get_fuel_mode_as_afprop_metadata)

    _get_fuel_mode_as_cea_metadata = { "offset" : _get_fuel_mode_as_cea_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def fuel_mode_as_cea(self) -> "FuelModelKeroseneCEA":
        """Get the interface for a Kerosene - CEA fuel mode."""
        return self._intf.get_property(AdvancedFixedWingTurbofanBasicABPropulsion._metadata, AdvancedFixedWingTurbofanBasicABPropulsion._get_fuel_mode_as_cea_metadata)

    _property_names[can_use_afterburner] = "can_use_afterburner"
    _property_names[design_altitude] = "design_altitude"
    _property_names[design_mach] = "design_mach"
    _property_names[design_thrust] = "design_thrust"
    _property_names[afterburner_on] = "afterburner_on"
    _property_names[max_compression_temp] = "max_compression_temp"
    _property_names[max_burner_temp] = "max_burner_temp"
    _property_names[max_afterburner_temp] = "max_afterburner_temp"
    _property_names[hpc_pressure_ratio] = "hpc_pressure_ratio"
    _property_names[lpc_pressure_ratio] = "lpc_pressure_ratio"
    _property_names[fan_pressure_ratio] = "fan_pressure_ratio"
    _property_names[efficiencies_and_losses] = "efficiencies_and_losses"
    _property_names[fuel_type] = "fuel_type"
    _property_names[fuel_mode_as_afprop] = "fuel_mode_as_afprop"
    _property_names[fuel_mode_as_cea] = "fuel_mode_as_cea"

    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingTurbofanBasicABPropulsion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingTurbofanBasicABPropulsion)
    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, AdvancedFixedWingTurbofanBasicABPropulsion, [AdvancedFixedWingTurbofanBasicABPropulsion, ])

agcls.AgClassCatalog.add_catalog_entry((4926635412744452730, 7898790107185743281), AdvancedFixedWingTurbofanBasicABPropulsion)
agcls.AgTypeNameMap["AdvancedFixedWingTurbofanBasicABPropulsion"] = AdvancedFixedWingTurbofanBasicABPropulsion

class AdvancedFixedWingTurbojetBasicABPropulsion(SupportsDeleteCallback):
    """Interface used to access the options for the Turbojet - Basic w/AB (Thermodynamic) powerplant strategy in the advanced fixed wing tool."""

    _num_methods = 25
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_can_use_afterburner_method_offset = 1
    _set_can_use_afterburner_method_offset = 2
    _get_design_altitude_method_offset = 3
    _set_design_altitude_method_offset = 4
    _get_design_mach_method_offset = 5
    _set_design_mach_method_offset = 6
    _get_design_thrust_method_offset = 7
    _set_design_thrust_method_offset = 8
    _get_afterburner_on_method_offset = 9
    _set_afterburner_on_method_offset = 10
    _get_max_compression_temp_method_offset = 11
    _set_max_compression_temp_method_offset = 12
    _get_max_burner_temp_method_offset = 13
    _set_max_burner_temp_method_offset = 14
    _get_max_afterburner_temp_method_offset = 15
    _set_max_afterburner_temp_method_offset = 16
    _get_hpc_pressure_ratio_method_offset = 17
    _set_hpc_pressure_ratio_method_offset = 18
    _get_lpc_pressure_ratio_method_offset = 19
    _set_lpc_pressure_ratio_method_offset = 20
    _get_efficiencies_and_losses_method_offset = 21
    _get_fuel_type_method_offset = 22
    _set_fuel_type_method_offset = 23
    _get_fuel_mode_as_afprop_method_offset = 24
    _get_fuel_mode_as_cea_method_offset = 25
    _metadata = {
        "iid_data" : (4804351312805502443, 1729423068310996360),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingTurbojetBasicABPropulsion)

    _get_can_use_afterburner_metadata = { "offset" : _get_can_use_afterburner_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def can_use_afterburner(self) -> bool:
        """Opt whether the engine has an afterburner."""
        return self._intf.get_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._get_can_use_afterburner_metadata)

    _set_can_use_afterburner_metadata = { "offset" : _set_can_use_afterburner_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @can_use_afterburner.setter
    def can_use_afterburner(self, value:bool) -> None:
        """Opt whether the engine has an afterburner."""
        return self._intf.set_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._set_can_use_afterburner_metadata, value)

    _get_design_altitude_metadata = { "offset" : _get_design_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_altitude(self) -> float:
        """Get or set the altitude design point of the engine."""
        return self._intf.get_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._get_design_altitude_metadata)

    _set_design_altitude_metadata = { "offset" : _set_design_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_altitude.setter
    def design_altitude(self, value:float) -> None:
        """Get or set the altitude design point of the engine."""
        return self._intf.set_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._set_design_altitude_metadata, value)

    _get_design_mach_metadata = { "offset" : _get_design_mach_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_mach(self) -> float:
        """Get or set the mach number design point of the engine."""
        return self._intf.get_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._get_design_mach_metadata)

    _set_design_mach_metadata = { "offset" : _set_design_mach_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_mach.setter
    def design_mach(self, value:float) -> None:
        """Get or set the mach number design point of the engine."""
        return self._intf.set_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._set_design_mach_metadata, value)

    _get_design_thrust_metadata = { "offset" : _get_design_thrust_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_thrust(self) -> float:
        """Get or set the thrust design point of the engine."""
        return self._intf.get_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._get_design_thrust_metadata)

    _set_design_thrust_metadata = { "offset" : _set_design_thrust_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_thrust.setter
    def design_thrust(self, value:float) -> None:
        """Get or set the thrust design point of the engine."""
        return self._intf.set_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._set_design_thrust_metadata, value)

    _get_afterburner_on_metadata = { "offset" : _get_afterburner_on_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def afterburner_on(self) -> bool:
        """Opt whether to specify the design point with the afterburner on."""
        return self._intf.get_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._get_afterburner_on_metadata)

    _set_afterburner_on_metadata = { "offset" : _set_afterburner_on_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @afterburner_on.setter
    def afterburner_on(self, value:bool) -> None:
        """Opt whether to specify the design point with the afterburner on."""
        return self._intf.set_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._set_afterburner_on_metadata, value)

    _get_max_compression_temp_metadata = { "offset" : _get_max_compression_temp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_compression_temp(self) -> float:
        """Get or set the maximum temperature at the compressor stage."""
        return self._intf.get_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._get_max_compression_temp_metadata)

    _set_max_compression_temp_metadata = { "offset" : _set_max_compression_temp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_compression_temp.setter
    def max_compression_temp(self, value:float) -> None:
        """Get or set the maximum temperature at the compressor stage."""
        return self._intf.set_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._set_max_compression_temp_metadata, value)

    _get_max_burner_temp_metadata = { "offset" : _get_max_burner_temp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_burner_temp(self) -> float:
        """Get or set the maximum temperature at the combustion stage."""
        return self._intf.get_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._get_max_burner_temp_metadata)

    _set_max_burner_temp_metadata = { "offset" : _set_max_burner_temp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_burner_temp.setter
    def max_burner_temp(self, value:float) -> None:
        """Get or set the maximum temperature at the combustion stage."""
        return self._intf.set_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._set_max_burner_temp_metadata, value)

    _get_max_afterburner_temp_metadata = { "offset" : _get_max_afterburner_temp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_afterburner_temp(self) -> float:
        """Get or set the maximum temperature at the afterburner."""
        return self._intf.get_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._get_max_afterburner_temp_metadata)

    _set_max_afterburner_temp_metadata = { "offset" : _set_max_afterburner_temp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_afterburner_temp.setter
    def max_afterburner_temp(self, value:float) -> None:
        """Get or set the maximum temperature at the afterburner."""
        return self._intf.set_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._set_max_afterburner_temp_metadata, value)

    _get_hpc_pressure_ratio_metadata = { "offset" : _get_hpc_pressure_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def hpc_pressure_ratio(self) -> float:
        """Get or set the pressure ratio of the high-pressure compressor."""
        return self._intf.get_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._get_hpc_pressure_ratio_metadata)

    _set_hpc_pressure_ratio_metadata = { "offset" : _set_hpc_pressure_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @hpc_pressure_ratio.setter
    def hpc_pressure_ratio(self, value:float) -> None:
        """Get or set the pressure ratio of the high-pressure compressor."""
        return self._intf.set_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._set_hpc_pressure_ratio_metadata, value)

    _get_lpc_pressure_ratio_metadata = { "offset" : _get_lpc_pressure_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def lpc_pressure_ratio(self) -> float:
        """Get or set the pressure ratio of the low-pressure compressor."""
        return self._intf.get_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._get_lpc_pressure_ratio_metadata)

    _set_lpc_pressure_ratio_metadata = { "offset" : _set_lpc_pressure_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @lpc_pressure_ratio.setter
    def lpc_pressure_ratio(self, value:float) -> None:
        """Get or set the pressure ratio of the low-pressure compressor."""
        return self._intf.set_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._set_lpc_pressure_ratio_metadata, value)

    _get_efficiencies_and_losses_metadata = { "offset" : _get_efficiencies_and_losses_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def efficiencies_and_losses(self) -> "PropulsionEfficiencies":
        """Get the jet engine's propulsion efficiencies and losses."""
        return self._intf.get_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._get_efficiencies_and_losses_metadata)

    _get_fuel_type_metadata = { "offset" : _get_fuel_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(JetFuelType),) }
    @property
    def fuel_type(self) -> "JetFuelType":
        """Get or set the jet engine's fuel type."""
        return self._intf.get_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._get_fuel_type_metadata)

    _set_fuel_type_metadata = { "offset" : _set_fuel_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(JetFuelType),) }
    @fuel_type.setter
    def fuel_type(self, value:"JetFuelType") -> None:
        """Get or set the jet engine's fuel type."""
        return self._intf.set_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._set_fuel_type_metadata, value)

    _get_fuel_mode_as_afprop_metadata = { "offset" : _get_fuel_mode_as_afprop_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def fuel_mode_as_afprop(self) -> "FuelModelKeroseneAFPROP":
        """Get the interface for a Kerosene - AFPROP fuel mode."""
        return self._intf.get_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._get_fuel_mode_as_afprop_metadata)

    _get_fuel_mode_as_cea_metadata = { "offset" : _get_fuel_mode_as_cea_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def fuel_mode_as_cea(self) -> "FuelModelKeroseneCEA":
        """Get the interface for a Kerosene - CEA fuel mode."""
        return self._intf.get_property(AdvancedFixedWingTurbojetBasicABPropulsion._metadata, AdvancedFixedWingTurbojetBasicABPropulsion._get_fuel_mode_as_cea_metadata)

    _property_names[can_use_afterburner] = "can_use_afterburner"
    _property_names[design_altitude] = "design_altitude"
    _property_names[design_mach] = "design_mach"
    _property_names[design_thrust] = "design_thrust"
    _property_names[afterburner_on] = "afterburner_on"
    _property_names[max_compression_temp] = "max_compression_temp"
    _property_names[max_burner_temp] = "max_burner_temp"
    _property_names[max_afterburner_temp] = "max_afterburner_temp"
    _property_names[hpc_pressure_ratio] = "hpc_pressure_ratio"
    _property_names[lpc_pressure_ratio] = "lpc_pressure_ratio"
    _property_names[efficiencies_and_losses] = "efficiencies_and_losses"
    _property_names[fuel_type] = "fuel_type"
    _property_names[fuel_mode_as_afprop] = "fuel_mode_as_afprop"
    _property_names[fuel_mode_as_cea] = "fuel_mode_as_cea"

    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingTurbojetBasicABPropulsion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingTurbojetBasicABPropulsion)
    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, AdvancedFixedWingTurbojetBasicABPropulsion, [AdvancedFixedWingTurbojetBasicABPropulsion, ])

agcls.AgClassCatalog.add_catalog_entry((5587093581665900282, 11546350750593065653), AdvancedFixedWingTurbojetBasicABPropulsion)
agcls.AgTypeNameMap["AdvancedFixedWingTurbojetBasicABPropulsion"] = AdvancedFixedWingTurbojetBasicABPropulsion

class AdvancedFixedWingTurbopropPowerplant(SupportsDeleteCallback):
    """Interface used to access the options for the Turboprop powerplant strategy in the advanced fixed wing tool."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_max_sea_level_static_power_method_offset = 1
    _set_max_sea_level_static_power_method_offset = 2
    _get_propeller_count_method_offset = 3
    _set_propeller_count_method_offset = 4
    _get_propeller_diameter_method_offset = 5
    _set_propeller_diameter_method_offset = 6
    _get_fuel_flow_method_offset = 7
    _set_fuel_flow_method_offset = 8
    _metadata = {
        "iid_data" : (5310999714701599668, 10622134511892274314),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingTurbopropPowerplant)

    _get_max_sea_level_static_power_metadata = { "offset" : _get_max_sea_level_static_power_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_sea_level_static_power(self) -> float:
        """Get or set the maximum static power of the engine at sea level."""
        return self._intf.get_property(AdvancedFixedWingTurbopropPowerplant._metadata, AdvancedFixedWingTurbopropPowerplant._get_max_sea_level_static_power_metadata)

    _set_max_sea_level_static_power_metadata = { "offset" : _set_max_sea_level_static_power_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_sea_level_static_power.setter
    def max_sea_level_static_power(self, value:float) -> None:
        """Get or set the maximum static power of the engine at sea level."""
        return self._intf.set_property(AdvancedFixedWingTurbopropPowerplant._metadata, AdvancedFixedWingTurbopropPowerplant._set_max_sea_level_static_power_metadata, value)

    _get_propeller_count_metadata = { "offset" : _get_propeller_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def propeller_count(self) -> int:
        """Get or set the number of propellers."""
        return self._intf.get_property(AdvancedFixedWingTurbopropPowerplant._metadata, AdvancedFixedWingTurbopropPowerplant._get_propeller_count_metadata)

    _set_propeller_count_metadata = { "offset" : _set_propeller_count_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @propeller_count.setter
    def propeller_count(self, value:int) -> None:
        """Get or set the number of propellers."""
        return self._intf.set_property(AdvancedFixedWingTurbopropPowerplant._metadata, AdvancedFixedWingTurbopropPowerplant._set_propeller_count_metadata, value)

    _get_propeller_diameter_metadata = { "offset" : _get_propeller_diameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def propeller_diameter(self) -> float:
        """Get or set the propeller diameter."""
        return self._intf.get_property(AdvancedFixedWingTurbopropPowerplant._metadata, AdvancedFixedWingTurbopropPowerplant._get_propeller_diameter_metadata)

    _set_propeller_diameter_metadata = { "offset" : _set_propeller_diameter_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @propeller_diameter.setter
    def propeller_diameter(self, value:float) -> None:
        """Get or set the propeller diameter."""
        return self._intf.set_property(AdvancedFixedWingTurbopropPowerplant._metadata, AdvancedFixedWingTurbopropPowerplant._set_propeller_diameter_metadata, value)

    _get_fuel_flow_metadata = { "offset" : _get_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fuel_flow(self) -> float:
        """Get or set the engine's fuel flow at max power."""
        return self._intf.get_property(AdvancedFixedWingTurbopropPowerplant._metadata, AdvancedFixedWingTurbopropPowerplant._get_fuel_flow_metadata)

    _set_fuel_flow_metadata = { "offset" : _set_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fuel_flow.setter
    def fuel_flow(self, value:float) -> None:
        """Get or set the engine's fuel flow at max power."""
        return self._intf.set_property(AdvancedFixedWingTurbopropPowerplant._metadata, AdvancedFixedWingTurbopropPowerplant._set_fuel_flow_metadata, value)

    _property_names[max_sea_level_static_power] = "max_sea_level_static_power"
    _property_names[propeller_count] = "propeller_count"
    _property_names[propeller_diameter] = "propeller_diameter"
    _property_names[fuel_flow] = "fuel_flow"

    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingTurbopropPowerplant."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingTurbopropPowerplant)
    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, AdvancedFixedWingTurbopropPowerplant, [AdvancedFixedWingTurbopropPowerplant, ])

agcls.AgClassCatalog.add_catalog_entry((5749297225109159978, 6837240057346569620), AdvancedFixedWingTurbopropPowerplant)
agcls.AgTypeNameMap["AdvancedFixedWingTurbopropPowerplant"] = AdvancedFixedWingTurbopropPowerplant

class MissileSimpleAerodynamic(SupportsDeleteCallback):
    """Interface used to access the Simple aerodynamics options for a missile."""

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_s_reference_method_offset = 1
    _set_s_reference_method_offset = 2
    _get_cl_max_method_offset = 3
    _set_cl_max_method_offset = 4
    _get_cd_method_offset = 5
    _set_cd_method_offset = 6
    _get_calculate_aoa_method_offset = 7
    _get_max_aoa_method_offset = 8
    _set_max_aoa_method_offset = 9
    _metadata = {
        "iid_data" : (4678957940349729997, 9265137374292967825),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MissileSimpleAerodynamic)

    _get_s_reference_metadata = { "offset" : _get_s_reference_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def s_reference(self) -> float:
        """Get or set the area of the lifting surface of the missile."""
        return self._intf.get_property(MissileSimpleAerodynamic._metadata, MissileSimpleAerodynamic._get_s_reference_metadata)

    _set_s_reference_metadata = { "offset" : _set_s_reference_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @s_reference.setter
    def s_reference(self, value:float) -> None:
        """Get or set the area of the lifting surface of the missile."""
        return self._intf.set_property(MissileSimpleAerodynamic._metadata, MissileSimpleAerodynamic._set_s_reference_metadata, value)

    _get_cl_max_metadata = { "offset" : _get_cl_max_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cl_max(self) -> float:
        """Get or set the max coefficient of lift."""
        return self._intf.get_property(MissileSimpleAerodynamic._metadata, MissileSimpleAerodynamic._get_cl_max_metadata)

    _set_cl_max_metadata = { "offset" : _set_cl_max_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cl_max.setter
    def cl_max(self, value:float) -> None:
        """Get or set the max coefficient of lift."""
        return self._intf.set_property(MissileSimpleAerodynamic._metadata, MissileSimpleAerodynamic._set_cl_max_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 coefficient of drag."""
        return self._intf.get_property(MissileSimpleAerodynamic._metadata, MissileSimpleAerodynamic._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:
        """Get or set the coefficient of drag."""
        return self._intf.set_property(MissileSimpleAerodynamic._metadata, MissileSimpleAerodynamic._set_cd_metadata, value)

    _get_calculate_aoa_metadata = { "offset" : _get_calculate_aoa_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def calculate_aoa(self) -> bool:
        """Opt to allow Aviator to calculate the Angle of Attack. Otherwise, the value will be 0 by default."""
        return self._intf.get_property(MissileSimpleAerodynamic._metadata, MissileSimpleAerodynamic._get_calculate_aoa_metadata)

    _get_max_aoa_metadata = { "offset" : _get_max_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_aoa(self) -> typing.Any:
        """Get the missile's maximum angle of attack."""
        return self._intf.get_property(MissileSimpleAerodynamic._metadata, MissileSimpleAerodynamic._get_max_aoa_metadata)

    _set_max_aoa_metadata = { "offset" : _set_max_aoa_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL, agcom.Variant,),
            "marshallers" : (agmarshall.VariantBoolArg, agmarshall.VariantArg,) }
    def set_max_aoa(self, calculate_aoa:bool, max_aoa:typing.Any) -> None:
        """Set whether to calculate the Angle of Attack and the corresponding value."""
        return self._intf.invoke(MissileSimpleAerodynamic._metadata, MissileSimpleAerodynamic._set_max_aoa_metadata, calculate_aoa, max_aoa)

    _property_names[s_reference] = "s_reference"
    _property_names[cl_max] = "cl_max"
    _property_names[cd] = "cd"
    _property_names[calculate_aoa] = "calculate_aoa"
    _property_names[max_aoa] = "max_aoa"

    def __init__(self, source_object=None):
        """Construct an object of type MissileSimpleAerodynamic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MissileSimpleAerodynamic)
    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, MissileSimpleAerodynamic, [MissileSimpleAerodynamic, ])

agcls.AgClassCatalog.add_catalog_entry((4705636248765593079, 6791367994635073692), MissileSimpleAerodynamic)
agcls.AgTypeNameMap["MissileSimpleAerodynamic"] = MissileSimpleAerodynamic

class MissileExternalAerodynamic(SupportsDeleteCallback):
    """Interface used to access the External aerodynamics options for a missile."""

    _num_methods = 7
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_filepath_method_offset = 1
    _set_filepath_method_offset = 2
    _reload_method_offset = 3
    _get_reference_area_method_offset = 4
    _set_reference_area_method_offset = 5
    _get_can_set_reference_area_method_offset = 6
    _get_is_valid_method_offset = 7
    _metadata = {
        "iid_data" : (4736392640115188686, 5273808291474334094),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MissileExternalAerodynamic)

    _get_filepath_metadata = { "offset" : _get_filepath_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def filepath(self) -> str:
        """Get the filepath for the external aero file."""
        return self._intf.get_property(MissileExternalAerodynamic._metadata, MissileExternalAerodynamic._get_filepath_metadata)

    _set_filepath_metadata = { "offset" : _set_filepath_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg,) }
    def set_filepath(self, filepath:str) -> str:
        """Set the filepath for the external aero file."""
        return self._intf.invoke(MissileExternalAerodynamic._metadata, MissileExternalAerodynamic._set_filepath_metadata, filepath, OutArg())

    _reload_metadata = { "offset" : _reload_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    def reload(self) -> str:
        """Reload the external aero file."""
        return self._intf.invoke(MissileExternalAerodynamic._metadata, MissileExternalAerodynamic._reload_metadata, OutArg())

    _get_reference_area_metadata = { "offset" : _get_reference_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def reference_area(self) -> float:
        """Get or set the area of the lifting surface of the missile."""
        return self._intf.get_property(MissileExternalAerodynamic._metadata, MissileExternalAerodynamic._get_reference_area_metadata)

    _set_reference_area_metadata = { "offset" : _set_reference_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @reference_area.setter
    def reference_area(self, value:float) -> None:
        """Get or set the area of the lifting surface of the missile."""
        return self._intf.set_property(MissileExternalAerodynamic._metadata, MissileExternalAerodynamic._set_reference_area_metadata, value)

    _get_can_set_reference_area_metadata = { "offset" : _get_can_set_reference_area_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def can_set_reference_area(self) -> bool:
        """Check whether you can set the reference area or whether it is specified in the file."""
        return self._intf.get_property(MissileExternalAerodynamic._metadata, MissileExternalAerodynamic._get_can_set_reference_area_metadata)

    _get_is_valid_metadata = { "offset" : _get_is_valid_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def is_valid(self) -> bool:
        """Check whether the filepath is valid."""
        return self._intf.get_property(MissileExternalAerodynamic._metadata, MissileExternalAerodynamic._get_is_valid_metadata)

    _property_names[filepath] = "filepath"
    _property_names[reference_area] = "reference_area"
    _property_names[can_set_reference_area] = "can_set_reference_area"
    _property_names[is_valid] = "is_valid"

    def __init__(self, source_object=None):
        """Construct an object of type MissileExternalAerodynamic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MissileExternalAerodynamic)
    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, MissileExternalAerodynamic, [MissileExternalAerodynamic, ])

agcls.AgClassCatalog.add_catalog_entry((5636656773253566004, 13838327309331494071), MissileExternalAerodynamic)
agcls.AgTypeNameMap["MissileExternalAerodynamic"] = MissileExternalAerodynamic

class MissileAdvancedAerodynamic(SupportsDeleteCallback):
    """Interface used to access the Advanced aerodynamics options for a missile."""

    _num_methods = 48
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_body_width_method_offset = 1
    _set_body_width_method_offset = 2
    _get_body_height_method_offset = 3
    _set_body_height_method_offset = 4
    _get_body_length_method_offset = 5
    _set_body_length_method_offset = 6
    _get_nose_length_method_offset = 7
    _set_nose_length_method_offset = 8
    _get_nose_tip_diameter_method_offset = 9
    _set_nose_tip_diameter_method_offset = 10
    _get_nozzle_diameter_method_offset = 11
    _set_nozzle_diameter_method_offset = 12
    _get_max_aoa_method_offset = 13
    _set_max_aoa_method_offset = 14
    _get_min_mach_method_offset = 15
    _set_min_mach_method_offset = 16
    _get_wing_count_method_offset = 17
    _set_wing_count_method_offset = 18
    _get_wing_span_method_offset = 19
    _set_wing_span_method_offset = 20
    _get_wing_surface_area_method_offset = 21
    _set_wing_surface_area_method_offset = 22
    _get_wing_leading_edge_sweep_angle_method_offset = 23
    _set_wing_leading_edge_sweep_angle_method_offset = 24
    _get_wing_leading_edge_section_angle_method_offset = 25
    _set_wing_leading_edge_section_angle_method_offset = 26
    _get_wing_mean_aerodynamic_chord_length_method_offset = 27
    _set_wing_mean_aerodynamic_chord_length_method_offset = 28
    _get_wing_max_thickness_along_mac_method_offset = 29
    _set_wing_max_thickness_along_mac_method_offset = 30
    _get_wing_lift_fraction_method_offset = 31
    _set_wing_lift_fraction_method_offset = 32
    _get_tail_count_method_offset = 33
    _set_tail_count_method_offset = 34
    _get_tail_span_method_offset = 35
    _set_tail_span_method_offset = 36
    _get_tail_surface_area_method_offset = 37
    _set_tail_surface_area_method_offset = 38
    _get_tail_leading_edge_sweep_angle_method_offset = 39
    _set_tail_leading_edge_sweep_angle_method_offset = 40
    _get_tail_leading_edge_section_angle_method_offset = 41
    _set_tail_leading_edge_section_angle_method_offset = 42
    _get_tail_mean_aerodynamic_chord_length_method_offset = 43
    _set_tail_mean_aerodynamic_chord_length_method_offset = 44
    _get_tail_max_thickness_along_mac_method_offset = 45
    _set_tail_max_thickness_along_mac_method_offset = 46
    _get_tail_lift_fraction_method_offset = 47
    _set_tail_lift_fraction_method_offset = 48
    _metadata = {
        "iid_data" : (4964129577173509264, 2983138932485106581),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MissileAdvancedAerodynamic)

    _get_body_width_metadata = { "offset" : _get_body_width_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def body_width(self) -> float:
        """Get or set the missile body's width."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_body_width_metadata)

    _set_body_width_metadata = { "offset" : _set_body_width_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @body_width.setter
    def body_width(self, value:float) -> None:
        """Get or set the missile body's width."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_body_width_metadata, value)

    _get_body_height_metadata = { "offset" : _get_body_height_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def body_height(self) -> float:
        """Get or set the missile body's height."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_body_height_metadata)

    _set_body_height_metadata = { "offset" : _set_body_height_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @body_height.setter
    def body_height(self, value:float) -> None:
        """Get or set the missile body's height."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_body_height_metadata, value)

    _get_body_length_metadata = { "offset" : _get_body_length_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def body_length(self) -> float:
        """Get or set the missile body's length."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_body_length_metadata)

    _set_body_length_metadata = { "offset" : _set_body_length_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @body_length.setter
    def body_length(self, value:float) -> None:
        """Get or set the missile body's length."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_body_length_metadata, value)

    _get_nose_length_metadata = { "offset" : _get_nose_length_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def nose_length(self) -> float:
        """Get or set the missile nose's length."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_nose_length_metadata)

    _set_nose_length_metadata = { "offset" : _set_nose_length_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @nose_length.setter
    def nose_length(self, value:float) -> None:
        """Get or set the missile nose's length."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_nose_length_metadata, value)

    _get_nose_tip_diameter_metadata = { "offset" : _get_nose_tip_diameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def nose_tip_diameter(self) -> float:
        """Get or set the missile nose's diameter at the tip."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_nose_tip_diameter_metadata)

    _set_nose_tip_diameter_metadata = { "offset" : _set_nose_tip_diameter_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @nose_tip_diameter.setter
    def nose_tip_diameter(self, value:float) -> None:
        """Get or set the missile nose's diameter at the tip."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_nose_tip_diameter_metadata, value)

    _get_nozzle_diameter_metadata = { "offset" : _get_nozzle_diameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def nozzle_diameter(self) -> float:
        """Get or set the diameter of the missile's nozzle."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_nozzle_diameter_metadata)

    _set_nozzle_diameter_metadata = { "offset" : _set_nozzle_diameter_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @nozzle_diameter.setter
    def nozzle_diameter(self, value:float) -> None:
        """Get or set the diameter of the missile's nozzle."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_nozzle_diameter_metadata, value)

    _get_max_aoa_metadata = { "offset" : _get_max_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_aoa(self) -> typing.Any:
        """Get or set the missile's maximum angle of attack."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_max_aoa_metadata)

    _set_max_aoa_metadata = { "offset" : _set_max_aoa_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_aoa.setter
    def max_aoa(self, value:typing.Any) -> None:
        """Get or set the missile's maximum angle of attack."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_max_aoa_metadata, value)

    _get_min_mach_metadata = { "offset" : _get_min_mach_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_mach(self) -> float:
        """Get or set the minimum mach number of the missile."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_min_mach_metadata)

    _set_min_mach_metadata = { "offset" : _set_min_mach_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_mach.setter
    def min_mach(self, value:float) -> None:
        """Get or set the minimum mach number of the missile."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_min_mach_metadata, value)

    _get_wing_count_metadata = { "offset" : _get_wing_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def wing_count(self) -> int:
        """Get or set the number of wings on the missile."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_wing_count_metadata)

    _set_wing_count_metadata = { "offset" : _set_wing_count_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @wing_count.setter
    def wing_count(self, value:int) -> None:
        """Get or set the number of wings on the missile."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_wing_count_metadata, value)

    _get_wing_span_metadata = { "offset" : _get_wing_span_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def wing_span(self) -> float:
        """Get or set the span of one of the missile's wings."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_wing_span_metadata)

    _set_wing_span_metadata = { "offset" : _set_wing_span_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @wing_span.setter
    def wing_span(self, value:float) -> None:
        """Get or set the span of one of the missile's wings."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_wing_span_metadata, value)

    _get_wing_surface_area_metadata = { "offset" : _get_wing_surface_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def wing_surface_area(self) -> float:
        """Get or set the area of one of the missile's wings."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_wing_surface_area_metadata)

    _set_wing_surface_area_metadata = { "offset" : _set_wing_surface_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @wing_surface_area.setter
    def wing_surface_area(self, value:float) -> None:
        """Get or set the area of one of the missile's wings."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_wing_surface_area_metadata, value)

    _get_wing_leading_edge_sweep_angle_metadata = { "offset" : _get_wing_leading_edge_sweep_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def wing_leading_edge_sweep_angle(self) -> typing.Any:
        """Get or set the leading edge weep angle of the wings."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_wing_leading_edge_sweep_angle_metadata)

    _set_wing_leading_edge_sweep_angle_metadata = { "offset" : _set_wing_leading_edge_sweep_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @wing_leading_edge_sweep_angle.setter
    def wing_leading_edge_sweep_angle(self, value:typing.Any) -> None:
        """Get or set the leading edge weep angle of the wings."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_wing_leading_edge_sweep_angle_metadata, value)

    _get_wing_leading_edge_section_angle_metadata = { "offset" : _get_wing_leading_edge_section_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def wing_leading_edge_section_angle(self) -> typing.Any:
        """Get or set the leading edge section angle of the wings."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_wing_leading_edge_section_angle_metadata)

    _set_wing_leading_edge_section_angle_metadata = { "offset" : _set_wing_leading_edge_section_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @wing_leading_edge_section_angle.setter
    def wing_leading_edge_section_angle(self, value:typing.Any) -> None:
        """Get or set the leading edge section angle of the wings."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_wing_leading_edge_section_angle_metadata, value)

    _get_wing_mean_aerodynamic_chord_length_metadata = { "offset" : _get_wing_mean_aerodynamic_chord_length_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def wing_mean_aerodynamic_chord_length(self) -> float:
        """Get or set the mean chord length of one of the missile's wings."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_wing_mean_aerodynamic_chord_length_metadata)

    _set_wing_mean_aerodynamic_chord_length_metadata = { "offset" : _set_wing_mean_aerodynamic_chord_length_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @wing_mean_aerodynamic_chord_length.setter
    def wing_mean_aerodynamic_chord_length(self, value:float) -> None:
        """Get or set the mean chord length of one of the missile's wings."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_wing_mean_aerodynamic_chord_length_metadata, value)

    _get_wing_max_thickness_along_mac_metadata = { "offset" : _get_wing_max_thickness_along_mac_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def wing_max_thickness_along_mac(self) -> float:
        """Get or set the max thickness of the wing along the mean aerodynamic chord."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_wing_max_thickness_along_mac_metadata)

    _set_wing_max_thickness_along_mac_metadata = { "offset" : _set_wing_max_thickness_along_mac_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @wing_max_thickness_along_mac.setter
    def wing_max_thickness_along_mac(self, value:float) -> None:
        """Get or set the max thickness of the wing along the mean aerodynamic chord."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_wing_max_thickness_along_mac_metadata, value)

    _get_wing_lift_fraction_metadata = { "offset" : _get_wing_lift_fraction_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def wing_lift_fraction(self) -> float:
        """Get or set the lift fraction of the wing."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_wing_lift_fraction_metadata)

    _set_wing_lift_fraction_metadata = { "offset" : _set_wing_lift_fraction_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @wing_lift_fraction.setter
    def wing_lift_fraction(self, value:float) -> None:
        """Get or set the lift fraction of the wing."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_wing_lift_fraction_metadata, value)

    _get_tail_count_metadata = { "offset" : _get_tail_count_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.LongArg,) }
    @property
    def tail_count(self) -> int:
        """Get or set the number of tails on the missile."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_tail_count_metadata)

    _set_tail_count_metadata = { "offset" : _set_tail_count_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.LongArg,) }
    @tail_count.setter
    def tail_count(self, value:int) -> None:
        """Get or set the number of tails on the missile."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_tail_count_metadata, value)

    _get_tail_span_metadata = { "offset" : _get_tail_span_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tail_span(self) -> float:
        """Get or set the span of one of the missile's tails."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_tail_span_metadata)

    _set_tail_span_metadata = { "offset" : _set_tail_span_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tail_span.setter
    def tail_span(self, value:float) -> None:
        """Get or set the span of one of the missile's tails."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_tail_span_metadata, value)

    _get_tail_surface_area_metadata = { "offset" : _get_tail_surface_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tail_surface_area(self) -> float:
        """Get or set the area of one of the missile's tails."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_tail_surface_area_metadata)

    _set_tail_surface_area_metadata = { "offset" : _set_tail_surface_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tail_surface_area.setter
    def tail_surface_area(self, value:float) -> None:
        """Get or set the area of one of the missile's tails."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_tail_surface_area_metadata, value)

    _get_tail_leading_edge_sweep_angle_metadata = { "offset" : _get_tail_leading_edge_sweep_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def tail_leading_edge_sweep_angle(self) -> typing.Any:
        """Get or set the leading edge weep angle of the tails."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_tail_leading_edge_sweep_angle_metadata)

    _set_tail_leading_edge_sweep_angle_metadata = { "offset" : _set_tail_leading_edge_sweep_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @tail_leading_edge_sweep_angle.setter
    def tail_leading_edge_sweep_angle(self, value:typing.Any) -> None:
        """Get or set the leading edge weep angle of the tails."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_tail_leading_edge_sweep_angle_metadata, value)

    _get_tail_leading_edge_section_angle_metadata = { "offset" : _get_tail_leading_edge_section_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def tail_leading_edge_section_angle(self) -> typing.Any:
        """Get or set the leading edge section angle of the tails."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_tail_leading_edge_section_angle_metadata)

    _set_tail_leading_edge_section_angle_metadata = { "offset" : _set_tail_leading_edge_section_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @tail_leading_edge_section_angle.setter
    def tail_leading_edge_section_angle(self, value:typing.Any) -> None:
        """Get or set the leading edge section angle of the tails."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_tail_leading_edge_section_angle_metadata, value)

    _get_tail_mean_aerodynamic_chord_length_metadata = { "offset" : _get_tail_mean_aerodynamic_chord_length_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tail_mean_aerodynamic_chord_length(self) -> float:
        """Get or set the mean chord length of one of the missile's tails."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_tail_mean_aerodynamic_chord_length_metadata)

    _set_tail_mean_aerodynamic_chord_length_metadata = { "offset" : _set_tail_mean_aerodynamic_chord_length_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tail_mean_aerodynamic_chord_length.setter
    def tail_mean_aerodynamic_chord_length(self, value:float) -> None:
        """Get or set the mean chord length of one of the missile's tails."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_tail_mean_aerodynamic_chord_length_metadata, value)

    _get_tail_max_thickness_along_mac_metadata = { "offset" : _get_tail_max_thickness_along_mac_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tail_max_thickness_along_mac(self) -> float:
        """Get or set the max thickness of the tail along the mean aerodynamic chord."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_tail_max_thickness_along_mac_metadata)

    _set_tail_max_thickness_along_mac_metadata = { "offset" : _set_tail_max_thickness_along_mac_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tail_max_thickness_along_mac.setter
    def tail_max_thickness_along_mac(self, value:float) -> None:
        """Get or set the max thickness of the tail along the mean aerodynamic chord."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_tail_max_thickness_along_mac_metadata, value)

    _get_tail_lift_fraction_metadata = { "offset" : _get_tail_lift_fraction_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tail_lift_fraction(self) -> float:
        """Get or set the lift fraction of the tail."""
        return self._intf.get_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._get_tail_lift_fraction_metadata)

    _set_tail_lift_fraction_metadata = { "offset" : _set_tail_lift_fraction_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @tail_lift_fraction.setter
    def tail_lift_fraction(self, value:float) -> None:
        """Get or set the lift fraction of the tail."""
        return self._intf.set_property(MissileAdvancedAerodynamic._metadata, MissileAdvancedAerodynamic._set_tail_lift_fraction_metadata, value)

    _property_names[body_width] = "body_width"
    _property_names[body_height] = "body_height"
    _property_names[body_length] = "body_length"
    _property_names[nose_length] = "nose_length"
    _property_names[nose_tip_diameter] = "nose_tip_diameter"
    _property_names[nozzle_diameter] = "nozzle_diameter"
    _property_names[max_aoa] = "max_aoa"
    _property_names[min_mach] = "min_mach"
    _property_names[wing_count] = "wing_count"
    _property_names[wing_span] = "wing_span"
    _property_names[wing_surface_area] = "wing_surface_area"
    _property_names[wing_leading_edge_sweep_angle] = "wing_leading_edge_sweep_angle"
    _property_names[wing_leading_edge_section_angle] = "wing_leading_edge_section_angle"
    _property_names[wing_mean_aerodynamic_chord_length] = "wing_mean_aerodynamic_chord_length"
    _property_names[wing_max_thickness_along_mac] = "wing_max_thickness_along_mac"
    _property_names[wing_lift_fraction] = "wing_lift_fraction"
    _property_names[tail_count] = "tail_count"
    _property_names[tail_span] = "tail_span"
    _property_names[tail_surface_area] = "tail_surface_area"
    _property_names[tail_leading_edge_sweep_angle] = "tail_leading_edge_sweep_angle"
    _property_names[tail_leading_edge_section_angle] = "tail_leading_edge_section_angle"
    _property_names[tail_mean_aerodynamic_chord_length] = "tail_mean_aerodynamic_chord_length"
    _property_names[tail_max_thickness_along_mac] = "tail_max_thickness_along_mac"
    _property_names[tail_lift_fraction] = "tail_lift_fraction"

    def __init__(self, source_object=None):
        """Construct an object of type MissileAdvancedAerodynamic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MissileAdvancedAerodynamic)
    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, MissileAdvancedAerodynamic, [MissileAdvancedAerodynamic, ])

agcls.AgClassCatalog.add_catalog_entry((5052893031100834404, 2206664014496294047), MissileAdvancedAerodynamic)
agcls.AgTypeNameMap["MissileAdvancedAerodynamic"] = MissileAdvancedAerodynamic

class MissileAerodynamic(SupportsDeleteCallback):
    """Interface used to access the aerodynamics options for a missile."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_aerodynamic_strategy_method_offset = 1
    _set_aerodynamic_strategy_method_offset = 2
    _get_mode_as_simple_method_offset = 3
    _get_mode_as_external_method_offset = 4
    _get_mode_as_advanced_method_offset = 5
    _get_mode_as_four_point_method_offset = 6
    _metadata = {
        "iid_data" : (5364173899613717274, 6266031543543176121),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MissileAerodynamic)

    _get_aerodynamic_strategy_metadata = { "offset" : _get_aerodynamic_strategy_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(MissileAerodynamicStrategy),) }
    @property
    def aerodynamic_strategy(self) -> "MissileAerodynamicStrategy":
        """Get or set the aerodynamic strategy type."""
        return self._intf.get_property(MissileAerodynamic._metadata, MissileAerodynamic._get_aerodynamic_strategy_metadata)

    _set_aerodynamic_strategy_metadata = { "offset" : _set_aerodynamic_strategy_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(MissileAerodynamicStrategy),) }
    @aerodynamic_strategy.setter
    def aerodynamic_strategy(self, value:"MissileAerodynamicStrategy") -> None:
        """Get or set the aerodynamic strategy type."""
        return self._intf.set_property(MissileAerodynamic._metadata, MissileAerodynamic._set_aerodynamic_strategy_metadata, value)

    _get_mode_as_simple_metadata = { "offset" : _get_mode_as_simple_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_simple(self) -> "MissileSimpleAerodynamic":
        """Get the interface for a simple aerodynamics strategy."""
        return self._intf.get_property(MissileAerodynamic._metadata, MissileAerodynamic._get_mode_as_simple_metadata)

    _get_mode_as_external_metadata = { "offset" : _get_mode_as_external_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_external(self) -> "MissileExternalAerodynamic":
        """Get the interface for an external file aerodynamics strategy."""
        return self._intf.get_property(MissileAerodynamic._metadata, MissileAerodynamic._get_mode_as_external_metadata)

    _get_mode_as_advanced_metadata = { "offset" : _get_mode_as_advanced_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_advanced(self) -> "MissileAdvancedAerodynamic":
        """Get the interface for an advanced aerodynamics strategy."""
        return self._intf.get_property(MissileAerodynamic._metadata, MissileAerodynamic._get_mode_as_advanced_metadata)

    _get_mode_as_four_point_metadata = { "offset" : _get_mode_as_four_point_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_four_point(self) -> "MissileFourPointAerodynamic":
        """Get the interface for an four point aerodynamics strategy."""
        return self._intf.get_property(MissileAerodynamic._metadata, MissileAerodynamic._get_mode_as_four_point_metadata)

    _property_names[aerodynamic_strategy] = "aerodynamic_strategy"
    _property_names[mode_as_simple] = "mode_as_simple"
    _property_names[mode_as_external] = "mode_as_external"
    _property_names[mode_as_advanced] = "mode_as_advanced"
    _property_names[mode_as_four_point] = "mode_as_four_point"

    def __init__(self, source_object=None):
        """Construct an object of type MissileAerodynamic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MissileAerodynamic)
    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, MissileAerodynamic, [MissileAerodynamic, ])

agcls.AgClassCatalog.add_catalog_entry((5323354002225726516, 2938484025708401802), MissileAerodynamic)
agcls.AgTypeNameMap["MissileAerodynamic"] = MissileAerodynamic

class MissilePropulsion(SupportsDeleteCallback):
    """Interface used to access the Propulsion options for a missile."""

    _num_methods = 7
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_propulsion_strategy_method_offset = 1
    _set_propulsion_strategy_method_offset = 2
    _get_mode_as_simple_method_offset = 3
    _get_mode_as_external_method_offset = 4
    _get_mode_as_ramjet_method_offset = 5
    _get_mode_as_turbojet_method_offset = 6
    _get_mode_as_rocket_method_offset = 7
    _metadata = {
        "iid_data" : (4913907629478761898, 14650265376795744152),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MissilePropulsion)

    _get_propulsion_strategy_metadata = { "offset" : _get_propulsion_strategy_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(MissilePropulsionStrategy),) }
    @property
    def propulsion_strategy(self) -> "MissilePropulsionStrategy":
        """Get or set the propulsion strategy type."""
        return self._intf.get_property(MissilePropulsion._metadata, MissilePropulsion._get_propulsion_strategy_metadata)

    _set_propulsion_strategy_metadata = { "offset" : _set_propulsion_strategy_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(MissilePropulsionStrategy),) }
    @propulsion_strategy.setter
    def propulsion_strategy(self, value:"MissilePropulsionStrategy") -> None:
        """Get or set the propulsion strategy type."""
        return self._intf.set_property(MissilePropulsion._metadata, MissilePropulsion._set_propulsion_strategy_metadata, value)

    _get_mode_as_simple_metadata = { "offset" : _get_mode_as_simple_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_simple(self) -> "MissileSimplePropulsion":
        """Get the interface for a simple propulsion strategy."""
        return self._intf.get_property(MissilePropulsion._metadata, MissilePropulsion._get_mode_as_simple_metadata)

    _get_mode_as_external_metadata = { "offset" : _get_mode_as_external_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_external(self) -> "MissileExternalPropulsion":
        """Get the interface for an external file propulsion strategy."""
        return self._intf.get_property(MissilePropulsion._metadata, MissilePropulsion._get_mode_as_external_metadata)

    _get_mode_as_ramjet_metadata = { "offset" : _get_mode_as_ramjet_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_ramjet(self) -> "MissileRamjetPropulsion":
        """Get the interface for an Ramjet propulsion strategy."""
        return self._intf.get_property(MissilePropulsion._metadata, MissilePropulsion._get_mode_as_ramjet_metadata)

    _get_mode_as_turbojet_metadata = { "offset" : _get_mode_as_turbojet_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_turbojet(self) -> "MissileTurbojetPropulsion":
        """Get the interface for an Turbojet propulsion strategy."""
        return self._intf.get_property(MissilePropulsion._metadata, MissilePropulsion._get_mode_as_turbojet_metadata)

    _get_mode_as_rocket_metadata = { "offset" : _get_mode_as_rocket_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_rocket(self) -> "MissileRocketPropulsion":
        """Get the interface for an Rocket propulsion strategy."""
        return self._intf.get_property(MissilePropulsion._metadata, MissilePropulsion._get_mode_as_rocket_metadata)

    _property_names[propulsion_strategy] = "propulsion_strategy"
    _property_names[mode_as_simple] = "mode_as_simple"
    _property_names[mode_as_external] = "mode_as_external"
    _property_names[mode_as_ramjet] = "mode_as_ramjet"
    _property_names[mode_as_turbojet] = "mode_as_turbojet"
    _property_names[mode_as_rocket] = "mode_as_rocket"

    def __init__(self, source_object=None):
        """Construct an object of type MissilePropulsion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MissilePropulsion)
    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, MissilePropulsion, [MissilePropulsion, ])

agcls.AgClassCatalog.add_catalog_entry((5659655677833601230, 74880851413770914), MissilePropulsion)
agcls.AgTypeNameMap["MissilePropulsion"] = MissilePropulsion

class MissileSimplePropulsion(SupportsDeleteCallback):
    """Interface used to access the Simple propulsion options for a missile."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_max_thrust_method_offset = 1
    _set_max_thrust_method_offset = 2
    _get_fuel_flow_method_offset = 3
    _set_fuel_flow_method_offset = 4
    _get_no_thrust_when_no_fuel_method_offset = 5
    _set_no_thrust_when_no_fuel_method_offset = 6
    _metadata = {
        "iid_data" : (5725392479848476812, 5093874335426318747),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MissileSimplePropulsion)

    _get_max_thrust_metadata = { "offset" : _get_max_thrust_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_thrust(self) -> float:
        """Get or set the maximum thrust of the missile."""
        return self._intf.get_property(MissileSimplePropulsion._metadata, MissileSimplePropulsion._get_max_thrust_metadata)

    _set_max_thrust_metadata = { "offset" : _set_max_thrust_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_thrust.setter
    def max_thrust(self, value:float) -> None:
        """Get or set the maximum thrust of the missile."""
        return self._intf.set_property(MissileSimplePropulsion._metadata, MissileSimplePropulsion._set_max_thrust_metadata, value)

    _get_fuel_flow_metadata = { "offset" : _get_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fuel_flow(self) -> float:
        """Get or set the fuel flow at max thrust."""
        return self._intf.get_property(MissileSimplePropulsion._metadata, MissileSimplePropulsion._get_fuel_flow_metadata)

    _set_fuel_flow_metadata = { "offset" : _set_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fuel_flow.setter
    def fuel_flow(self, value:float) -> None:
        """Get or set the fuel flow at max thrust."""
        return self._intf.set_property(MissileSimplePropulsion._metadata, MissileSimplePropulsion._set_fuel_flow_metadata, value)

    _get_no_thrust_when_no_fuel_metadata = { "offset" : _get_no_thrust_when_no_fuel_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def no_thrust_when_no_fuel(self) -> bool:
        """Opt to have no thrust if the fuel is empty."""
        return self._intf.get_property(MissileSimplePropulsion._metadata, MissileSimplePropulsion._get_no_thrust_when_no_fuel_metadata)

    _set_no_thrust_when_no_fuel_metadata = { "offset" : _set_no_thrust_when_no_fuel_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @no_thrust_when_no_fuel.setter
    def no_thrust_when_no_fuel(self, value:bool) -> None:
        """Opt to have no thrust if the fuel is empty."""
        return self._intf.set_property(MissileSimplePropulsion._metadata, MissileSimplePropulsion._set_no_thrust_when_no_fuel_metadata, value)

    _property_names[max_thrust] = "max_thrust"
    _property_names[fuel_flow] = "fuel_flow"
    _property_names[no_thrust_when_no_fuel] = "no_thrust_when_no_fuel"

    def __init__(self, source_object=None):
        """Construct an object of type MissileSimplePropulsion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MissileSimplePropulsion)
    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, MissileSimplePropulsion, [MissileSimplePropulsion, ])

agcls.AgClassCatalog.add_catalog_entry((5403921619446802984, 4318640400048778903), MissileSimplePropulsion)
agcls.AgTypeNameMap["MissileSimplePropulsion"] = MissileSimplePropulsion

class MissileExternalPropulsion(SupportsDeleteCallback):
    """Interface used to access the External Prop file options for a missile."""

    _num_methods = 6
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_filepath_method_offset = 1
    _set_filepath_method_offset = 2
    _reload_method_offset = 3
    _get_no_thrust_when_no_fuel_method_offset = 4
    _set_no_thrust_when_no_fuel_method_offset = 5
    _get_is_valid_method_offset = 6
    _metadata = {
        "iid_data" : (5134992612305711861, 891238092002507934),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MissileExternalPropulsion)

    _get_filepath_metadata = { "offset" : _get_filepath_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def filepath(self) -> str:
        """Get the filepath for the external prop file."""
        return self._intf.get_property(MissileExternalPropulsion._metadata, MissileExternalPropulsion._get_filepath_metadata)

    _set_filepath_metadata = { "offset" : _set_filepath_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.BStrArg,) }
    def set_filepath(self, filepath:str) -> str:
        """Set the filepath for the external prop file."""
        return self._intf.invoke(MissileExternalPropulsion._metadata, MissileExternalPropulsion._set_filepath_metadata, filepath, OutArg())

    _reload_metadata = { "offset" : _reload_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    def reload(self) -> str:
        """Reload the external prop file."""
        return self._intf.invoke(MissileExternalPropulsion._metadata, MissileExternalPropulsion._reload_metadata, OutArg())

    _get_no_thrust_when_no_fuel_metadata = { "offset" : _get_no_thrust_when_no_fuel_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def no_thrust_when_no_fuel(self) -> bool:
        """Opt to have no thrust if the fuel is empty."""
        return self._intf.get_property(MissileExternalPropulsion._metadata, MissileExternalPropulsion._get_no_thrust_when_no_fuel_metadata)

    _set_no_thrust_when_no_fuel_metadata = { "offset" : _set_no_thrust_when_no_fuel_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @no_thrust_when_no_fuel.setter
    def no_thrust_when_no_fuel(self, value:bool) -> None:
        """Opt to have no thrust if the fuel is empty."""
        return self._intf.set_property(MissileExternalPropulsion._metadata, MissileExternalPropulsion._set_no_thrust_when_no_fuel_metadata, value)

    _get_is_valid_metadata = { "offset" : _get_is_valid_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def is_valid(self) -> bool:
        """Check whether the filepath is valid."""
        return self._intf.get_property(MissileExternalPropulsion._metadata, MissileExternalPropulsion._get_is_valid_metadata)

    _property_names[filepath] = "filepath"
    _property_names[no_thrust_when_no_fuel] = "no_thrust_when_no_fuel"
    _property_names[is_valid] = "is_valid"

    def __init__(self, source_object=None):
        """Construct an object of type MissileExternalPropulsion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MissileExternalPropulsion)
    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, MissileExternalPropulsion, [MissileExternalPropulsion, ])

agcls.AgClassCatalog.add_catalog_entry((4988835713659863239, 13600985963996914596), MissileExternalPropulsion)
agcls.AgTypeNameMap["MissileExternalPropulsion"] = MissileExternalPropulsion

class MissileRamjetPropulsion(SupportsDeleteCallback):
    """Interface used to access the Ramjet propulsion options for a missile."""

    _num_methods = 22
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_design_mach_method_offset = 1
    _set_design_mach_method_offset = 2
    _get_design_altitude_method_offset = 3
    _set_design_altitude_method_offset = 4
    _get_design_thrust_method_offset = 5
    _set_design_thrust_method_offset = 6
    _get_engine_temp_method_offset = 7
    _set_engine_temp_method_offset = 8
    _get_fuel_heating_value_method_offset = 9
    _set_fuel_heating_value_method_offset = 10
    _get_inlet_pressure_ratio_method_offset = 11
    _set_inlet_pressure_ratio_method_offset = 12
    _get_burner_pressure_ratio_method_offset = 13
    _set_burner_pressure_ratio_method_offset = 14
    _get_nozzle_pressure_ratio_method_offset = 15
    _set_nozzle_pressure_ratio_method_offset = 16
    _get_p_0over_p9_method_offset = 17
    _set_p_0over_p9_method_offset = 18
    _get_burner_efficiency_method_offset = 19
    _set_burner_efficiency_method_offset = 20
    _get_no_thrust_when_no_fuel_method_offset = 21
    _set_no_thrust_when_no_fuel_method_offset = 22
    _metadata = {
        "iid_data" : (4953229289448602378, 1061703612136417712),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MissileRamjetPropulsion)

    _get_design_mach_metadata = { "offset" : _get_design_mach_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_mach(self) -> float:
        """Get or set the mach number design point of the engine."""
        return self._intf.get_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._get_design_mach_metadata)

    _set_design_mach_metadata = { "offset" : _set_design_mach_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_mach.setter
    def design_mach(self, value:float) -> None:
        """Get or set the mach number design point of the engine."""
        return self._intf.set_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._set_design_mach_metadata, value)

    _get_design_altitude_metadata = { "offset" : _get_design_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_altitude(self) -> float:
        """Get or set the altitude design point of the engine."""
        return self._intf.get_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._get_design_altitude_metadata)

    _set_design_altitude_metadata = { "offset" : _set_design_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_altitude.setter
    def design_altitude(self, value:float) -> None:
        """Get or set the altitude design point of the engine."""
        return self._intf.set_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._set_design_altitude_metadata, value)

    _get_design_thrust_metadata = { "offset" : _get_design_thrust_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_thrust(self) -> float:
        """Get or set the thrust design point of the engine."""
        return self._intf.get_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._get_design_thrust_metadata)

    _set_design_thrust_metadata = { "offset" : _set_design_thrust_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_thrust.setter
    def design_thrust(self, value:float) -> None:
        """Get or set the thrust design point of the engine."""
        return self._intf.set_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._set_design_thrust_metadata, value)

    _get_engine_temp_metadata = { "offset" : _get_engine_temp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def engine_temp(self) -> float:
        """Get or set the maximum temperature that the engine material can support."""
        return self._intf.get_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._get_engine_temp_metadata)

    _set_engine_temp_metadata = { "offset" : _set_engine_temp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @engine_temp.setter
    def engine_temp(self, value:float) -> None:
        """Get or set the maximum temperature that the engine material can support."""
        return self._intf.set_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._set_engine_temp_metadata, value)

    _get_fuel_heating_value_metadata = { "offset" : _get_fuel_heating_value_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fuel_heating_value(self) -> float:
        """Get or set the heating value of the fuel."""
        return self._intf.get_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._get_fuel_heating_value_metadata)

    _set_fuel_heating_value_metadata = { "offset" : _set_fuel_heating_value_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fuel_heating_value.setter
    def fuel_heating_value(self, value:float) -> None:
        """Get or set the heating value of the fuel."""
        return self._intf.set_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._set_fuel_heating_value_metadata, value)

    _get_inlet_pressure_ratio_metadata = { "offset" : _get_inlet_pressure_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def inlet_pressure_ratio(self) -> float:
        """Get or set the pressure ratio from the inlet exit to the entrance."""
        return self._intf.get_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._get_inlet_pressure_ratio_metadata)

    _set_inlet_pressure_ratio_metadata = { "offset" : _set_inlet_pressure_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @inlet_pressure_ratio.setter
    def inlet_pressure_ratio(self, value:float) -> None:
        """Get or set the pressure ratio from the inlet exit to the entrance."""
        return self._intf.set_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._set_inlet_pressure_ratio_metadata, value)

    _get_burner_pressure_ratio_metadata = { "offset" : _get_burner_pressure_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def burner_pressure_ratio(self) -> float:
        """Get or set the pressure ratio from the burner exit to the entrance."""
        return self._intf.get_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._get_burner_pressure_ratio_metadata)

    _set_burner_pressure_ratio_metadata = { "offset" : _set_burner_pressure_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @burner_pressure_ratio.setter
    def burner_pressure_ratio(self, value:float) -> None:
        """Get or set the pressure ratio from the burner exit to the entrance."""
        return self._intf.set_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._set_burner_pressure_ratio_metadata, value)

    _get_nozzle_pressure_ratio_metadata = { "offset" : _get_nozzle_pressure_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def nozzle_pressure_ratio(self) -> float:
        """Get or set the pressure ratio from the nozzle exit to the entrance."""
        return self._intf.get_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._get_nozzle_pressure_ratio_metadata)

    _set_nozzle_pressure_ratio_metadata = { "offset" : _set_nozzle_pressure_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @nozzle_pressure_ratio.setter
    def nozzle_pressure_ratio(self, value:float) -> None:
        """Get or set the pressure ratio from the nozzle exit to the entrance."""
        return self._intf.set_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._set_nozzle_pressure_ratio_metadata, value)

    _get_p_0over_p9_metadata = { "offset" : _get_p_0over_p9_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def p_0over_p9(self) -> float:
        """Get or set the pressure ratio from ambient conditions to the engine exit."""
        return self._intf.get_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._get_p_0over_p9_metadata)

    _set_p_0over_p9_metadata = { "offset" : _set_p_0over_p9_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @p_0over_p9.setter
    def p_0over_p9(self, value:float) -> None:
        """Get or set the pressure ratio from ambient conditions to the engine exit."""
        return self._intf.set_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._set_p_0over_p9_metadata, value)

    _get_burner_efficiency_metadata = { "offset" : _get_burner_efficiency_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def burner_efficiency(self) -> float:
        """Get or set the efficiency of the burner."""
        return self._intf.get_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._get_burner_efficiency_metadata)

    _set_burner_efficiency_metadata = { "offset" : _set_burner_efficiency_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @burner_efficiency.setter
    def burner_efficiency(self, value:float) -> None:
        """Get or set the efficiency of the burner."""
        return self._intf.set_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._set_burner_efficiency_metadata, value)

    _get_no_thrust_when_no_fuel_metadata = { "offset" : _get_no_thrust_when_no_fuel_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def no_thrust_when_no_fuel(self) -> bool:
        """Opt to have no thrust if the fuel is empty."""
        return self._intf.get_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._get_no_thrust_when_no_fuel_metadata)

    _set_no_thrust_when_no_fuel_metadata = { "offset" : _set_no_thrust_when_no_fuel_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @no_thrust_when_no_fuel.setter
    def no_thrust_when_no_fuel(self, value:bool) -> None:
        """Opt to have no thrust if the fuel is empty."""
        return self._intf.set_property(MissileRamjetPropulsion._metadata, MissileRamjetPropulsion._set_no_thrust_when_no_fuel_metadata, value)

    _property_names[design_mach] = "design_mach"
    _property_names[design_altitude] = "design_altitude"
    _property_names[design_thrust] = "design_thrust"
    _property_names[engine_temp] = "engine_temp"
    _property_names[fuel_heating_value] = "fuel_heating_value"
    _property_names[inlet_pressure_ratio] = "inlet_pressure_ratio"
    _property_names[burner_pressure_ratio] = "burner_pressure_ratio"
    _property_names[nozzle_pressure_ratio] = "nozzle_pressure_ratio"
    _property_names[p_0over_p9] = "p_0over_p9"
    _property_names[burner_efficiency] = "burner_efficiency"
    _property_names[no_thrust_when_no_fuel] = "no_thrust_when_no_fuel"

    def __init__(self, source_object=None):
        """Construct an object of type MissileRamjetPropulsion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MissileRamjetPropulsion)
    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, MissileRamjetPropulsion, [MissileRamjetPropulsion, ])

agcls.AgClassCatalog.add_catalog_entry((5614474896998347186, 3316151172710167988), MissileRamjetPropulsion)
agcls.AgTypeNameMap["MissileRamjetPropulsion"] = MissileRamjetPropulsion

class MissileRocketPropulsion(SupportsDeleteCallback):
    """Interface used to access the Rocket propulsion options for a missile."""

    _num_methods = 18
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_nozzle_expansion_ratio_method_offset = 1
    _set_nozzle_expansion_ratio_method_offset = 2
    _get_nozzle_exit_diameter_method_offset = 3
    _set_nozzle_exit_diameter_method_offset = 4
    _get_combustion_chamber_pressure_method_offset = 5
    _set_combustion_chamber_pressure_method_offset = 6
    _get_propellant_specific_heat_ratio_method_offset = 7
    _set_propellant_specific_heat_ratio_method_offset = 8
    _get_propellant_characteristic_velocity_method_offset = 9
    _set_propellant_characteristic_velocity_method_offset = 10
    _get_use_boost_sustain_mode_method_offset = 11
    _set_use_boost_sustain_mode_method_offset = 12
    _get_boost_fuel_fraction_method_offset = 13
    _set_boost_fuel_fraction_method_offset = 14
    _get_boost_chamber_pressure_method_offset = 15
    _set_boost_chamber_pressure_method_offset = 16
    _get_no_thrust_when_no_fuel_method_offset = 17
    _set_no_thrust_when_no_fuel_method_offset = 18
    _metadata = {
        "iid_data" : (4680524213606493608, 17871549589587163067),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MissileRocketPropulsion)

    _get_nozzle_expansion_ratio_metadata = { "offset" : _get_nozzle_expansion_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def nozzle_expansion_ratio(self) -> float:
        """Get or set the exit area divided by the throat area."""
        return self._intf.get_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._get_nozzle_expansion_ratio_metadata)

    _set_nozzle_expansion_ratio_metadata = { "offset" : _set_nozzle_expansion_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @nozzle_expansion_ratio.setter
    def nozzle_expansion_ratio(self, value:float) -> None:
        """Get or set the exit area divided by the throat area."""
        return self._intf.set_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._set_nozzle_expansion_ratio_metadata, value)

    _get_nozzle_exit_diameter_metadata = { "offset" : _get_nozzle_exit_diameter_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def nozzle_exit_diameter(self) -> float:
        """Get or set the diameter of the nozzle exit."""
        return self._intf.get_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._get_nozzle_exit_diameter_metadata)

    _set_nozzle_exit_diameter_metadata = { "offset" : _set_nozzle_exit_diameter_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @nozzle_exit_diameter.setter
    def nozzle_exit_diameter(self, value:float) -> None:
        """Get or set the diameter of the nozzle exit."""
        return self._intf.set_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._set_nozzle_exit_diameter_metadata, value)

    _get_combustion_chamber_pressure_metadata = { "offset" : _get_combustion_chamber_pressure_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def combustion_chamber_pressure(self) -> float:
        """Get or set the pressure in the combustion chamber."""
        return self._intf.get_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._get_combustion_chamber_pressure_metadata)

    _set_combustion_chamber_pressure_metadata = { "offset" : _set_combustion_chamber_pressure_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @combustion_chamber_pressure.setter
    def combustion_chamber_pressure(self, value:float) -> None:
        """Get or set the pressure in the combustion chamber."""
        return self._intf.set_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._set_combustion_chamber_pressure_metadata, value)

    _get_propellant_specific_heat_ratio_metadata = { "offset" : _get_propellant_specific_heat_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def propellant_specific_heat_ratio(self) -> float:
        """Get or set the ratio of the propellant's constant-pressure specific heat to the constant volume specific heat."""
        return self._intf.get_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._get_propellant_specific_heat_ratio_metadata)

    _set_propellant_specific_heat_ratio_metadata = { "offset" : _set_propellant_specific_heat_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @propellant_specific_heat_ratio.setter
    def propellant_specific_heat_ratio(self, value:float) -> None:
        """Get or set the ratio of the propellant's constant-pressure specific heat to the constant volume specific heat."""
        return self._intf.set_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._set_propellant_specific_heat_ratio_metadata, value)

    _get_propellant_characteristic_velocity_metadata = { "offset" : _get_propellant_characteristic_velocity_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def propellant_characteristic_velocity(self) -> float:
        """Get or set the propellant's characteristic velocity (Chamber Pressure * Throat Area / Mass Flow Rate of the engine)."""
        return self._intf.get_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._get_propellant_characteristic_velocity_metadata)

    _set_propellant_characteristic_velocity_metadata = { "offset" : _set_propellant_characteristic_velocity_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @propellant_characteristic_velocity.setter
    def propellant_characteristic_velocity(self, value:float) -> None:
        """Get or set the propellant's characteristic velocity (Chamber Pressure * Throat Area / Mass Flow Rate of the engine)."""
        return self._intf.set_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._set_propellant_characteristic_velocity_metadata, value)

    _get_use_boost_sustain_mode_metadata = { "offset" : _get_use_boost_sustain_mode_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_boost_sustain_mode(self) -> bool:
        """Opt for the engine to use a boost phase to achieve a target velocity and then transition to a sustenance phase."""
        return self._intf.get_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._get_use_boost_sustain_mode_metadata)

    _set_use_boost_sustain_mode_metadata = { "offset" : _set_use_boost_sustain_mode_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_boost_sustain_mode.setter
    def use_boost_sustain_mode(self, value:bool) -> None:
        """Opt for the engine to use a boost phase to achieve a target velocity and then transition to a sustenance phase."""
        return self._intf.set_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._set_use_boost_sustain_mode_metadata, value)

    _get_boost_fuel_fraction_metadata = { "offset" : _get_boost_fuel_fraction_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def boost_fuel_fraction(self) -> float:
        """Get or set the amount of fuel that is consumed during the boost phase."""
        return self._intf.get_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._get_boost_fuel_fraction_metadata)

    _set_boost_fuel_fraction_metadata = { "offset" : _set_boost_fuel_fraction_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @boost_fuel_fraction.setter
    def boost_fuel_fraction(self, value:float) -> None:
        """Get or set the amount of fuel that is consumed during the boost phase."""
        return self._intf.set_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._set_boost_fuel_fraction_metadata, value)

    _get_boost_chamber_pressure_metadata = { "offset" : _get_boost_chamber_pressure_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def boost_chamber_pressure(self) -> float:
        """Get or set the combustion chamber pressure during the boost phase."""
        return self._intf.get_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._get_boost_chamber_pressure_metadata)

    _set_boost_chamber_pressure_metadata = { "offset" : _set_boost_chamber_pressure_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @boost_chamber_pressure.setter
    def boost_chamber_pressure(self, value:float) -> None:
        """Get or set the combustion chamber pressure during the boost phase."""
        return self._intf.set_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._set_boost_chamber_pressure_metadata, value)

    _get_no_thrust_when_no_fuel_metadata = { "offset" : _get_no_thrust_when_no_fuel_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def no_thrust_when_no_fuel(self) -> bool:
        """Opt to have no thrust if the fuel is empty."""
        return self._intf.get_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._get_no_thrust_when_no_fuel_metadata)

    _set_no_thrust_when_no_fuel_metadata = { "offset" : _set_no_thrust_when_no_fuel_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @no_thrust_when_no_fuel.setter
    def no_thrust_when_no_fuel(self, value:bool) -> None:
        """Opt to have no thrust if the fuel is empty."""
        return self._intf.set_property(MissileRocketPropulsion._metadata, MissileRocketPropulsion._set_no_thrust_when_no_fuel_metadata, value)

    _property_names[nozzle_expansion_ratio] = "nozzle_expansion_ratio"
    _property_names[nozzle_exit_diameter] = "nozzle_exit_diameter"
    _property_names[combustion_chamber_pressure] = "combustion_chamber_pressure"
    _property_names[propellant_specific_heat_ratio] = "propellant_specific_heat_ratio"
    _property_names[propellant_characteristic_velocity] = "propellant_characteristic_velocity"
    _property_names[use_boost_sustain_mode] = "use_boost_sustain_mode"
    _property_names[boost_fuel_fraction] = "boost_fuel_fraction"
    _property_names[boost_chamber_pressure] = "boost_chamber_pressure"
    _property_names[no_thrust_when_no_fuel] = "no_thrust_when_no_fuel"

    def __init__(self, source_object=None):
        """Construct an object of type MissileRocketPropulsion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MissileRocketPropulsion)
    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, MissileRocketPropulsion, [MissileRocketPropulsion, ])

agcls.AgClassCatalog.add_catalog_entry((4829527676256086967, 2901581551454081419), MissileRocketPropulsion)
agcls.AgTypeNameMap["MissileRocketPropulsion"] = MissileRocketPropulsion

class MissileTurbojetPropulsion(SupportsDeleteCallback):
    """Interface used to access the Turbojet propulsion options for a missile."""

    _num_methods = 30
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_design_mach_method_offset = 1
    _set_design_mach_method_offset = 2
    _get_design_altitude_method_offset = 3
    _set_design_altitude_method_offset = 4
    _get_design_thrust_method_offset = 5
    _set_design_thrust_method_offset = 6
    _get_turbine_temp_method_offset = 7
    _set_turbine_temp_method_offset = 8
    _get_compressor_pressure_ratio_method_offset = 9
    _set_compressor_pressure_ratio_method_offset = 10
    _get_fuel_heating_value_method_offset = 11
    _set_fuel_heating_value_method_offset = 12
    _get_inlet_subsonic_pressure_ratio_method_offset = 13
    _set_inlet_subsonic_pressure_ratio_method_offset = 14
    _get_burner_pressure_ratio_method_offset = 15
    _set_burner_pressure_ratio_method_offset = 16
    _get_nozzle_pressure_ratio_method_offset = 17
    _set_nozzle_pressure_ratio_method_offset = 18
    _get_p_0over_p9_method_offset = 19
    _set_p_0over_p9_method_offset = 20
    _get_compressor_efficiency_method_offset = 21
    _set_compressor_efficiency_method_offset = 22
    _get_turbine_efficiency_method_offset = 23
    _set_turbine_efficiency_method_offset = 24
    _get_burner_efficiency_method_offset = 25
    _set_burner_efficiency_method_offset = 26
    _get_mechanical_efficiency_method_offset = 27
    _set_mechanical_efficiency_method_offset = 28
    _get_no_thrust_when_no_fuel_method_offset = 29
    _set_no_thrust_when_no_fuel_method_offset = 30
    _metadata = {
        "iid_data" : (4912983800323282819, 1816753828352084142),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MissileTurbojetPropulsion)

    _get_design_mach_metadata = { "offset" : _get_design_mach_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_mach(self) -> float:
        """Get or set the mach number design point of the engine."""
        return self._intf.get_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._get_design_mach_metadata)

    _set_design_mach_metadata = { "offset" : _set_design_mach_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_mach.setter
    def design_mach(self, value:float) -> None:
        """Get or set the mach number design point of the engine."""
        return self._intf.set_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._set_design_mach_metadata, value)

    _get_design_altitude_metadata = { "offset" : _get_design_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_altitude(self) -> float:
        """Get or set the altitude design point of the engine."""
        return self._intf.get_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._get_design_altitude_metadata)

    _set_design_altitude_metadata = { "offset" : _set_design_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_altitude.setter
    def design_altitude(self, value:float) -> None:
        """Get or set the altitude design point of the engine."""
        return self._intf.set_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._set_design_altitude_metadata, value)

    _get_design_thrust_metadata = { "offset" : _get_design_thrust_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_thrust(self) -> float:
        """Get or set the thrust design point of the engine."""
        return self._intf.get_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._get_design_thrust_metadata)

    _set_design_thrust_metadata = { "offset" : _set_design_thrust_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_thrust.setter
    def design_thrust(self, value:float) -> None:
        """Get or set the thrust design point of the engine."""
        return self._intf.set_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._set_design_thrust_metadata, value)

    _get_turbine_temp_metadata = { "offset" : _get_turbine_temp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def turbine_temp(self) -> float:
        """Get or set the maximum temperature that the turbine material can support."""
        return self._intf.get_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._get_turbine_temp_metadata)

    _set_turbine_temp_metadata = { "offset" : _set_turbine_temp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @turbine_temp.setter
    def turbine_temp(self, value:float) -> None:
        """Get or set the maximum temperature that the turbine material can support."""
        return self._intf.set_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._set_turbine_temp_metadata, value)

    _get_compressor_pressure_ratio_metadata = { "offset" : _get_compressor_pressure_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def compressor_pressure_ratio(self) -> float:
        """Get or set the maximum compressor pressure ratio."""
        return self._intf.get_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._get_compressor_pressure_ratio_metadata)

    _set_compressor_pressure_ratio_metadata = { "offset" : _set_compressor_pressure_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @compressor_pressure_ratio.setter
    def compressor_pressure_ratio(self, value:float) -> None:
        """Get or set the maximum compressor pressure ratio."""
        return self._intf.set_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._set_compressor_pressure_ratio_metadata, value)

    _get_fuel_heating_value_metadata = { "offset" : _get_fuel_heating_value_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def fuel_heating_value(self) -> float:
        """Get or set the heating value of the fuel."""
        return self._intf.get_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._get_fuel_heating_value_metadata)

    _set_fuel_heating_value_metadata = { "offset" : _set_fuel_heating_value_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @fuel_heating_value.setter
    def fuel_heating_value(self, value:float) -> None:
        """Get or set the heating value of the fuel."""
        return self._intf.set_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._set_fuel_heating_value_metadata, value)

    _get_inlet_subsonic_pressure_ratio_metadata = { "offset" : _get_inlet_subsonic_pressure_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def inlet_subsonic_pressure_ratio(self) -> float:
        """Get or set the subsonic pressure ratio from the inlet exit to the entrance."""
        return self._intf.get_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._get_inlet_subsonic_pressure_ratio_metadata)

    _set_inlet_subsonic_pressure_ratio_metadata = { "offset" : _set_inlet_subsonic_pressure_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @inlet_subsonic_pressure_ratio.setter
    def inlet_subsonic_pressure_ratio(self, value:float) -> None:
        """Get or set the subsonic pressure ratio from the inlet exit to the entrance."""
        return self._intf.set_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._set_inlet_subsonic_pressure_ratio_metadata, value)

    _get_burner_pressure_ratio_metadata = { "offset" : _get_burner_pressure_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def burner_pressure_ratio(self) -> float:
        """Get or set the pressure ratio from the burner exit to the entrance."""
        return self._intf.get_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._get_burner_pressure_ratio_metadata)

    _set_burner_pressure_ratio_metadata = { "offset" : _set_burner_pressure_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @burner_pressure_ratio.setter
    def burner_pressure_ratio(self, value:float) -> None:
        """Get or set the pressure ratio from the burner exit to the entrance."""
        return self._intf.set_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._set_burner_pressure_ratio_metadata, value)

    _get_nozzle_pressure_ratio_metadata = { "offset" : _get_nozzle_pressure_ratio_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def nozzle_pressure_ratio(self) -> float:
        """Get or set the pressure ratio from the nozzle exit to the entrance."""
        return self._intf.get_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._get_nozzle_pressure_ratio_metadata)

    _set_nozzle_pressure_ratio_metadata = { "offset" : _set_nozzle_pressure_ratio_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @nozzle_pressure_ratio.setter
    def nozzle_pressure_ratio(self, value:float) -> None:
        """Get or set the pressure ratio from the nozzle exit to the entrance."""
        return self._intf.set_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._set_nozzle_pressure_ratio_metadata, value)

    _get_p_0over_p9_metadata = { "offset" : _get_p_0over_p9_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def p_0over_p9(self) -> float:
        """Get or set the pressure ratio from ambient conditions to the engine exit."""
        return self._intf.get_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._get_p_0over_p9_metadata)

    _set_p_0over_p9_metadata = { "offset" : _set_p_0over_p9_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @p_0over_p9.setter
    def p_0over_p9(self, value:float) -> None:
        """Get or set the pressure ratio from ambient conditions to the engine exit."""
        return self._intf.set_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._set_p_0over_p9_metadata, value)

    _get_compressor_efficiency_metadata = { "offset" : _get_compressor_efficiency_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def compressor_efficiency(self) -> float:
        """Get or set the efficiency of the compressor."""
        return self._intf.get_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._get_compressor_efficiency_metadata)

    _set_compressor_efficiency_metadata = { "offset" : _set_compressor_efficiency_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @compressor_efficiency.setter
    def compressor_efficiency(self, value:float) -> None:
        """Get or set the efficiency of the compressor."""
        return self._intf.set_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._set_compressor_efficiency_metadata, value)

    _get_turbine_efficiency_metadata = { "offset" : _get_turbine_efficiency_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def turbine_efficiency(self) -> float:
        """Get or set the efficiency of the turbine."""
        return self._intf.get_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._get_turbine_efficiency_metadata)

    _set_turbine_efficiency_metadata = { "offset" : _set_turbine_efficiency_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @turbine_efficiency.setter
    def turbine_efficiency(self, value:float) -> None:
        """Get or set the efficiency of the turbine."""
        return self._intf.set_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._set_turbine_efficiency_metadata, value)

    _get_burner_efficiency_metadata = { "offset" : _get_burner_efficiency_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def burner_efficiency(self) -> float:
        """Get or set the efficiency of the burner."""
        return self._intf.get_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._get_burner_efficiency_metadata)

    _set_burner_efficiency_metadata = { "offset" : _set_burner_efficiency_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @burner_efficiency.setter
    def burner_efficiency(self, value:float) -> None:
        """Get or set the efficiency of the burner."""
        return self._intf.set_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._set_burner_efficiency_metadata, value)

    _get_mechanical_efficiency_metadata = { "offset" : _get_mechanical_efficiency_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mechanical_efficiency(self) -> float:
        """Get or set the mechanical efficiency of the engine."""
        return self._intf.get_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._get_mechanical_efficiency_metadata)

    _set_mechanical_efficiency_metadata = { "offset" : _set_mechanical_efficiency_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mechanical_efficiency.setter
    def mechanical_efficiency(self, value:float) -> None:
        """Get or set the mechanical efficiency of the engine."""
        return self._intf.set_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._set_mechanical_efficiency_metadata, value)

    _get_no_thrust_when_no_fuel_metadata = { "offset" : _get_no_thrust_when_no_fuel_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def no_thrust_when_no_fuel(self) -> bool:
        """Opt to have no thrust if the fuel is empty."""
        return self._intf.get_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._get_no_thrust_when_no_fuel_metadata)

    _set_no_thrust_when_no_fuel_metadata = { "offset" : _set_no_thrust_when_no_fuel_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @no_thrust_when_no_fuel.setter
    def no_thrust_when_no_fuel(self, value:bool) -> None:
        """Opt to have no thrust if the fuel is empty."""
        return self._intf.set_property(MissileTurbojetPropulsion._metadata, MissileTurbojetPropulsion._set_no_thrust_when_no_fuel_metadata, value)

    _property_names[design_mach] = "design_mach"
    _property_names[design_altitude] = "design_altitude"
    _property_names[design_thrust] = "design_thrust"
    _property_names[turbine_temp] = "turbine_temp"
    _property_names[compressor_pressure_ratio] = "compressor_pressure_ratio"
    _property_names[fuel_heating_value] = "fuel_heating_value"
    _property_names[inlet_subsonic_pressure_ratio] = "inlet_subsonic_pressure_ratio"
    _property_names[burner_pressure_ratio] = "burner_pressure_ratio"
    _property_names[nozzle_pressure_ratio] = "nozzle_pressure_ratio"
    _property_names[p_0over_p9] = "p_0over_p9"
    _property_names[compressor_efficiency] = "compressor_efficiency"
    _property_names[turbine_efficiency] = "turbine_efficiency"
    _property_names[burner_efficiency] = "burner_efficiency"
    _property_names[mechanical_efficiency] = "mechanical_efficiency"
    _property_names[no_thrust_when_no_fuel] = "no_thrust_when_no_fuel"

    def __init__(self, source_object=None):
        """Construct an object of type MissileTurbojetPropulsion."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MissileTurbojetPropulsion)
    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, MissileTurbojetPropulsion, [MissileTurbojetPropulsion, ])

agcls.AgClassCatalog.add_catalog_entry((4617727346808770983, 17951140982718247851), MissileTurbojetPropulsion)
agcls.AgTypeNameMap["MissileTurbojetPropulsion"] = MissileTurbojetPropulsion

class ReferenceStateForwardFlightOptions(SupportsDeleteCallback):
    """Interface used to access the forward flight options for a reference state procedure."""

    _num_methods = 33
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_airspeed_type_method_offset = 1
    _get_airspeed_method_offset = 2
    _set_airspeed_method_offset = 3
    _get_altitude_rate_method_offset = 4
    _set_altitude_rate_method_offset = 5
    _get_flight_path_angle_method_offset = 6
    _set_flight_path_angle_method_offset = 7
    _get_tas_dot_method_offset = 8
    _get_groundspeed_dot_method_offset = 9
    _get_longitudinal_acceleration_type_method_offset = 10
    _set_longitudinal_acceleration_method_offset = 11
    _get_heading_method_offset = 12
    _set_heading_method_offset = 13
    _get_heading_is_magnetic_method_offset = 14
    _set_heading_is_magnetic_method_offset = 15
    _get_course_method_offset = 16
    _set_course_method_offset = 17
    _get_course_is_magnetic_method_offset = 18
    _set_course_is_magnetic_method_offset = 19
    _get_heading_dot_method_offset = 20
    _get_course_dot_method_offset = 21
    _get_lateral_acceleration_type_method_offset = 22
    _set_lateral_acceleration_method_offset = 23
    _get_roll_angle_method_offset = 24
    _set_roll_angle_method_offset = 25
    _get_aoa_method_offset = 26
    _set_aoa_method_offset = 27
    _get_sideslip_method_offset = 28
    _set_sideslip_method_offset = 29
    _get_pitch_rate_method_offset = 30
    _get_push_pull_g_method_offset = 31
    _get_attitude_rate_type_method_offset = 32
    _set_attitude_rate_method_offset = 33
    _metadata = {
        "iid_data" : (5013024766168834944, 7318791218673534633),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ReferenceStateForwardFlightOptions)

    _get_airspeed_type_metadata = { "offset" : _get_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_airspeed_type_metadata)

    _get_airspeed_metadata = { "offset" : _get_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def airspeed(self) -> float:
        """Get the goal airspeed for the launch."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_airspeed_metadata)

    _set_airspeed_metadata = { "offset" : _set_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the launch airspeed."""
        return self._intf.invoke(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._set_airspeed_metadata, airspeed_type, airspeed)

    _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 at which the aircraft will climb or descend."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._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:
        """Get or set the rate at which the aircraft will climb or descend."""
        return self._intf.set_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._set_altitude_rate_metadata, value)

    _get_flight_path_angle_metadata = { "offset" : _get_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def flight_path_angle(self) -> typing.Any:
        """Get or set the initial pitch angle of the flight path."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_flight_path_angle_metadata)

    _set_flight_path_angle_metadata = { "offset" : _set_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @flight_path_angle.setter
    def flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the initial pitch angle of the flight path."""
        return self._intf.set_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._set_flight_path_angle_metadata, value)

    _get_tas_dot_metadata = { "offset" : _get_tas_dot_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tas_dot(self) -> float:
        """Get the true airspeed acceleration."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_tas_dot_metadata)

    _get_groundspeed_dot_metadata = { "offset" : _get_groundspeed_dot_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def groundspeed_dot(self) -> float:
        """Get the groundspeed acceleration."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_groundspeed_dot_metadata)

    _get_longitudinal_acceleration_type_metadata = { "offset" : _get_longitudinal_acceleration_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateLongitudinalAccelerationMode),) }
    @property
    def longitudinal_acceleration_type(self) -> "ReferenceStateLongitudinalAccelerationMode":
        """Get the mode to specify the longitudinal acceleration."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_longitudinal_acceleration_type_metadata)

    _set_longitudinal_acceleration_metadata = { "offset" : _set_longitudinal_acceleration_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateLongitudinalAccelerationMode), agmarshall.DoubleArg,) }
    def set_longitudinal_acceleration(self, accel_type:"ReferenceStateLongitudinalAccelerationMode", value:float) -> None:
        """Set the longitudinal acceleration."""
        return self._intf.invoke(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._set_longitudinal_acceleration_metadata, accel_type, value)

    _get_heading_metadata = { "offset" : _get_heading_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def heading(self) -> typing.Any:
        """Get or set the direction the aircraft is pointing."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_heading_metadata)

    _set_heading_metadata = { "offset" : _set_heading_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @heading.setter
    def heading(self, value:typing.Any) -> None:
        """Get or set the direction the aircraft is pointing."""
        return self._intf.set_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._set_heading_metadata, value)

    _get_heading_is_magnetic_metadata = { "offset" : _get_heading_is_magnetic_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def heading_is_magnetic(self) -> bool:
        """Opt whether to specify the heading using magnetic North."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_heading_is_magnetic_metadata)

    _set_heading_is_magnetic_metadata = { "offset" : _set_heading_is_magnetic_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @heading_is_magnetic.setter
    def heading_is_magnetic(self, value:bool) -> None:
        """Opt whether to specify the heading using magnetic North."""
        return self._intf.set_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._set_heading_is_magnetic_metadata, value)

    _get_course_metadata = { "offset" : _get_course_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def course(self) -> typing.Any:
        """Get or set the direction the aircraft is traveling."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_course_metadata)

    _set_course_metadata = { "offset" : _set_course_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @course.setter
    def course(self, value:typing.Any) -> None:
        """Get or set the direction the aircraft is traveling."""
        return self._intf.set_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._set_course_metadata, value)

    _get_course_is_magnetic_metadata = { "offset" : _get_course_is_magnetic_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def course_is_magnetic(self) -> bool:
        """Opt whether to specify the course using magnetic North."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_course_is_magnetic_metadata)

    _set_course_is_magnetic_metadata = { "offset" : _set_course_is_magnetic_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @course_is_magnetic.setter
    def course_is_magnetic(self, value:bool) -> None:
        """Opt whether to specify the course using magnetic North."""
        return self._intf.set_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._set_course_is_magnetic_metadata, value)

    _get_heading_dot_metadata = { "offset" : _get_heading_dot_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def heading_dot(self) -> typing.Any:
        """Get the heading rate of change."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_heading_dot_metadata)

    _get_course_dot_metadata = { "offset" : _get_course_dot_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def course_dot(self) -> typing.Any:
        """Get the course rate of change."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_course_dot_metadata)

    _get_lateral_acceleration_type_metadata = { "offset" : _get_lateral_acceleration_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateLateralAccelerationMode),) }
    @property
    def lateral_acceleration_type(self) -> "ReferenceStateLateralAccelerationMode":
        """Get the mode to specify the lateral acceleration."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_lateral_acceleration_type_metadata)

    _set_lateral_acceleration_metadata = { "offset" : _set_lateral_acceleration_method_offset,
            "arg_types" : (agcom.LONG, agcom.Variant,),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateLateralAccelerationMode), agmarshall.VariantArg,) }
    def set_lateral_acceleration(self, accel_type:"ReferenceStateLateralAccelerationMode", value:typing.Any) -> None:
        """Set the lateral acceleration."""
        return self._intf.invoke(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._set_lateral_acceleration_metadata, accel_type, value)

    _get_roll_angle_metadata = { "offset" : _get_roll_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def roll_angle(self) -> typing.Any:
        """Get or set the aircraft's bank angle."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_roll_angle_metadata)

    _set_roll_angle_metadata = { "offset" : _set_roll_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @roll_angle.setter
    def roll_angle(self, value:typing.Any) -> None:
        """Get or set the aircraft's bank angle."""
        return self._intf.set_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._set_roll_angle_metadata, value)

    _get_aoa_metadata = { "offset" : _get_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def aoa(self) -> typing.Any:
        """Get or set the aircraft's angle of attack."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_aoa_metadata)

    _set_aoa_metadata = { "offset" : _set_aoa_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @aoa.setter
    def aoa(self, value:typing.Any) -> None:
        """Get or set the aircraft's angle of attack."""
        return self._intf.set_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._set_aoa_metadata, value)

    _get_sideslip_metadata = { "offset" : _get_sideslip_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def sideslip(self) -> typing.Any:
        """Get or set the aircraft's yaw angle."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_sideslip_metadata)

    _set_sideslip_metadata = { "offset" : _set_sideslip_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @sideslip.setter
    def sideslip(self, value:typing.Any) -> None:
        """Get or set the aircraft's yaw angle."""
        return self._intf.set_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._set_sideslip_metadata, value)

    _get_pitch_rate_metadata = { "offset" : _get_pitch_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def pitch_rate(self) -> typing.Any:
        """Get the aircraft's pitch rate."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_pitch_rate_metadata)

    _get_push_pull_g_metadata = { "offset" : _get_push_pull_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def push_pull_g(self) -> float:
        """Get the G force on the aircraft resulting from its attitude."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_push_pull_g_metadata)

    _get_attitude_rate_type_metadata = { "offset" : _get_attitude_rate_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateAttitudeMode),) }
    @property
    def attitude_rate_type(self) -> "ReferenceStateAttitudeMode":
        """Get the mode to specify the vertical attitude rate."""
        return self._intf.get_property(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._get_attitude_rate_type_metadata)

    _set_attitude_rate_metadata = { "offset" : _set_attitude_rate_method_offset,
            "arg_types" : (agcom.LONG, agcom.Variant,),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateAttitudeMode), agmarshall.VariantArg,) }
    def set_attitude_rate(self, attitude_rate_type:"ReferenceStateAttitudeMode", value:typing.Any) -> None:
        """Set the vertical attitude rate."""
        return self._intf.invoke(ReferenceStateForwardFlightOptions._metadata, ReferenceStateForwardFlightOptions._set_attitude_rate_metadata, attitude_rate_type, value)

    _property_names[airspeed_type] = "airspeed_type"
    _property_names[airspeed] = "airspeed"
    _property_names[altitude_rate] = "altitude_rate"
    _property_names[flight_path_angle] = "flight_path_angle"
    _property_names[tas_dot] = "tas_dot"
    _property_names[groundspeed_dot] = "groundspeed_dot"
    _property_names[longitudinal_acceleration_type] = "longitudinal_acceleration_type"
    _property_names[heading] = "heading"
    _property_names[heading_is_magnetic] = "heading_is_magnetic"
    _property_names[course] = "course"
    _property_names[course_is_magnetic] = "course_is_magnetic"
    _property_names[heading_dot] = "heading_dot"
    _property_names[course_dot] = "course_dot"
    _property_names[lateral_acceleration_type] = "lateral_acceleration_type"
    _property_names[roll_angle] = "roll_angle"
    _property_names[aoa] = "aoa"
    _property_names[sideslip] = "sideslip"
    _property_names[pitch_rate] = "pitch_rate"
    _property_names[push_pull_g] = "push_pull_g"
    _property_names[attitude_rate_type] = "attitude_rate_type"

    def __init__(self, source_object=None):
        """Construct an object of type ReferenceStateForwardFlightOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ReferenceStateForwardFlightOptions)
    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, ReferenceStateForwardFlightOptions, [ReferenceStateForwardFlightOptions, ])

agcls.AgClassCatalog.add_catalog_entry((5234709410703539467, 10676721452242537360), ReferenceStateForwardFlightOptions)
agcls.AgTypeNameMap["ReferenceStateForwardFlightOptions"] = ReferenceStateForwardFlightOptions

class ReferenceStateTakeoffLandingOptions(SupportsDeleteCallback):
    """Interface used to access the takeoff or landing options for a reference state procedure."""

    _num_methods = 33
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_airspeed_type_method_offset = 1
    _get_airspeed_method_offset = 2
    _set_airspeed_method_offset = 3
    _get_altitude_rate_method_offset = 4
    _set_altitude_rate_method_offset = 5
    _get_flight_path_angle_method_offset = 6
    _set_flight_path_angle_method_offset = 7
    _get_tas_dot_method_offset = 8
    _get_groundspeed_dot_method_offset = 9
    _get_longitudinal_acceleration_type_method_offset = 10
    _set_longitudinal_acceleration_method_offset = 11
    _get_heading_method_offset = 12
    _set_heading_method_offset = 13
    _get_heading_is_magnetic_method_offset = 14
    _set_heading_is_magnetic_method_offset = 15
    _get_course_method_offset = 16
    _set_course_method_offset = 17
    _get_course_is_magnetic_method_offset = 18
    _set_course_is_magnetic_method_offset = 19
    _get_heading_dot_method_offset = 20
    _get_course_dot_method_offset = 21
    _get_lateral_acceleration_type_method_offset = 22
    _set_lateral_acceleration_method_offset = 23
    _get_roll_angle_method_offset = 24
    _set_roll_angle_method_offset = 25
    _get_aoa_method_offset = 26
    _set_aoa_method_offset = 27
    _get_sideslip_method_offset = 28
    _set_sideslip_method_offset = 29
    _get_pitch_rate_method_offset = 30
    _get_push_pull_g_method_offset = 31
    _get_attitude_rate_type_method_offset = 32
    _set_attitude_rate_method_offset = 33
    _metadata = {
        "iid_data" : (4651719458875810155, 1686236741447702718),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ReferenceStateTakeoffLandingOptions)

    _get_airspeed_type_metadata = { "offset" : _get_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_airspeed_type_metadata)

    _get_airspeed_metadata = { "offset" : _get_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def airspeed(self) -> float:
        """Get the goal airspeed for the launch."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_airspeed_metadata)

    _set_airspeed_metadata = { "offset" : _set_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the launch airspeed."""
        return self._intf.invoke(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._set_airspeed_metadata, airspeed_type, airspeed)

    _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 at which the aircraft will climb or descend."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._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:
        """Get or set the rate at which the aircraft will climb or descend."""
        return self._intf.set_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._set_altitude_rate_metadata, value)

    _get_flight_path_angle_metadata = { "offset" : _get_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def flight_path_angle(self) -> typing.Any:
        """Get or set the initial pitch angle of the flight path."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_flight_path_angle_metadata)

    _set_flight_path_angle_metadata = { "offset" : _set_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @flight_path_angle.setter
    def flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the initial pitch angle of the flight path."""
        return self._intf.set_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._set_flight_path_angle_metadata, value)

    _get_tas_dot_metadata = { "offset" : _get_tas_dot_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tas_dot(self) -> float:
        """Get the true airspeed acceleration."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_tas_dot_metadata)

    _get_groundspeed_dot_metadata = { "offset" : _get_groundspeed_dot_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def groundspeed_dot(self) -> float:
        """Get the groundspeed acceleration."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_groundspeed_dot_metadata)

    _get_longitudinal_acceleration_type_metadata = { "offset" : _get_longitudinal_acceleration_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateLongitudinalAccelerationMode),) }
    @property
    def longitudinal_acceleration_type(self) -> "ReferenceStateLongitudinalAccelerationMode":
        """Get the mode to specify the longitudinal acceleration."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_longitudinal_acceleration_type_metadata)

    _set_longitudinal_acceleration_metadata = { "offset" : _set_longitudinal_acceleration_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateLongitudinalAccelerationMode), agmarshall.DoubleArg,) }
    def set_longitudinal_acceleration(self, accel_type:"ReferenceStateLongitudinalAccelerationMode", value:float) -> None:
        """Set the longitudinal acceleration."""
        return self._intf.invoke(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._set_longitudinal_acceleration_metadata, accel_type, value)

    _get_heading_metadata = { "offset" : _get_heading_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def heading(self) -> typing.Any:
        """Get or set the direction the aircraft is pointing."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_heading_metadata)

    _set_heading_metadata = { "offset" : _set_heading_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @heading.setter
    def heading(self, value:typing.Any) -> None:
        """Get or set the direction the aircraft is pointing."""
        return self._intf.set_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._set_heading_metadata, value)

    _get_heading_is_magnetic_metadata = { "offset" : _get_heading_is_magnetic_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def heading_is_magnetic(self) -> bool:
        """Opt whether to specify the heading using magnetic North."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_heading_is_magnetic_metadata)

    _set_heading_is_magnetic_metadata = { "offset" : _set_heading_is_magnetic_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @heading_is_magnetic.setter
    def heading_is_magnetic(self, value:bool) -> None:
        """Opt whether to specify the heading using magnetic North."""
        return self._intf.set_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._set_heading_is_magnetic_metadata, value)

    _get_course_metadata = { "offset" : _get_course_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def course(self) -> typing.Any:
        """Get or set the direction the aircraft is traveling."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_course_metadata)

    _set_course_metadata = { "offset" : _set_course_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @course.setter
    def course(self, value:typing.Any) -> None:
        """Get or set the direction the aircraft is traveling."""
        return self._intf.set_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._set_course_metadata, value)

    _get_course_is_magnetic_metadata = { "offset" : _get_course_is_magnetic_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def course_is_magnetic(self) -> bool:
        """Opt whether to specify the course using magnetic North."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_course_is_magnetic_metadata)

    _set_course_is_magnetic_metadata = { "offset" : _set_course_is_magnetic_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @course_is_magnetic.setter
    def course_is_magnetic(self, value:bool) -> None:
        """Opt whether to specify the course using magnetic North."""
        return self._intf.set_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._set_course_is_magnetic_metadata, value)

    _get_heading_dot_metadata = { "offset" : _get_heading_dot_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def heading_dot(self) -> typing.Any:
        """Get the heading rate of change."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_heading_dot_metadata)

    _get_course_dot_metadata = { "offset" : _get_course_dot_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def course_dot(self) -> typing.Any:
        """Get the course rate of change."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_course_dot_metadata)

    _get_lateral_acceleration_type_metadata = { "offset" : _get_lateral_acceleration_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateLateralAccelerationMode),) }
    @property
    def lateral_acceleration_type(self) -> "ReferenceStateLateralAccelerationMode":
        """Get the mode to specify the lateral acceleration."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_lateral_acceleration_type_metadata)

    _set_lateral_acceleration_metadata = { "offset" : _set_lateral_acceleration_method_offset,
            "arg_types" : (agcom.LONG, agcom.Variant,),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateLateralAccelerationMode), agmarshall.VariantArg,) }
    def set_lateral_acceleration(self, accel_type:"ReferenceStateLateralAccelerationMode", value:typing.Any) -> None:
        """Set the lateral acceleration."""
        return self._intf.invoke(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._set_lateral_acceleration_metadata, accel_type, value)

    _get_roll_angle_metadata = { "offset" : _get_roll_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def roll_angle(self) -> typing.Any:
        """Get or set the aircraft's bank angle."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_roll_angle_metadata)

    _set_roll_angle_metadata = { "offset" : _set_roll_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @roll_angle.setter
    def roll_angle(self, value:typing.Any) -> None:
        """Get or set the aircraft's bank angle."""
        return self._intf.set_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._set_roll_angle_metadata, value)

    _get_aoa_metadata = { "offset" : _get_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def aoa(self) -> typing.Any:
        """Get or set the aircraft's angle of attack."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_aoa_metadata)

    _set_aoa_metadata = { "offset" : _set_aoa_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @aoa.setter
    def aoa(self, value:typing.Any) -> None:
        """Get or set the aircraft's angle of attack."""
        return self._intf.set_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._set_aoa_metadata, value)

    _get_sideslip_metadata = { "offset" : _get_sideslip_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def sideslip(self) -> typing.Any:
        """Get or set the aircraft's yaw angle."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_sideslip_metadata)

    _set_sideslip_metadata = { "offset" : _set_sideslip_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @sideslip.setter
    def sideslip(self, value:typing.Any) -> None:
        """Get or set the aircraft's yaw angle."""
        return self._intf.set_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._set_sideslip_metadata, value)

    _get_pitch_rate_metadata = { "offset" : _get_pitch_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def pitch_rate(self) -> typing.Any:
        """Get the aircraft's pitch rate."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_pitch_rate_metadata)

    _get_push_pull_g_metadata = { "offset" : _get_push_pull_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def push_pull_g(self) -> float:
        """Get the G force on the aircraft resulting from its attitude."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_push_pull_g_metadata)

    _get_attitude_rate_type_metadata = { "offset" : _get_attitude_rate_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateAttitudeMode),) }
    @property
    def attitude_rate_type(self) -> "ReferenceStateAttitudeMode":
        """Get the mode to specify the vertical attitude rate."""
        return self._intf.get_property(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._get_attitude_rate_type_metadata)

    _set_attitude_rate_metadata = { "offset" : _set_attitude_rate_method_offset,
            "arg_types" : (agcom.LONG, agcom.Variant,),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateAttitudeMode), agmarshall.VariantArg,) }
    def set_attitude_rate(self, attitude_rate_type:"ReferenceStateAttitudeMode", value:typing.Any) -> None:
        """Set the vertical attitude rate."""
        return self._intf.invoke(ReferenceStateTakeoffLandingOptions._metadata, ReferenceStateTakeoffLandingOptions._set_attitude_rate_metadata, attitude_rate_type, value)

    _property_names[airspeed_type] = "airspeed_type"
    _property_names[airspeed] = "airspeed"
    _property_names[altitude_rate] = "altitude_rate"
    _property_names[flight_path_angle] = "flight_path_angle"
    _property_names[tas_dot] = "tas_dot"
    _property_names[groundspeed_dot] = "groundspeed_dot"
    _property_names[longitudinal_acceleration_type] = "longitudinal_acceleration_type"
    _property_names[heading] = "heading"
    _property_names[heading_is_magnetic] = "heading_is_magnetic"
    _property_names[course] = "course"
    _property_names[course_is_magnetic] = "course_is_magnetic"
    _property_names[heading_dot] = "heading_dot"
    _property_names[course_dot] = "course_dot"
    _property_names[lateral_acceleration_type] = "lateral_acceleration_type"
    _property_names[roll_angle] = "roll_angle"
    _property_names[aoa] = "aoa"
    _property_names[sideslip] = "sideslip"
    _property_names[pitch_rate] = "pitch_rate"
    _property_names[push_pull_g] = "push_pull_g"
    _property_names[attitude_rate_type] = "attitude_rate_type"

    def __init__(self, source_object=None):
        """Construct an object of type ReferenceStateTakeoffLandingOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ReferenceStateTakeoffLandingOptions)
    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, ReferenceStateTakeoffLandingOptions, [ReferenceStateTakeoffLandingOptions, ])

agcls.AgClassCatalog.add_catalog_entry((4691645314423358479, 2511314558928168111), ReferenceStateTakeoffLandingOptions)
agcls.AgTypeNameMap["ReferenceStateTakeoffLandingOptions"] = ReferenceStateTakeoffLandingOptions

class ReferenceStateHoverOptions(SupportsDeleteCallback):
    """Interface used to access the hover options for a reference state procedure."""

    _num_methods = 28
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_groundspeed_method_offset = 1
    _set_groundspeed_method_offset = 2
    _get_altitude_rate_method_offset = 3
    _set_altitude_rate_method_offset = 4
    _get_tas_dot_method_offset = 5
    _get_groundspeed_dot_method_offset = 6
    _get_longitudinal_acceleration_type_method_offset = 7
    _set_longitudinal_acceleration_method_offset = 8
    _get_heading_method_offset = 9
    _set_heading_method_offset = 10
    _get_heading_is_magnetic_method_offset = 11
    _set_heading_is_magnetic_method_offset = 12
    _get_course_method_offset = 13
    _set_course_method_offset = 14
    _get_course_is_magnetic_method_offset = 15
    _set_course_is_magnetic_method_offset = 16
    _get_heading_dot_method_offset = 17
    _set_heading_dot_method_offset = 18
    _get_course_dot_method_offset = 19
    _set_course_dot_method_offset = 20
    _get_roll_angle_method_offset = 21
    _set_roll_angle_method_offset = 22
    _get_aoa_method_offset = 23
    _set_aoa_method_offset = 24
    _get_pitch_rate_method_offset = 25
    _get_push_pull_g_method_offset = 26
    _get_attitude_rate_type_method_offset = 27
    _set_attitude_rate_method_offset = 28
    _metadata = {
        "iid_data" : (4967723453880432265, 4533941470478217912),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ReferenceStateHoverOptions)

    _get_groundspeed_metadata = { "offset" : _get_groundspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def groundspeed(self) -> float:
        """Get or set the aircraft's speed relative to the ground."""
        return self._intf.get_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._get_groundspeed_metadata)

    _set_groundspeed_metadata = { "offset" : _set_groundspeed_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @groundspeed.setter
    def groundspeed(self, value:float) -> None:
        """Get or set the aircraft's speed relative to the ground."""
        return self._intf.set_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._set_groundspeed_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 at which the aircraft will climb or descend."""
        return self._intf.get_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._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:
        """Get or set the rate at which the aircraft will climb or descend."""
        return self._intf.set_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._set_altitude_rate_metadata, value)

    _get_tas_dot_metadata = { "offset" : _get_tas_dot_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tas_dot(self) -> float:
        """Get the true airspeed acceleration."""
        return self._intf.get_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._get_tas_dot_metadata)

    _get_groundspeed_dot_metadata = { "offset" : _get_groundspeed_dot_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def groundspeed_dot(self) -> float:
        """Get the groundspeed acceleration."""
        return self._intf.get_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._get_groundspeed_dot_metadata)

    _get_longitudinal_acceleration_type_metadata = { "offset" : _get_longitudinal_acceleration_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateLongitudinalAccelerationMode),) }
    @property
    def longitudinal_acceleration_type(self) -> "ReferenceStateLongitudinalAccelerationMode":
        """Get the mode to specify the longitudinal acceleration."""
        return self._intf.get_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._get_longitudinal_acceleration_type_metadata)

    _set_longitudinal_acceleration_metadata = { "offset" : _set_longitudinal_acceleration_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateLongitudinalAccelerationMode), agmarshall.DoubleArg,) }
    def set_longitudinal_acceleration(self, accel_type:"ReferenceStateLongitudinalAccelerationMode", value:float) -> None:
        """Set the longitudinal acceleration."""
        return self._intf.invoke(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._set_longitudinal_acceleration_metadata, accel_type, value)

    _get_heading_metadata = { "offset" : _get_heading_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def heading(self) -> typing.Any:
        """Get or set the direction the aircraft is pointing."""
        return self._intf.get_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._get_heading_metadata)

    _set_heading_metadata = { "offset" : _set_heading_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @heading.setter
    def heading(self, value:typing.Any) -> None:
        """Get or set the direction the aircraft is pointing."""
        return self._intf.set_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._set_heading_metadata, value)

    _get_heading_is_magnetic_metadata = { "offset" : _get_heading_is_magnetic_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def heading_is_magnetic(self) -> bool:
        """Opt whether to specify the heading using magnetic North."""
        return self._intf.get_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._get_heading_is_magnetic_metadata)

    _set_heading_is_magnetic_metadata = { "offset" : _set_heading_is_magnetic_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @heading_is_magnetic.setter
    def heading_is_magnetic(self, value:bool) -> None:
        """Opt whether to specify the heading using magnetic North."""
        return self._intf.set_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._set_heading_is_magnetic_metadata, value)

    _get_course_metadata = { "offset" : _get_course_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def course(self) -> typing.Any:
        """Get or set the direction the aircraft is traveling."""
        return self._intf.get_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._get_course_metadata)

    _set_course_metadata = { "offset" : _set_course_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @course.setter
    def course(self, value:typing.Any) -> None:
        """Get or set the direction the aircraft is traveling."""
        return self._intf.set_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._set_course_metadata, value)

    _get_course_is_magnetic_metadata = { "offset" : _get_course_is_magnetic_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def course_is_magnetic(self) -> bool:
        """Opt whether to specify the course using magnetic North."""
        return self._intf.get_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._get_course_is_magnetic_metadata)

    _set_course_is_magnetic_metadata = { "offset" : _set_course_is_magnetic_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @course_is_magnetic.setter
    def course_is_magnetic(self, value:bool) -> None:
        """Opt whether to specify the course using magnetic North."""
        return self._intf.set_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._set_course_is_magnetic_metadata, value)

    _get_heading_dot_metadata = { "offset" : _get_heading_dot_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def heading_dot(self) -> typing.Any:
        """Get or set the heading rate of change."""
        return self._intf.get_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._get_heading_dot_metadata)

    _set_heading_dot_metadata = { "offset" : _set_heading_dot_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @heading_dot.setter
    def heading_dot(self, value:typing.Any) -> None:
        """Get or set the heading rate of change."""
        return self._intf.set_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._set_heading_dot_metadata, value)

    _get_course_dot_metadata = { "offset" : _get_course_dot_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def course_dot(self) -> typing.Any:
        """Get or set the course rate of change."""
        return self._intf.get_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._get_course_dot_metadata)

    _set_course_dot_metadata = { "offset" : _set_course_dot_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @course_dot.setter
    def course_dot(self, value:typing.Any) -> None:
        """Get or set the course rate of change."""
        return self._intf.set_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._set_course_dot_metadata, value)

    _get_roll_angle_metadata = { "offset" : _get_roll_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def roll_angle(self) -> typing.Any:
        """Get or set the aircraft's bank angle."""
        return self._intf.get_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._get_roll_angle_metadata)

    _set_roll_angle_metadata = { "offset" : _set_roll_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @roll_angle.setter
    def roll_angle(self, value:typing.Any) -> None:
        """Get or set the aircraft's bank angle."""
        return self._intf.set_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._set_roll_angle_metadata, value)

    _get_aoa_metadata = { "offset" : _get_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def aoa(self) -> typing.Any:
        """Get or set the aircraft's angle of attack."""
        return self._intf.get_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._get_aoa_metadata)

    _set_aoa_metadata = { "offset" : _set_aoa_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @aoa.setter
    def aoa(self, value:typing.Any) -> None:
        """Get or set the aircraft's angle of attack."""
        return self._intf.set_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._set_aoa_metadata, value)

    _get_pitch_rate_metadata = { "offset" : _get_pitch_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def pitch_rate(self) -> typing.Any:
        """Get the aircraft's pitch rate."""
        return self._intf.get_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._get_pitch_rate_metadata)

    _get_push_pull_g_metadata = { "offset" : _get_push_pull_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def push_pull_g(self) -> float:
        """Get the G force on the aircraft resulting from its attitude."""
        return self._intf.get_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._get_push_pull_g_metadata)

    _get_attitude_rate_type_metadata = { "offset" : _get_attitude_rate_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateAttitudeMode),) }
    @property
    def attitude_rate_type(self) -> "ReferenceStateAttitudeMode":
        """Get the mode to specify the vertical attitude rate."""
        return self._intf.get_property(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._get_attitude_rate_type_metadata)

    _set_attitude_rate_metadata = { "offset" : _set_attitude_rate_method_offset,
            "arg_types" : (agcom.LONG, agcom.Variant,),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateAttitudeMode), agmarshall.VariantArg,) }
    def set_attitude_rate(self, attitude_rate_type:"ReferenceStateAttitudeMode", value:typing.Any) -> None:
        """Set the vertical attitude rate."""
        return self._intf.invoke(ReferenceStateHoverOptions._metadata, ReferenceStateHoverOptions._set_attitude_rate_metadata, attitude_rate_type, value)

    _property_names[groundspeed] = "groundspeed"
    _property_names[altitude_rate] = "altitude_rate"
    _property_names[tas_dot] = "tas_dot"
    _property_names[groundspeed_dot] = "groundspeed_dot"
    _property_names[longitudinal_acceleration_type] = "longitudinal_acceleration_type"
    _property_names[heading] = "heading"
    _property_names[heading_is_magnetic] = "heading_is_magnetic"
    _property_names[course] = "course"
    _property_names[course_is_magnetic] = "course_is_magnetic"
    _property_names[heading_dot] = "heading_dot"
    _property_names[course_dot] = "course_dot"
    _property_names[roll_angle] = "roll_angle"
    _property_names[aoa] = "aoa"
    _property_names[pitch_rate] = "pitch_rate"
    _property_names[push_pull_g] = "push_pull_g"
    _property_names[attitude_rate_type] = "attitude_rate_type"

    def __init__(self, source_object=None):
        """Construct an object of type ReferenceStateHoverOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ReferenceStateHoverOptions)
    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, ReferenceStateHoverOptions, [ReferenceStateHoverOptions, ])

agcls.AgClassCatalog.add_catalog_entry((4935166501266633550, 18202366864290377365), ReferenceStateHoverOptions)
agcls.AgTypeNameMap["ReferenceStateHoverOptions"] = ReferenceStateHoverOptions

class ReferenceStateWeightOnWheelsOptions(SupportsDeleteCallback):
    """Interface used to access the weight on wheels options for a reference state procedure."""

    _num_methods = 14
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_groundspeed_method_offset = 1
    _set_groundspeed_method_offset = 2
    _get_tas_dot_method_offset = 3
    _get_groundspeed_dot_method_offset = 4
    _get_longitudinal_acceleration_type_method_offset = 5
    _set_longitudinal_acceleration_method_offset = 6
    _get_heading_method_offset = 7
    _set_heading_method_offset = 8
    _get_heading_is_magnetic_method_offset = 9
    _set_heading_is_magnetic_method_offset = 10
    _get_heading_dot_method_offset = 11
    _get_course_dot_method_offset = 12
    _get_lateral_acceleration_type_method_offset = 13
    _set_lateral_acceleration_method_offset = 14
    _metadata = {
        "iid_data" : (4614298239361583107, 13743389205874316980),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ReferenceStateWeightOnWheelsOptions)

    _get_groundspeed_metadata = { "offset" : _get_groundspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def groundspeed(self) -> float:
        """Get or set the aircraft's speed relative to the ground."""
        return self._intf.get_property(ReferenceStateWeightOnWheelsOptions._metadata, ReferenceStateWeightOnWheelsOptions._get_groundspeed_metadata)

    _set_groundspeed_metadata = { "offset" : _set_groundspeed_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @groundspeed.setter
    def groundspeed(self, value:float) -> None:
        """Get or set the aircraft's speed relative to the ground."""
        return self._intf.set_property(ReferenceStateWeightOnWheelsOptions._metadata, ReferenceStateWeightOnWheelsOptions._set_groundspeed_metadata, value)

    _get_tas_dot_metadata = { "offset" : _get_tas_dot_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def tas_dot(self) -> float:
        """Get the true airspeed acceleration."""
        return self._intf.get_property(ReferenceStateWeightOnWheelsOptions._metadata, ReferenceStateWeightOnWheelsOptions._get_tas_dot_metadata)

    _get_groundspeed_dot_metadata = { "offset" : _get_groundspeed_dot_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def groundspeed_dot(self) -> float:
        """Get the groundspeed acceleration."""
        return self._intf.get_property(ReferenceStateWeightOnWheelsOptions._metadata, ReferenceStateWeightOnWheelsOptions._get_groundspeed_dot_metadata)

    _get_longitudinal_acceleration_type_metadata = { "offset" : _get_longitudinal_acceleration_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateLongitudinalAccelerationMode),) }
    @property
    def longitudinal_acceleration_type(self) -> "ReferenceStateLongitudinalAccelerationMode":
        """Get the mode to specify the longitudinal acceleration."""
        return self._intf.get_property(ReferenceStateWeightOnWheelsOptions._metadata, ReferenceStateWeightOnWheelsOptions._get_longitudinal_acceleration_type_metadata)

    _set_longitudinal_acceleration_metadata = { "offset" : _set_longitudinal_acceleration_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateLongitudinalAccelerationMode), agmarshall.DoubleArg,) }
    def set_longitudinal_acceleration(self, accel_type:"ReferenceStateLongitudinalAccelerationMode", value:float) -> None:
        """Set the longitudinal acceleration."""
        return self._intf.invoke(ReferenceStateWeightOnWheelsOptions._metadata, ReferenceStateWeightOnWheelsOptions._set_longitudinal_acceleration_metadata, accel_type, value)

    _get_heading_metadata = { "offset" : _get_heading_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def heading(self) -> typing.Any:
        """Get or set the direction the aircraft is pointing."""
        return self._intf.get_property(ReferenceStateWeightOnWheelsOptions._metadata, ReferenceStateWeightOnWheelsOptions._get_heading_metadata)

    _set_heading_metadata = { "offset" : _set_heading_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @heading.setter
    def heading(self, value:typing.Any) -> None:
        """Get or set the direction the aircraft is pointing."""
        return self._intf.set_property(ReferenceStateWeightOnWheelsOptions._metadata, ReferenceStateWeightOnWheelsOptions._set_heading_metadata, value)

    _get_heading_is_magnetic_metadata = { "offset" : _get_heading_is_magnetic_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def heading_is_magnetic(self) -> bool:
        """Opt whether to specify the heading using magnetic North."""
        return self._intf.get_property(ReferenceStateWeightOnWheelsOptions._metadata, ReferenceStateWeightOnWheelsOptions._get_heading_is_magnetic_metadata)

    _set_heading_is_magnetic_metadata = { "offset" : _set_heading_is_magnetic_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @heading_is_magnetic.setter
    def heading_is_magnetic(self, value:bool) -> None:
        """Opt whether to specify the heading using magnetic North."""
        return self._intf.set_property(ReferenceStateWeightOnWheelsOptions._metadata, ReferenceStateWeightOnWheelsOptions._set_heading_is_magnetic_metadata, value)

    _get_heading_dot_metadata = { "offset" : _get_heading_dot_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def heading_dot(self) -> typing.Any:
        """Get the heading rate of change."""
        return self._intf.get_property(ReferenceStateWeightOnWheelsOptions._metadata, ReferenceStateWeightOnWheelsOptions._get_heading_dot_metadata)

    _get_course_dot_metadata = { "offset" : _get_course_dot_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def course_dot(self) -> typing.Any:
        """Get the course rate of change."""
        return self._intf.get_property(ReferenceStateWeightOnWheelsOptions._metadata, ReferenceStateWeightOnWheelsOptions._get_course_dot_metadata)

    _get_lateral_acceleration_type_metadata = { "offset" : _get_lateral_acceleration_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateLateralAccelerationMode),) }
    @property
    def lateral_acceleration_type(self) -> "ReferenceStateLateralAccelerationMode":
        """Get the mode to specify the lateral acceleration."""
        return self._intf.get_property(ReferenceStateWeightOnWheelsOptions._metadata, ReferenceStateWeightOnWheelsOptions._get_lateral_acceleration_type_metadata)

    _set_lateral_acceleration_metadata = { "offset" : _set_lateral_acceleration_method_offset,
            "arg_types" : (agcom.LONG, agcom.Variant,),
            "marshallers" : (agmarshall.EnumArg(ReferenceStateLateralAccelerationMode), agmarshall.VariantArg,) }
    def set_lateral_acceleration(self, accel_type:"ReferenceStateLateralAccelerationMode", value:typing.Any) -> None:
        """Set the lateral acceleration."""
        return self._intf.invoke(ReferenceStateWeightOnWheelsOptions._metadata, ReferenceStateWeightOnWheelsOptions._set_lateral_acceleration_metadata, accel_type, value)

    _property_names[groundspeed] = "groundspeed"
    _property_names[tas_dot] = "tas_dot"
    _property_names[groundspeed_dot] = "groundspeed_dot"
    _property_names[longitudinal_acceleration_type] = "longitudinal_acceleration_type"
    _property_names[heading] = "heading"
    _property_names[heading_is_magnetic] = "heading_is_magnetic"
    _property_names[heading_dot] = "heading_dot"
    _property_names[course_dot] = "course_dot"
    _property_names[lateral_acceleration_type] = "lateral_acceleration_type"

    def __init__(self, source_object=None):
        """Construct an object of type ReferenceStateWeightOnWheelsOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ReferenceStateWeightOnWheelsOptions)
    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, ReferenceStateWeightOnWheelsOptions, [ReferenceStateWeightOnWheelsOptions, ])

agcls.AgClassCatalog.add_catalog_entry((4746073259629533532, 13362726578078342823), ReferenceStateWeightOnWheelsOptions)
agcls.AgTypeNameMap["ReferenceStateWeightOnWheelsOptions"] = ReferenceStateWeightOnWheelsOptions

class SiteRunwayFromCatalog(ISite, SupportsDeleteCallback):
    """Interface used to access the options for a Runway From Catalog site type."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_catalog_runway_method_offset = 1
    _set_catalog_runway_method_offset = 2
    _get_as_site_method_offset = 3
    _metadata = {
        "iid_data" : (5634494088710483634, 4136369912068985016),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteRunwayFromCatalog)

    _get_catalog_runway_metadata = { "offset" : _get_catalog_runway_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_catalog_runway(self) -> "ICatalogRunway":
        """Get the catalog runway."""
        return self._intf.invoke(SiteRunwayFromCatalog._metadata, SiteRunwayFromCatalog._get_catalog_runway_metadata, OutArg())

    _set_catalog_runway_metadata = { "offset" : _set_catalog_runway_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("ICatalogRunway"),) }
    def set_catalog_runway(self, value:"ICatalogRunway") -> None:
        """Set the catalog runway."""
        return self._intf.invoke(SiteRunwayFromCatalog._metadata, SiteRunwayFromCatalog._set_catalog_runway_metadata, value)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteRunwayFromCatalog._metadata, SiteRunwayFromCatalog._get_as_site_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((5432583218947739306, 4484750288509271693), SiteRunwayFromCatalog)
agcls.AgTypeNameMap["SiteRunwayFromCatalog"] = SiteRunwayFromCatalog

class SiteAirportFromCatalog(ISite, SupportsDeleteCallback):
    """Interface used to access the options for a airport From Catalog site type."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_catalog_airport_method_offset = 1
    _set_catalog_airport_method_offset = 2
    _get_as_site_method_offset = 3
    _metadata = {
        "iid_data" : (5145879454474821904, 9199213237675117193),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteAirportFromCatalog)

    _get_catalog_airport_metadata = { "offset" : _get_catalog_airport_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_catalog_airport(self) -> "ICatalogAirport":
        """Get the catalog airport."""
        return self._intf.invoke(SiteAirportFromCatalog._metadata, SiteAirportFromCatalog._get_catalog_airport_metadata, OutArg())

    _set_catalog_airport_metadata = { "offset" : _set_catalog_airport_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("ICatalogAirport"),) }
    def set_catalog_airport(self, value:"ICatalogAirport") -> None:
        """Set the catalog airport."""
        return self._intf.invoke(SiteAirportFromCatalog._metadata, SiteAirportFromCatalog._set_catalog_airport_metadata, value)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteAirportFromCatalog._metadata, SiteAirportFromCatalog._get_as_site_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((4736989613571461001, 1367197901097188494), SiteAirportFromCatalog)
agcls.AgTypeNameMap["SiteAirportFromCatalog"] = SiteAirportFromCatalog

class SiteNavaidFromCatalog(ISite, SupportsDeleteCallback):
    """Interface used to access the options for a navaid From Catalog site type."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_catalog_navaid_method_offset = 1
    _set_catalog_navaid_method_offset = 2
    _get_as_site_method_offset = 3
    _metadata = {
        "iid_data" : (4957428865343325572, 11959601014297479563),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteNavaidFromCatalog)

    _get_catalog_navaid_metadata = { "offset" : _get_catalog_navaid_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_catalog_navaid(self) -> "ICatalogNavaid":
        """Get the catalog navaid."""
        return self._intf.invoke(SiteNavaidFromCatalog._metadata, SiteNavaidFromCatalog._get_catalog_navaid_metadata, OutArg())

    _set_catalog_navaid_metadata = { "offset" : _set_catalog_navaid_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("ICatalogNavaid"),) }
    def set_catalog_navaid(self, value:"ICatalogNavaid") -> None:
        """Set the catalog navaid."""
        return self._intf.invoke(SiteNavaidFromCatalog._metadata, SiteNavaidFromCatalog._set_catalog_navaid_metadata, value)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteNavaidFromCatalog._metadata, SiteNavaidFromCatalog._get_as_site_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((5491384812081208211, 8045247953710753921), SiteNavaidFromCatalog)
agcls.AgTypeNameMap["SiteNavaidFromCatalog"] = SiteNavaidFromCatalog

class SiteVTOLPointFromCatalog(ISite, SupportsDeleteCallback):
    """Interface used to access the options for a VTOL Point From Catalog site type."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_catalog_vtol_point_method_offset = 1
    _set_catalog_vtol_point_method_offset = 2
    _get_as_site_method_offset = 3
    _metadata = {
        "iid_data" : (5029003088096487458, 10941850249683653276),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteVTOLPointFromCatalog)

    _get_catalog_vtol_point_metadata = { "offset" : _get_catalog_vtol_point_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_catalog_vtol_point(self) -> "ICatalogVTOLPoint":
        """Get the catalog VTOL point."""
        return self._intf.invoke(SiteVTOLPointFromCatalog._metadata, SiteVTOLPointFromCatalog._get_catalog_vtol_point_metadata, OutArg())

    _set_catalog_vtol_point_metadata = { "offset" : _set_catalog_vtol_point_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("ICatalogVTOLPoint"),) }
    def set_catalog_vtol_point(self, value:"ICatalogVTOLPoint") -> None:
        """Set the catalog VTOL point."""
        return self._intf.invoke(SiteVTOLPointFromCatalog._metadata, SiteVTOLPointFromCatalog._set_catalog_vtol_point_metadata, value)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteVTOLPointFromCatalog._metadata, SiteVTOLPointFromCatalog._get_as_site_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((4778256137753234442, 15315831279471165362), SiteVTOLPointFromCatalog)
agcls.AgTypeNameMap["SiteVTOLPointFromCatalog"] = SiteVTOLPointFromCatalog

class SiteWaypointFromCatalog(ISite, SupportsDeleteCallback):
    """Interface used to access the options for a waypoint From Catalog site type."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_catalog_waypoint_method_offset = 1
    _set_catalog_waypoint_method_offset = 2
    _get_as_site_method_offset = 3
    _metadata = {
        "iid_data" : (5020241597903773768, 13236896574173633725),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteWaypointFromCatalog)

    _get_catalog_waypoint_metadata = { "offset" : _get_catalog_waypoint_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_catalog_waypoint(self) -> "ICatalogWaypoint":
        """Get the catalog waypoint."""
        return self._intf.invoke(SiteWaypointFromCatalog._metadata, SiteWaypointFromCatalog._get_catalog_waypoint_metadata, OutArg())

    _set_catalog_waypoint_metadata = { "offset" : _set_catalog_waypoint_method_offset,
            "arg_types" : (agcom.PVOID,),
            "marshallers" : (agmarshall.InterfaceInArg("ICatalogWaypoint"),) }
    def set_catalog_waypoint(self, value:"ICatalogWaypoint") -> None:
        """Set the catalog waypoint."""
        return self._intf.invoke(SiteWaypointFromCatalog._metadata, SiteWaypointFromCatalog._set_catalog_waypoint_metadata, value)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteWaypointFromCatalog._metadata, SiteWaypointFromCatalog._get_as_site_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((4884194644614735130, 4678068853271565703), SiteWaypointFromCatalog)
agcls.AgTypeNameMap["SiteWaypointFromCatalog"] = SiteWaypointFromCatalog

class NavaidCategory(SupportsDeleteCallback):
    """Interface used to access the navaids in the Aviator catalog."""

    _num_methods = 1
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_arinc424_navaids_method_offset = 1
    _metadata = {
        "iid_data" : (4767324386243364667, 11619546343216473789),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, NavaidCategory)

    _get_arinc424_navaids_metadata = { "offset" : _get_arinc424_navaids_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def arinc424_navaids(self) -> "ARINC424Source":
        """Get the ARINC-424 navaids."""
        return self._intf.get_property(NavaidCategory._metadata, NavaidCategory._get_arinc424_navaids_metadata)

    _property_names[arinc424_navaids] = "arinc424_navaids"

    def __init__(self, source_object=None):
        """Construct an object of type NavaidCategory."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, NavaidCategory)
    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, NavaidCategory, [NavaidCategory, ])

agcls.AgClassCatalog.add_catalog_entry((5432459549836284524, 13783249384820279445), NavaidCategory)
agcls.AgTypeNameMap["NavaidCategory"] = NavaidCategory

class VTOLPointCategory(SupportsDeleteCallback):
    """Interface used to access the VTOL Points in the Aviator catalog."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_user_vtol_points_method_offset = 1
    _get_arinc424_helipads_method_offset = 2
    _get_dafif_helipads_method_offset = 3
    _metadata = {
        "iid_data" : (5140292971359621491, 7182381113514930067),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, VTOLPointCategory)

    _get_user_vtol_points_metadata = { "offset" : _get_user_vtol_points_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def user_vtol_points(self) -> "UserVTOLPointSource":
        """Get the User VTOL Points."""
        return self._intf.get_property(VTOLPointCategory._metadata, VTOLPointCategory._get_user_vtol_points_metadata)

    _get_arinc424_helipads_metadata = { "offset" : _get_arinc424_helipads_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def arinc424_helipads(self) -> "ARINC424Source":
        """Get the ARINC-424 helipads."""
        return self._intf.get_property(VTOLPointCategory._metadata, VTOLPointCategory._get_arinc424_helipads_metadata)

    _get_dafif_helipads_metadata = { "offset" : _get_dafif_helipads_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def dafif_helipads(self) -> "DAFIFSource":
        """Get the DAFIF helipads."""
        return self._intf.get_property(VTOLPointCategory._metadata, VTOLPointCategory._get_dafif_helipads_metadata)

    _property_names[user_vtol_points] = "user_vtol_points"
    _property_names[arinc424_helipads] = "arinc424_helipads"
    _property_names[dafif_helipads] = "dafif_helipads"

    def __init__(self, source_object=None):
        """Construct an object of type VTOLPointCategory."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, VTOLPointCategory)
    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, VTOLPointCategory, [VTOLPointCategory, ])

agcls.AgClassCatalog.add_catalog_entry((5167063348405119438, 2498351164565518994), VTOLPointCategory)
agcls.AgTypeNameMap["VTOLPointCategory"] = VTOLPointCategory

class WaypointCategory(SupportsDeleteCallback):
    """Interface used to access the waypoints in the Aviator catalog."""

    _num_methods = 11
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_user_waypoints_method_offset = 1
    _get_user_runways_method_offset = 2
    _get_user_vtol_points_method_offset = 3
    _get_arinc424_airports_method_offset = 4
    _get_arinc424_helipads_method_offset = 5
    _get_arinc424_navaids_method_offset = 6
    _get_arinc424_runways_method_offset = 7
    _get_arinc424_waypoints_method_offset = 8
    _get_dafif_helipads_method_offset = 9
    _get_dafif_runways_method_offset = 10
    _get_dafif_waypoints_method_offset = 11
    _metadata = {
        "iid_data" : (4821896888722457850, 11063217582704392345),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, WaypointCategory)

    _get_user_waypoints_metadata = { "offset" : _get_user_waypoints_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def user_waypoints(self) -> "UserWaypointSource":
        """Get the User Waypoints."""
        return self._intf.get_property(WaypointCategory._metadata, WaypointCategory._get_user_waypoints_metadata)

    _get_user_runways_metadata = { "offset" : _get_user_runways_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def user_runways(self) -> "UserRunwaySource":
        """Get the User Runways."""
        return self._intf.get_property(WaypointCategory._metadata, WaypointCategory._get_user_runways_metadata)

    _get_user_vtol_points_metadata = { "offset" : _get_user_vtol_points_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def user_vtol_points(self) -> "UserVTOLPointSource":
        """Get the User VTOL Points."""
        return self._intf.get_property(WaypointCategory._metadata, WaypointCategory._get_user_vtol_points_metadata)

    _get_arinc424_airports_metadata = { "offset" : _get_arinc424_airports_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def arinc424_airports(self) -> "ARINC424Source":
        """Get the ARINC-424 airports."""
        return self._intf.get_property(WaypointCategory._metadata, WaypointCategory._get_arinc424_airports_metadata)

    _get_arinc424_helipads_metadata = { "offset" : _get_arinc424_helipads_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def arinc424_helipads(self) -> "ARINC424Source":
        """Get the ARINC-424 helipads."""
        return self._intf.get_property(WaypointCategory._metadata, WaypointCategory._get_arinc424_helipads_metadata)

    _get_arinc424_navaids_metadata = { "offset" : _get_arinc424_navaids_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def arinc424_navaids(self) -> "ARINC424Source":
        """Get the ARINC-424 navaids."""
        return self._intf.get_property(WaypointCategory._metadata, WaypointCategory._get_arinc424_navaids_metadata)

    _get_arinc424_runways_metadata = { "offset" : _get_arinc424_runways_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def arinc424_runways(self) -> "ARINC424Source":
        """Get the ARINC-424 runways."""
        return self._intf.get_property(WaypointCategory._metadata, WaypointCategory._get_arinc424_runways_metadata)

    _get_arinc424_waypoints_metadata = { "offset" : _get_arinc424_waypoints_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def arinc424_waypoints(self) -> "ARINC424Source":
        """Get the ARINC-424 waypoints."""
        return self._intf.get_property(WaypointCategory._metadata, WaypointCategory._get_arinc424_waypoints_metadata)

    _get_dafif_helipads_metadata = { "offset" : _get_dafif_helipads_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def dafif_helipads(self) -> "DAFIFSource":
        """Get the DAFIF helipads."""
        return self._intf.get_property(WaypointCategory._metadata, WaypointCategory._get_dafif_helipads_metadata)

    _get_dafif_runways_metadata = { "offset" : _get_dafif_runways_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def dafif_runways(self) -> "DAFIFSource":
        """Get the DAFIF runways."""
        return self._intf.get_property(WaypointCategory._metadata, WaypointCategory._get_dafif_runways_metadata)

    _get_dafif_waypoints_metadata = { "offset" : _get_dafif_waypoints_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def dafif_waypoints(self) -> "DAFIFSource":
        """Get the DAFIF waypoints."""
        return self._intf.get_property(WaypointCategory._metadata, WaypointCategory._get_dafif_waypoints_metadata)

    _property_names[user_waypoints] = "user_waypoints"
    _property_names[user_runways] = "user_runways"
    _property_names[user_vtol_points] = "user_vtol_points"
    _property_names[arinc424_airports] = "arinc424_airports"
    _property_names[arinc424_helipads] = "arinc424_helipads"
    _property_names[arinc424_navaids] = "arinc424_navaids"
    _property_names[arinc424_runways] = "arinc424_runways"
    _property_names[arinc424_waypoints] = "arinc424_waypoints"
    _property_names[dafif_helipads] = "dafif_helipads"
    _property_names[dafif_runways] = "dafif_runways"
    _property_names[dafif_waypoints] = "dafif_waypoints"

    def __init__(self, source_object=None):
        """Construct an object of type WaypointCategory."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, WaypointCategory)
    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, WaypointCategory, [WaypointCategory, ])

agcls.AgClassCatalog.add_catalog_entry((5334398087905690330, 105878899444753553), WaypointCategory)
agcls.AgTypeNameMap["WaypointCategory"] = WaypointCategory

class ARINC424Navaid(IARINC424Item, ICatalogNavaid, ICatalogWaypoint, ICatalogItem, SupportsDeleteCallback):
    """Class defining an ARINC424 Navaid."""
    def __init__(self, source_object=None):
        """Construct an object of type ARINC424Navaid."""
        SupportsDeleteCallback.__init__(self)
        IARINC424Item.__init__(self, source_object)
        ICatalogNavaid.__init__(self, source_object)
        ICatalogWaypoint.__init__(self, source_object)
        ICatalogItem.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IARINC424Item._private_init(self, intf)
        ICatalogNavaid._private_init(self, intf)
        ICatalogWaypoint._private_init(self, intf)
        ICatalogItem._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ARINC424Navaid, [IARINC424Item, ICatalogNavaid, ICatalogWaypoint, ICatalogItem])

agcls.AgClassCatalog.add_catalog_entry((5197157372005485531, 1093323223683680135), ARINC424Navaid)
agcls.AgTypeNameMap["ARINC424Navaid"] = ARINC424Navaid

class ARINC424Helipad(IARINC424Item, ICatalogVTOLPoint, ICatalogWaypoint, ICatalogItem, SupportsDeleteCallback):
    """Class defining an ARINC424 Helipad."""
    def __init__(self, source_object=None):
        """Construct an object of type ARINC424Helipad."""
        SupportsDeleteCallback.__init__(self)
        IARINC424Item.__init__(self, source_object)
        ICatalogVTOLPoint.__init__(self, source_object)
        ICatalogWaypoint.__init__(self, source_object)
        ICatalogItem.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IARINC424Item._private_init(self, intf)
        ICatalogVTOLPoint._private_init(self, intf)
        ICatalogWaypoint._private_init(self, intf)
        ICatalogItem._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ARINC424Helipad, [IARINC424Item, ICatalogVTOLPoint, ICatalogWaypoint, ICatalogItem])

agcls.AgClassCatalog.add_catalog_entry((5277898751387810758, 3304972005706513837), ARINC424Helipad)
agcls.AgTypeNameMap["ARINC424Helipad"] = ARINC424Helipad

class ARINC424Waypoint(IARINC424Item, ICatalogWaypoint, ICatalogItem, SupportsDeleteCallback):
    """Class defining an ARINC424 Waypoint."""
    def __init__(self, source_object=None):
        """Construct an object of type ARINC424Waypoint."""
        SupportsDeleteCallback.__init__(self)
        IARINC424Item.__init__(self, source_object)
        ICatalogWaypoint.__init__(self, source_object)
        ICatalogItem.__init__(self, source_object)
    def _private_init(self, intf:InterfaceProxy):
        self.__dict__["_intf"] = intf
        IARINC424Item._private_init(self, intf)
        ICatalogWaypoint._private_init(self, intf)
        ICatalogItem._private_init(self, intf)
    def __eq__(self, other):
        """Check equality of the underlying STK references."""
        return agcls.compare_com_objects(self, other)
    def __setattr__(self, attrname, value):
        """Attempt to assign an attribute."""
        set_class_attribute(self, attrname, value, ARINC424Waypoint, [IARINC424Item, ICatalogWaypoint, ICatalogItem])

agcls.AgClassCatalog.add_catalog_entry((5082141889769092101, 1479692394985179811), ARINC424Waypoint)
agcls.AgTypeNameMap["ARINC424Waypoint"] = ARINC424Waypoint

class UserVTOLPointSource(ICatalogSource, SupportsDeleteCallback):
    """Interface used to access the user VTOL Points in the Aviator catalog."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_user_vtol_point_method_offset = 1
    _add_user_vtol_point_method_offset = 2
    _get_as_catalog_source_method_offset = 3
    _metadata = {
        "iid_data" : (5545256129940298652, 8073919850080497329),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, UserVTOLPointSource)

    _get_user_vtol_point_metadata = { "offset" : _get_user_vtol_point_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_user_vtol_point(self, name:str) -> "UserVTOLPoint":
        """Get the user VTOL Point with the given name."""
        return self._intf.invoke(UserVTOLPointSource._metadata, UserVTOLPointSource._get_user_vtol_point_metadata, name, OutArg())

    _add_user_vtol_point_metadata = { "offset" : _add_user_vtol_point_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add_user_vtol_point(self, name:str) -> "UserVTOLPoint":
        """Create a new user VTOL Point with the given name."""
        return self._intf.invoke(UserVTOLPointSource._metadata, UserVTOLPointSource._add_user_vtol_point_metadata, name, OutArg())

    _get_as_catalog_source_metadata = { "offset" : _get_as_catalog_source_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_source(self) -> "ICatalogSource":
        """Get the catalog source interface for this object."""
        return self._intf.invoke(UserVTOLPointSource._metadata, UserVTOLPointSource._get_as_catalog_source_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((5591773936808407339, 9073311703179615419), UserVTOLPointSource)
agcls.AgTypeNameMap["UserVTOLPointSource"] = UserVTOLPointSource

class UserVTOLPoint(ICatalogVTOLPoint, ICatalogWaypoint, ICatalogItem, SupportsDeleteCallback):
    """Interface used to access a user VTOL Point in the Aviator catalog."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_altitude_method_offset = 1
    _set_altitude_method_offset = 2
    _get_terrain_altitude_method_offset = 3
    _get_latitude_method_offset = 4
    _set_latitude_method_offset = 5
    _get_longitude_method_offset = 6
    _set_longitude_method_offset = 7
    _copy_site_method_offset = 8
    _paste_site_method_offset = 9
    _get_as_catalog_item_method_offset = 10
    _metadata = {
        "iid_data" : (4642085616828634150, 1045311095125105541),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, UserVTOLPoint)

    _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 VTOL Point altitude."""
        return self._intf.get_property(UserVTOLPoint._metadata, UserVTOLPoint._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:
        """Get or set the VTOL Point altitude."""
        return self._intf.set_property(UserVTOLPoint._metadata, UserVTOLPoint._set_altitude_metadata, value)

    _get_terrain_altitude_metadata = { "offset" : _get_terrain_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    def get_terrain_altitude(self) -> float:
        """Set the VTOL Point altitude to the terrain altitude."""
        return self._intf.invoke(UserVTOLPoint._metadata, UserVTOLPoint._get_terrain_altitude_metadata, OutArg())

    _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 VTOL Point latitude."""
        return self._intf.get_property(UserVTOLPoint._metadata, UserVTOLPoint._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:
        """Get or set the VTOL Point latitude."""
        return self._intf.set_property(UserVTOLPoint._metadata, UserVTOLPoint._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 VTOL Point longitude."""
        return self._intf.get_property(UserVTOLPoint._metadata, UserVTOLPoint._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:
        """Get or set the VTOL Point longitude."""
        return self._intf.set_property(UserVTOLPoint._metadata, UserVTOLPoint._set_longitude_metadata, value)

    _copy_site_metadata = { "offset" : _copy_site_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def copy_site(self) -> None:
        """Copy the site to the clipboard."""
        return self._intf.invoke(UserVTOLPoint._metadata, UserVTOLPoint._copy_site_metadata, )

    _paste_site_metadata = { "offset" : _paste_site_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def paste_site(self) -> None:
        """Paste the site to the clipboard."""
        return self._intf.invoke(UserVTOLPoint._metadata, UserVTOLPoint._paste_site_metadata, )

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(UserVTOLPoint._metadata, UserVTOLPoint._get_as_catalog_item_metadata, OutArg())

    _property_names[altitude] = "altitude"
    _property_names[latitude] = "latitude"
    _property_names[longitude] = "longitude"

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

agcls.AgClassCatalog.add_catalog_entry((5188231581110256829, 4041576687601455523), UserVTOLPoint)
agcls.AgTypeNameMap["UserVTOLPoint"] = UserVTOLPoint

class UserWaypointSource(ICatalogSource, SupportsDeleteCallback):
    """Interface used to access the user waypoints in the Aviator catalog."""

    _num_methods = 3
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_user_waypoint_method_offset = 1
    _add_user_waypoint_method_offset = 2
    _get_as_catalog_source_method_offset = 3
    _metadata = {
        "iid_data" : (5279612640020866043, 15570877531294755481),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, UserWaypointSource)

    _get_user_waypoint_metadata = { "offset" : _get_user_waypoint_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_user_waypoint(self, name:str) -> "UserWaypoint":
        """Get the user waypoint with the given name."""
        return self._intf.invoke(UserWaypointSource._metadata, UserWaypointSource._get_user_waypoint_metadata, name, OutArg())

    _add_user_waypoint_metadata = { "offset" : _add_user_waypoint_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def add_user_waypoint(self, name:str) -> "UserWaypoint":
        """Create a new user waypoint with the given name."""
        return self._intf.invoke(UserWaypointSource._metadata, UserWaypointSource._add_user_waypoint_metadata, name, OutArg())

    _get_as_catalog_source_metadata = { "offset" : _get_as_catalog_source_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_source(self) -> "ICatalogSource":
        """Get the catalog source interface for this object."""
        return self._intf.invoke(UserWaypointSource._metadata, UserWaypointSource._get_as_catalog_source_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((5553700995735085871, 15015689302005296311), UserWaypointSource)
agcls.AgTypeNameMap["UserWaypointSource"] = UserWaypointSource

class UserWaypoint(ICatalogWaypoint, ICatalogItem, SupportsDeleteCallback):
    """Interface used to access a user waypoint in the Aviator catalog."""

    _num_methods = 7
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_latitude_method_offset = 1
    _set_latitude_method_offset = 2
    _get_longitude_method_offset = 3
    _set_longitude_method_offset = 4
    _copy_site_method_offset = 5
    _paste_site_method_offset = 6
    _get_as_catalog_item_method_offset = 7
    _metadata = {
        "iid_data" : (4742016672898529376, 10155203190602153088),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, UserWaypoint)

    _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 waypoint latitude."""
        return self._intf.get_property(UserWaypoint._metadata, UserWaypoint._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:
        """Get or set the waypoint latitude."""
        return self._intf.set_property(UserWaypoint._metadata, UserWaypoint._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 waypoint longitude."""
        return self._intf.get_property(UserWaypoint._metadata, UserWaypoint._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:
        """Get or set the waypoint longitude."""
        return self._intf.set_property(UserWaypoint._metadata, UserWaypoint._set_longitude_metadata, value)

    _copy_site_metadata = { "offset" : _copy_site_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def copy_site(self) -> None:
        """Copy the site to the clipboard."""
        return self._intf.invoke(UserWaypoint._metadata, UserWaypoint._copy_site_metadata, )

    _paste_site_metadata = { "offset" : _paste_site_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def paste_site(self) -> None:
        """Paste the site to the clipboard."""
        return self._intf.invoke(UserWaypoint._metadata, UserWaypoint._paste_site_metadata, )

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(UserWaypoint._metadata, UserWaypoint._get_as_catalog_item_metadata, OutArg())

    _property_names[latitude] = "latitude"
    _property_names[longitude] = "longitude"

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

agcls.AgClassCatalog.add_catalog_entry((4655366019608724573, 12962300198636569770), UserWaypoint)
agcls.AgTypeNameMap["UserWaypoint"] = UserWaypoint

class PropulsionEfficiencies(SupportsDeleteCallback):
    """Interface used to access the options for the Efficiencies and Losses of a jet engine powerplant in the advanced fixed wing tool."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_technology_level_method_offset = 1
    _set_technology_level_method_offset = 2
    _get_intake_type_method_offset = 3
    _set_intake_type_method_offset = 4
    _get_turbine_type_method_offset = 5
    _set_turbine_type_method_offset = 6
    _get_exhaust_nozzle_type_method_offset = 7
    _set_exhaust_nozzle_type_method_offset = 8
    _metadata = {
        "iid_data" : (4674082899564096187, 17478685343173365401),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, PropulsionEfficiencies)

    _get_technology_level_metadata = { "offset" : _get_technology_level_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(JetEngineTechnologyLevel),) }
    @property
    def technology_level(self) -> "JetEngineTechnologyLevel":
        """Get or set the technology level of the jet engine."""
        return self._intf.get_property(PropulsionEfficiencies._metadata, PropulsionEfficiencies._get_technology_level_metadata)

    _set_technology_level_metadata = { "offset" : _set_technology_level_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(JetEngineTechnologyLevel),) }
    @technology_level.setter
    def technology_level(self, value:"JetEngineTechnologyLevel") -> None:
        """Get or set the technology level of the jet engine."""
        return self._intf.set_property(PropulsionEfficiencies._metadata, PropulsionEfficiencies._set_technology_level_metadata, value)

    _get_intake_type_metadata = { "offset" : _get_intake_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(JetEngineIntakeType),) }
    @property
    def intake_type(self) -> "JetEngineIntakeType":
        """Get or set the jet engine intake type."""
        return self._intf.get_property(PropulsionEfficiencies._metadata, PropulsionEfficiencies._get_intake_type_metadata)

    _set_intake_type_metadata = { "offset" : _set_intake_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(JetEngineIntakeType),) }
    @intake_type.setter
    def intake_type(self, value:"JetEngineIntakeType") -> None:
        """Get or set the jet engine intake type."""
        return self._intf.set_property(PropulsionEfficiencies._metadata, PropulsionEfficiencies._set_intake_type_metadata, value)

    _get_turbine_type_metadata = { "offset" : _get_turbine_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(JetEngineTurbineType),) }
    @property
    def turbine_type(self) -> "JetEngineTurbineType":
        """Get or set the jet engine turbine type."""
        return self._intf.get_property(PropulsionEfficiencies._metadata, PropulsionEfficiencies._get_turbine_type_metadata)

    _set_turbine_type_metadata = { "offset" : _set_turbine_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(JetEngineTurbineType),) }
    @turbine_type.setter
    def turbine_type(self, value:"JetEngineTurbineType") -> None:
        """Get or set the jet engine turbine type."""
        return self._intf.set_property(PropulsionEfficiencies._metadata, PropulsionEfficiencies._set_turbine_type_metadata, value)

    _get_exhaust_nozzle_type_metadata = { "offset" : _get_exhaust_nozzle_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(JetEngineExhaustNozzleType),) }
    @property
    def exhaust_nozzle_type(self) -> "JetEngineExhaustNozzleType":
        """Get or set the jet engine exhaust nozzle type."""
        return self._intf.get_property(PropulsionEfficiencies._metadata, PropulsionEfficiencies._get_exhaust_nozzle_type_metadata)

    _set_exhaust_nozzle_type_metadata = { "offset" : _set_exhaust_nozzle_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(JetEngineExhaustNozzleType),) }
    @exhaust_nozzle_type.setter
    def exhaust_nozzle_type(self, value:"JetEngineExhaustNozzleType") -> None:
        """Get or set the jet engine exhaust nozzle type."""
        return self._intf.set_property(PropulsionEfficiencies._metadata, PropulsionEfficiencies._set_exhaust_nozzle_type_metadata, value)

    _property_names[technology_level] = "technology_level"
    _property_names[intake_type] = "intake_type"
    _property_names[turbine_type] = "turbine_type"
    _property_names[exhaust_nozzle_type] = "exhaust_nozzle_type"

    def __init__(self, source_object=None):
        """Construct an object of type PropulsionEfficiencies."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, PropulsionEfficiencies)
    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, PropulsionEfficiencies, [PropulsionEfficiencies, ])

agcls.AgClassCatalog.add_catalog_entry((5669950747571598906, 12810061537460991396), PropulsionEfficiencies)
agcls.AgTypeNameMap["PropulsionEfficiencies"] = PropulsionEfficiencies

class FuelModelKeroseneAFPROP(SupportsDeleteCallback):
    """Interface used to access the options for Kerosense - CEA fuel for a thermodynamic a jet engine model."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_subtype_method_offset = 1
    _set_subtype_method_offset = 2
    _get_specific_energy_method_offset = 3
    _set_specific_energy_method_offset = 4
    _metadata = {
        "iid_data" : (5688721802955479363, 6483120801106639768),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, FuelModelKeroseneAFPROP)

    _get_subtype_metadata = { "offset" : _get_subtype_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AFPROPFuelType),) }
    @property
    def subtype(self) -> "AFPROPFuelType":
        """Get or set the fuel subtype."""
        return self._intf.get_property(FuelModelKeroseneAFPROP._metadata, FuelModelKeroseneAFPROP._get_subtype_metadata)

    _set_subtype_metadata = { "offset" : _set_subtype_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AFPROPFuelType),) }
    @subtype.setter
    def subtype(self, value:"AFPROPFuelType") -> None:
        """Get or set the fuel subtype."""
        return self._intf.set_property(FuelModelKeroseneAFPROP._metadata, FuelModelKeroseneAFPROP._set_subtype_metadata, value)

    _get_specific_energy_metadata = { "offset" : _get_specific_energy_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def specific_energy(self) -> float:
        """Get or set the specific energy of the jet fuel."""
        return self._intf.get_property(FuelModelKeroseneAFPROP._metadata, FuelModelKeroseneAFPROP._get_specific_energy_metadata)

    _set_specific_energy_metadata = { "offset" : _set_specific_energy_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @specific_energy.setter
    def specific_energy(self, value:float) -> None:
        """Get or set the specific energy of the jet fuel."""
        return self._intf.set_property(FuelModelKeroseneAFPROP._metadata, FuelModelKeroseneAFPROP._set_specific_energy_metadata, value)

    _property_names[subtype] = "subtype"
    _property_names[specific_energy] = "specific_energy"

    def __init__(self, source_object=None):
        """Construct an object of type FuelModelKeroseneAFPROP."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, FuelModelKeroseneAFPROP)
    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, FuelModelKeroseneAFPROP, [FuelModelKeroseneAFPROP, ])

agcls.AgClassCatalog.add_catalog_entry((5351779965155399689, 16994867648074421433), FuelModelKeroseneAFPROP)
agcls.AgTypeNameMap["FuelModelKeroseneAFPROP"] = FuelModelKeroseneAFPROP

class FuelModelKeroseneCEA(SupportsDeleteCallback):
    """Interface used to access the options for Kerosense - CEA fuel for a thermodynamic a jet engine model."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_subtype_method_offset = 1
    _set_subtype_method_offset = 2
    _get_specific_energy_method_offset = 3
    _set_specific_energy_method_offset = 4
    _metadata = {
        "iid_data" : (5088149015662987308, 10086007103281585070),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, FuelModelKeroseneCEA)

    _get_subtype_metadata = { "offset" : _get_subtype_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(CEAFuelType),) }
    @property
    def subtype(self) -> "CEAFuelType":
        """Get or set the fuel subtype."""
        return self._intf.get_property(FuelModelKeroseneCEA._metadata, FuelModelKeroseneCEA._get_subtype_metadata)

    _set_subtype_metadata = { "offset" : _set_subtype_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(CEAFuelType),) }
    @subtype.setter
    def subtype(self, value:"CEAFuelType") -> None:
        """Get or set the fuel subtype."""
        return self._intf.set_property(FuelModelKeroseneCEA._metadata, FuelModelKeroseneCEA._set_subtype_metadata, value)

    _get_specific_energy_metadata = { "offset" : _get_specific_energy_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def specific_energy(self) -> float:
        """Get or set the specific energy of the jet fuel."""
        return self._intf.get_property(FuelModelKeroseneCEA._metadata, FuelModelKeroseneCEA._get_specific_energy_metadata)

    _set_specific_energy_metadata = { "offset" : _set_specific_energy_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @specific_energy.setter
    def specific_energy(self, value:float) -> None:
        """Get or set the specific energy of the jet fuel."""
        return self._intf.set_property(FuelModelKeroseneCEA._metadata, FuelModelKeroseneCEA._set_specific_energy_metadata, value)

    _property_names[subtype] = "subtype"
    _property_names[specific_energy] = "specific_energy"

    def __init__(self, source_object=None):
        """Construct an object of type FuelModelKeroseneCEA."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, FuelModelKeroseneCEA)
    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, FuelModelKeroseneCEA, [FuelModelKeroseneCEA, ])

agcls.AgClassCatalog.add_catalog_entry((5679718093274217092, 12398336171793532820), FuelModelKeroseneCEA)
agcls.AgTypeNameMap["FuelModelKeroseneCEA"] = FuelModelKeroseneCEA

class AdvancedFixedWingRamjetBasic(SupportsDeleteCallback):
    """Interface used to access the options for a basic Ramjet mode."""

    _num_methods = 15
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_design_altitude_method_offset = 1
    _set_design_altitude_method_offset = 2
    _get_design_mach_method_offset = 3
    _set_design_mach_method_offset = 4
    _get_design_thrust_method_offset = 5
    _set_design_thrust_method_offset = 6
    _get_max_compression_temp_method_offset = 7
    _set_max_compression_temp_method_offset = 8
    _get_max_burner_temp_method_offset = 9
    _set_max_burner_temp_method_offset = 10
    _get_fuel_type_method_offset = 11
    _set_fuel_type_method_offset = 12
    _get_fuel_mode_as_afprop_method_offset = 13
    _get_fuel_mode_as_cea_method_offset = 14
    _get_efficiencies_and_losses_method_offset = 15
    _metadata = {
        "iid_data" : (4825685751456030732, 5762067210430664113),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingRamjetBasic)

    _get_design_altitude_metadata = { "offset" : _get_design_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_altitude(self) -> float:
        """Get or set the altitude design point of the engine."""
        return self._intf.get_property(AdvancedFixedWingRamjetBasic._metadata, AdvancedFixedWingRamjetBasic._get_design_altitude_metadata)

    _set_design_altitude_metadata = { "offset" : _set_design_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_altitude.setter
    def design_altitude(self, value:float) -> None:
        """Get or set the altitude design point of the engine."""
        return self._intf.set_property(AdvancedFixedWingRamjetBasic._metadata, AdvancedFixedWingRamjetBasic._set_design_altitude_metadata, value)

    _get_design_mach_metadata = { "offset" : _get_design_mach_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_mach(self) -> float:
        """Get or set the mach number design point of the engine."""
        return self._intf.get_property(AdvancedFixedWingRamjetBasic._metadata, AdvancedFixedWingRamjetBasic._get_design_mach_metadata)

    _set_design_mach_metadata = { "offset" : _set_design_mach_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_mach.setter
    def design_mach(self, value:float) -> None:
        """Get or set the mach number design point of the engine."""
        return self._intf.set_property(AdvancedFixedWingRamjetBasic._metadata, AdvancedFixedWingRamjetBasic._set_design_mach_metadata, value)

    _get_design_thrust_metadata = { "offset" : _get_design_thrust_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_thrust(self) -> float:
        """Get or set the thrust design point of the engine."""
        return self._intf.get_property(AdvancedFixedWingRamjetBasic._metadata, AdvancedFixedWingRamjetBasic._get_design_thrust_metadata)

    _set_design_thrust_metadata = { "offset" : _set_design_thrust_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_thrust.setter
    def design_thrust(self, value:float) -> None:
        """Get or set the thrust design point of the engine."""
        return self._intf.set_property(AdvancedFixedWingRamjetBasic._metadata, AdvancedFixedWingRamjetBasic._set_design_thrust_metadata, value)

    _get_max_compression_temp_metadata = { "offset" : _get_max_compression_temp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_compression_temp(self) -> float:
        """Get or set the maximum temperature at the compressor stage."""
        return self._intf.get_property(AdvancedFixedWingRamjetBasic._metadata, AdvancedFixedWingRamjetBasic._get_max_compression_temp_metadata)

    _set_max_compression_temp_metadata = { "offset" : _set_max_compression_temp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_compression_temp.setter
    def max_compression_temp(self, value:float) -> None:
        """Get or set the maximum temperature at the compressor stage."""
        return self._intf.set_property(AdvancedFixedWingRamjetBasic._metadata, AdvancedFixedWingRamjetBasic._set_max_compression_temp_metadata, value)

    _get_max_burner_temp_metadata = { "offset" : _get_max_burner_temp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_burner_temp(self) -> float:
        """Get or set the maximum temperature at the combustion stage."""
        return self._intf.get_property(AdvancedFixedWingRamjetBasic._metadata, AdvancedFixedWingRamjetBasic._get_max_burner_temp_metadata)

    _set_max_burner_temp_metadata = { "offset" : _set_max_burner_temp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_burner_temp.setter
    def max_burner_temp(self, value:float) -> None:
        """Get or set the maximum temperature at the combustion stage."""
        return self._intf.set_property(AdvancedFixedWingRamjetBasic._metadata, AdvancedFixedWingRamjetBasic._set_max_burner_temp_metadata, value)

    _get_fuel_type_metadata = { "offset" : _get_fuel_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(JetFuelType),) }
    @property
    def fuel_type(self) -> "JetFuelType":
        """Get or set the jet engine's fuel type."""
        return self._intf.get_property(AdvancedFixedWingRamjetBasic._metadata, AdvancedFixedWingRamjetBasic._get_fuel_type_metadata)

    _set_fuel_type_metadata = { "offset" : _set_fuel_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(JetFuelType),) }
    @fuel_type.setter
    def fuel_type(self, value:"JetFuelType") -> None:
        """Get or set the jet engine's fuel type."""
        return self._intf.set_property(AdvancedFixedWingRamjetBasic._metadata, AdvancedFixedWingRamjetBasic._set_fuel_type_metadata, value)

    _get_fuel_mode_as_afprop_metadata = { "offset" : _get_fuel_mode_as_afprop_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def fuel_mode_as_afprop(self) -> "FuelModelKeroseneAFPROP":
        """Get the interface for a Kerosene - AFPROP fuel mode."""
        return self._intf.get_property(AdvancedFixedWingRamjetBasic._metadata, AdvancedFixedWingRamjetBasic._get_fuel_mode_as_afprop_metadata)

    _get_fuel_mode_as_cea_metadata = { "offset" : _get_fuel_mode_as_cea_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def fuel_mode_as_cea(self) -> "FuelModelKeroseneCEA":
        """Get the interface for a Kerosene - CEA fuel mode."""
        return self._intf.get_property(AdvancedFixedWingRamjetBasic._metadata, AdvancedFixedWingRamjetBasic._get_fuel_mode_as_cea_metadata)

    _get_efficiencies_and_losses_metadata = { "offset" : _get_efficiencies_and_losses_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def efficiencies_and_losses(self) -> "PropulsionEfficiencies":
        """Get the jet engine's propulsion efficiencies and losses."""
        return self._intf.get_property(AdvancedFixedWingRamjetBasic._metadata, AdvancedFixedWingRamjetBasic._get_efficiencies_and_losses_metadata)

    _property_names[design_altitude] = "design_altitude"
    _property_names[design_mach] = "design_mach"
    _property_names[design_thrust] = "design_thrust"
    _property_names[max_compression_temp] = "max_compression_temp"
    _property_names[max_burner_temp] = "max_burner_temp"
    _property_names[fuel_type] = "fuel_type"
    _property_names[fuel_mode_as_afprop] = "fuel_mode_as_afprop"
    _property_names[fuel_mode_as_cea] = "fuel_mode_as_cea"
    _property_names[efficiencies_and_losses] = "efficiencies_and_losses"

    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingRamjetBasic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingRamjetBasic)
    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, AdvancedFixedWingRamjetBasic, [AdvancedFixedWingRamjetBasic, ])

agcls.AgClassCatalog.add_catalog_entry((4800059996755934875, 16027503078820577432), AdvancedFixedWingRamjetBasic)
agcls.AgTypeNameMap["AdvancedFixedWingRamjetBasic"] = AdvancedFixedWingRamjetBasic

class AdvancedFixedWingScramjetBasic(SupportsDeleteCallback):
    """Interface used to access the options for a basic Scramjet mode."""

    _num_methods = 15
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_design_altitude_method_offset = 1
    _set_design_altitude_method_offset = 2
    _get_design_mach_method_offset = 3
    _set_design_mach_method_offset = 4
    _get_design_thrust_method_offset = 5
    _set_design_thrust_method_offset = 6
    _get_max_compression_temp_method_offset = 7
    _set_max_compression_temp_method_offset = 8
    _get_max_burner_temp_method_offset = 9
    _set_max_burner_temp_method_offset = 10
    _get_fuel_type_method_offset = 11
    _set_fuel_type_method_offset = 12
    _get_fuel_mode_as_afprop_method_offset = 13
    _get_fuel_mode_as_cea_method_offset = 14
    _get_efficiencies_and_losses_method_offset = 15
    _metadata = {
        "iid_data" : (5739887637508413990, 943923446550695301),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingScramjetBasic)

    _get_design_altitude_metadata = { "offset" : _get_design_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_altitude(self) -> float:
        """Get or set the altitude design point of the engine."""
        return self._intf.get_property(AdvancedFixedWingScramjetBasic._metadata, AdvancedFixedWingScramjetBasic._get_design_altitude_metadata)

    _set_design_altitude_metadata = { "offset" : _set_design_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_altitude.setter
    def design_altitude(self, value:float) -> None:
        """Get or set the altitude design point of the engine."""
        return self._intf.set_property(AdvancedFixedWingScramjetBasic._metadata, AdvancedFixedWingScramjetBasic._set_design_altitude_metadata, value)

    _get_design_mach_metadata = { "offset" : _get_design_mach_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_mach(self) -> float:
        """Get or set the mach number design point of the engine."""
        return self._intf.get_property(AdvancedFixedWingScramjetBasic._metadata, AdvancedFixedWingScramjetBasic._get_design_mach_metadata)

    _set_design_mach_metadata = { "offset" : _set_design_mach_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_mach.setter
    def design_mach(self, value:float) -> None:
        """Get or set the mach number design point of the engine."""
        return self._intf.set_property(AdvancedFixedWingScramjetBasic._metadata, AdvancedFixedWingScramjetBasic._set_design_mach_metadata, value)

    _get_design_thrust_metadata = { "offset" : _get_design_thrust_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def design_thrust(self) -> float:
        """Get or set the thrust design point of the engine."""
        return self._intf.get_property(AdvancedFixedWingScramjetBasic._metadata, AdvancedFixedWingScramjetBasic._get_design_thrust_metadata)

    _set_design_thrust_metadata = { "offset" : _set_design_thrust_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @design_thrust.setter
    def design_thrust(self, value:float) -> None:
        """Get or set the thrust design point of the engine."""
        return self._intf.set_property(AdvancedFixedWingScramjetBasic._metadata, AdvancedFixedWingScramjetBasic._set_design_thrust_metadata, value)

    _get_max_compression_temp_metadata = { "offset" : _get_max_compression_temp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_compression_temp(self) -> float:
        """Get or set the maximum temperature at the compressor stage."""
        return self._intf.get_property(AdvancedFixedWingScramjetBasic._metadata, AdvancedFixedWingScramjetBasic._get_max_compression_temp_metadata)

    _set_max_compression_temp_metadata = { "offset" : _set_max_compression_temp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_compression_temp.setter
    def max_compression_temp(self, value:float) -> None:
        """Get or set the maximum temperature at the compressor stage."""
        return self._intf.set_property(AdvancedFixedWingScramjetBasic._metadata, AdvancedFixedWingScramjetBasic._set_max_compression_temp_metadata, value)

    _get_max_burner_temp_metadata = { "offset" : _get_max_burner_temp_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_burner_temp(self) -> float:
        """Get or set the maximum temperature at the combustion stage."""
        return self._intf.get_property(AdvancedFixedWingScramjetBasic._metadata, AdvancedFixedWingScramjetBasic._get_max_burner_temp_metadata)

    _set_max_burner_temp_metadata = { "offset" : _set_max_burner_temp_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_burner_temp.setter
    def max_burner_temp(self, value:float) -> None:
        """Get or set the maximum temperature at the combustion stage."""
        return self._intf.set_property(AdvancedFixedWingScramjetBasic._metadata, AdvancedFixedWingScramjetBasic._set_max_burner_temp_metadata, value)

    _get_fuel_type_metadata = { "offset" : _get_fuel_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(JetFuelType),) }
    @property
    def fuel_type(self) -> "JetFuelType":
        """Get or set the jet engine's fuel type."""
        return self._intf.get_property(AdvancedFixedWingScramjetBasic._metadata, AdvancedFixedWingScramjetBasic._get_fuel_type_metadata)

    _set_fuel_type_metadata = { "offset" : _set_fuel_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(JetFuelType),) }
    @fuel_type.setter
    def fuel_type(self, value:"JetFuelType") -> None:
        """Get or set the jet engine's fuel type."""
        return self._intf.set_property(AdvancedFixedWingScramjetBasic._metadata, AdvancedFixedWingScramjetBasic._set_fuel_type_metadata, value)

    _get_fuel_mode_as_afprop_metadata = { "offset" : _get_fuel_mode_as_afprop_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def fuel_mode_as_afprop(self) -> "FuelModelKeroseneAFPROP":
        """Get the interface for a Kerosene - AFPROP fuel mode."""
        return self._intf.get_property(AdvancedFixedWingScramjetBasic._metadata, AdvancedFixedWingScramjetBasic._get_fuel_mode_as_afprop_metadata)

    _get_fuel_mode_as_cea_metadata = { "offset" : _get_fuel_mode_as_cea_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def fuel_mode_as_cea(self) -> "FuelModelKeroseneCEA":
        """Get the interface for a Kerosene - CEA fuel mode."""
        return self._intf.get_property(AdvancedFixedWingScramjetBasic._metadata, AdvancedFixedWingScramjetBasic._get_fuel_mode_as_cea_metadata)

    _get_efficiencies_and_losses_metadata = { "offset" : _get_efficiencies_and_losses_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def efficiencies_and_losses(self) -> "PropulsionEfficiencies":
        """Get the jet engine's propulsion efficiencies and losses."""
        return self._intf.get_property(AdvancedFixedWingScramjetBasic._metadata, AdvancedFixedWingScramjetBasic._get_efficiencies_and_losses_metadata)

    _property_names[design_altitude] = "design_altitude"
    _property_names[design_mach] = "design_mach"
    _property_names[design_thrust] = "design_thrust"
    _property_names[max_compression_temp] = "max_compression_temp"
    _property_names[max_burner_temp] = "max_burner_temp"
    _property_names[fuel_type] = "fuel_type"
    _property_names[fuel_mode_as_afprop] = "fuel_mode_as_afprop"
    _property_names[fuel_mode_as_cea] = "fuel_mode_as_cea"
    _property_names[efficiencies_and_losses] = "efficiencies_and_losses"

    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingScramjetBasic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingScramjetBasic)
    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, AdvancedFixedWingScramjetBasic, [AdvancedFixedWingScramjetBasic, ])

agcls.AgClassCatalog.add_catalog_entry((5139325106206458342, 4967878671621867145), AdvancedFixedWingScramjetBasic)
agcls.AgTypeNameMap["AdvancedFixedWingScramjetBasic"] = AdvancedFixedWingScramjetBasic

class AircraftVTOLModel(SupportsDeleteCallback):
    """Interface used to access the options for a VTOL performance model of an aircraft."""

    _num_methods = 25
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_max_hover_altitude_method_offset = 1
    _set_max_hover_altitude_method_offset = 2
    _get_use_aerodynamic_propulsion_fuel_method_offset = 3
    _set_use_aerodynamic_propulsion_fuel_method_offset = 4
    _get_scale_fuel_flow_by_non_std_density_method_offset = 5
    _set_scale_fuel_flow_by_non_std_density_method_offset = 6
    _get_hover_fuel_method_offset = 7
    _set_hover_fuel_method_offset = 8
    _get_heading_rate_method_offset = 9
    _set_heading_rate_method_offset = 10
    _get_heading_transition_time_method_offset = 11
    _set_heading_transition_time_method_offset = 12
    _get_vertical_rate_method_offset = 13
    _set_vertical_rate_method_offset = 14
    _get_vertical_transition_time_method_offset = 15
    _set_vertical_transition_time_method_offset = 16
    _get_translation_rate_method_offset = 17
    _set_translation_rate_method_offset = 18
    _get_translation_transition_time_method_offset = 19
    _set_translation_transition_time_method_offset = 20
    _get_forward_flight_airspeed_method_offset = 21
    _get_forward_flight_airspeed_type_method_offset = 22
    _set_forward_flight_airspeed_method_offset = 23
    _get_forward_flight_transition_time_method_offset = 24
    _set_forward_flight_transition_time_method_offset = 25
    _metadata = {
        "iid_data" : (5759405462565022892, 5032690834817875131),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftVTOLModel)

    _get_max_hover_altitude_metadata = { "offset" : _get_max_hover_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_hover_altitude(self) -> float:
        """Get or set the maximum altitude at which the aircraft is capable of hovering."""
        return self._intf.get_property(AircraftVTOLModel._metadata, AircraftVTOLModel._get_max_hover_altitude_metadata)

    _set_max_hover_altitude_metadata = { "offset" : _set_max_hover_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_hover_altitude.setter
    def max_hover_altitude(self, value:float) -> None:
        """Get or set the maximum altitude at which the aircraft is capable of hovering."""
        return self._intf.set_property(AircraftVTOLModel._metadata, AircraftVTOLModel._set_max_hover_altitude_metadata, value)

    _get_use_aerodynamic_propulsion_fuel_metadata = { "offset" : _get_use_aerodynamic_propulsion_fuel_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_aerodynamic_propulsion_fuel(self) -> bool:
        """Get or set whether to use Aero/Propulsion fuel flow."""
        return self._intf.get_property(AircraftVTOLModel._metadata, AircraftVTOLModel._get_use_aerodynamic_propulsion_fuel_metadata)

    _set_use_aerodynamic_propulsion_fuel_metadata = { "offset" : _set_use_aerodynamic_propulsion_fuel_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_aerodynamic_propulsion_fuel.setter
    def use_aerodynamic_propulsion_fuel(self, value:bool) -> None:
        """Get or set whether to use Aero/Propulsion fuel flow."""
        return self._intf.set_property(AircraftVTOLModel._metadata, AircraftVTOLModel._set_use_aerodynamic_propulsion_fuel_metadata, value)

    _get_scale_fuel_flow_by_non_std_density_metadata = { "offset" : _get_scale_fuel_flow_by_non_std_density_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def scale_fuel_flow_by_non_std_density(self) -> bool:
        """Get or set whether to scale fuel flow by non std density."""
        return self._intf.get_property(AircraftVTOLModel._metadata, AircraftVTOLModel._get_scale_fuel_flow_by_non_std_density_metadata)

    _set_scale_fuel_flow_by_non_std_density_metadata = { "offset" : _set_scale_fuel_flow_by_non_std_density_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @scale_fuel_flow_by_non_std_density.setter
    def scale_fuel_flow_by_non_std_density(self, value:bool) -> None:
        """Get or set whether to scale fuel flow by non std density."""
        return self._intf.set_property(AircraftVTOLModel._metadata, AircraftVTOLModel._set_scale_fuel_flow_by_non_std_density_metadata, value)

    _get_hover_fuel_metadata = { "offset" : _get_hover_fuel_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def hover_fuel(self) -> float:
        """Get or set the aircraft's fuel flow rate while hovering."""
        return self._intf.get_property(AircraftVTOLModel._metadata, AircraftVTOLModel._get_hover_fuel_metadata)

    _set_hover_fuel_metadata = { "offset" : _set_hover_fuel_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @hover_fuel.setter
    def hover_fuel(self, value:float) -> None:
        """Get or set the aircraft's fuel flow rate while hovering."""
        return self._intf.set_property(AircraftVTOLModel._metadata, AircraftVTOLModel._set_hover_fuel_metadata, value)

    _get_heading_rate_metadata = { "offset" : _get_heading_rate_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def heading_rate(self) -> typing.Any:
        """Get or set the rate at which the aircraft can change heading while hovering."""
        return self._intf.get_property(AircraftVTOLModel._metadata, AircraftVTOLModel._get_heading_rate_metadata)

    _set_heading_rate_metadata = { "offset" : _set_heading_rate_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @heading_rate.setter
    def heading_rate(self, value:typing.Any) -> None:
        """Get or set the rate at which the aircraft can change heading while hovering."""
        return self._intf.set_property(AircraftVTOLModel._metadata, AircraftVTOLModel._set_heading_rate_metadata, value)

    _get_heading_transition_time_metadata = { "offset" : _get_heading_transition_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def heading_transition_time(self) -> float:
        """Get or set the time required to transition from another maneuvering mode to heading change maneuver mode."""
        return self._intf.get_property(AircraftVTOLModel._metadata, AircraftVTOLModel._get_heading_transition_time_metadata)

    _set_heading_transition_time_metadata = { "offset" : _set_heading_transition_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @heading_transition_time.setter
    def heading_transition_time(self, value:float) -> None:
        """Get or set the time required to transition from another maneuvering mode to heading change maneuver mode."""
        return self._intf.set_property(AircraftVTOLModel._metadata, AircraftVTOLModel._set_heading_transition_time_metadata, value)

    _get_vertical_rate_metadata = { "offset" : _get_vertical_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def vertical_rate(self) -> float:
        """Get or set the aircraft's vertical rate."""
        return self._intf.get_property(AircraftVTOLModel._metadata, AircraftVTOLModel._get_vertical_rate_metadata)

    _set_vertical_rate_metadata = { "offset" : _set_vertical_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @vertical_rate.setter
    def vertical_rate(self, value:float) -> None:
        """Get or set the aircraft's vertical rate."""
        return self._intf.set_property(AircraftVTOLModel._metadata, AircraftVTOLModel._set_vertical_rate_metadata, value)

    _get_vertical_transition_time_metadata = { "offset" : _get_vertical_transition_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def vertical_transition_time(self) -> float:
        """Get or set the time required to transition from another maneuvering mode to vertical maneuver mode."""
        return self._intf.get_property(AircraftVTOLModel._metadata, AircraftVTOLModel._get_vertical_transition_time_metadata)

    _set_vertical_transition_time_metadata = { "offset" : _set_vertical_transition_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @vertical_transition_time.setter
    def vertical_transition_time(self, value:float) -> None:
        """Get or set the time required to transition from another maneuvering mode to vertical maneuver mode."""
        return self._intf.set_property(AircraftVTOLModel._metadata, AircraftVTOLModel._set_vertical_transition_time_metadata, value)

    _get_translation_rate_metadata = { "offset" : _get_translation_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def translation_rate(self) -> float:
        """Get or set the rate at which the aircraft can translate while hovering."""
        return self._intf.get_property(AircraftVTOLModel._metadata, AircraftVTOLModel._get_translation_rate_metadata)

    _set_translation_rate_metadata = { "offset" : _set_translation_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @translation_rate.setter
    def translation_rate(self, value:float) -> None:
        """Get or set the rate at which the aircraft can translate while hovering."""
        return self._intf.set_property(AircraftVTOLModel._metadata, AircraftVTOLModel._set_translation_rate_metadata, value)

    _get_translation_transition_time_metadata = { "offset" : _get_translation_transition_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def translation_transition_time(self) -> float:
        """Get or set the time required to transition from another maneuvering mode to translation maneuver mode."""
        return self._intf.get_property(AircraftVTOLModel._metadata, AircraftVTOLModel._get_translation_transition_time_metadata)

    _set_translation_transition_time_metadata = { "offset" : _set_translation_transition_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @translation_transition_time.setter
    def translation_transition_time(self, value:float) -> None:
        """Get or set the time required to transition from another maneuvering mode to translation maneuver mode."""
        return self._intf.set_property(AircraftVTOLModel._metadata, AircraftVTOLModel._set_translation_transition_time_metadata, value)

    _get_forward_flight_airspeed_metadata = { "offset" : _get_forward_flight_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def forward_flight_airspeed(self) -> float:
        """Get the speed at which the aircraft can begin forward flight."""
        return self._intf.get_property(AircraftVTOLModel._metadata, AircraftVTOLModel._get_forward_flight_airspeed_metadata)

    _get_forward_flight_airspeed_type_metadata = { "offset" : _get_forward_flight_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def forward_flight_airspeed_type(self) -> "AirspeedType":
        """Get the forward flight airspeed type."""
        return self._intf.get_property(AircraftVTOLModel._metadata, AircraftVTOLModel._get_forward_flight_airspeed_type_metadata)

    _set_forward_flight_airspeed_metadata = { "offset" : _set_forward_flight_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_forward_flight_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the speed at which the aircraft can begin forward flight."""
        return self._intf.invoke(AircraftVTOLModel._metadata, AircraftVTOLModel._set_forward_flight_airspeed_metadata, airspeed_type, airspeed)

    _get_forward_flight_transition_time_metadata = { "offset" : _get_forward_flight_transition_time_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def forward_flight_transition_time(self) -> float:
        """Get or set the time required to transition from another maneuvering mode to forward flight at sea level."""
        return self._intf.get_property(AircraftVTOLModel._metadata, AircraftVTOLModel._get_forward_flight_transition_time_metadata)

    _set_forward_flight_transition_time_metadata = { "offset" : _set_forward_flight_transition_time_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @forward_flight_transition_time.setter
    def forward_flight_transition_time(self, value:float) -> None:
        """Get or set the time required to transition from another maneuvering mode to forward flight at sea level."""
        return self._intf.set_property(AircraftVTOLModel._metadata, AircraftVTOLModel._set_forward_flight_transition_time_metadata, value)

    _property_names[max_hover_altitude] = "max_hover_altitude"
    _property_names[use_aerodynamic_propulsion_fuel] = "use_aerodynamic_propulsion_fuel"
    _property_names[scale_fuel_flow_by_non_std_density] = "scale_fuel_flow_by_non_std_density"
    _property_names[hover_fuel] = "hover_fuel"
    _property_names[heading_rate] = "heading_rate"
    _property_names[heading_transition_time] = "heading_transition_time"
    _property_names[vertical_rate] = "vertical_rate"
    _property_names[vertical_transition_time] = "vertical_transition_time"
    _property_names[translation_rate] = "translation_rate"
    _property_names[translation_transition_time] = "translation_transition_time"
    _property_names[forward_flight_airspeed] = "forward_flight_airspeed"
    _property_names[forward_flight_airspeed_type] = "forward_flight_airspeed_type"
    _property_names[forward_flight_transition_time] = "forward_flight_transition_time"

    def __init__(self, source_object=None):
        """Construct an object of type AircraftVTOLModel."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AircraftVTOLModel)
    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, AircraftVTOLModel, [AircraftVTOLModel, ])

agcls.AgClassCatalog.add_catalog_entry((4651691522976222621, 3232698111153459360), AircraftVTOLModel)
agcls.AgTypeNameMap["AircraftVTOLModel"] = AircraftVTOLModel

class AircraftVTOL(ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the VTOL options for an aircraft in the Aviator catalog."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_vtol_by_name_method_offset = 1
    _get_as_catalog_item_method_offset = 2
    _metadata = {
        "iid_data" : (4997466023368198583, 2582936896164038578),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftVTOL)

    _get_vtol_by_name_metadata = { "offset" : _get_vtol_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_vtol_by_name(self, name:str) -> "AircraftVTOLModel":
        """Get the VTOL model with the given name."""
        return self._intf.invoke(AircraftVTOL._metadata, AircraftVTOL._get_vtol_by_name_metadata, name, OutArg())

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftVTOL._metadata, AircraftVTOL._get_as_catalog_item_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((4853877629771391834, 2473824918069775760), AircraftVTOL)
agcls.AgTypeNameMap["AircraftVTOL"] = AircraftVTOL

class AircraftTerrainFollowModel(SupportsDeleteCallback):
    """Interface used to access the options for a TerrainFollow performance model of an aircraft."""

    _num_methods = 31
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_airspeed_type_method_offset = 1
    _set_airspeed_type_method_offset = 2
    _get_use_aerodynamic_propulsion_fuel_method_offset = 3
    _set_use_aerodynamic_propulsion_fuel_method_offset = 4
    _get_scale_fuel_flow_by_non_std_density_method_offset = 5
    _set_scale_fuel_flow_by_non_std_density_method_offset = 6
    _get_min_airspeed_method_offset = 7
    _set_min_airspeed_method_offset = 8
    _get_max_endurance_airspeed_method_offset = 9
    _set_max_endurance_airspeed_method_offset = 10
    _get_max_range_airspeed_method_offset = 11
    _set_max_range_airspeed_method_offset = 12
    _get_max_airspeed_method_offset = 13
    _set_max_airspeed_method_offset = 14
    _get_max_performance_airspeed_method_offset = 15
    _set_max_performance_airspeed_method_offset = 16
    _get_min_airspeed_fuel_flow_method_offset = 17
    _set_min_airspeed_fuel_flow_method_offset = 18
    _get_max_endurance_fuel_flow_method_offset = 19
    _set_max_endurance_fuel_flow_method_offset = 20
    _get_max_range_fuel_flow_method_offset = 21
    _set_max_range_fuel_flow_method_offset = 22
    _get_max_airspeed_fuel_flow_method_offset = 23
    _set_max_airspeed_fuel_flow_method_offset = 24
    _get_max_performance_airspeed_fuel_flow_method_offset = 25
    _set_max_performance_airspeed_fuel_flow_method_offset = 26
    _get_max_pitch_angle_method_offset = 27
    _set_max_pitch_angle_method_offset = 28
    _get_terrain_window_method_offset = 29
    _set_terrain_window_method_offset = 30
    _get_max_load_factor_method_offset = 31
    _metadata = {
        "iid_data" : (5083354620477340854, 10481718300900310965),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftTerrainFollowModel)

    _get_airspeed_type_metadata = { "offset" : _get_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_type(self) -> "AirspeedType":
        """Get or set the airspeed type."""
        return self._intf.get_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._get_airspeed_type_metadata)

    _set_airspeed_type_metadata = { "offset" : _set_airspeed_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @airspeed_type.setter
    def airspeed_type(self, value:"AirspeedType") -> None:
        """Get or set the airspeed type."""
        return self._intf.set_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._set_airspeed_type_metadata, value)

    _get_use_aerodynamic_propulsion_fuel_metadata = { "offset" : _get_use_aerodynamic_propulsion_fuel_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_aerodynamic_propulsion_fuel(self) -> bool:
        """Opt to use the fuel flow calculated by the acceleration performance model."""
        return self._intf.get_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._get_use_aerodynamic_propulsion_fuel_metadata)

    _set_use_aerodynamic_propulsion_fuel_metadata = { "offset" : _set_use_aerodynamic_propulsion_fuel_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_aerodynamic_propulsion_fuel.setter
    def use_aerodynamic_propulsion_fuel(self, value:bool) -> None:
        """Opt to use the fuel flow calculated by the acceleration performance model."""
        return self._intf.set_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._set_use_aerodynamic_propulsion_fuel_metadata, value)

    _get_scale_fuel_flow_by_non_std_density_metadata = { "offset" : _get_scale_fuel_flow_by_non_std_density_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def scale_fuel_flow_by_non_std_density(self) -> bool:
        """Opt to scale the fuel flow by the aircraft's actual altitude."""
        return self._intf.get_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._get_scale_fuel_flow_by_non_std_density_metadata)

    _set_scale_fuel_flow_by_non_std_density_metadata = { "offset" : _set_scale_fuel_flow_by_non_std_density_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @scale_fuel_flow_by_non_std_density.setter
    def scale_fuel_flow_by_non_std_density(self, value:bool) -> None:
        """Opt to scale the fuel flow by the aircraft's actual altitude."""
        return self._intf.set_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._set_scale_fuel_flow_by_non_std_density_metadata, value)

    _get_min_airspeed_metadata = { "offset" : _get_min_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_airspeed(self) -> float:
        """Get or set the minimum airspeed."""
        return self._intf.get_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._get_min_airspeed_metadata)

    _set_min_airspeed_metadata = { "offset" : _set_min_airspeed_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_airspeed.setter
    def min_airspeed(self, value:float) -> None:
        """Get or set the minimum airspeed."""
        return self._intf.set_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._set_min_airspeed_metadata, value)

    _get_max_endurance_airspeed_metadata = { "offset" : _get_max_endurance_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_endurance_airspeed(self) -> float:
        """Get or set the airspeed that will provide the maximum flying time for the aircraft."""
        return self._intf.get_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._get_max_endurance_airspeed_metadata)

    _set_max_endurance_airspeed_metadata = { "offset" : _set_max_endurance_airspeed_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_endurance_airspeed.setter
    def max_endurance_airspeed(self, value:float) -> None:
        """Get or set the airspeed that will provide the maximum flying time for the aircraft."""
        return self._intf.set_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._set_max_endurance_airspeed_metadata, value)

    _get_max_range_airspeed_metadata = { "offset" : _get_max_range_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_range_airspeed(self) -> float:
        """Get or set the maximum range airspeed."""
        return self._intf.get_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._get_max_range_airspeed_metadata)

    _set_max_range_airspeed_metadata = { "offset" : _set_max_range_airspeed_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_range_airspeed.setter
    def max_range_airspeed(self, value:float) -> None:
        """Get or set the maximum range airspeed."""
        return self._intf.set_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._set_max_range_airspeed_metadata, value)

    _get_max_airspeed_metadata = { "offset" : _get_max_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_airspeed(self) -> float:
        """Get or set the maximum airspeed."""
        return self._intf.get_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._get_max_airspeed_metadata)

    _set_max_airspeed_metadata = { "offset" : _set_max_airspeed_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_airspeed.setter
    def max_airspeed(self, value:float) -> None:
        """Get or set the maximum airspeed."""
        return self._intf.set_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._set_max_airspeed_metadata, value)

    _get_max_performance_airspeed_metadata = { "offset" : _get_max_performance_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_performance_airspeed(self) -> float:
        """Get or set the custom performance airspeed that can be used to model specific flight conditions."""
        return self._intf.get_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._get_max_performance_airspeed_metadata)

    _set_max_performance_airspeed_metadata = { "offset" : _set_max_performance_airspeed_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_performance_airspeed.setter
    def max_performance_airspeed(self, value:float) -> None:
        """Get or set the custom performance airspeed that can be used to model specific flight conditions."""
        return self._intf.set_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._set_max_performance_airspeed_metadata, value)

    _get_min_airspeed_fuel_flow_metadata = { "offset" : _get_min_airspeed_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def min_airspeed_fuel_flow(self) -> float:
        """Get or set the fuel flow for the minimum airspeed."""
        return self._intf.get_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._get_min_airspeed_fuel_flow_metadata)

    _set_min_airspeed_fuel_flow_metadata = { "offset" : _set_min_airspeed_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @min_airspeed_fuel_flow.setter
    def min_airspeed_fuel_flow(self, value:float) -> None:
        """Get or set the fuel flow for the minimum airspeed."""
        return self._intf.set_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._set_min_airspeed_fuel_flow_metadata, value)

    _get_max_endurance_fuel_flow_metadata = { "offset" : _get_max_endurance_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_endurance_fuel_flow(self) -> float:
        """Get or set the fuel flow for the maximum endurance airspeed."""
        return self._intf.get_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._get_max_endurance_fuel_flow_metadata)

    _set_max_endurance_fuel_flow_metadata = { "offset" : _set_max_endurance_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_endurance_fuel_flow.setter
    def max_endurance_fuel_flow(self, value:float) -> None:
        """Get or set the fuel flow for the maximum endurance airspeed."""
        return self._intf.set_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._set_max_endurance_fuel_flow_metadata, value)

    _get_max_range_fuel_flow_metadata = { "offset" : _get_max_range_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_range_fuel_flow(self) -> float:
        """Get or set the fuel flow for the maximum range airspeed."""
        return self._intf.get_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._get_max_range_fuel_flow_metadata)

    _set_max_range_fuel_flow_metadata = { "offset" : _set_max_range_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_range_fuel_flow.setter
    def max_range_fuel_flow(self, value:float) -> None:
        """Get or set the fuel flow for the maximum range airspeed."""
        return self._intf.set_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._set_max_range_fuel_flow_metadata, value)

    _get_max_airspeed_fuel_flow_metadata = { "offset" : _get_max_airspeed_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_airspeed_fuel_flow(self) -> float:
        """Get or set the fuel flow for the maximum airspeed."""
        return self._intf.get_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._get_max_airspeed_fuel_flow_metadata)

    _set_max_airspeed_fuel_flow_metadata = { "offset" : _set_max_airspeed_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_airspeed_fuel_flow.setter
    def max_airspeed_fuel_flow(self, value:float) -> None:
        """Get or set the fuel flow for the maximum airspeed."""
        return self._intf.set_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._set_max_airspeed_fuel_flow_metadata, value)

    _get_max_performance_airspeed_fuel_flow_metadata = { "offset" : _get_max_performance_airspeed_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_performance_airspeed_fuel_flow(self) -> float:
        """Get or set the fuel flow for the maximum performance airspeed."""
        return self._intf.get_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._get_max_performance_airspeed_fuel_flow_metadata)

    _set_max_performance_airspeed_fuel_flow_metadata = { "offset" : _set_max_performance_airspeed_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @max_performance_airspeed_fuel_flow.setter
    def max_performance_airspeed_fuel_flow(self, value:float) -> None:
        """Get or set the fuel flow for the maximum performance airspeed."""
        return self._intf.set_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._set_max_performance_airspeed_fuel_flow_metadata, value)

    _get_max_pitch_angle_metadata = { "offset" : _get_max_pitch_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_pitch_angle(self) -> typing.Any:
        """Get or set the maximum pitch angle the aircraft will be allowed to use."""
        return self._intf.get_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._get_max_pitch_angle_metadata)

    _set_max_pitch_angle_metadata = { "offset" : _set_max_pitch_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_pitch_angle.setter
    def max_pitch_angle(self, value:typing.Any) -> None:
        """Get or set the maximum pitch angle the aircraft will be allowed to use."""
        return self._intf.set_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._set_max_pitch_angle_metadata, value)

    _get_terrain_window_metadata = { "offset" : _get_terrain_window_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def terrain_window(self) -> float:
        """Get or set the time interval over which terrain points are sampled."""
        return self._intf.get_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._get_terrain_window_metadata)

    _set_terrain_window_metadata = { "offset" : _set_terrain_window_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @terrain_window.setter
    def terrain_window(self, value:float) -> None:
        """Get or set the time interval over which terrain points are sampled."""
        return self._intf.set_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._set_terrain_window_metadata, value)

    _get_max_load_factor_metadata = { "offset" : _get_max_load_factor_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def max_load_factor(self) -> float:
        """Get the maximum load factor - during straight and level flight - that the aircraft can bear."""
        return self._intf.get_property(AircraftTerrainFollowModel._metadata, AircraftTerrainFollowModel._get_max_load_factor_metadata)

    _property_names[airspeed_type] = "airspeed_type"
    _property_names[use_aerodynamic_propulsion_fuel] = "use_aerodynamic_propulsion_fuel"
    _property_names[scale_fuel_flow_by_non_std_density] = "scale_fuel_flow_by_non_std_density"
    _property_names[min_airspeed] = "min_airspeed"
    _property_names[max_endurance_airspeed] = "max_endurance_airspeed"
    _property_names[max_range_airspeed] = "max_range_airspeed"
    _property_names[max_airspeed] = "max_airspeed"
    _property_names[max_performance_airspeed] = "max_performance_airspeed"
    _property_names[min_airspeed_fuel_flow] = "min_airspeed_fuel_flow"
    _property_names[max_endurance_fuel_flow] = "max_endurance_fuel_flow"
    _property_names[max_range_fuel_flow] = "max_range_fuel_flow"
    _property_names[max_airspeed_fuel_flow] = "max_airspeed_fuel_flow"
    _property_names[max_performance_airspeed_fuel_flow] = "max_performance_airspeed_fuel_flow"
    _property_names[max_pitch_angle] = "max_pitch_angle"
    _property_names[terrain_window] = "terrain_window"
    _property_names[max_load_factor] = "max_load_factor"

    def __init__(self, source_object=None):
        """Construct an object of type AircraftTerrainFollowModel."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AircraftTerrainFollowModel)
    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, AircraftTerrainFollowModel, [AircraftTerrainFollowModel, ])

agcls.AgClassCatalog.add_catalog_entry((4928571652541958513, 102701150438612899), AircraftTerrainFollowModel)
agcls.AgTypeNameMap["AircraftTerrainFollowModel"] = AircraftTerrainFollowModel

class AircraftTerrainFollow(ICatalogItem, SupportsDeleteCallback):
    """Interface used to access the TerrainFollow options for an aircraft in the Aviator catalog."""

    _num_methods = 2
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_terrain_follow_by_name_method_offset = 1
    _get_as_catalog_item_method_offset = 2
    _metadata = {
        "iid_data" : (5356275649931379516, 11489826839698717631),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AircraftTerrainFollow)

    _get_terrain_follow_by_name_metadata = { "offset" : _get_terrain_follow_by_name_method_offset,
            "arg_types" : (agcom.BSTR, POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.BStrArg, agmarshall.InterfaceOutArg,) }
    def get_terrain_follow_by_name(self, name:str) -> "AircraftTerrainFollowModel":
        """Get the TerrainFollow model with the given name."""
        return self._intf.invoke(AircraftTerrainFollow._metadata, AircraftTerrainFollow._get_terrain_follow_by_name_metadata, name, OutArg())

    _get_as_catalog_item_metadata = { "offset" : _get_as_catalog_item_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_catalog_item(self) -> "ICatalogItem":
        """Get the catalog item interface for this object."""
        return self._intf.invoke(AircraftTerrainFollow._metadata, AircraftTerrainFollow._get_as_catalog_item_metadata, OutArg())


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

agcls.AgClassCatalog.add_catalog_entry((5402676046702832653, 16456783136885484449), AircraftTerrainFollow)
agcls.AgTypeNameMap["AircraftTerrainFollow"] = AircraftTerrainFollow

class BasicManeuverStrategyBallistic3D(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a balistic 3D strategy of a basic maneuver procedure."""

    _num_methods = 9
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_control_mode_method_offset = 1
    _set_control_mode_method_offset = 2
    _get_airspeed_options_method_offset = 3
    _get_parachute_area_method_offset = 4
    _set_parachute_area_method_offset = 5
    _get_parachute_cd_method_offset = 6
    _set_parachute_cd_method_offset = 7
    _get_wind_force_effective_area_method_offset = 8
    _set_wind_force_effective_area_method_offset = 9
    _metadata = {
        "iid_data" : (5513664194462998876, 11966460193713901738),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyBallistic3D)

    _get_control_mode_metadata = { "offset" : _get_control_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(Ballistic3DControlMode),) }
    @property
    def control_mode(self) -> "Ballistic3DControlMode":
        """Get or set the control mode for the ballistic 3D strategy."""
        return self._intf.get_property(BasicManeuverStrategyBallistic3D._metadata, BasicManeuverStrategyBallistic3D._get_control_mode_metadata)

    _set_control_mode_metadata = { "offset" : _set_control_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(Ballistic3DControlMode),) }
    @control_mode.setter
    def control_mode(self, value:"Ballistic3DControlMode") -> None:
        """Get or set the control mode for the ballistic 3D strategy."""
        return self._intf.set_property(BasicManeuverStrategyBallistic3D._metadata, BasicManeuverStrategyBallistic3D._set_control_mode_metadata, value)

    _get_airspeed_options_metadata = { "offset" : _get_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def airspeed_options(self) -> "BasicManeuverAirspeedOptions":
        """Get the airspeed options."""
        return self._intf.get_property(BasicManeuverStrategyBallistic3D._metadata, BasicManeuverStrategyBallistic3D._get_airspeed_options_metadata)

    _get_parachute_area_metadata = { "offset" : _get_parachute_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def parachute_area(self) -> float:
        """Get or set the parachute area used as part of the Parachute control mode for the ballistic 3D strategy."""
        return self._intf.get_property(BasicManeuverStrategyBallistic3D._metadata, BasicManeuverStrategyBallistic3D._get_parachute_area_metadata)

    _set_parachute_area_metadata = { "offset" : _set_parachute_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @parachute_area.setter
    def parachute_area(self, value:float) -> None:
        """Get or set the parachute area used as part of the Parachute control mode for the ballistic 3D strategy."""
        return self._intf.set_property(BasicManeuverStrategyBallistic3D._metadata, BasicManeuverStrategyBallistic3D._set_parachute_area_metadata, value)

    _get_parachute_cd_metadata = { "offset" : _get_parachute_cd_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def parachute_cd(self) -> float:
        """Get or set the parachute coefficient of drag used as part of the Parachute control mode for the ballistic 3D strategy."""
        return self._intf.get_property(BasicManeuverStrategyBallistic3D._metadata, BasicManeuverStrategyBallistic3D._get_parachute_cd_metadata)

    _set_parachute_cd_metadata = { "offset" : _set_parachute_cd_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @parachute_cd.setter
    def parachute_cd(self, value:float) -> None:
        """Get or set the parachute coefficient of drag used as part of the Parachute control mode for the ballistic 3D strategy."""
        return self._intf.set_property(BasicManeuverStrategyBallistic3D._metadata, BasicManeuverStrategyBallistic3D._set_parachute_cd_metadata, value)

    _get_wind_force_effective_area_metadata = { "offset" : _get_wind_force_effective_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def wind_force_effective_area(self) -> float:
        """Get or set the vehicle's wind force effective area."""
        return self._intf.get_property(BasicManeuverStrategyBallistic3D._metadata, BasicManeuverStrategyBallistic3D._get_wind_force_effective_area_metadata)

    _set_wind_force_effective_area_metadata = { "offset" : _set_wind_force_effective_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @wind_force_effective_area.setter
    def wind_force_effective_area(self, value:float) -> None:
        """Get or set the vehicle's wind force effective area."""
        return self._intf.set_property(BasicManeuverStrategyBallistic3D._metadata, BasicManeuverStrategyBallistic3D._set_wind_force_effective_area_metadata, value)

    _property_names[control_mode] = "control_mode"
    _property_names[airspeed_options] = "airspeed_options"
    _property_names[parachute_area] = "parachute_area"
    _property_names[parachute_cd] = "parachute_cd"
    _property_names[wind_force_effective_area] = "wind_force_effective_area"

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

agcls.AgClassCatalog.add_catalog_entry((5015647986010523822, 9925779917142272656), BasicManeuverStrategyBallistic3D)
agcls.AgTypeNameMap["BasicManeuverStrategyBallistic3D"] = BasicManeuverStrategyBallistic3D

class ProcedureLaunchDynamicState(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a dyn state launch procedure."""

    _num_methods = 26
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_launch_time_method_offset = 1
    _set_launch_time_method_offset = 2
    _get_coord_frame_method_offset = 3
    _set_coord_frame_method_offset = 4
    _get_bearing_reference_method_offset = 5
    _set_bearing_reference_method_offset = 6
    _get_launch_bearing_method_offset = 7
    _set_launch_bearing_method_offset = 8
    _get_launch_elevation_method_offset = 9
    _set_launch_elevation_method_offset = 10
    _get_attitude_mode_method_offset = 11
    _set_attitude_mode_method_offset = 12
    _get_specify_launch_airspeed_method_offset = 13
    _set_specify_launch_airspeed_method_offset = 14
    _get_acceleration_g_method_offset = 15
    _set_acceleration_g_method_offset = 16
    _get_airspeed_type_method_offset = 17
    _get_airspeed_method_offset = 18
    _set_airspeed_method_offset = 19
    _get_fuel_flow_type_method_offset = 20
    _set_fuel_flow_type_method_offset = 21
    _get_override_fuel_flow_method_offset = 22
    _set_override_fuel_flow_method_offset = 23
    _get_true_course_hint_method_offset = 24
    _set_true_course_hint_method_offset = 25
    _get_as_procedure_method_offset = 26
    _metadata = {
        "iid_data" : (5422937096765915618, 8286874079330926474),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureLaunchDynamicState)

    _get_launch_time_metadata = { "offset" : _get_launch_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def launch_time(self) -> typing.Any:
        """Get or set the launch time of the aircraft."""
        return self._intf.get_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._get_launch_time_metadata)

    _set_launch_time_metadata = { "offset" : _set_launch_time_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @launch_time.setter
    def launch_time(self, value:typing.Any) -> None:
        """Get or set the launch time of the aircraft."""
        return self._intf.set_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._set_launch_time_metadata, value)

    _get_coord_frame_metadata = { "offset" : _get_coord_frame_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(LaunchDynamicStateCoordFrame),) }
    @property
    def coord_frame(self) -> "LaunchDynamicStateCoordFrame":
        """Get or set the reference coordinate frame for the dyn state launch procedure."""
        return self._intf.get_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._get_coord_frame_metadata)

    _set_coord_frame_metadata = { "offset" : _set_coord_frame_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(LaunchDynamicStateCoordFrame),) }
    @coord_frame.setter
    def coord_frame(self, value:"LaunchDynamicStateCoordFrame") -> None:
        """Get or set the reference coordinate frame for the dyn state launch procedure."""
        return self._intf.set_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._set_coord_frame_metadata, value)

    _get_bearing_reference_metadata = { "offset" : _get_bearing_reference_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(LaunchDynamicStateBearingReference),) }
    @property
    def bearing_reference(self) -> "LaunchDynamicStateBearingReference":
        """Get or set the bearing reference for the dyn state launch procedure."""
        return self._intf.get_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._get_bearing_reference_metadata)

    _set_bearing_reference_metadata = { "offset" : _set_bearing_reference_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(LaunchDynamicStateBearingReference),) }
    @bearing_reference.setter
    def bearing_reference(self, value:"LaunchDynamicStateBearingReference") -> None:
        """Get or set the bearing reference for the dyn state launch procedure."""
        return self._intf.set_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._set_bearing_reference_metadata, value)

    _get_launch_bearing_metadata = { "offset" : _get_launch_bearing_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def launch_bearing(self) -> typing.Any:
        """Get or set the launch direction bearing."""
        return self._intf.get_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._get_launch_bearing_metadata)

    _set_launch_bearing_metadata = { "offset" : _set_launch_bearing_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @launch_bearing.setter
    def launch_bearing(self, value:typing.Any) -> None:
        """Get or set the launch direction bearing."""
        return self._intf.set_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._set_launch_bearing_metadata, value)

    _get_launch_elevation_metadata = { "offset" : _get_launch_elevation_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def launch_elevation(self) -> typing.Any:
        """Get or set the launch direction elevation."""
        return self._intf.get_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._get_launch_elevation_metadata)

    _set_launch_elevation_metadata = { "offset" : _set_launch_elevation_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @launch_elevation.setter
    def launch_elevation(self, value:typing.Any) -> None:
        """Get or set the launch direction elevation."""
        return self._intf.set_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._set_launch_elevation_metadata, value)

    _get_attitude_mode_metadata = { "offset" : _get_attitude_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(LaunchAttitudeMode),) }
    @property
    def attitude_mode(self) -> "LaunchAttitudeMode":
        """Get or set the attitude mode during the launch."""
        return self._intf.get_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._get_attitude_mode_metadata)

    _set_attitude_mode_metadata = { "offset" : _set_attitude_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(LaunchAttitudeMode),) }
    @attitude_mode.setter
    def attitude_mode(self, value:"LaunchAttitudeMode") -> None:
        """Get or set the attitude mode during the launch."""
        return self._intf.set_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._set_attitude_mode_metadata, value)

    _get_specify_launch_airspeed_metadata = { "offset" : _get_specify_launch_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def specify_launch_airspeed(self) -> bool:
        """Opt to specify a minimum launch speed the aircraft will accelerate to."""
        return self._intf.get_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._get_specify_launch_airspeed_metadata)

    _set_specify_launch_airspeed_metadata = { "offset" : _set_specify_launch_airspeed_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @specify_launch_airspeed.setter
    def specify_launch_airspeed(self, value:bool) -> None:
        """Opt to specify a minimum launch speed the aircraft will accelerate to."""
        return self._intf.set_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._set_specify_launch_airspeed_metadata, value)

    _get_acceleration_g_metadata = { "offset" : _get_acceleration_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def acceleration_g(self) -> float:
        """Get or set the acceleration of the aircraft during the launch."""
        return self._intf.get_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._get_acceleration_g_metadata)

    _set_acceleration_g_metadata = { "offset" : _set_acceleration_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @acceleration_g.setter
    def acceleration_g(self, value:float) -> None:
        """Get or set the acceleration of the aircraft during the launch."""
        return self._intf.set_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._set_acceleration_g_metadata, value)

    _get_airspeed_type_metadata = { "offset" : _get_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type."""
        return self._intf.get_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._get_airspeed_type_metadata)

    _get_airspeed_metadata = { "offset" : _get_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def airspeed(self) -> float:
        """Get the goal airspeed for the launch."""
        return self._intf.get_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._get_airspeed_metadata)

    _set_airspeed_metadata = { "offset" : _set_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the launch airspeed."""
        return self._intf.invoke(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._set_airspeed_metadata, airspeed_type, airspeed)

    _get_fuel_flow_type_metadata = { "offset" : _get_fuel_flow_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(FuelFlowType),) }
    @property
    def fuel_flow_type(self) -> "FuelFlowType":
        """Get or set the fuel flow type of the aircraft during the launch."""
        return self._intf.get_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._get_fuel_flow_type_metadata)

    _set_fuel_flow_type_metadata = { "offset" : _set_fuel_flow_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(FuelFlowType),) }
    @fuel_flow_type.setter
    def fuel_flow_type(self, value:"FuelFlowType") -> None:
        """Get or set the fuel flow type of the aircraft during the launch."""
        return self._intf.set_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._set_fuel_flow_type_metadata, value)

    _get_override_fuel_flow_metadata = { "offset" : _get_override_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def override_fuel_flow(self) -> float:
        """Get or set the fuel flow value for a fuel flow type set to Override."""
        return self._intf.get_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._get_override_fuel_flow_metadata)

    _set_override_fuel_flow_metadata = { "offset" : _set_override_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @override_fuel_flow.setter
    def override_fuel_flow(self, value:float) -> None:
        """Get or set the fuel flow value for a fuel flow type set to Override."""
        return self._intf.set_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._set_override_fuel_flow_metadata, value)

    _get_true_course_hint_metadata = { "offset" : _get_true_course_hint_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def true_course_hint(self) -> typing.Any:
        """Get or set the true course used when the vehicle's direction vector is set to Zenith."""
        return self._intf.get_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._get_true_course_hint_metadata)

    _set_true_course_hint_metadata = { "offset" : _set_true_course_hint_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @true_course_hint.setter
    def true_course_hint(self, value:typing.Any) -> None:
        """Get or set the true course used when the vehicle's direction vector is set to Zenith."""
        return self._intf.set_property(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._set_true_course_hint_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureLaunchDynamicState._metadata, ProcedureLaunchDynamicState._get_as_procedure_metadata, OutArg())

    _property_names[launch_time] = "launch_time"
    _property_names[coord_frame] = "coord_frame"
    _property_names[bearing_reference] = "bearing_reference"
    _property_names[launch_bearing] = "launch_bearing"
    _property_names[launch_elevation] = "launch_elevation"
    _property_names[attitude_mode] = "attitude_mode"
    _property_names[specify_launch_airspeed] = "specify_launch_airspeed"
    _property_names[acceleration_g] = "acceleration_g"
    _property_names[airspeed_type] = "airspeed_type"
    _property_names[airspeed] = "airspeed"
    _property_names[fuel_flow_type] = "fuel_flow_type"
    _property_names[override_fuel_flow] = "override_fuel_flow"
    _property_names[true_course_hint] = "true_course_hint"

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

agcls.AgClassCatalog.add_catalog_entry((5103080724342277659, 9519329222150555578), ProcedureLaunchDynamicState)
agcls.AgTypeNameMap["ProcedureLaunchDynamicState"] = ProcedureLaunchDynamicState

class ProcedureLaunchWaypoint(IProcedure, SupportsDeleteCallback):
    """Interface used to access the options for a waypoint launch procedure."""

    _num_methods = 20
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_launch_time_method_offset = 1
    _set_launch_time_method_offset = 2
    _get_altitude_reference_method_offset = 3
    _set_altitude_reference_method_offset = 4
    _get_launch_altitude_method_offset = 5
    _set_launch_altitude_method_offset = 6
    _get_launch_true_bearing_method_offset = 7
    _set_launch_true_bearing_method_offset = 8
    _get_launch_elevation_method_offset = 9
    _set_launch_elevation_method_offset = 10
    _get_acceleration_g_method_offset = 11
    _set_acceleration_g_method_offset = 12
    _get_airspeed_type_method_offset = 13
    _get_airspeed_method_offset = 14
    _set_airspeed_method_offset = 15
    _get_fuel_flow_type_method_offset = 16
    _set_fuel_flow_type_method_offset = 17
    _get_override_fuel_flow_method_offset = 18
    _set_override_fuel_flow_method_offset = 19
    _get_as_procedure_method_offset = 20
    _metadata = {
        "iid_data" : (5346148590434943901, 2615963635447694235),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureLaunchWaypoint)

    _get_launch_time_metadata = { "offset" : _get_launch_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def launch_time(self) -> typing.Any:
        """Get or set the launch time of the aircraft."""
        return self._intf.get_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._get_launch_time_metadata)

    _set_launch_time_metadata = { "offset" : _set_launch_time_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @launch_time.setter
    def launch_time(self, value:typing.Any) -> None:
        """Get or set the launch time of the aircraft."""
        return self._intf.set_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._set_launch_time_metadata, value)

    _get_altitude_reference_metadata = { "offset" : _get_altitude_reference_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AltitudeReference),) }
    @property
    def altitude_reference(self) -> "AltitudeReference":
        """Get or set the launch altitude reference."""
        return self._intf.get_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._get_altitude_reference_metadata)

    _set_altitude_reference_metadata = { "offset" : _set_altitude_reference_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(AltitudeReference),) }
    @altitude_reference.setter
    def altitude_reference(self, value:"AltitudeReference") -> None:
        """Get or set the launch altitude reference."""
        return self._intf.set_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._set_altitude_reference_metadata, value)

    _get_launch_altitude_metadata = { "offset" : _get_launch_altitude_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def launch_altitude(self) -> float:
        """Get or set the launch altitude."""
        return self._intf.get_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._get_launch_altitude_metadata)

    _set_launch_altitude_metadata = { "offset" : _set_launch_altitude_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @launch_altitude.setter
    def launch_altitude(self, value:float) -> None:
        """Get or set the launch altitude."""
        return self._intf.set_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._set_launch_altitude_metadata, value)

    _get_launch_true_bearing_metadata = { "offset" : _get_launch_true_bearing_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def launch_true_bearing(self) -> typing.Any:
        """Get or set the launch direction bearing."""
        return self._intf.get_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._get_launch_true_bearing_metadata)

    _set_launch_true_bearing_metadata = { "offset" : _set_launch_true_bearing_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @launch_true_bearing.setter
    def launch_true_bearing(self, value:typing.Any) -> None:
        """Get or set the launch direction bearing."""
        return self._intf.set_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._set_launch_true_bearing_metadata, value)

    _get_launch_elevation_metadata = { "offset" : _get_launch_elevation_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def launch_elevation(self) -> typing.Any:
        """Get or set the launch direction elevation."""
        return self._intf.get_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._get_launch_elevation_metadata)

    _set_launch_elevation_metadata = { "offset" : _set_launch_elevation_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @launch_elevation.setter
    def launch_elevation(self, value:typing.Any) -> None:
        """Get or set the launch direction elevation."""
        return self._intf.set_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._set_launch_elevation_metadata, value)

    _get_acceleration_g_metadata = { "offset" : _get_acceleration_g_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def acceleration_g(self) -> float:
        """Get or set the acceleration of the aircraft during the launch."""
        return self._intf.get_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._get_acceleration_g_metadata)

    _set_acceleration_g_metadata = { "offset" : _set_acceleration_g_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @acceleration_g.setter
    def acceleration_g(self, value:float) -> None:
        """Get or set the acceleration of the aircraft during the launch."""
        return self._intf.set_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._set_acceleration_g_metadata, value)

    _get_airspeed_type_metadata = { "offset" : _get_airspeed_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(AirspeedType),) }
    @property
    def airspeed_type(self) -> "AirspeedType":
        """Get the airspeed type."""
        return self._intf.get_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._get_airspeed_type_metadata)

    _get_airspeed_metadata = { "offset" : _get_airspeed_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def airspeed(self) -> float:
        """Get the goal airspeed for the launch."""
        return self._intf.get_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._get_airspeed_metadata)

    _set_airspeed_metadata = { "offset" : _set_airspeed_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(AirspeedType), agmarshall.DoubleArg,) }
    def set_airspeed(self, airspeed_type:"AirspeedType", airspeed:float) -> None:
        """Set the launch airspeed."""
        return self._intf.invoke(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._set_airspeed_metadata, airspeed_type, airspeed)

    _get_fuel_flow_type_metadata = { "offset" : _get_fuel_flow_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(FuelFlowType),) }
    @property
    def fuel_flow_type(self) -> "FuelFlowType":
        """Get or set the fuel flow type of the aircraft during the launch."""
        return self._intf.get_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._get_fuel_flow_type_metadata)

    _set_fuel_flow_type_metadata = { "offset" : _set_fuel_flow_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(FuelFlowType),) }
    @fuel_flow_type.setter
    def fuel_flow_type(self, value:"FuelFlowType") -> None:
        """Get or set the fuel flow type of the aircraft during the launch."""
        return self._intf.set_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._set_fuel_flow_type_metadata, value)

    _get_override_fuel_flow_metadata = { "offset" : _get_override_fuel_flow_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def override_fuel_flow(self) -> float:
        """Get or set the fuel flow value for a fuel flow type set to Override."""
        return self._intf.get_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._get_override_fuel_flow_metadata)

    _set_override_fuel_flow_metadata = { "offset" : _set_override_fuel_flow_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @override_fuel_flow.setter
    def override_fuel_flow(self, value:float) -> None:
        """Get or set the fuel flow value for a fuel flow type set to Override."""
        return self._intf.set_property(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._set_override_fuel_flow_metadata, value)

    _get_as_procedure_metadata = { "offset" : _get_as_procedure_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_procedure(self) -> "IProcedure":
        """Get the procedure interface."""
        return self._intf.invoke(ProcedureLaunchWaypoint._metadata, ProcedureLaunchWaypoint._get_as_procedure_metadata, OutArg())

    _property_names[launch_time] = "launch_time"
    _property_names[altitude_reference] = "altitude_reference"
    _property_names[launch_altitude] = "launch_altitude"
    _property_names[launch_true_bearing] = "launch_true_bearing"
    _property_names[launch_elevation] = "launch_elevation"
    _property_names[acceleration_g] = "acceleration_g"
    _property_names[airspeed_type] = "airspeed_type"
    _property_names[airspeed] = "airspeed"
    _property_names[fuel_flow_type] = "fuel_flow_type"
    _property_names[override_fuel_flow] = "override_fuel_flow"

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

agcls.AgClassCatalog.add_catalog_entry((5333950039959211110, 14850972797194543528), ProcedureLaunchWaypoint)
agcls.AgTypeNameMap["ProcedureLaunchWaypoint"] = ProcedureLaunchWaypoint

class SiteDynamicState(ISite, SupportsDeleteCallback):
    """Interface used to access the options for a dyn state site type."""

    _num_methods = 4
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_object_name_method_offset = 1
    _set_object_name_method_offset = 2
    _get_valid_object_names_method_offset = 3
    _get_as_site_method_offset = 4
    _metadata = {
        "iid_data" : (5104605018364334696, 9914056885151665295),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, SiteDynamicState)

    _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 object name to link to."""
        return self._intf.get_property(SiteDynamicState._metadata, SiteDynamicState._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:
        """Get or set the object name to link to."""
        return self._intf.set_property(SiteDynamicState._metadata, SiteDynamicState._set_object_name_metadata, value)

    _get_valid_object_names_metadata = { "offset" : _get_valid_object_names_method_offset,
            "arg_types" : (POINTER(agcom.LPSAFEARRAY),),
            "marshallers" : (agmarshall.LPSafearrayArg,) }
    @property
    def valid_object_names(self) -> list:
        """Return the valid object names."""
        return self._intf.get_property(SiteDynamicState._metadata, SiteDynamicState._get_valid_object_names_metadata)

    _get_as_site_metadata = { "offset" : _get_as_site_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    def get_as_site(self) -> "ISite":
        """Get the site interface."""
        return self._intf.invoke(SiteDynamicState._metadata, SiteDynamicState._get_as_site_metadata, OutArg())

    _property_names[object_name] = "object_name"
    _property_names[valid_object_names] = "valid_object_names"

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

agcls.AgClassCatalog.add_catalog_entry((4847814716997792407, 18231396679680366494), SiteDynamicState)
agcls.AgTypeNameMap["SiteDynamicState"] = SiteDynamicState

class BasicManeuverStrategyPitch3D(IBasicManeuverStrategy, SupportsDeleteCallback):
    """Interface used to access options for a pitch 3D strategy of a basic maneuver procedure."""

    _num_methods = 11
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_control_mode_method_offset = 1
    _set_control_mode_method_offset = 2
    _get_command_flight_path_angle_method_offset = 3
    _set_command_flight_path_angle_method_offset = 4
    _get_control_flight_path_angle_dot_method_offset = 5
    _set_control_flight_path_angle_dot_method_offset = 6
    _get_stop_when_flight_path_angle_achieved_method_offset = 7
    _set_stop_when_flight_path_angle_achieved_method_offset = 8
    _get_airspeed_options_method_offset = 9
    _get_wind_force_effective_area_method_offset = 10
    _set_wind_force_effective_area_method_offset = 11
    _metadata = {
        "iid_data" : (5105306656992613469, 3540505748559672255),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverStrategyPitch3D)

    _get_control_mode_metadata = { "offset" : _get_control_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(Pitch3DControlMode),) }
    @property
    def control_mode(self) -> "Pitch3DControlMode":
        """Get or set the control mode for the pitch 3D strategy."""
        return self._intf.get_property(BasicManeuverStrategyPitch3D._metadata, BasicManeuverStrategyPitch3D._get_control_mode_metadata)

    _set_control_mode_metadata = { "offset" : _set_control_mode_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(Pitch3DControlMode),) }
    @control_mode.setter
    def control_mode(self, value:"Pitch3DControlMode") -> None:
        """Get or set the control mode for the pitch 3D strategy."""
        return self._intf.set_property(BasicManeuverStrategyPitch3D._metadata, BasicManeuverStrategyPitch3D._set_control_mode_metadata, value)

    _get_command_flight_path_angle_metadata = { "offset" : _get_command_flight_path_angle_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def command_flight_path_angle(self) -> typing.Any:
        """Get or set the commanded flight path angle."""
        return self._intf.get_property(BasicManeuverStrategyPitch3D._metadata, BasicManeuverStrategyPitch3D._get_command_flight_path_angle_metadata)

    _set_command_flight_path_angle_metadata = { "offset" : _set_command_flight_path_angle_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @command_flight_path_angle.setter
    def command_flight_path_angle(self, value:typing.Any) -> None:
        """Get or set the commanded flight path angle."""
        return self._intf.set_property(BasicManeuverStrategyPitch3D._metadata, BasicManeuverStrategyPitch3D._set_command_flight_path_angle_metadata, value)

    _get_control_flight_path_angle_dot_metadata = { "offset" : _get_control_flight_path_angle_dot_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def control_flight_path_angle_dot(self) -> typing.Any:
        """Get or set the flight path angle rate."""
        return self._intf.get_property(BasicManeuverStrategyPitch3D._metadata, BasicManeuverStrategyPitch3D._get_control_flight_path_angle_dot_metadata)

    _set_control_flight_path_angle_dot_metadata = { "offset" : _set_control_flight_path_angle_dot_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @control_flight_path_angle_dot.setter
    def control_flight_path_angle_dot(self, value:typing.Any) -> None:
        """Get or set the flight path angle rate."""
        return self._intf.set_property(BasicManeuverStrategyPitch3D._metadata, BasicManeuverStrategyPitch3D._set_control_flight_path_angle_dot_metadata, value)

    _get_stop_when_flight_path_angle_achieved_metadata = { "offset" : _get_stop_when_flight_path_angle_achieved_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def stop_when_flight_path_angle_achieved(self) -> bool:
        """Stop when the commanded flight path angle is achieved."""
        return self._intf.get_property(BasicManeuverStrategyPitch3D._metadata, BasicManeuverStrategyPitch3D._get_stop_when_flight_path_angle_achieved_metadata)

    _set_stop_when_flight_path_angle_achieved_metadata = { "offset" : _set_stop_when_flight_path_angle_achieved_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @stop_when_flight_path_angle_achieved.setter
    def stop_when_flight_path_angle_achieved(self, value:bool) -> None:
        """Stop when the commanded flight path angle is achieved."""
        return self._intf.set_property(BasicManeuverStrategyPitch3D._metadata, BasicManeuverStrategyPitch3D._set_stop_when_flight_path_angle_achieved_metadata, value)

    _get_airspeed_options_metadata = { "offset" : _get_airspeed_options_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def airspeed_options(self) -> "BasicManeuverAirspeedOptions":
        """Get the airspeed options."""
        return self._intf.get_property(BasicManeuverStrategyPitch3D._metadata, BasicManeuverStrategyPitch3D._get_airspeed_options_metadata)

    _get_wind_force_effective_area_metadata = { "offset" : _get_wind_force_effective_area_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def wind_force_effective_area(self) -> float:
        """Get or set the vehicle's wind force effective area."""
        return self._intf.get_property(BasicManeuverStrategyPitch3D._metadata, BasicManeuverStrategyPitch3D._get_wind_force_effective_area_metadata)

    _set_wind_force_effective_area_metadata = { "offset" : _set_wind_force_effective_area_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @wind_force_effective_area.setter
    def wind_force_effective_area(self, value:float) -> None:
        """Get or set the vehicle's wind force effective area."""
        return self._intf.set_property(BasicManeuverStrategyPitch3D._metadata, BasicManeuverStrategyPitch3D._set_wind_force_effective_area_metadata, value)

    _property_names[control_mode] = "control_mode"
    _property_names[command_flight_path_angle] = "command_flight_path_angle"
    _property_names[control_flight_path_angle_dot] = "control_flight_path_angle_dot"
    _property_names[stop_when_flight_path_angle_achieved] = "stop_when_flight_path_angle_achieved"
    _property_names[airspeed_options] = "airspeed_options"
    _property_names[wind_force_effective_area] = "wind_force_effective_area"

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

agcls.AgClassCatalog.add_catalog_entry((5136301321259769219, 4000378802845039279), BasicManeuverStrategyPitch3D)
agcls.AgTypeNameMap["BasicManeuverStrategyPitch3D"] = BasicManeuverStrategyPitch3D

class RefuelDumpProperties(SupportsDeleteCallback):
    """Interface used to access the refuel/dump properties for the current procedure."""

    _num_methods = 10
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_refuel_dump_mode_method_offset = 1
    _get_refuel_dump_mode_value_method_offset = 2
    _set_refuel_dump_mode_method_offset = 3
    _get_refuel_dump_rate_method_offset = 4
    _set_refuel_dump_rate_method_offset = 5
    _get_refuel_dump_time_offset_method_offset = 6
    _set_refuel_dump_time_offset_method_offset = 7
    _get_can_use_end_of_enroute_segment_as_epoch_method_offset = 8
    _get_use_end_of_enroute_segment_as_epoch_method_offset = 9
    _set_use_end_of_enroute_segment_as_epoch_method_offset = 10
    _metadata = {
        "iid_data" : (5003191604278196525, 17721617824266326670),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, RefuelDumpProperties)

    _get_refuel_dump_mode_metadata = { "offset" : _get_refuel_dump_mode_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(RefuelDumpMode),) }
    @property
    def refuel_dump_mode(self) -> "RefuelDumpMode":
        """Get the RefuelDumpMode."""
        return self._intf.get_property(RefuelDumpProperties._metadata, RefuelDumpProperties._get_refuel_dump_mode_metadata)

    _get_refuel_dump_mode_value_metadata = { "offset" : _get_refuel_dump_mode_value_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def refuel_dump_mode_value(self) -> float:
        """Get the RefuelDumpModeValue if applicable."""
        return self._intf.get_property(RefuelDumpProperties._metadata, RefuelDumpProperties._get_refuel_dump_mode_value_metadata)

    _set_refuel_dump_mode_metadata = { "offset" : _set_refuel_dump_mode_method_offset,
            "arg_types" : (agcom.LONG, agcom.DOUBLE,),
            "marshallers" : (agmarshall.EnumArg(RefuelDumpMode), agmarshall.DoubleArg,) }
    def set_refuel_dump_mode(self, mode:"RefuelDumpMode", value:float) -> None:
        """Set RefuelDumpMode and RefuelDumpModeValue if applicable."""
        return self._intf.invoke(RefuelDumpProperties._metadata, RefuelDumpProperties._set_refuel_dump_mode_metadata, mode, value)

    _get_refuel_dump_rate_metadata = { "offset" : _get_refuel_dump_rate_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def refuel_dump_rate(self) -> float:
        """Get or set the RefuelDump rate."""
        return self._intf.get_property(RefuelDumpProperties._metadata, RefuelDumpProperties._get_refuel_dump_rate_metadata)

    _set_refuel_dump_rate_metadata = { "offset" : _set_refuel_dump_rate_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @refuel_dump_rate.setter
    def refuel_dump_rate(self, value:float) -> None:
        """Get or set the RefuelDump rate."""
        return self._intf.set_property(RefuelDumpProperties._metadata, RefuelDumpProperties._set_refuel_dump_rate_metadata, value)

    _get_refuel_dump_time_offset_metadata = { "offset" : _get_refuel_dump_time_offset_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def refuel_dump_time_offset(self) -> float:
        """Get or set the RefuelDump time offset."""
        return self._intf.get_property(RefuelDumpProperties._metadata, RefuelDumpProperties._get_refuel_dump_time_offset_metadata)

    _set_refuel_dump_time_offset_metadata = { "offset" : _set_refuel_dump_time_offset_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @refuel_dump_time_offset.setter
    def refuel_dump_time_offset(self, value:float) -> None:
        """Get or set the RefuelDump time offset."""
        return self._intf.set_property(RefuelDumpProperties._metadata, RefuelDumpProperties._set_refuel_dump_time_offset_metadata, value)

    _get_can_use_end_of_enroute_segment_as_epoch_metadata = { "offset" : _get_can_use_end_of_enroute_segment_as_epoch_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def can_use_end_of_enroute_segment_as_epoch(self) -> bool:
        """Can use end of enroute segment as the epoch."""
        return self._intf.get_property(RefuelDumpProperties._metadata, RefuelDumpProperties._get_can_use_end_of_enroute_segment_as_epoch_metadata)

    _get_use_end_of_enroute_segment_as_epoch_metadata = { "offset" : _get_use_end_of_enroute_segment_as_epoch_method_offset,
            "arg_types" : (POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @property
    def use_end_of_enroute_segment_as_epoch(self) -> bool:
        """Use end of enroute segment as the epoch."""
        return self._intf.get_property(RefuelDumpProperties._metadata, RefuelDumpProperties._get_use_end_of_enroute_segment_as_epoch_metadata)

    _set_use_end_of_enroute_segment_as_epoch_metadata = { "offset" : _set_use_end_of_enroute_segment_as_epoch_method_offset,
            "arg_types" : (agcom.VARIANT_BOOL,),
            "marshallers" : (agmarshall.VariantBoolArg,) }
    @use_end_of_enroute_segment_as_epoch.setter
    def use_end_of_enroute_segment_as_epoch(self, value:bool) -> None:
        """Use end of enroute segment as the epoch."""
        return self._intf.set_property(RefuelDumpProperties._metadata, RefuelDumpProperties._set_use_end_of_enroute_segment_as_epoch_metadata, value)

    _property_names[refuel_dump_mode] = "refuel_dump_mode"
    _property_names[refuel_dump_mode_value] = "refuel_dump_mode_value"
    _property_names[refuel_dump_rate] = "refuel_dump_rate"
    _property_names[refuel_dump_time_offset] = "refuel_dump_time_offset"
    _property_names[can_use_end_of_enroute_segment_as_epoch] = "can_use_end_of_enroute_segment_as_epoch"
    _property_names[use_end_of_enroute_segment_as_epoch] = "use_end_of_enroute_segment_as_epoch"

    def __init__(self, source_object=None):
        """Construct an object of type RefuelDumpProperties."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, RefuelDumpProperties)
    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, RefuelDumpProperties, [RefuelDumpProperties, ])

agcls.AgClassCatalog.add_catalog_entry((5061480753212287074, 15441067619561720244), RefuelDumpProperties)
agcls.AgTypeNameMap["RefuelDumpProperties"] = RefuelDumpProperties

class ProcedureFastTimeOptions(SupportsDeleteCallback):
    """Interface used to access the fast time options (without error or constraint checks) for the current procedure. Use this interface to set an Interrupt Time or Fixed Duration for a procedure."""

    _num_methods = 5
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_start_time_method_offset = 1
    _set_start_time_method_offset = 2
    _set_interrupt_time_method_offset = 3
    _get_stop_time_method_offset = 4
    _set_stop_time_method_offset = 5
    _metadata = {
        "iid_data" : (5526509407324515531, 1179628310041269673),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, ProcedureFastTimeOptions)

    _get_start_time_metadata = { "offset" : _get_start_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def start_time(self) -> typing.Any:
        """Start time for the procedure."""
        return self._intf.get_property(ProcedureFastTimeOptions._metadata, ProcedureFastTimeOptions._get_start_time_metadata)

    _set_start_time_metadata = { "offset" : _set_start_time_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def set_start_time(self, time:typing.Any) -> None:
        """Set the start time for the procedure."""
        return self._intf.invoke(ProcedureFastTimeOptions._metadata, ProcedureFastTimeOptions._set_start_time_metadata, time)

    _set_interrupt_time_metadata = { "offset" : _set_interrupt_time_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def set_interrupt_time(self, time:typing.Any) -> None:
        """Set the interrupt time for the procedure."""
        return self._intf.invoke(ProcedureFastTimeOptions._metadata, ProcedureFastTimeOptions._set_interrupt_time_metadata, time)

    _get_stop_time_metadata = { "offset" : _get_stop_time_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def stop_time(self) -> typing.Any:
        """Stop time for the procedure."""
        return self._intf.get_property(ProcedureFastTimeOptions._metadata, ProcedureFastTimeOptions._get_stop_time_metadata)

    _set_stop_time_metadata = { "offset" : _set_stop_time_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    def set_stop_time(self, time:typing.Any) -> None:
        """Set the stop time for the procedure."""
        return self._intf.invoke(ProcedureFastTimeOptions._metadata, ProcedureFastTimeOptions._set_stop_time_metadata, time)

    _property_names[start_time] = "start_time"
    _property_names[stop_time] = "stop_time"

    def __init__(self, source_object=None):
        """Construct an object of type ProcedureFastTimeOptions."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, ProcedureFastTimeOptions)
    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, ProcedureFastTimeOptions, [ProcedureFastTimeOptions, ])

agcls.AgClassCatalog.add_catalog_entry((5256046032572971350, 11552615131980125109), ProcedureFastTimeOptions)
agcls.AgTypeNameMap["ProcedureFastTimeOptions"] = ProcedureFastTimeOptions

class BasicManeuverTargetPositionVelocity(SupportsDeleteCallback):
    """Interface used to access target position and velocity strategies for basic maneuvers."""

    _num_methods = 8
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_target_position_velocity_type_method_offset = 1
    _set_target_position_velocity_type_method_offset = 2
    _get_target_position_velocity_type_string_method_offset = 3
    _set_target_position_velocity_type_string_method_offset = 4
    _get_mode_as_noisy_bearing_range_method_offset = 5
    _get_mode_as_noisy_surf_target_method_offset = 6
    _apply_position_velocity_method_offset = 7
    _cancel_position_velocity_method_offset = 8
    _metadata = {
        "iid_data" : (5569224259406810828, 11943865142217919666),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverTargetPositionVelocity)

    _get_target_position_velocity_type_metadata = { "offset" : _get_target_position_velocity_type_method_offset,
            "arg_types" : (POINTER(agcom.LONG),),
            "marshallers" : (agmarshall.EnumArg(TargetPositionVelocityType),) }
    @property
    def target_position_velocity_type(self) -> "TargetPositionVelocityType":
        """Get or set the target pos vel type."""
        return self._intf.get_property(BasicManeuverTargetPositionVelocity._metadata, BasicManeuverTargetPositionVelocity._get_target_position_velocity_type_metadata)

    _set_target_position_velocity_type_metadata = { "offset" : _set_target_position_velocity_type_method_offset,
            "arg_types" : (agcom.LONG,),
            "marshallers" : (agmarshall.EnumArg(TargetPositionVelocityType),) }
    @target_position_velocity_type.setter
    def target_position_velocity_type(self, value:"TargetPositionVelocityType") -> None:
        """Get or set the target pos vel type."""
        return self._intf.set_property(BasicManeuverTargetPositionVelocity._metadata, BasicManeuverTargetPositionVelocity._set_target_position_velocity_type_metadata, value)

    _get_target_position_velocity_type_string_metadata = { "offset" : _get_target_position_velocity_type_string_method_offset,
            "arg_types" : (POINTER(agcom.BSTR),),
            "marshallers" : (agmarshall.BStrArg,) }
    @property
    def target_position_velocity_type_string(self) -> str:
        """Get or set the target pos vel as a string value. Use this for custom models."""
        return self._intf.get_property(BasicManeuverTargetPositionVelocity._metadata, BasicManeuverTargetPositionVelocity._get_target_position_velocity_type_string_metadata)

    _set_target_position_velocity_type_string_metadata = { "offset" : _set_target_position_velocity_type_string_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    @target_position_velocity_type_string.setter
    def target_position_velocity_type_string(self, value:str) -> None:
        """Get or set the target pos vel as a string value. Use this for custom models."""
        return self._intf.set_property(BasicManeuverTargetPositionVelocity._metadata, BasicManeuverTargetPositionVelocity._set_target_position_velocity_type_string_metadata, value)

    _get_mode_as_noisy_bearing_range_metadata = { "offset" : _get_mode_as_noisy_bearing_range_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_noisy_bearing_range(self) -> "BasicManeuverTargetPositionVelocityNoisyBearingRange":
        """Get the options for a noisy bearing range velocity strategy."""
        return self._intf.get_property(BasicManeuverTargetPositionVelocity._metadata, BasicManeuverTargetPositionVelocity._get_mode_as_noisy_bearing_range_metadata)

    _get_mode_as_noisy_surf_target_metadata = { "offset" : _get_mode_as_noisy_surf_target_method_offset,
            "arg_types" : (POINTER(agcom.PVOID),),
            "marshallers" : (agmarshall.InterfaceOutArg,) }
    @property
    def mode_as_noisy_surf_target(self) -> "BasicManeuverTargetPositionVelocityNoisySurfTarget":
        """Get the options for a noisy surface target position velocity strategy."""
        return self._intf.get_property(BasicManeuverTargetPositionVelocity._metadata, BasicManeuverTargetPositionVelocity._get_mode_as_noisy_surf_target_metadata)

    _apply_position_velocity_metadata = { "offset" : _apply_position_velocity_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def apply_position_velocity(self) -> None:
        """Apply the current position velocity strategy."""
        return self._intf.invoke(BasicManeuverTargetPositionVelocity._metadata, BasicManeuverTargetPositionVelocity._apply_position_velocity_metadata, )

    _cancel_position_velocity_metadata = { "offset" : _cancel_position_velocity_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def cancel_position_velocity(self) -> None:
        """Cancel the current position velocity strategy."""
        return self._intf.invoke(BasicManeuverTargetPositionVelocity._metadata, BasicManeuverTargetPositionVelocity._cancel_position_velocity_metadata, )

    _property_names[target_position_velocity_type] = "target_position_velocity_type"
    _property_names[target_position_velocity_type_string] = "target_position_velocity_type_string"
    _property_names[mode_as_noisy_bearing_range] = "mode_as_noisy_bearing_range"
    _property_names[mode_as_noisy_surf_target] = "mode_as_noisy_surf_target"

    def __init__(self, source_object=None):
        """Construct an object of type BasicManeuverTargetPositionVelocity."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BasicManeuverTargetPositionVelocity)
    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, BasicManeuverTargetPositionVelocity, [BasicManeuverTargetPositionVelocity, ])

agcls.AgClassCatalog.add_catalog_entry((5720707950419700583, 14220721990871486647), BasicManeuverTargetPositionVelocity)
agcls.AgTypeNameMap["BasicManeuverTargetPositionVelocity"] = BasicManeuverTargetPositionVelocity

class BasicManeuverTargetPositionVelocityNoisyBearingRange(SupportsDeleteCallback):
    """Interface used to access target position and velocity strategy, NoisyBrnRng."""

    _num_methods = 12
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _new_random_engine_seed_method_offset = 1
    _get_smoothing_constant_method_offset = 2
    _set_smoothing_constant_method_offset = 3
    _get_velocity_time_step_method_offset = 4
    _set_velocity_time_step_method_offset = 5
    _get_angle_error_std_dev_method_offset = 6
    _set_angle_error_std_dev_method_offset = 7
    _get_range_error_std_dev_method_offset = 8
    _set_range_error_std_dev_method_offset = 9
    _apply_position_velocity_method_offset = 10
    _cancel_position_velocity_method_offset = 11
    _set_base_dynamic_state_link_name_method_offset = 12
    _metadata = {
        "iid_data" : (5036622950677551442, 17790904143506270117),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverTargetPositionVelocityNoisyBearingRange)

    _new_random_engine_seed_metadata = { "offset" : _new_random_engine_seed_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def new_random_engine_seed(self) -> None:
        """Generate a new random engine seed."""
        return self._intf.invoke(BasicManeuverTargetPositionVelocityNoisyBearingRange._metadata, BasicManeuverTargetPositionVelocityNoisyBearingRange._new_random_engine_seed_metadata, )

    _get_smoothing_constant_metadata = { "offset" : _get_smoothing_constant_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def smoothing_constant(self) -> float:
        """Get or set the smoothing constant property."""
        return self._intf.get_property(BasicManeuverTargetPositionVelocityNoisyBearingRange._metadata, BasicManeuverTargetPositionVelocityNoisyBearingRange._get_smoothing_constant_metadata)

    _set_smoothing_constant_metadata = { "offset" : _set_smoothing_constant_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @smoothing_constant.setter
    def smoothing_constant(self, value:float) -> None:
        return self._intf.set_property(BasicManeuverTargetPositionVelocityNoisyBearingRange._metadata, BasicManeuverTargetPositionVelocityNoisyBearingRange._set_smoothing_constant_metadata, value)

    _get_velocity_time_step_metadata = { "offset" : _get_velocity_time_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def velocity_time_step(self) -> float:
        """Get or set the velocity time step property."""
        return self._intf.get_property(BasicManeuverTargetPositionVelocityNoisyBearingRange._metadata, BasicManeuverTargetPositionVelocityNoisyBearingRange._get_velocity_time_step_metadata)

    _set_velocity_time_step_metadata = { "offset" : _set_velocity_time_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @velocity_time_step.setter
    def velocity_time_step(self, value:float) -> None:
        return self._intf.set_property(BasicManeuverTargetPositionVelocityNoisyBearingRange._metadata, BasicManeuverTargetPositionVelocityNoisyBearingRange._set_velocity_time_step_metadata, value)

    _get_angle_error_std_dev_metadata = { "offset" : _get_angle_error_std_dev_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def angle_error_std_dev(self) -> float:
        """Get or set the angle error standard deviation property."""
        return self._intf.get_property(BasicManeuverTargetPositionVelocityNoisyBearingRange._metadata, BasicManeuverTargetPositionVelocityNoisyBearingRange._get_angle_error_std_dev_metadata)

    _set_angle_error_std_dev_metadata = { "offset" : _set_angle_error_std_dev_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @angle_error_std_dev.setter
    def angle_error_std_dev(self, value:float) -> None:
        return self._intf.set_property(BasicManeuverTargetPositionVelocityNoisyBearingRange._metadata, BasicManeuverTargetPositionVelocityNoisyBearingRange._set_angle_error_std_dev_metadata, value)

    _get_range_error_std_dev_metadata = { "offset" : _get_range_error_std_dev_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def range_error_std_dev(self) -> float:
        """Get or set the range error standard deviation property."""
        return self._intf.get_property(BasicManeuverTargetPositionVelocityNoisyBearingRange._metadata, BasicManeuverTargetPositionVelocityNoisyBearingRange._get_range_error_std_dev_metadata)

    _set_range_error_std_dev_metadata = { "offset" : _set_range_error_std_dev_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @range_error_std_dev.setter
    def range_error_std_dev(self, value:float) -> None:
        return self._intf.set_property(BasicManeuverTargetPositionVelocityNoisyBearingRange._metadata, BasicManeuverTargetPositionVelocityNoisyBearingRange._set_range_error_std_dev_metadata, value)

    _apply_position_velocity_metadata = { "offset" : _apply_position_velocity_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def apply_position_velocity(self) -> None:
        """Apply the current position velocity strategy."""
        return self._intf.invoke(BasicManeuverTargetPositionVelocityNoisyBearingRange._metadata, BasicManeuverTargetPositionVelocityNoisyBearingRange._apply_position_velocity_metadata, )

    _cancel_position_velocity_metadata = { "offset" : _cancel_position_velocity_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def cancel_position_velocity(self) -> None:
        """Cancel the current position velocity strategy."""
        return self._intf.invoke(BasicManeuverTargetPositionVelocityNoisyBearingRange._metadata, BasicManeuverTargetPositionVelocityNoisyBearingRange._cancel_position_velocity_metadata, )

    _set_base_dynamic_state_link_name_metadata = { "offset" : _set_base_dynamic_state_link_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def set_base_dynamic_state_link_name(self, value:str) -> None:
        """Set the BaseDynStateLinkName."""
        return self._intf.invoke(BasicManeuverTargetPositionVelocityNoisyBearingRange._metadata, BasicManeuverTargetPositionVelocityNoisyBearingRange._set_base_dynamic_state_link_name_metadata, value)

    _property_names[smoothing_constant] = "smoothing_constant"
    _property_names[velocity_time_step] = "velocity_time_step"
    _property_names[angle_error_std_dev] = "angle_error_std_dev"
    _property_names[range_error_std_dev] = "range_error_std_dev"

    def __init__(self, source_object=None):
        """Construct an object of type BasicManeuverTargetPositionVelocityNoisyBearingRange."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BasicManeuverTargetPositionVelocityNoisyBearingRange)
    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, BasicManeuverTargetPositionVelocityNoisyBearingRange, [BasicManeuverTargetPositionVelocityNoisyBearingRange, ])

agcls.AgClassCatalog.add_catalog_entry((5183636736005802859, 6010191698451056009), BasicManeuverTargetPositionVelocityNoisyBearingRange)
agcls.AgTypeNameMap["BasicManeuverTargetPositionVelocityNoisyBearingRange"] = BasicManeuverTargetPositionVelocityNoisyBearingRange

class BasicManeuverTargetPositionVelocityNoisySurfTarget(SupportsDeleteCallback):
    """Interface used to access target position and velocity strategy, Surf Tgt Pos Vel."""

    _num_methods = 12
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _new_random_engine_seed_method_offset = 1
    _get_measurement_time_step_method_offset = 2
    _set_measurement_time_step_method_offset = 3
    _get_position_cep_method_offset = 4
    _set_position_cep_method_offset = 5
    _get_course_error_method_offset = 6
    _set_course_error_method_offset = 7
    _get_speed_error_method_offset = 8
    _set_speed_error_method_offset = 9
    _apply_position_velocity_method_offset = 10
    _cancel_position_velocity_method_offset = 11
    _set_base_dynamic_state_link_name_method_offset = 12
    _metadata = {
        "iid_data" : (5603321029489925551, 13135773816960132759),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, BasicManeuverTargetPositionVelocityNoisySurfTarget)

    _new_random_engine_seed_metadata = { "offset" : _new_random_engine_seed_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def new_random_engine_seed(self) -> None:
        """Generate a new random engine seed."""
        return self._intf.invoke(BasicManeuverTargetPositionVelocityNoisySurfTarget._metadata, BasicManeuverTargetPositionVelocityNoisySurfTarget._new_random_engine_seed_metadata, )

    _get_measurement_time_step_metadata = { "offset" : _get_measurement_time_step_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def measurement_time_step(self) -> float:
        """Get or set the measurement time step property."""
        return self._intf.get_property(BasicManeuverTargetPositionVelocityNoisySurfTarget._metadata, BasicManeuverTargetPositionVelocityNoisySurfTarget._get_measurement_time_step_metadata)

    _set_measurement_time_step_metadata = { "offset" : _set_measurement_time_step_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @measurement_time_step.setter
    def measurement_time_step(self, value:float) -> None:
        return self._intf.set_property(BasicManeuverTargetPositionVelocityNoisySurfTarget._metadata, BasicManeuverTargetPositionVelocityNoisySurfTarget._set_measurement_time_step_metadata, value)

    _get_position_cep_metadata = { "offset" : _get_position_cep_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def position_cep(self) -> float:
        """Get or set the position CEP property."""
        return self._intf.get_property(BasicManeuverTargetPositionVelocityNoisySurfTarget._metadata, BasicManeuverTargetPositionVelocityNoisySurfTarget._get_position_cep_metadata)

    _set_position_cep_metadata = { "offset" : _set_position_cep_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @position_cep.setter
    def position_cep(self, value:float) -> None:
        return self._intf.set_property(BasicManeuverTargetPositionVelocityNoisySurfTarget._metadata, BasicManeuverTargetPositionVelocityNoisySurfTarget._set_position_cep_metadata, value)

    _get_course_error_metadata = { "offset" : _get_course_error_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def course_error(self) -> float:
        """Get or set the course error property."""
        return self._intf.get_property(BasicManeuverTargetPositionVelocityNoisySurfTarget._metadata, BasicManeuverTargetPositionVelocityNoisySurfTarget._get_course_error_metadata)

    _set_course_error_metadata = { "offset" : _set_course_error_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @course_error.setter
    def course_error(self, value:float) -> None:
        return self._intf.set_property(BasicManeuverTargetPositionVelocityNoisySurfTarget._metadata, BasicManeuverTargetPositionVelocityNoisySurfTarget._set_course_error_metadata, value)

    _get_speed_error_metadata = { "offset" : _get_speed_error_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def speed_error(self) -> float:
        """Get or set the speed error property."""
        return self._intf.get_property(BasicManeuverTargetPositionVelocityNoisySurfTarget._metadata, BasicManeuverTargetPositionVelocityNoisySurfTarget._get_speed_error_metadata)

    _set_speed_error_metadata = { "offset" : _set_speed_error_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @speed_error.setter
    def speed_error(self, value:float) -> None:
        return self._intf.set_property(BasicManeuverTargetPositionVelocityNoisySurfTarget._metadata, BasicManeuverTargetPositionVelocityNoisySurfTarget._set_speed_error_metadata, value)

    _apply_position_velocity_metadata = { "offset" : _apply_position_velocity_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def apply_position_velocity(self) -> None:
        """Apply the current position velocity strategy."""
        return self._intf.invoke(BasicManeuverTargetPositionVelocityNoisySurfTarget._metadata, BasicManeuverTargetPositionVelocityNoisySurfTarget._apply_position_velocity_metadata, )

    _cancel_position_velocity_metadata = { "offset" : _cancel_position_velocity_method_offset,
            "arg_types" : (),
            "marshallers" : () }
    def cancel_position_velocity(self) -> None:
        """Cancel the current position velocity strategy."""
        return self._intf.invoke(BasicManeuverTargetPositionVelocityNoisySurfTarget._metadata, BasicManeuverTargetPositionVelocityNoisySurfTarget._cancel_position_velocity_metadata, )

    _set_base_dynamic_state_link_name_metadata = { "offset" : _set_base_dynamic_state_link_name_method_offset,
            "arg_types" : (agcom.BSTR,),
            "marshallers" : (agmarshall.BStrArg,) }
    def set_base_dynamic_state_link_name(self, value:str) -> None:
        """Set the BaseDynStateLinkName."""
        return self._intf.invoke(BasicManeuverTargetPositionVelocityNoisySurfTarget._metadata, BasicManeuverTargetPositionVelocityNoisySurfTarget._set_base_dynamic_state_link_name_metadata, value)

    _property_names[measurement_time_step] = "measurement_time_step"
    _property_names[position_cep] = "position_cep"
    _property_names[course_error] = "course_error"
    _property_names[speed_error] = "speed_error"

    def __init__(self, source_object=None):
        """Construct an object of type BasicManeuverTargetPositionVelocityNoisySurfTarget."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, BasicManeuverTargetPositionVelocityNoisySurfTarget)
    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, BasicManeuverTargetPositionVelocityNoisySurfTarget, [BasicManeuverTargetPositionVelocityNoisySurfTarget, ])

agcls.AgClassCatalog.add_catalog_entry((5226338563214008525, 1195314219041710241), BasicManeuverTargetPositionVelocityNoisySurfTarget)
agcls.AgTypeNameMap["BasicManeuverTargetPositionVelocityNoisySurfTarget"] = BasicManeuverTargetPositionVelocityNoisySurfTarget

class AdvancedFixedWingFourPointAerodynamic(SupportsDeleteCallback):
    """Interface used to access the options for the FourPoint aerodynamic strategy in the advanced fixed wing tool."""

    _num_methods = 36
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_max_aoa_method_offset = 1
    _set_max_aoa_method_offset = 2
    _get_mach_1_method_offset = 3
    _set_mach_1_method_offset = 4
    _get_aoa_1_method_offset = 5
    _set_aoa_1_method_offset = 6
    _get_cl_1_method_offset = 7
    _set_cl_1_method_offset = 8
    _get_cd_1_method_offset = 9
    _set_cd_1_method_offset = 10
    _get_mach_2_method_offset = 11
    _set_mach_2_method_offset = 12
    _get_aoa_2_method_offset = 13
    _set_aoa_2_method_offset = 14
    _get_cl_2_method_offset = 15
    _set_cl_2_method_offset = 16
    _get_cd_2_method_offset = 17
    _set_cd_2_method_offset = 18
    _get_mach_3_method_offset = 19
    _set_mach_3_method_offset = 20
    _get_aoa_3_method_offset = 21
    _set_aoa_3_method_offset = 22
    _get_cl_3_method_offset = 23
    _set_cl_3_method_offset = 24
    _get_cd_3_method_offset = 25
    _set_cd_3_method_offset = 26
    _get_mach_4_method_offset = 27
    _set_mach_4_method_offset = 28
    _get_aoa_4_method_offset = 29
    _set_aoa_4_method_offset = 30
    _get_cl_4_method_offset = 31
    _set_cl_4_method_offset = 32
    _get_cd_4_method_offset = 33
    _set_cd_4_method_offset = 34
    _validate_lift_design_points_method_offset = 35
    _validate_drag_design_points_method_offset = 36
    _metadata = {
        "iid_data" : (4877073665632949624, 11672716552880349597),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, AdvancedFixedWingFourPointAerodynamic)

    _get_max_aoa_metadata = { "offset" : _get_max_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_aoa(self) -> typing.Any:
        """Get or set the maximum AOA for the aircraft."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_max_aoa_metadata)

    _set_max_aoa_metadata = { "offset" : _set_max_aoa_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_aoa.setter
    def max_aoa(self, value:typing.Any) -> None:
        """Get or set the maximum AOA for the aircraft."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_max_aoa_metadata, value)

    _get_mach_1_metadata = { "offset" : _get_mach_1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mach_1(self) -> float:
        """Get or set the Mach for the first design point."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_mach_1_metadata)

    _set_mach_1_metadata = { "offset" : _set_mach_1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mach_1.setter
    def mach_1(self, value:float) -> None:
        """Get or set the Mach for the first design point."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_mach_1_metadata, value)

    _get_aoa_1_metadata = { "offset" : _get_aoa_1_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def aoa_1(self) -> typing.Any:
        """Get or set the AOA for the first design point."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_aoa_1_metadata)

    _set_aoa_1_metadata = { "offset" : _set_aoa_1_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @aoa_1.setter
    def aoa_1(self, value:typing.Any) -> None:
        """Get or set the AOA for the first design point."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_aoa_1_metadata, value)

    _get_cl_1_metadata = { "offset" : _get_cl_1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cl_1(self) -> float:
        """Get or set the lift coefficient for the first design point."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_cl_1_metadata)

    _set_cl_1_metadata = { "offset" : _set_cl_1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cl_1.setter
    def cl_1(self, value:float) -> None:
        """Get or set the lift coefficient for the first design point."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_cl_1_metadata, value)

    _get_cd_1_metadata = { "offset" : _get_cd_1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cd_1(self) -> float:
        """Get or set the drag coefficient for the first design point."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_cd_1_metadata)

    _set_cd_1_metadata = { "offset" : _set_cd_1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cd_1.setter
    def cd_1(self, value:float) -> None:
        """Get or set the drag coefficient for the first design point."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_cd_1_metadata, value)

    _get_mach_2_metadata = { "offset" : _get_mach_2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mach_2(self) -> float:
        """Get or set the Mach for the second design point."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_mach_2_metadata)

    _set_mach_2_metadata = { "offset" : _set_mach_2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mach_2.setter
    def mach_2(self, value:float) -> None:
        """Get or set the Mach for the second design point."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_mach_2_metadata, value)

    _get_aoa_2_metadata = { "offset" : _get_aoa_2_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def aoa_2(self) -> typing.Any:
        """Get or set the AOA for the second design point."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_aoa_2_metadata)

    _set_aoa_2_metadata = { "offset" : _set_aoa_2_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @aoa_2.setter
    def aoa_2(self, value:typing.Any) -> None:
        """Get or set the AOA for the second design point."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_aoa_2_metadata, value)

    _get_cl_2_metadata = { "offset" : _get_cl_2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cl_2(self) -> float:
        """Get or set the lift coefficient for the second design point."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_cl_2_metadata)

    _set_cl_2_metadata = { "offset" : _set_cl_2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cl_2.setter
    def cl_2(self, value:float) -> None:
        """Get or set the lift coefficient for the second design point."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_cl_2_metadata, value)

    _get_cd_2_metadata = { "offset" : _get_cd_2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cd_2(self) -> float:
        """Get or set the drag coefficient for the second design point."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_cd_2_metadata)

    _set_cd_2_metadata = { "offset" : _set_cd_2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cd_2.setter
    def cd_2(self, value:float) -> None:
        """Get or set the drag coefficient for the second design point."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_cd_2_metadata, value)

    _get_mach_3_metadata = { "offset" : _get_mach_3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mach_3(self) -> float:
        """Get or set the Mach for the third design point."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_mach_3_metadata)

    _set_mach_3_metadata = { "offset" : _set_mach_3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mach_3.setter
    def mach_3(self, value:float) -> None:
        """Get or set the Mach for the third design point."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_mach_3_metadata, value)

    _get_aoa_3_metadata = { "offset" : _get_aoa_3_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def aoa_3(self) -> typing.Any:
        """Get or set the AOA for the third design point."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_aoa_3_metadata)

    _set_aoa_3_metadata = { "offset" : _set_aoa_3_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @aoa_3.setter
    def aoa_3(self, value:typing.Any) -> None:
        """Get or set the AOA for the third design point."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_aoa_3_metadata, value)

    _get_cl_3_metadata = { "offset" : _get_cl_3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cl_3(self) -> float:
        """Get or set the lift coefficient for the third design point."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_cl_3_metadata)

    _set_cl_3_metadata = { "offset" : _set_cl_3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cl_3.setter
    def cl_3(self, value:float) -> None:
        """Get or set the lift coefficient for the third design point."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_cl_3_metadata, value)

    _get_cd_3_metadata = { "offset" : _get_cd_3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cd_3(self) -> float:
        """Get or set the drag coefficient for the third design point."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_cd_3_metadata)

    _set_cd_3_metadata = { "offset" : _set_cd_3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cd_3.setter
    def cd_3(self, value:float) -> None:
        """Get or set the drag coefficient for the third design point."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_cd_3_metadata, value)

    _get_mach_4_metadata = { "offset" : _get_mach_4_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mach_4(self) -> float:
        """Get or set the Mach for the fourth design point."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_mach_4_metadata)

    _set_mach_4_metadata = { "offset" : _set_mach_4_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mach_4.setter
    def mach_4(self, value:float) -> None:
        """Get or set the Mach for the fourth design point."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_mach_4_metadata, value)

    _get_aoa_4_metadata = { "offset" : _get_aoa_4_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def aoa_4(self) -> typing.Any:
        """Get or set the AOA for the fourth design point."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_aoa_4_metadata)

    _set_aoa_4_metadata = { "offset" : _set_aoa_4_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @aoa_4.setter
    def aoa_4(self, value:typing.Any) -> None:
        """Get or set the AOA for the fourth design point."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_aoa_4_metadata, value)

    _get_cl_4_metadata = { "offset" : _get_cl_4_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cl_4(self) -> float:
        """Get or set the lift coefficient for the fourth design point."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_cl_4_metadata)

    _set_cl_4_metadata = { "offset" : _set_cl_4_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cl_4.setter
    def cl_4(self, value:float) -> None:
        """Get or set the lift coefficient for the fourth design point."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_cl_4_metadata, value)

    _get_cd_4_metadata = { "offset" : _get_cd_4_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cd_4(self) -> float:
        """Get or set the drag coefficient for the fourth design point."""
        return self._intf.get_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._get_cd_4_metadata)

    _set_cd_4_metadata = { "offset" : _set_cd_4_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cd_4.setter
    def cd_4(self, value:float) -> None:
        """Get or set the drag coefficient for the fourth design point."""
        return self._intf.set_property(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._set_cd_4_metadata, value)

    _validate_lift_design_points_metadata = { "offset" : _validate_lift_design_points_method_offset,
            "arg_types" : (agcom.DOUBLE, agcom.Variant, agcom.DOUBLE, agcom.Variant, agcom.DOUBLE, agcom.Variant, agcom.DOUBLE, agcom.Variant, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.DoubleArg, agmarshall.VariantArg, agmarshall.DoubleArg, agmarshall.VariantArg, agmarshall.DoubleArg, agmarshall.VariantArg, agmarshall.DoubleArg, agmarshall.VariantArg, agmarshall.VariantBoolArg,) }
    def validate_lift_design_points(self, d_mach_1:float, d_aoa_1:typing.Any, d_mach_2:float, d_aoa_2:typing.Any, d_mach_3:float, d_aoa_3:typing.Any, d_mach_4:float, d_aoa_4:typing.Any) -> bool:
        """Validate the lift design points - ensure the choices do not result in a singular system of equations."""
        return self._intf.invoke(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._validate_lift_design_points_metadata, d_mach_1, d_aoa_1, d_mach_2, d_aoa_2, d_mach_3, d_aoa_3, d_mach_4, d_aoa_4, OutArg())

    _validate_drag_design_points_metadata = { "offset" : _validate_drag_design_points_method_offset,
            "arg_types" : (agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.VariantBoolArg,) }
    def validate_drag_design_points(self, d_mach_1:float, d_c_l_1:float, d_mach_2:float, d_c_l_2:float, d_mach_3:float, d_c_l_3:float, d_mach_4:float, d_c_l_4:float) -> bool:
        """Validate the drag design points - ensure the choices do not result in a singular system of equations."""
        return self._intf.invoke(AdvancedFixedWingFourPointAerodynamic._metadata, AdvancedFixedWingFourPointAerodynamic._validate_drag_design_points_metadata, d_mach_1, d_c_l_1, d_mach_2, d_c_l_2, d_mach_3, d_c_l_3, d_mach_4, d_c_l_4, OutArg())

    _property_names[max_aoa] = "max_aoa"
    _property_names[mach_1] = "mach_1"
    _property_names[aoa_1] = "aoa_1"
    _property_names[cl_1] = "cl_1"
    _property_names[cd_1] = "cd_1"
    _property_names[mach_2] = "mach_2"
    _property_names[aoa_2] = "aoa_2"
    _property_names[cl_2] = "cl_2"
    _property_names[cd_2] = "cd_2"
    _property_names[mach_3] = "mach_3"
    _property_names[aoa_3] = "aoa_3"
    _property_names[cl_3] = "cl_3"
    _property_names[cd_3] = "cd_3"
    _property_names[mach_4] = "mach_4"
    _property_names[aoa_4] = "aoa_4"
    _property_names[cl_4] = "cl_4"
    _property_names[cd_4] = "cd_4"

    def __init__(self, source_object=None):
        """Construct an object of type AdvancedFixedWingFourPointAerodynamic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, AdvancedFixedWingFourPointAerodynamic)
    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, AdvancedFixedWingFourPointAerodynamic, [AdvancedFixedWingFourPointAerodynamic, ])

agcls.AgClassCatalog.add_catalog_entry((5395193493490888646, 11199330471138564483), AdvancedFixedWingFourPointAerodynamic)
agcls.AgTypeNameMap["AdvancedFixedWingFourPointAerodynamic"] = AdvancedFixedWingFourPointAerodynamic

class MissileFourPointAerodynamic(SupportsDeleteCallback):
    """Interface used to access the options for the FourPoint aerodynamic strategy in the missile."""

    _num_methods = 40
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_mach_1_method_offset = 1
    _set_mach_1_method_offset = 2
    _get_aoa_1_method_offset = 3
    _set_aoa_1_method_offset = 4
    _get_cl_1_method_offset = 5
    _set_cl_1_method_offset = 6
    _get_cd_1_method_offset = 7
    _set_cd_1_method_offset = 8
    _get_mach_2_method_offset = 9
    _set_mach_2_method_offset = 10
    _get_aoa_2_method_offset = 11
    _set_aoa_2_method_offset = 12
    _get_cl_2_method_offset = 13
    _set_cl_2_method_offset = 14
    _get_cd_2_method_offset = 15
    _set_cd_2_method_offset = 16
    _get_mach_3_method_offset = 17
    _set_mach_3_method_offset = 18
    _get_aoa_3_method_offset = 19
    _set_aoa_3_method_offset = 20
    _get_cl_3_method_offset = 21
    _set_cl_3_method_offset = 22
    _get_cd_3_method_offset = 23
    _set_cd_3_method_offset = 24
    _get_mach_4_method_offset = 25
    _set_mach_4_method_offset = 26
    _get_aoa_4_method_offset = 27
    _set_aoa_4_method_offset = 28
    _get_cl_4_method_offset = 29
    _set_cl_4_method_offset = 30
    _get_cd_4_method_offset = 31
    _set_cd_4_method_offset = 32
    _validate_lift_design_points_method_offset = 33
    _validate_drag_design_points_method_offset = 34
    _get_s_reference_method_offset = 35
    _set_s_reference_method_offset = 36
    _set_aoa_method_offset = 37
    _get_max_aoa_method_offset = 38
    _get_max_endurance_aoa_method_offset = 39
    _get_max_range_aoa_method_offset = 40
    _metadata = {
        "iid_data" : (4730269207064615935, 16334924616545939868),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, MissileFourPointAerodynamic)

    _get_mach_1_metadata = { "offset" : _get_mach_1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mach_1(self) -> float:
        """Get or set the Mach for the first design point."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_mach_1_metadata)

    _set_mach_1_metadata = { "offset" : _set_mach_1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mach_1.setter
    def mach_1(self, value:float) -> None:
        """Get or set the Mach for the first design point."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_mach_1_metadata, value)

    _get_aoa_1_metadata = { "offset" : _get_aoa_1_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def aoa_1(self) -> typing.Any:
        """Get or set the AOA for the first design point."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_aoa_1_metadata)

    _set_aoa_1_metadata = { "offset" : _set_aoa_1_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @aoa_1.setter
    def aoa_1(self, value:typing.Any) -> None:
        """Get or set the AOA for the first design point."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_aoa_1_metadata, value)

    _get_cl_1_metadata = { "offset" : _get_cl_1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cl_1(self) -> float:
        """Get or set the lift coefficient for the first design point."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_cl_1_metadata)

    _set_cl_1_metadata = { "offset" : _set_cl_1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cl_1.setter
    def cl_1(self, value:float) -> None:
        """Get or set the lift coefficient for the first design point."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_cl_1_metadata, value)

    _get_cd_1_metadata = { "offset" : _get_cd_1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cd_1(self) -> float:
        """Get or set the drag coefficient for the first design point."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_cd_1_metadata)

    _set_cd_1_metadata = { "offset" : _set_cd_1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cd_1.setter
    def cd_1(self, value:float) -> None:
        """Get or set the drag coefficient for the first design point."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_cd_1_metadata, value)

    _get_mach_2_metadata = { "offset" : _get_mach_2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mach_2(self) -> float:
        """Get or set the Mach for the second design point."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_mach_2_metadata)

    _set_mach_2_metadata = { "offset" : _set_mach_2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mach_2.setter
    def mach_2(self, value:float) -> None:
        """Get or set the Mach for the second design point."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_mach_2_metadata, value)

    _get_aoa_2_metadata = { "offset" : _get_aoa_2_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def aoa_2(self) -> typing.Any:
        """Get or set the AOA for the second design point."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_aoa_2_metadata)

    _set_aoa_2_metadata = { "offset" : _set_aoa_2_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @aoa_2.setter
    def aoa_2(self, value:typing.Any) -> None:
        """Get or set the AOA for the second design point."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_aoa_2_metadata, value)

    _get_cl_2_metadata = { "offset" : _get_cl_2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cl_2(self) -> float:
        """Get or set the lift coefficient for the second design point."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_cl_2_metadata)

    _set_cl_2_metadata = { "offset" : _set_cl_2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cl_2.setter
    def cl_2(self, value:float) -> None:
        """Get or set the lift coefficient for the second design point."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_cl_2_metadata, value)

    _get_cd_2_metadata = { "offset" : _get_cd_2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cd_2(self) -> float:
        """Get or set the drag coefficient for the second design point."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_cd_2_metadata)

    _set_cd_2_metadata = { "offset" : _set_cd_2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cd_2.setter
    def cd_2(self, value:float) -> None:
        """Get or set the drag coefficient for the second design point."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_cd_2_metadata, value)

    _get_mach_3_metadata = { "offset" : _get_mach_3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mach_3(self) -> float:
        """Get or set the Mach for the third design point."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_mach_3_metadata)

    _set_mach_3_metadata = { "offset" : _set_mach_3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mach_3.setter
    def mach_3(self, value:float) -> None:
        """Get or set the Mach for the third design point."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_mach_3_metadata, value)

    _get_aoa_3_metadata = { "offset" : _get_aoa_3_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def aoa_3(self) -> typing.Any:
        """Get or set the AOA for the third design point."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_aoa_3_metadata)

    _set_aoa_3_metadata = { "offset" : _set_aoa_3_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @aoa_3.setter
    def aoa_3(self, value:typing.Any) -> None:
        """Get or set the AOA for the third design point."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_aoa_3_metadata, value)

    _get_cl_3_metadata = { "offset" : _get_cl_3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cl_3(self) -> float:
        """Get or set the lift coefficient for the third design point."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_cl_3_metadata)

    _set_cl_3_metadata = { "offset" : _set_cl_3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cl_3.setter
    def cl_3(self, value:float) -> None:
        """Get or set the lift coefficient for the third design point."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_cl_3_metadata, value)

    _get_cd_3_metadata = { "offset" : _get_cd_3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cd_3(self) -> float:
        """Get or set the drag coefficient for the third design point."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_cd_3_metadata)

    _set_cd_3_metadata = { "offset" : _set_cd_3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cd_3.setter
    def cd_3(self, value:float) -> None:
        """Get or set the drag coefficient for the third design point."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_cd_3_metadata, value)

    _get_mach_4_metadata = { "offset" : _get_mach_4_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mach_4(self) -> float:
        """Get or set the Mach for the fourth design point."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_mach_4_metadata)

    _set_mach_4_metadata = { "offset" : _set_mach_4_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mach_4.setter
    def mach_4(self, value:float) -> None:
        """Get or set the Mach for the fourth design point."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_mach_4_metadata, value)

    _get_aoa_4_metadata = { "offset" : _get_aoa_4_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def aoa_4(self) -> typing.Any:
        """Get or set the AOA for the fourth design point."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_aoa_4_metadata)

    _set_aoa_4_metadata = { "offset" : _set_aoa_4_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @aoa_4.setter
    def aoa_4(self, value:typing.Any) -> None:
        """Get or set the AOA for the fourth design point."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_aoa_4_metadata, value)

    _get_cl_4_metadata = { "offset" : _get_cl_4_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cl_4(self) -> float:
        """Get or set the lift coefficient for the fourth design point."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_cl_4_metadata)

    _set_cl_4_metadata = { "offset" : _set_cl_4_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cl_4.setter
    def cl_4(self, value:float) -> None:
        """Get or set the lift coefficient for the fourth design point."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_cl_4_metadata, value)

    _get_cd_4_metadata = { "offset" : _get_cd_4_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cd_4(self) -> float:
        """Get or set the drag coefficient for the fourth design point."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_cd_4_metadata)

    _set_cd_4_metadata = { "offset" : _set_cd_4_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cd_4.setter
    def cd_4(self, value:float) -> None:
        """Get or set the drag coefficient for the fourth design point."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_cd_4_metadata, value)

    _validate_lift_design_points_metadata = { "offset" : _validate_lift_design_points_method_offset,
            "arg_types" : (agcom.DOUBLE, agcom.Variant, agcom.DOUBLE, agcom.Variant, agcom.DOUBLE, agcom.Variant, agcom.DOUBLE, agcom.Variant, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.DoubleArg, agmarshall.VariantArg, agmarshall.DoubleArg, agmarshall.VariantArg, agmarshall.DoubleArg, agmarshall.VariantArg, agmarshall.DoubleArg, agmarshall.VariantArg, agmarshall.VariantBoolArg,) }
    def validate_lift_design_points(self, d_mach_1:float, d_aoa_1:typing.Any, d_mach_2:float, d_aoa_2:typing.Any, d_mach_3:float, d_aoa_3:typing.Any, d_mach_4:float, d_aoa_4:typing.Any) -> bool:
        """Validate the lift design points - ensure the choices do not result in a singular system of equations."""
        return self._intf.invoke(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._validate_lift_design_points_metadata, d_mach_1, d_aoa_1, d_mach_2, d_aoa_2, d_mach_3, d_aoa_3, d_mach_4, d_aoa_4, OutArg())

    _validate_drag_design_points_metadata = { "offset" : _validate_drag_design_points_method_offset,
            "arg_types" : (agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.VariantBoolArg,) }
    def validate_drag_design_points(self, d_mach_1:float, d_c_l_1:float, d_mach_2:float, d_c_l_2:float, d_mach_3:float, d_c_l_3:float, d_mach_4:float, d_c_l_4:float) -> bool:
        """Validate the drag design points - ensure the choices do not result in a singular system of equations."""
        return self._intf.invoke(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._validate_drag_design_points_metadata, d_mach_1, d_c_l_1, d_mach_2, d_c_l_2, d_mach_3, d_c_l_3, d_mach_4, d_c_l_4, OutArg())

    _get_s_reference_metadata = { "offset" : _get_s_reference_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def s_reference(self) -> typing.Any:
        """Get or set the aerodynamic reference area for the aircraft."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_s_reference_metadata)

    _set_s_reference_metadata = { "offset" : _set_s_reference_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @s_reference.setter
    def s_reference(self, value:typing.Any) -> None:
        """Get or set the aerodynamic reference area for the aircraft."""
        return self._intf.set_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_s_reference_metadata, value)

    _set_aoa_metadata = { "offset" : _set_aoa_method_offset,
            "arg_types" : (agcom.Variant, agcom.Variant, agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg, agmarshall.VariantArg, agmarshall.VariantArg,) }
    def set_aoa(self, d_max_aoa:typing.Any, d_max_endurance_aoa:typing.Any, d_max_range_aoa:typing.Any) -> None:
        """Get or set and validates the maximum, max range and max endurance AOA values for the aircraft."""
        return self._intf.invoke(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._set_aoa_metadata, d_max_aoa, d_max_endurance_aoa, d_max_range_aoa)

    _get_max_aoa_metadata = { "offset" : _get_max_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_aoa(self) -> typing.Any:
        """Get the maximum AOA for the aircraft."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_max_aoa_metadata)

    _get_max_endurance_aoa_metadata = { "offset" : _get_max_endurance_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_endurance_aoa(self) -> typing.Any:
        """Get the maximum endurance AOA for the aircraft."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_max_endurance_aoa_metadata)

    _get_max_range_aoa_metadata = { "offset" : _get_max_range_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_range_aoa(self) -> typing.Any:
        """Get the maximum range AOA for the aircraft."""
        return self._intf.get_property(MissileFourPointAerodynamic._metadata, MissileFourPointAerodynamic._get_max_range_aoa_metadata)

    _property_names[mach_1] = "mach_1"
    _property_names[aoa_1] = "aoa_1"
    _property_names[cl_1] = "cl_1"
    _property_names[cd_1] = "cd_1"
    _property_names[mach_2] = "mach_2"
    _property_names[aoa_2] = "aoa_2"
    _property_names[cl_2] = "cl_2"
    _property_names[cd_2] = "cd_2"
    _property_names[mach_3] = "mach_3"
    _property_names[aoa_3] = "aoa_3"
    _property_names[cl_3] = "cl_3"
    _property_names[cd_3] = "cd_3"
    _property_names[mach_4] = "mach_4"
    _property_names[aoa_4] = "aoa_4"
    _property_names[cl_4] = "cl_4"
    _property_names[cd_4] = "cd_4"
    _property_names[s_reference] = "s_reference"
    _property_names[max_aoa] = "max_aoa"
    _property_names[max_endurance_aoa] = "max_endurance_aoa"
    _property_names[max_range_aoa] = "max_range_aoa"

    def __init__(self, source_object=None):
        """Construct an object of type MissileFourPointAerodynamic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, MissileFourPointAerodynamic)
    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, MissileFourPointAerodynamic, [MissileFourPointAerodynamic, ])

agcls.AgClassCatalog.add_catalog_entry((5716462331802832450, 2304689591626170533), MissileFourPointAerodynamic)
agcls.AgTypeNameMap["MissileFourPointAerodynamic"] = MissileFourPointAerodynamic

class FourPointAerodynamic(SupportsDeleteCallback):
    """Interface used to access the options for the FourPoint aerodynamic strategy."""

    _num_methods = 38
    _vtable_offset = IUnknown._vtable_offset + IUnknown._num_methods
    _get_mach_1_method_offset = 1
    _set_mach_1_method_offset = 2
    _get_aoa_1_method_offset = 3
    _set_aoa_1_method_offset = 4
    _get_cl_1_method_offset = 5
    _set_cl_1_method_offset = 6
    _get_cd_1_method_offset = 7
    _set_cd_1_method_offset = 8
    _get_mach_2_method_offset = 9
    _set_mach_2_method_offset = 10
    _get_aoa_2_method_offset = 11
    _set_aoa_2_method_offset = 12
    _get_cl_2_method_offset = 13
    _set_cl_2_method_offset = 14
    _get_cd_2_method_offset = 15
    _set_cd_2_method_offset = 16
    _get_mach_3_method_offset = 17
    _set_mach_3_method_offset = 18
    _get_aoa_3_method_offset = 19
    _set_aoa_3_method_offset = 20
    _get_cl_3_method_offset = 21
    _set_cl_3_method_offset = 22
    _get_cd_3_method_offset = 23
    _set_cd_3_method_offset = 24
    _get_mach_4_method_offset = 25
    _set_mach_4_method_offset = 26
    _get_aoa_4_method_offset = 27
    _set_aoa_4_method_offset = 28
    _get_cl_4_method_offset = 29
    _set_cl_4_method_offset = 30
    _get_cd_4_method_offset = 31
    _set_cd_4_method_offset = 32
    _validate_lift_design_points_method_offset = 33
    _validate_drag_design_points_method_offset = 34
    _get_s_reference_method_offset = 35
    _set_s_reference_method_offset = 36
    _get_max_aoa_method_offset = 37
    _set_max_aoa_method_offset = 38
    _metadata = {
        "iid_data" : (5484477733759286553, 11826654122719919528),
        "vtable_reference" : IUnknown._vtable_offset + IUnknown._num_methods - 1,
    }
    _property_names = {}
    def _get_property(self, attrname):
        return get_interface_property(attrname, FourPointAerodynamic)

    _get_mach_1_metadata = { "offset" : _get_mach_1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mach_1(self) -> float:
        """Get or set the Mach for the first design point."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_mach_1_metadata)

    _set_mach_1_metadata = { "offset" : _set_mach_1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mach_1.setter
    def mach_1(self, value:float) -> None:
        """Get or set the Mach for the first design point."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_mach_1_metadata, value)

    _get_aoa_1_metadata = { "offset" : _get_aoa_1_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def aoa_1(self) -> typing.Any:
        """Get or set the AOA for the first design point."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_aoa_1_metadata)

    _set_aoa_1_metadata = { "offset" : _set_aoa_1_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @aoa_1.setter
    def aoa_1(self, value:typing.Any) -> None:
        """Get or set the AOA for the first design point."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_aoa_1_metadata, value)

    _get_cl_1_metadata = { "offset" : _get_cl_1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cl_1(self) -> float:
        """Get or set the lift coefficient for the first design point."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_cl_1_metadata)

    _set_cl_1_metadata = { "offset" : _set_cl_1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cl_1.setter
    def cl_1(self, value:float) -> None:
        """Get or set the lift coefficient for the first design point."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_cl_1_metadata, value)

    _get_cd_1_metadata = { "offset" : _get_cd_1_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cd_1(self) -> float:
        """Get or set the drag coefficient for the first design point."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_cd_1_metadata)

    _set_cd_1_metadata = { "offset" : _set_cd_1_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cd_1.setter
    def cd_1(self, value:float) -> None:
        """Get or set the drag coefficient for the first design point."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_cd_1_metadata, value)

    _get_mach_2_metadata = { "offset" : _get_mach_2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mach_2(self) -> float:
        """Get or set the Mach for the second design point."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_mach_2_metadata)

    _set_mach_2_metadata = { "offset" : _set_mach_2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mach_2.setter
    def mach_2(self, value:float) -> None:
        """Get or set the Mach for the second design point."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_mach_2_metadata, value)

    _get_aoa_2_metadata = { "offset" : _get_aoa_2_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def aoa_2(self) -> typing.Any:
        """Get or set the AOA for the second design point."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_aoa_2_metadata)

    _set_aoa_2_metadata = { "offset" : _set_aoa_2_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @aoa_2.setter
    def aoa_2(self, value:typing.Any) -> None:
        """Get or set the AOA for the second design point."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_aoa_2_metadata, value)

    _get_cl_2_metadata = { "offset" : _get_cl_2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cl_2(self) -> float:
        """Get or set the lift coefficient for the second design point."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_cl_2_metadata)

    _set_cl_2_metadata = { "offset" : _set_cl_2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cl_2.setter
    def cl_2(self, value:float) -> None:
        """Get or set the lift coefficient for the second design point."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_cl_2_metadata, value)

    _get_cd_2_metadata = { "offset" : _get_cd_2_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cd_2(self) -> float:
        """Get or set the drag coefficient for the second design point."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_cd_2_metadata)

    _set_cd_2_metadata = { "offset" : _set_cd_2_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cd_2.setter
    def cd_2(self, value:float) -> None:
        """Get or set the drag coefficient for the second design point."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_cd_2_metadata, value)

    _get_mach_3_metadata = { "offset" : _get_mach_3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mach_3(self) -> float:
        """Get or set the Mach for the third design point."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_mach_3_metadata)

    _set_mach_3_metadata = { "offset" : _set_mach_3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mach_3.setter
    def mach_3(self, value:float) -> None:
        """Get or set the Mach for the third design point."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_mach_3_metadata, value)

    _get_aoa_3_metadata = { "offset" : _get_aoa_3_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def aoa_3(self) -> typing.Any:
        """Get or set the AOA for the third design point."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_aoa_3_metadata)

    _set_aoa_3_metadata = { "offset" : _set_aoa_3_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @aoa_3.setter
    def aoa_3(self, value:typing.Any) -> None:
        """Get or set the AOA for the third design point."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_aoa_3_metadata, value)

    _get_cl_3_metadata = { "offset" : _get_cl_3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cl_3(self) -> float:
        """Get or set the lift coefficient for the third design point."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_cl_3_metadata)

    _set_cl_3_metadata = { "offset" : _set_cl_3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cl_3.setter
    def cl_3(self, value:float) -> None:
        """Get or set the lift coefficient for the third design point."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_cl_3_metadata, value)

    _get_cd_3_metadata = { "offset" : _get_cd_3_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cd_3(self) -> float:
        """Get or set the drag coefficient for the third design point."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_cd_3_metadata)

    _set_cd_3_metadata = { "offset" : _set_cd_3_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cd_3.setter
    def cd_3(self, value:float) -> None:
        """Get or set the drag coefficient for the third design point."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_cd_3_metadata, value)

    _get_mach_4_metadata = { "offset" : _get_mach_4_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def mach_4(self) -> float:
        """Get or set the Mach for the fourth design point."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_mach_4_metadata)

    _set_mach_4_metadata = { "offset" : _set_mach_4_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @mach_4.setter
    def mach_4(self, value:float) -> None:
        """Get or set the Mach for the fourth design point."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_mach_4_metadata, value)

    _get_aoa_4_metadata = { "offset" : _get_aoa_4_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def aoa_4(self) -> typing.Any:
        """Get or set the AOA for the fourth design point."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_aoa_4_metadata)

    _set_aoa_4_metadata = { "offset" : _set_aoa_4_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @aoa_4.setter
    def aoa_4(self, value:typing.Any) -> None:
        """Get or set the AOA for the fourth design point."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_aoa_4_metadata, value)

    _get_cl_4_metadata = { "offset" : _get_cl_4_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cl_4(self) -> float:
        """Get or set the lift coefficient for the fourth design point."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_cl_4_metadata)

    _set_cl_4_metadata = { "offset" : _set_cl_4_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cl_4.setter
    def cl_4(self, value:float) -> None:
        """Get or set the lift coefficient for the fourth design point."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_cl_4_metadata, value)

    _get_cd_4_metadata = { "offset" : _get_cd_4_method_offset,
            "arg_types" : (POINTER(agcom.DOUBLE),),
            "marshallers" : (agmarshall.DoubleArg,) }
    @property
    def cd_4(self) -> float:
        """Get or set the drag coefficient for the fourth design point."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_cd_4_metadata)

    _set_cd_4_metadata = { "offset" : _set_cd_4_method_offset,
            "arg_types" : (agcom.DOUBLE,),
            "marshallers" : (agmarshall.DoubleArg,) }
    @cd_4.setter
    def cd_4(self, value:float) -> None:
        """Get or set the drag coefficient for the fourth design point."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_cd_4_metadata, value)

    _validate_lift_design_points_metadata = { "offset" : _validate_lift_design_points_method_offset,
            "arg_types" : (agcom.DOUBLE, agcom.Variant, agcom.DOUBLE, agcom.Variant, agcom.DOUBLE, agcom.Variant, agcom.DOUBLE, agcom.Variant, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.DoubleArg, agmarshall.VariantArg, agmarshall.DoubleArg, agmarshall.VariantArg, agmarshall.DoubleArg, agmarshall.VariantArg, agmarshall.DoubleArg, agmarshall.VariantArg, agmarshall.VariantBoolArg,) }
    def validate_lift_design_points(self, d_mach_1:float, d_aoa_1:typing.Any, d_mach_2:float, d_aoa_2:typing.Any, d_mach_3:float, d_aoa_3:typing.Any, d_mach_4:float, d_aoa_4:typing.Any) -> bool:
        """Validate the lift design points - ensure the choices do not result in a singular system of equations."""
        return self._intf.invoke(FourPointAerodynamic._metadata, FourPointAerodynamic._validate_lift_design_points_metadata, d_mach_1, d_aoa_1, d_mach_2, d_aoa_2, d_mach_3, d_aoa_3, d_mach_4, d_aoa_4, OutArg())

    _validate_drag_design_points_metadata = { "offset" : _validate_drag_design_points_method_offset,
            "arg_types" : (agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, agcom.DOUBLE, POINTER(agcom.VARIANT_BOOL),),
            "marshallers" : (agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.DoubleArg, agmarshall.VariantBoolArg,) }
    def validate_drag_design_points(self, d_mach_1:float, d_c_l_1:float, d_mach_2:float, d_c_l_2:float, d_mach_3:float, d_c_l_3:float, d_mach_4:float, d_c_l_4:float) -> bool:
        """Validate the drag design points - ensure the choices do not result in a singular system of equations."""
        return self._intf.invoke(FourPointAerodynamic._metadata, FourPointAerodynamic._validate_drag_design_points_metadata, d_mach_1, d_c_l_1, d_mach_2, d_c_l_2, d_mach_3, d_c_l_3, d_mach_4, d_c_l_4, OutArg())

    _get_s_reference_metadata = { "offset" : _get_s_reference_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def s_reference(self) -> typing.Any:
        """Get or set the aerodynamic reference area for the aircraft."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_s_reference_metadata)

    _set_s_reference_metadata = { "offset" : _set_s_reference_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @s_reference.setter
    def s_reference(self, value:typing.Any) -> None:
        """Get or set the aerodynamic reference area for the aircraft."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_s_reference_metadata, value)

    _get_max_aoa_metadata = { "offset" : _get_max_aoa_method_offset,
            "arg_types" : (POINTER(agcom.Variant),),
            "marshallers" : (agmarshall.VariantArg,) }
    @property
    def max_aoa(self) -> typing.Any:
        """Get or set the maximum AOA for the aircraft."""
        return self._intf.get_property(FourPointAerodynamic._metadata, FourPointAerodynamic._get_max_aoa_metadata)

    _set_max_aoa_metadata = { "offset" : _set_max_aoa_method_offset,
            "arg_types" : (agcom.Variant,),
            "marshallers" : (agmarshall.VariantArg,) }
    @max_aoa.setter
    def max_aoa(self, value:typing.Any) -> None:
        """Get or set the maximum AOA for the aircraft."""
        return self._intf.set_property(FourPointAerodynamic._metadata, FourPointAerodynamic._set_max_aoa_metadata, value)

    _property_names[mach_1] = "mach_1"
    _property_names[aoa_1] = "aoa_1"
    _property_names[cl_1] = "cl_1"
    _property_names[cd_1] = "cd_1"
    _property_names[mach_2] = "mach_2"
    _property_names[aoa_2] = "aoa_2"
    _property_names[cl_2] = "cl_2"
    _property_names[cd_2] = "cd_2"
    _property_names[mach_3] = "mach_3"
    _property_names[aoa_3] = "aoa_3"
    _property_names[cl_3] = "cl_3"
    _property_names[cd_3] = "cd_3"
    _property_names[mach_4] = "mach_4"
    _property_names[aoa_4] = "aoa_4"
    _property_names[cl_4] = "cl_4"
    _property_names[cd_4] = "cd_4"
    _property_names[s_reference] = "s_reference"
    _property_names[max_aoa] = "max_aoa"

    def __init__(self, source_object=None):
        """Construct an object of type FourPointAerodynamic."""
        SupportsDeleteCallback.__init__(self)
        initialize_from_source_object(self, source_object, FourPointAerodynamic)
    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, FourPointAerodynamic, [FourPointAerodynamic, ])

agcls.AgClassCatalog.add_catalog_entry((5736042625051820997, 10368039465623093694), FourPointAerodynamic)
agcls.AgTypeNameMap["FourPointAerodynamic"] = FourPointAerodynamic