from __future__ import annotations
import pxr.UsdPhysics._usdPhysics
import typing
import Boost.Python
import pxr.Usd
import pxr.UsdGeom
import pxr.UsdPhysics

__all__ = [
    "ArticulationRootAPI",
    "CollisionAPI",
    "CollisionGroup",
    "CollisionGroupTable",
    "DistanceJoint",
    "DriveAPI",
    "FilteredPairsAPI",
    "FixedJoint",
    "GetStageKilogramsPerUnit",
    "Joint",
    "LimitAPI",
    "MassAPI",
    "MassUnits",
    "MassUnitsAre",
    "MaterialAPI",
    "MeshCollisionAPI",
    "PrismaticJoint",
    "RevoluteJoint",
    "RigidBodyAPI",
    "Scene",
    "SetStageKilogramsPerUnit",
    "SphericalJoint",
    "StageHasAuthoredKilogramsPerUnit",
    "Tokens"
]


class ArticulationRootAPI(pxr.Usd.APISchemaBase, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    PhysicsArticulationRootAPI can be applied to a scene graph node, and
    marks the subtree rooted here for inclusion in one or more reduced
    coordinate articulations. For floating articulations, this should be
    on the root body. For fixed articulations (robotics jargon for e.g. a
    robot arm for welding that is bolted to the floor), this API can be on
    a direct or indirect parent of the root joint which is connected to
    the world, or on the joint itself\.\.
    """
    @staticmethod
    def Apply(*args, **kwargs) -> None: 
        """
        **classmethod** Apply(prim) -> ArticulationRootAPI


        Applies this **single-apply** API schema to the given ``prim`` .


        This information is stored by adding"PhysicsArticulationRootAPI"to the
        token-valued, listOp metadata *apiSchemas* on the prim.

        A valid UsdPhysicsArticulationRootAPI object is returned upon success.
        An invalid (or empty) UsdPhysicsArticulationRootAPI object is returned
        upon failure. See UsdPrim::ApplyAPI() for conditions resulting in
        failure.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim
        """
    @staticmethod
    def CanApply(*args, **kwargs) -> None: 
        """
        **classmethod** CanApply(prim, whyNot) -> bool


        Returns true if this **single-apply** API schema can be applied to the
        given ``prim`` .


        If this schema can not be a applied to the prim, this returns false
        and, if provided, populates ``whyNot`` with the reason it can not be
        applied.

        Note that if CanApply returns false, that does not necessarily imply
        that calling Apply will fail. Callers are expected to call CanApply
        before calling Apply if they want to ensure that it is valid to apply
        a schema.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim

        whyNot : str
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> ArticulationRootAPI


        Return a UsdPhysicsArticulationRootAPI holding the prim adhering to
        this schema at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdPhysicsArticulationRootAPI(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 48
    pass
class CollisionAPI(pxr.Usd.APISchemaBase, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Applies collision attributes to a UsdGeomXformable prim. If a
    simulation is running, this geometry will collide with other
    geometries that have PhysicsCollisionAPI applied. If a prim in the
    parent hierarchy has the RigidBodyAPI applied, this collider is a part
    of that body. If there is no body in the parent hierarchy, this
    collider is considered to be static.
    """
    @staticmethod
    def Apply(*args, **kwargs) -> None: 
        """
        **classmethod** Apply(prim) -> CollisionAPI


        Applies this **single-apply** API schema to the given ``prim`` .


        This information is stored by adding"PhysicsCollisionAPI"to the token-
        valued, listOp metadata *apiSchemas* on the prim.

        A valid UsdPhysicsCollisionAPI object is returned upon success. An
        invalid (or empty) UsdPhysicsCollisionAPI object is returned upon
        failure. See UsdPrim::ApplyAPI() for conditions resulting in failure.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim
        """
    @staticmethod
    def CanApply(*args, **kwargs) -> None: 
        """
        **classmethod** CanApply(prim, whyNot) -> bool


        Returns true if this **single-apply** API schema can be applied to the
        given ``prim`` .


        If this schema can not be a applied to the prim, this returns false
        and, if provided, populates ``whyNot`` with the reason it can not be
        applied.

        Note that if CanApply returns false, that does not necessarily imply
        that calling Apply will fail. Callers are expected to call CanApply
        before calling Apply if they want to ensure that it is valid to apply
        a schema.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim

        whyNot : str
        """
    @staticmethod
    def CreateCollisionEnabledAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateCollisionEnabledAttr(defaultValue, writeSparsely) -> Attribute


        See GetCollisionEnabledAttr() , and also Create vs Get Property
        Methods for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateSimulationOwnerRel() -> Relationship: 
        """
        CreateSimulationOwnerRel() -> Relationship


        See GetSimulationOwnerRel() , and also Create vs Get Property Methods
        for when to use Get vs Create.
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> CollisionAPI


        Return a UsdPhysicsCollisionAPI holding the prim adhering to this
        schema at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdPhysicsCollisionAPI(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetCollisionEnabledAttr() -> Attribute: 
        """
        GetCollisionEnabledAttr() -> Attribute


        Determines if the PhysicsCollisionAPI is enabled.



        Declaration

        ``bool physics:collisionEnabled = 1``

        C++ Type

        bool

        Usd Type

        SdfValueTypeNames->Bool
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetSimulationOwnerRel() -> Relationship: 
        """
        GetSimulationOwnerRel() -> Relationship


        Single PhysicsScene that will simulate this collider.


        By default this object belongs to the first PhysicsScene. Note that if
        a RigidBodyAPI in the hierarchy above has a different simulationOwner
        then it has a precedence over this relationship.
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 48
    pass
class CollisionGroup(pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Defines a collision group for coarse filtering. When a collision
    occurs between two objects that have a PhysicsCollisionGroup assigned,
    they will collide with each other unless this PhysicsCollisionGroup
    pair is filtered. See filteredGroups attribute.

    A CollectionAPI:colliders maintains a list of PhysicsCollisionAPI
    rel-s that defines the members of this Collisiongroup.
    """
    @staticmethod
    def ComputeCollisionGroupTable(*args, **kwargs) -> None: 
        """
        **classmethod** ComputeCollisionGroupTable(stage) -> CollisionGroupTable


        Compute a table encoding all the collision groups filter rules for a
        stage.


        This can be used as a reference to validate an implementation of the
        collision groups filters. The returned table is diagonally symmetric.


        Parameters
        ----------
        stage : Stage
        """
    @staticmethod
    def CreateFilteredGroupsRel() -> Relationship: 
        """
        CreateFilteredGroupsRel() -> Relationship


        See GetFilteredGroupsRel() , and also Create vs Get Property Methods
        for when to use Get vs Create.
        """
    @staticmethod
    def CreateInvertFilteredGroupsAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateInvertFilteredGroupsAttr(defaultValue, writeSparsely) -> Attribute


        See GetInvertFilteredGroupsAttr() , and also Create vs Get Property
        Methods for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateMergeGroupNameAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateMergeGroupNameAttr(defaultValue, writeSparsely) -> Attribute


        See GetMergeGroupNameAttr() , and also Create vs Get Property Methods
        for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> CollisionGroup


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> CollisionGroup


        Return a UsdPhysicsCollisionGroup holding the prim adhering to this
        schema at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdPhysicsCollisionGroup(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetCollidersCollectionAPI() -> CollectionAPI: 
        """
        GetCollidersCollectionAPI() -> CollectionAPI


        Return the UsdCollectionAPI interface used for defining what colliders
        belong to the CollisionGroup.
        """
    @staticmethod
    def GetFilteredGroupsRel() -> Relationship: 
        """
        GetFilteredGroupsRel() -> Relationship


        References a list of PhysicsCollisionGroups with which collisions
        should be ignored.
        """
    @staticmethod
    def GetInvertFilteredGroupsAttr() -> Attribute: 
        """
        GetInvertFilteredGroupsAttr() -> Attribute


        Normally, the filter will disable collisions against the selected
        filter groups.


        However, if this option is set, the filter will disable collisions
        against all colliders except for those in the selected filter groups.

        Declaration

        ``bool physics:invertFilteredGroups``

        C++ Type

        bool

        Usd Type

        SdfValueTypeNames->Bool
        """
    @staticmethod
    def GetMergeGroupNameAttr() -> Attribute: 
        """
        GetMergeGroupNameAttr() -> Attribute


        If non-empty, any collision groups in a stage with a matching
        mergeGroup should be considered to refer to the same collection.


        Matching collision groups should behave as if there were a single
        group containing referenced colliders and filter groups from both
        collections.

        Declaration

        ``string physics:mergeGroup``

        C++ Type

        std::string

        Usd Type

        SdfValueTypeNames->String
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class CollisionGroupTable(Boost.Python.instance):
    @staticmethod
    def GetGroups(*args, **kwargs) -> None: ...
    @staticmethod
    def IsCollisionEnabled(*args, **kwargs) -> None: ...
    __instance_size__ = 72
    pass
class DistanceJoint(Joint, pxr.UsdGeom.Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Predefined distance joint type (Distance between rigid bodies may be
    limited to given minimum or maximum distance.)
    """
    @staticmethod
    def CreateMaxDistanceAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateMaxDistanceAttr(defaultValue, writeSparsely) -> Attribute


        See GetMaxDistanceAttr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateMinDistanceAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateMinDistanceAttr(defaultValue, writeSparsely) -> Attribute


        See GetMinDistanceAttr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> DistanceJoint


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> DistanceJoint


        Return a UsdPhysicsDistanceJoint holding the prim adhering to this
        schema at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdPhysicsDistanceJoint(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetMaxDistanceAttr() -> Attribute: 
        """
        GetMaxDistanceAttr() -> Attribute


        Maximum distance.


        If attribute is negative, the joint is not limited. Units: distance.

        Declaration

        ``float physics:maxDistance = -1``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetMinDistanceAttr() -> Attribute: 
        """
        GetMinDistanceAttr() -> Attribute


        Minimum distance.


        If attribute is negative, the joint is not limited. Units: distance.

        Declaration

        ``float physics:minDistance = -1``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class DriveAPI(pxr.Usd.APISchemaBase, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    The PhysicsDriveAPI when applied to any joint primitive will drive the
    joint towards a given target. The PhysicsDriveAPI is a multipleApply
    schema: drive can be set per
    axis"transX","transY","transZ","rotX","rotY","rotZ"or its"linear"for
    prismatic joint or"angular"for revolute joints. Setting these as a
    multipleApply schema TfToken name will define the degree of freedom
    the DriveAPI is applied to. Each drive is an implicit force-limited
    damped spring: Force or acceleration = stiffness \* (targetPosition -
    position)

       - damping \* (targetVelocity - velocity)

    For any described attribute *Fallback* *Value* or *Allowed* *Values*
    below that are text/tokens, the actual token is published and defined
    in UsdPhysicsTokens. So to set an attribute to the value"rightHanded",
    use UsdPhysicsTokens->rightHanded as the value.
    """
    @staticmethod
    def Apply(*args, **kwargs) -> None: 
        """
        **classmethod** Apply(prim, name) -> DriveAPI


        Applies this **multiple-apply** API schema to the given ``prim`` along
        with the given instance name, ``name`` .


        This information is stored by adding"PhysicsDriveAPI:<i>name</i>"to
        the token-valued, listOp metadata *apiSchemas* on the prim. For
        example, if ``name`` is'instance1', the
        token'PhysicsDriveAPI:instance1'is added to'apiSchemas'.

        A valid UsdPhysicsDriveAPI object is returned upon success. An invalid
        (or empty) UsdPhysicsDriveAPI object is returned upon failure. See
        UsdPrim::ApplyAPI() for conditions resulting in failure.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim

        name : str
        """
    @staticmethod
    def CanApply(*args, **kwargs) -> None: 
        """
        **classmethod** CanApply(prim, name, whyNot) -> bool


        Returns true if this **multiple-apply** API schema can be applied,
        with the given instance name, ``name`` , to the given ``prim`` .


        If this schema can not be a applied the prim, this returns false and,
        if provided, populates ``whyNot`` with the reason it can not be
        applied.

        Note that if CanApply returns false, that does not necessarily imply
        that calling Apply will fail. Callers are expected to call CanApply
        before calling Apply if they want to ensure that it is valid to apply
        a schema.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim

        name : str

        whyNot : str
        """
    @staticmethod
    def CreateDampingAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateDampingAttr(defaultValue, writeSparsely) -> Attribute


        See GetDampingAttr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateMaxForceAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateMaxForceAttr(defaultValue, writeSparsely) -> Attribute


        See GetMaxForceAttr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateStiffnessAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateStiffnessAttr(defaultValue, writeSparsely) -> Attribute


        See GetStiffnessAttr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateTargetPositionAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateTargetPositionAttr(defaultValue, writeSparsely) -> Attribute


        See GetTargetPositionAttr() , and also Create vs Get Property Methods
        for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateTargetVelocityAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateTargetVelocityAttr(defaultValue, writeSparsely) -> Attribute


        See GetTargetVelocityAttr() , and also Create vs Get Property Methods
        for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateTypeAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateTypeAttr(defaultValue, writeSparsely) -> Attribute


        See GetTypeAttr() , and also Create vs Get Property Methods for when
        to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Get(prim, name) -> DriveAPI: 
        """
        **classmethod** Get(stage, path) -> DriveAPI


        Return a UsdPhysicsDriveAPI holding the prim adhering to this schema
        at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        ``path`` must be of the format<path>.drive:name.

        This is shorthand for the following:

        .. code-block:: text

          TfToken name = SdfPath::StripNamespace(path.GetToken());
          UsdPhysicsDriveAPI(
              stage->GetPrimAtPath(path.GetPrimPath()), name);



        Parameters
        ----------
        stage : Stage

        path : Path



        ----------------------------------------------------------------------


        Return a UsdPhysicsDriveAPI with name ``name`` holding the prim
        ``prim`` .


        Shorthand for UsdPhysicsDriveAPI(prim, name);


        Parameters
        ----------
        prim : Prim

        name : str
        """
    @staticmethod
    def GetAll(*args, **kwargs) -> None: 
        """
        **classmethod** GetAll(prim) -> list[DriveAPI]


        Return a vector of all named instances of UsdPhysicsDriveAPI on the
        given ``prim`` .


        Parameters
        ----------
        prim : Prim
        """
    @staticmethod
    def GetDampingAttr() -> Attribute: 
        """
        GetDampingAttr() -> Attribute


        Damping of the drive.


        Units: if linear drive: mass/second If angular drive:
        mass\*DIST_UNITS\*DIST_UNITS/second/second/degrees.

        Declaration

        ``float physics:damping = 0``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetMaxForceAttr() -> Attribute: 
        """
        GetMaxForceAttr() -> Attribute


        Maximum force that can be applied to drive.


        Units: if linear drive: mass\*DIST_UNITS/second/second if angular
        drive: mass\*DIST_UNITS\*DIST_UNITS/second/second inf means not
        limited. Must be non-negative.

        Declaration

        ``float physics:maxForce = inf``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetSchemaAttributeNames(includeInherited, instanceName) -> list[TfToken]: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool



        ----------------------------------------------------------------------


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes for a given instance name.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved. The names returned will have the
        proper namespace prefix.


        Parameters
        ----------
        includeInherited : bool

        instanceName : str
        """
    @staticmethod
    def GetStiffnessAttr() -> Attribute: 
        """
        GetStiffnessAttr() -> Attribute


        Stiffness of the drive.


        Units: if linear drive: mass/second/second if angular drive:
        mass\*DIST_UNITS\*DIST_UNITS/degree/second/second.

        Declaration

        ``float physics:stiffness = 0``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetTargetPositionAttr() -> Attribute: 
        """
        GetTargetPositionAttr() -> Attribute


        Target value for position.


        Units: if linear drive: distance if angular drive: degrees.

        Declaration

        ``float physics:targetPosition = 0``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetTargetVelocityAttr() -> Attribute: 
        """
        GetTargetVelocityAttr() -> Attribute


        Target value for velocity.


        Units: if linear drive: distance/second if angular drive:
        degrees/second.

        Declaration

        ``float physics:targetVelocity = 0``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetTypeAttr() -> Attribute: 
        """
        GetTypeAttr() -> Attribute


        Drive spring is for the acceleration at the joint (rather than the
        force).



        Declaration

        ``uniform token physics:type ="force"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        force, acceleration
        """
    @staticmethod
    def IsPhysicsDriveAPIPath(*args, **kwargs) -> None: 
        """
        **classmethod** IsPhysicsDriveAPIPath(path, name) -> bool


        Checks if the given path ``path`` is of an API schema of type
        PhysicsDriveAPI.


        If so, it stores the instance name of the schema in ``name`` and
        returns true. Otherwise, it returns false.


        Parameters
        ----------
        path : Path

        name : str
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 48
    pass
class FilteredPairsAPI(pxr.Usd.APISchemaBase, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    API to describe fine-grained filtering. If a collision between two
    objects occurs, this pair might be filtered if the pair is defined
    through this API. This API can be applied either to a body or
    collision or even articulation. The"filteredPairs"defines what objects
    it should not collide against. Note that FilteredPairsAPI filtering
    has precedence over CollisionGroup filtering.
    """
    @staticmethod
    def Apply(*args, **kwargs) -> None: 
        """
        **classmethod** Apply(prim) -> FilteredPairsAPI


        Applies this **single-apply** API schema to the given ``prim`` .


        This information is stored by adding"PhysicsFilteredPairsAPI"to the
        token-valued, listOp metadata *apiSchemas* on the prim.

        A valid UsdPhysicsFilteredPairsAPI object is returned upon success. An
        invalid (or empty) UsdPhysicsFilteredPairsAPI object is returned upon
        failure. See UsdPrim::ApplyAPI() for conditions resulting in failure.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim
        """
    @staticmethod
    def CanApply(*args, **kwargs) -> None: 
        """
        **classmethod** CanApply(prim, whyNot) -> bool


        Returns true if this **single-apply** API schema can be applied to the
        given ``prim`` .


        If this schema can not be a applied to the prim, this returns false
        and, if provided, populates ``whyNot`` with the reason it can not be
        applied.

        Note that if CanApply returns false, that does not necessarily imply
        that calling Apply will fail. Callers are expected to call CanApply
        before calling Apply if they want to ensure that it is valid to apply
        a schema.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim

        whyNot : str
        """
    @staticmethod
    def CreateFilteredPairsRel() -> Relationship: 
        """
        CreateFilteredPairsRel() -> Relationship


        See GetFilteredPairsRel() , and also Create vs Get Property Methods
        for when to use Get vs Create.
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> FilteredPairsAPI


        Return a UsdPhysicsFilteredPairsAPI holding the prim adhering to this
        schema at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdPhysicsFilteredPairsAPI(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetFilteredPairsRel() -> Relationship: 
        """
        GetFilteredPairsRel() -> Relationship


        Relationship to objects that should be filtered.
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 48
    pass
class FixedJoint(Joint, pxr.UsdGeom.Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Predefined fixed joint type (All degrees of freedom are removed.)
    """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> FixedJoint


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> FixedJoint


        Return a UsdPhysicsFixedJoint holding the prim adhering to this schema
        at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdPhysicsFixedJoint(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class Joint(pxr.UsdGeom.Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    A joint constrains the movement of rigid bodies. Joint can be created
    between two rigid bodies or between one rigid body and world. By
    default joint primitive defines a D6 joint where all degrees of
    freedom are free. Three linear and three angular degrees of freedom.
    Note that default behavior is to disable collision between jointed
    bodies.
    """
    @staticmethod
    def CreateBody0Rel() -> Relationship: 
        """
        CreateBody0Rel() -> Relationship


        See GetBody0Rel() , and also Create vs Get Property Methods for when
        to use Get vs Create.
        """
    @staticmethod
    def CreateBody1Rel() -> Relationship: 
        """
        CreateBody1Rel() -> Relationship


        See GetBody1Rel() , and also Create vs Get Property Methods for when
        to use Get vs Create.
        """
    @staticmethod
    def CreateBreakForceAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateBreakForceAttr(defaultValue, writeSparsely) -> Attribute


        See GetBreakForceAttr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateBreakTorqueAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateBreakTorqueAttr(defaultValue, writeSparsely) -> Attribute


        See GetBreakTorqueAttr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateCollisionEnabledAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateCollisionEnabledAttr(defaultValue, writeSparsely) -> Attribute


        See GetCollisionEnabledAttr() , and also Create vs Get Property
        Methods for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateExcludeFromArticulationAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateExcludeFromArticulationAttr(defaultValue, writeSparsely) -> Attribute


        See GetExcludeFromArticulationAttr() , and also Create vs Get Property
        Methods for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateJointEnabledAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateJointEnabledAttr(defaultValue, writeSparsely) -> Attribute


        See GetJointEnabledAttr() , and also Create vs Get Property Methods
        for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateLocalPos0Attr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateLocalPos0Attr(defaultValue, writeSparsely) -> Attribute


        See GetLocalPos0Attr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateLocalPos1Attr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateLocalPos1Attr(defaultValue, writeSparsely) -> Attribute


        See GetLocalPos1Attr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateLocalRot0Attr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateLocalRot0Attr(defaultValue, writeSparsely) -> Attribute


        See GetLocalRot0Attr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateLocalRot1Attr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateLocalRot1Attr(defaultValue, writeSparsely) -> Attribute


        See GetLocalRot1Attr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> Joint


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Joint


        Return a UsdPhysicsJoint holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdPhysicsJoint(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetBody0Rel() -> Relationship: 
        """
        GetBody0Rel() -> Relationship


        Relationship to any UsdGeomXformable.
        """
    @staticmethod
    def GetBody1Rel() -> Relationship: 
        """
        GetBody1Rel() -> Relationship


        Relationship to any UsdGeomXformable.
        """
    @staticmethod
    def GetBreakForceAttr() -> Attribute: 
        """
        GetBreakForceAttr() -> Attribute


        Joint break force.


        If set, joint is to break when this force limit is reached. (Used for
        linear DOFs.) Units: mass \* distance / second / second

        Declaration

        ``float physics:breakForce = inf``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetBreakTorqueAttr() -> Attribute: 
        """
        GetBreakTorqueAttr() -> Attribute


        Joint break torque.


        If set, joint is to break when this torque limit is reached. (Used for
        angular DOFs.) Units: mass \* distance \* distance / second / second

        Declaration

        ``float physics:breakTorque = inf``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetCollisionEnabledAttr() -> Attribute: 
        """
        GetCollisionEnabledAttr() -> Attribute


        Determines if the jointed subtrees should collide or not.



        Declaration

        ``bool physics:collisionEnabled = 0``

        C++ Type

        bool

        Usd Type

        SdfValueTypeNames->Bool
        """
    @staticmethod
    def GetExcludeFromArticulationAttr() -> Attribute: 
        """
        GetExcludeFromArticulationAttr() -> Attribute


        Determines if the joint can be included in an Articulation.



        Declaration

        ``uniform bool physics:excludeFromArticulation = 0``

        C++ Type

        bool

        Usd Type

        SdfValueTypeNames->Bool

        Variability

        SdfVariabilityUniform
        """
    @staticmethod
    def GetJointEnabledAttr() -> Attribute: 
        """
        GetJointEnabledAttr() -> Attribute


        Determines if the joint is enabled.



        Declaration

        ``bool physics:jointEnabled = 1``

        C++ Type

        bool

        Usd Type

        SdfValueTypeNames->Bool
        """
    @staticmethod
    def GetLocalPos0Attr() -> Attribute: 
        """
        GetLocalPos0Attr() -> Attribute


        Relative position of the joint frame to body0's frame.



        Declaration

        ``point3f physics:localPos0 = (0, 0, 0)``

        C++ Type

        GfVec3f

        Usd Type

        SdfValueTypeNames->Point3f
        """
    @staticmethod
    def GetLocalPos1Attr() -> Attribute: 
        """
        GetLocalPos1Attr() -> Attribute


        Relative position of the joint frame to body1's frame.



        Declaration

        ``point3f physics:localPos1 = (0, 0, 0)``

        C++ Type

        GfVec3f

        Usd Type

        SdfValueTypeNames->Point3f
        """
    @staticmethod
    def GetLocalRot0Attr() -> Attribute: 
        """
        GetLocalRot0Attr() -> Attribute


        Relative orientation of the joint frame to body0's frame.



        Declaration

        ``quatf physics:localRot0 = (1, 0, 0, 0)``

        C++ Type

        GfQuatf

        Usd Type

        SdfValueTypeNames->Quatf
        """
    @staticmethod
    def GetLocalRot1Attr() -> Attribute: 
        """
        GetLocalRot1Attr() -> Attribute


        Relative orientation of the joint frame to body1's frame.



        Declaration

        ``quatf physics:localRot1 = (1, 0, 0, 0)``

        C++ Type

        GfQuatf

        Usd Type

        SdfValueTypeNames->Quatf
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class LimitAPI(pxr.Usd.APISchemaBase, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    The PhysicsLimitAPI can be applied to a PhysicsJoint and will restrict
    the movement along an axis. PhysicsLimitAPI is a multipleApply schema:
    The PhysicsJoint can be restricted
    along"transX","transY","transZ","rotX","rotY","rotZ","distance".
    Setting these as a multipleApply schema TfToken name will define the
    degree of freedom the PhysicsLimitAPI is applied to. Note that if the
    low limit is higher than the high limit, motion along this axis is
    considered locked.
    """
    @staticmethod
    def Apply(*args, **kwargs) -> None: 
        """
        **classmethod** Apply(prim, name) -> LimitAPI


        Applies this **multiple-apply** API schema to the given ``prim`` along
        with the given instance name, ``name`` .


        This information is stored by adding"PhysicsLimitAPI:<i>name</i>"to
        the token-valued, listOp metadata *apiSchemas* on the prim. For
        example, if ``name`` is'instance1', the
        token'PhysicsLimitAPI:instance1'is added to'apiSchemas'.

        A valid UsdPhysicsLimitAPI object is returned upon success. An invalid
        (or empty) UsdPhysicsLimitAPI object is returned upon failure. See
        UsdPrim::ApplyAPI() for conditions resulting in failure.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim

        name : str
        """
    @staticmethod
    def CanApply(*args, **kwargs) -> None: 
        """
        **classmethod** CanApply(prim, name, whyNot) -> bool


        Returns true if this **multiple-apply** API schema can be applied,
        with the given instance name, ``name`` , to the given ``prim`` .


        If this schema can not be a applied the prim, this returns false and,
        if provided, populates ``whyNot`` with the reason it can not be
        applied.

        Note that if CanApply returns false, that does not necessarily imply
        that calling Apply will fail. Callers are expected to call CanApply
        before calling Apply if they want to ensure that it is valid to apply
        a schema.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim

        name : str

        whyNot : str
        """
    @staticmethod
    def CreateHighAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateHighAttr(defaultValue, writeSparsely) -> Attribute


        See GetHighAttr() , and also Create vs Get Property Methods for when
        to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateLowAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateLowAttr(defaultValue, writeSparsely) -> Attribute


        See GetLowAttr() , and also Create vs Get Property Methods for when to
        use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Get(prim, name) -> LimitAPI: 
        """
        **classmethod** Get(stage, path) -> LimitAPI


        Return a UsdPhysicsLimitAPI holding the prim adhering to this schema
        at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        ``path`` must be of the format<path>.limit:name.

        This is shorthand for the following:

        .. code-block:: text

          TfToken name = SdfPath::StripNamespace(path.GetToken());
          UsdPhysicsLimitAPI(
              stage->GetPrimAtPath(path.GetPrimPath()), name);



        Parameters
        ----------
        stage : Stage

        path : Path



        ----------------------------------------------------------------------


        Return a UsdPhysicsLimitAPI with name ``name`` holding the prim
        ``prim`` .


        Shorthand for UsdPhysicsLimitAPI(prim, name);


        Parameters
        ----------
        prim : Prim

        name : str
        """
    @staticmethod
    def GetAll(*args, **kwargs) -> None: 
        """
        **classmethod** GetAll(prim) -> list[LimitAPI]


        Return a vector of all named instances of UsdPhysicsLimitAPI on the
        given ``prim`` .


        Parameters
        ----------
        prim : Prim
        """
    @staticmethod
    def GetHighAttr() -> Attribute: 
        """
        GetHighAttr() -> Attribute


        Upper limit.


        Units: degrees or distance depending on trans or rot axis applied to.
        inf means not limited in positive direction.

        Declaration

        ``float physics:high = inf``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetLowAttr() -> Attribute: 
        """
        GetLowAttr() -> Attribute


        Lower limit.


        Units: degrees or distance depending on trans or rot axis applied to.
        \-inf means not limited in negative direction.

        Declaration

        ``float physics:low = -inf``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetSchemaAttributeNames(includeInherited, instanceName) -> list[TfToken]: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool



        ----------------------------------------------------------------------


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes for a given instance name.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved. The names returned will have the
        proper namespace prefix.


        Parameters
        ----------
        includeInherited : bool

        instanceName : str
        """
    @staticmethod
    def IsPhysicsLimitAPIPath(*args, **kwargs) -> None: 
        """
        **classmethod** IsPhysicsLimitAPIPath(path, name) -> bool


        Checks if the given path ``path`` is of an API schema of type
        PhysicsLimitAPI.


        If so, it stores the instance name of the schema in ``name`` and
        returns true. Otherwise, it returns false.


        Parameters
        ----------
        path : Path

        name : str
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 48
    pass
class MassAPI(pxr.Usd.APISchemaBase, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Defines explicit mass properties (mass, density, inertia etc.).
    MassAPI can be applied to any object that has a PhysicsCollisionAPI or
    a PhysicsRigidBodyAPI.
    """
    @staticmethod
    def Apply(*args, **kwargs) -> None: 
        """
        **classmethod** Apply(prim) -> MassAPI


        Applies this **single-apply** API schema to the given ``prim`` .


        This information is stored by adding"PhysicsMassAPI"to the token-
        valued, listOp metadata *apiSchemas* on the prim.

        A valid UsdPhysicsMassAPI object is returned upon success. An invalid
        (or empty) UsdPhysicsMassAPI object is returned upon failure. See
        UsdPrim::ApplyAPI() for conditions resulting in failure.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim
        """
    @staticmethod
    def CanApply(*args, **kwargs) -> None: 
        """
        **classmethod** CanApply(prim, whyNot) -> bool


        Returns true if this **single-apply** API schema can be applied to the
        given ``prim`` .


        If this schema can not be a applied to the prim, this returns false
        and, if provided, populates ``whyNot`` with the reason it can not be
        applied.

        Note that if CanApply returns false, that does not necessarily imply
        that calling Apply will fail. Callers are expected to call CanApply
        before calling Apply if they want to ensure that it is valid to apply
        a schema.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim

        whyNot : str
        """
    @staticmethod
    def CreateCenterOfMassAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateCenterOfMassAttr(defaultValue, writeSparsely) -> Attribute


        See GetCenterOfMassAttr() , and also Create vs Get Property Methods
        for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateDensityAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateDensityAttr(defaultValue, writeSparsely) -> Attribute


        See GetDensityAttr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateDiagonalInertiaAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateDiagonalInertiaAttr(defaultValue, writeSparsely) -> Attribute


        See GetDiagonalInertiaAttr() , and also Create vs Get Property Methods
        for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateMassAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateMassAttr(defaultValue, writeSparsely) -> Attribute


        See GetMassAttr() , and also Create vs Get Property Methods for when
        to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreatePrincipalAxesAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreatePrincipalAxesAttr(defaultValue, writeSparsely) -> Attribute


        See GetPrincipalAxesAttr() , and also Create vs Get Property Methods
        for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> MassAPI


        Return a UsdPhysicsMassAPI holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdPhysicsMassAPI(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetCenterOfMassAttr() -> Attribute: 
        """
        GetCenterOfMassAttr() -> Attribute


        Center of mass in the prim's local space.


        Units: distance.

        Declaration

        ``point3f physics:centerOfMass = (-inf, -inf, -inf)``

        C++ Type

        GfVec3f

        Usd Type

        SdfValueTypeNames->Point3f
        """
    @staticmethod
    def GetDensityAttr() -> Attribute: 
        """
        GetDensityAttr() -> Attribute


        If non-zero, specifies the density of the object.


        In the context of rigid body physics, density indirectly results in
        setting mass via (mass = density x volume of the object). How the
        volume is computed is up to implementation of the physics system. It
        is generally computed from the collision approximation rather than the
        graphical mesh. In the case where both density and mass are specified
        for the same object, mass has precedence over density. Unlike mass,
        child's prim's density overrides parent prim's density as it is
        accumulative. Note that density of a collisionAPI can be also
        alternatively set through a PhysicsMaterialAPI. The material density
        has the weakest precedence in density definition. Note if density is
        0.0 it is ignored. Units: mass/distance/distance/distance.

        Declaration

        ``float physics:density = 0``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetDiagonalInertiaAttr() -> Attribute: 
        """
        GetDiagonalInertiaAttr() -> Attribute


        If non-zero, specifies diagonalized inertia tensor along the principal
        axes.


        Note if diagonalInertial is (0.0, 0.0, 0.0) it is ignored. Units:
        mass\*distance\*distance.

        Declaration

        ``float3 physics:diagonalInertia = (0, 0, 0)``

        C++ Type

        GfVec3f

        Usd Type

        SdfValueTypeNames->Float3
        """
    @staticmethod
    def GetMassAttr() -> Attribute: 
        """
        GetMassAttr() -> Attribute


        If non-zero, directly specifies the mass of the object.


        Note that any child prim can also have a mass when they apply massAPI.
        In this case, the precedence rule is'parent mass overrides the
        child's'. This may come as counter-intuitive, but mass is a computed
        quantity and in general not accumulative. For example, if a parent has
        mass of 10, and one of two children has mass of 20, allowing child's
        mass to override its parent results in a mass of -10 for the other
        child. Note if mass is 0.0 it is ignored. Units: mass.

        Declaration

        ``float physics:mass = 0``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetPrincipalAxesAttr() -> Attribute: 
        """
        GetPrincipalAxesAttr() -> Attribute


        Orientation of the inertia tensor's principal axes in the prim's local
        space.



        Declaration

        ``quatf physics:principalAxes = (0, 0, 0, 0)``

        C++ Type

        GfQuatf

        Usd Type

        SdfValueTypeNames->Quatf
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 48
    pass
class MassUnits(Boost.Python.instance):
    """
    Container class for static double-precision symbols representing
    common mass units of measure expressed in kilograms.
    """
    grams = 0.001
    kilograms = 1.0
    slugs = 14.5939
    pass
class MaterialAPI(pxr.Usd.APISchemaBase, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Adds simulation material properties to a Material. All collisions that
    have a relationship to this material will have their collision
    response defined through this material.
    """
    @staticmethod
    def Apply(*args, **kwargs) -> None: 
        """
        **classmethod** Apply(prim) -> MaterialAPI


        Applies this **single-apply** API schema to the given ``prim`` .


        This information is stored by adding"PhysicsMaterialAPI"to the token-
        valued, listOp metadata *apiSchemas* on the prim.

        A valid UsdPhysicsMaterialAPI object is returned upon success. An
        invalid (or empty) UsdPhysicsMaterialAPI object is returned upon
        failure. See UsdPrim::ApplyAPI() for conditions resulting in failure.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim
        """
    @staticmethod
    def CanApply(*args, **kwargs) -> None: 
        """
        **classmethod** CanApply(prim, whyNot) -> bool


        Returns true if this **single-apply** API schema can be applied to the
        given ``prim`` .


        If this schema can not be a applied to the prim, this returns false
        and, if provided, populates ``whyNot`` with the reason it can not be
        applied.

        Note that if CanApply returns false, that does not necessarily imply
        that calling Apply will fail. Callers are expected to call CanApply
        before calling Apply if they want to ensure that it is valid to apply
        a schema.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim

        whyNot : str
        """
    @staticmethod
    def CreateDensityAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateDensityAttr(defaultValue, writeSparsely) -> Attribute


        See GetDensityAttr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateDynamicFrictionAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateDynamicFrictionAttr(defaultValue, writeSparsely) -> Attribute


        See GetDynamicFrictionAttr() , and also Create vs Get Property Methods
        for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateRestitutionAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateRestitutionAttr(defaultValue, writeSparsely) -> Attribute


        See GetRestitutionAttr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateStaticFrictionAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateStaticFrictionAttr(defaultValue, writeSparsely) -> Attribute


        See GetStaticFrictionAttr() , and also Create vs Get Property Methods
        for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> MaterialAPI


        Return a UsdPhysicsMaterialAPI holding the prim adhering to this
        schema at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdPhysicsMaterialAPI(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetDensityAttr() -> Attribute: 
        """
        GetDensityAttr() -> Attribute


        If non-zero, defines the density of the material.


        This can be used for body mass computation, see PhysicsMassAPI. Note
        that if the density is 0.0 it is ignored. Units:
        mass/distance/distance/distance.

        Declaration

        ``float physics:density = 0``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetDynamicFrictionAttr() -> Attribute: 
        """
        GetDynamicFrictionAttr() -> Attribute


        Dynamic friction coefficient.


        Unitless.

        Declaration

        ``float physics:dynamicFriction = 0``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetRestitutionAttr() -> Attribute: 
        """
        GetRestitutionAttr() -> Attribute


        Restitution coefficient.


        Unitless.

        Declaration

        ``float physics:restitution = 0``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetStaticFrictionAttr() -> Attribute: 
        """
        GetStaticFrictionAttr() -> Attribute


        Static friction coefficient.


        Unitless.

        Declaration

        ``float physics:staticFriction = 0``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 48
    pass
class MeshCollisionAPI(pxr.Usd.APISchemaBase, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Attributes to control how a Mesh is made into a collider. Can be
    applied to only a USDGeomMesh in addition to its PhysicsCollisionAPI.

    For any described attribute *Fallback* *Value* or *Allowed* *Values*
    below that are text/tokens, the actual token is published and defined
    in UsdPhysicsTokens. So to set an attribute to the value"rightHanded",
    use UsdPhysicsTokens->rightHanded as the value.
    """
    @staticmethod
    def Apply(*args, **kwargs) -> None: 
        """
        **classmethod** Apply(prim) -> MeshCollisionAPI


        Applies this **single-apply** API schema to the given ``prim`` .


        This information is stored by adding"PhysicsMeshCollisionAPI"to the
        token-valued, listOp metadata *apiSchemas* on the prim.

        A valid UsdPhysicsMeshCollisionAPI object is returned upon success. An
        invalid (or empty) UsdPhysicsMeshCollisionAPI object is returned upon
        failure. See UsdPrim::ApplyAPI() for conditions resulting in failure.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim
        """
    @staticmethod
    def CanApply(*args, **kwargs) -> None: 
        """
        **classmethod** CanApply(prim, whyNot) -> bool


        Returns true if this **single-apply** API schema can be applied to the
        given ``prim`` .


        If this schema can not be a applied to the prim, this returns false
        and, if provided, populates ``whyNot`` with the reason it can not be
        applied.

        Note that if CanApply returns false, that does not necessarily imply
        that calling Apply will fail. Callers are expected to call CanApply
        before calling Apply if they want to ensure that it is valid to apply
        a schema.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim

        whyNot : str
        """
    @staticmethod
    def CreateApproximationAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateApproximationAttr(defaultValue, writeSparsely) -> Attribute


        See GetApproximationAttr() , and also Create vs Get Property Methods
        for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> MeshCollisionAPI


        Return a UsdPhysicsMeshCollisionAPI holding the prim adhering to this
        schema at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdPhysicsMeshCollisionAPI(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetApproximationAttr() -> Attribute: 
        """
        GetApproximationAttr() -> Attribute


        Determines the mesh's collision approximation:"none"- The mesh
        geometry is used directly as a collider without any approximation.


        "convexDecomposition"- A convex mesh decomposition is performed. This
        results in a set of convex mesh colliders."convexHull"- A convex hull
        of the mesh is generated and used as the collider."boundingSphere"- A
        bounding sphere is computed around the mesh and used as a
        collider."boundingCube"- An optimally fitting box collider is computed
        around the mesh."meshSimplification"- A mesh simplification step is
        performed, resulting in a simplified triangle mesh collider.

        Declaration

        ``uniform token physics:approximation ="none"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        none, convexDecomposition, convexHull, boundingSphere, boundingCube,
        meshSimplification
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 48
    pass
class PrismaticJoint(Joint, pxr.UsdGeom.Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Predefined prismatic joint type (translation along prismatic joint
    axis is permitted.)

    For any described attribute *Fallback* *Value* or *Allowed* *Values*
    below that are text/tokens, the actual token is published and defined
    in UsdPhysicsTokens. So to set an attribute to the value"rightHanded",
    use UsdPhysicsTokens->rightHanded as the value.
    """
    @staticmethod
    def CreateAxisAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateAxisAttr(defaultValue, writeSparsely) -> Attribute


        See GetAxisAttr() , and also Create vs Get Property Methods for when
        to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateLowerLimitAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateLowerLimitAttr(defaultValue, writeSparsely) -> Attribute


        See GetLowerLimitAttr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateUpperLimitAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateUpperLimitAttr(defaultValue, writeSparsely) -> Attribute


        See GetUpperLimitAttr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> PrismaticJoint


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> PrismaticJoint


        Return a UsdPhysicsPrismaticJoint holding the prim adhering to this
        schema at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdPhysicsPrismaticJoint(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetAxisAttr() -> Attribute: 
        """
        GetAxisAttr() -> Attribute


        Joint axis.



        Declaration

        ``uniform token physics:axis ="X"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        X, Y, Z
        """
    @staticmethod
    def GetLowerLimitAttr() -> Attribute: 
        """
        GetLowerLimitAttr() -> Attribute


        Lower limit.


        Units: distance. -inf means not limited in negative direction.

        Declaration

        ``float physics:lowerLimit = -inf``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetUpperLimitAttr() -> Attribute: 
        """
        GetUpperLimitAttr() -> Attribute


        Upper limit.


        Units: distance. inf means not limited in positive direction.

        Declaration

        ``float physics:upperLimit = inf``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class RevoluteJoint(Joint, pxr.UsdGeom.Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Predefined revolute joint type (rotation along revolute joint axis is
    permitted.)

    For any described attribute *Fallback* *Value* or *Allowed* *Values*
    below that are text/tokens, the actual token is published and defined
    in UsdPhysicsTokens. So to set an attribute to the value"rightHanded",
    use UsdPhysicsTokens->rightHanded as the value.
    """
    @staticmethod
    def CreateAxisAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateAxisAttr(defaultValue, writeSparsely) -> Attribute


        See GetAxisAttr() , and also Create vs Get Property Methods for when
        to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateLowerLimitAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateLowerLimitAttr(defaultValue, writeSparsely) -> Attribute


        See GetLowerLimitAttr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateUpperLimitAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateUpperLimitAttr(defaultValue, writeSparsely) -> Attribute


        See GetUpperLimitAttr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> RevoluteJoint


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> RevoluteJoint


        Return a UsdPhysicsRevoluteJoint holding the prim adhering to this
        schema at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdPhysicsRevoluteJoint(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetAxisAttr() -> Attribute: 
        """
        GetAxisAttr() -> Attribute


        Joint axis.



        Declaration

        ``uniform token physics:axis ="X"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        X, Y, Z
        """
    @staticmethod
    def GetLowerLimitAttr() -> Attribute: 
        """
        GetLowerLimitAttr() -> Attribute


        Lower limit.


        Units: degrees. -inf means not limited in negative direction.

        Declaration

        ``float physics:lowerLimit = -inf``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetUpperLimitAttr() -> Attribute: 
        """
        GetUpperLimitAttr() -> Attribute


        Upper limit.


        Units: degrees. inf means not limited in positive direction.

        Declaration

        ``float physics:upperLimit = inf``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class RigidBodyAPI(pxr.Usd.APISchemaBase, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Applies physics body attributes to any UsdGeomXformable prim and marks
    that prim to be driven by a simulation. If a simulation is running it
    will update this prim's pose. All prims in the hierarchy below this
    prim should move accordingly.
    """
    class MassInformation(Boost.Python.instance):
        @property
        def centerOfMass(self) -> None:
            """
            :type: None
            """
        @property
        def inertia(self) -> None:
            """
            :type: None
            """
        @property
        def localPos(self) -> None:
            """
            :type: None
            """
        @property
        def localRot(self) -> None:
            """
            :type: None
            """
        @property
        def volume(self) -> None:
            """
            :type: None
            """
        __instance_size__ = 96
        pass
    @staticmethod
    def Apply(*args, **kwargs) -> None: 
        """
        **classmethod** Apply(prim) -> RigidBodyAPI


        Applies this **single-apply** API schema to the given ``prim`` .


        This information is stored by adding"PhysicsRigidBodyAPI"to the token-
        valued, listOp metadata *apiSchemas* on the prim.

        A valid UsdPhysicsRigidBodyAPI object is returned upon success. An
        invalid (or empty) UsdPhysicsRigidBodyAPI object is returned upon
        failure. See UsdPrim::ApplyAPI() for conditions resulting in failure.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim
        """
    @staticmethod
    def CanApply(*args, **kwargs) -> None: 
        """
        **classmethod** CanApply(prim, whyNot) -> bool


        Returns true if this **single-apply** API schema can be applied to the
        given ``prim`` .


        If this schema can not be a applied to the prim, this returns false
        and, if provided, populates ``whyNot`` with the reason it can not be
        applied.

        Note that if CanApply returns false, that does not necessarily imply
        that calling Apply will fail. Callers are expected to call CanApply
        before calling Apply if they want to ensure that it is valid to apply
        a schema.

        UsdPrim::GetAppliedSchemas()

        UsdPrim::HasAPI()

        UsdPrim::CanApplyAPI()

        UsdPrim::ApplyAPI()

        UsdPrim::RemoveAPI()


        Parameters
        ----------
        prim : Prim

        whyNot : str
        """
    @staticmethod
    def ComputeMassProperties(diagonalInertia, com, principalAxes, massInfoFn) -> float: 
        """
        ComputeMassProperties(diagonalInertia, com, principalAxes, massInfoFn) -> float


        Compute mass properties of the rigid body ``diagonalInertia`` Computed
        diagonal of the inertial tensor for the rigid body.


        ``com`` Computed center of mass for the rigid body. ``principalAxes``
        Inertia tensor's principal axes orienttion for the rigid body.
        ``massInfoFn`` Callback function to get collision mass information.

        Computed mass of the rigid body


        Parameters
        ----------
        diagonalInertia : Vec3f

        com : Vec3f

        principalAxes : Quatf

        massInfoFn : MassInformationFn
        """
    @staticmethod
    def CreateAngularVelocityAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateAngularVelocityAttr(defaultValue, writeSparsely) -> Attribute


        See GetAngularVelocityAttr() , and also Create vs Get Property Methods
        for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateKinematicEnabledAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateKinematicEnabledAttr(defaultValue, writeSparsely) -> Attribute


        See GetKinematicEnabledAttr() , and also Create vs Get Property
        Methods for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateRigidBodyEnabledAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateRigidBodyEnabledAttr(defaultValue, writeSparsely) -> Attribute


        See GetRigidBodyEnabledAttr() , and also Create vs Get Property
        Methods for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateSimulationOwnerRel() -> Relationship: 
        """
        CreateSimulationOwnerRel() -> Relationship


        See GetSimulationOwnerRel() , and also Create vs Get Property Methods
        for when to use Get vs Create.
        """
    @staticmethod
    def CreateStartsAsleepAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateStartsAsleepAttr(defaultValue, writeSparsely) -> Attribute


        See GetStartsAsleepAttr() , and also Create vs Get Property Methods
        for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateVelocityAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateVelocityAttr(defaultValue, writeSparsely) -> Attribute


        See GetVelocityAttr() , and also Create vs Get Property Methods for
        when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> RigidBodyAPI


        Return a UsdPhysicsRigidBodyAPI holding the prim adhering to this
        schema at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdPhysicsRigidBodyAPI(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetAngularVelocityAttr() -> Attribute: 
        """
        GetAngularVelocityAttr() -> Attribute


        Angular velocity in the same space as the node's xform.


        Units: degrees/second.

        Declaration

        ``vector3f physics:angularVelocity = (0, 0, 0)``

        C++ Type

        GfVec3f

        Usd Type

        SdfValueTypeNames->Vector3f
        """
    @staticmethod
    def GetKinematicEnabledAttr() -> Attribute: 
        """
        GetKinematicEnabledAttr() -> Attribute


        Determines whether the body is kinematic or not.


        A kinematic body is a body that is moved through animated poses or
        through user defined poses. The simulation derives velocities for the
        kinematic body based on the external motion. When a continuous motion
        is not desired, this kinematic flag should be set to false.

        Declaration

        ``bool physics:kinematicEnabled = 0``

        C++ Type

        bool

        Usd Type

        SdfValueTypeNames->Bool
        """
    @staticmethod
    def GetRigidBodyEnabledAttr() -> Attribute: 
        """
        GetRigidBodyEnabledAttr() -> Attribute


        Determines if this PhysicsRigidBodyAPI is enabled.



        Declaration

        ``bool physics:rigidBodyEnabled = 1``

        C++ Type

        bool

        Usd Type

        SdfValueTypeNames->Bool
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def GetSimulationOwnerRel() -> Relationship: 
        """
        GetSimulationOwnerRel() -> Relationship


        Single PhysicsScene that will simulate this body.


        By default this is the first PhysicsScene found in the stage using
        UsdStage::Traverse() .
        """
    @staticmethod
    def GetStartsAsleepAttr() -> Attribute: 
        """
        GetStartsAsleepAttr() -> Attribute


        Determines if the body is asleep when the simulation starts.



        Declaration

        ``uniform bool physics:startsAsleep = 0``

        C++ Type

        bool

        Usd Type

        SdfValueTypeNames->Bool

        Variability

        SdfVariabilityUniform
        """
    @staticmethod
    def GetVelocityAttr() -> Attribute: 
        """
        GetVelocityAttr() -> Attribute


        Linear velocity in the same space as the node's xform.


        Units: distance/second.

        Declaration

        ``vector3f physics:velocity = (0, 0, 0)``

        C++ Type

        GfVec3f

        Usd Type

        SdfValueTypeNames->Vector3f
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 48
    pass
class Scene(pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    General physics simulation properties, required for simulation.
    """
    @staticmethod
    def CreateGravityDirectionAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateGravityDirectionAttr(defaultValue, writeSparsely) -> Attribute


        See GetGravityDirectionAttr() , and also Create vs Get Property
        Methods for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateGravityMagnitudeAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateGravityMagnitudeAttr(defaultValue, writeSparsely) -> Attribute


        See GetGravityMagnitudeAttr() , and also Create vs Get Property
        Methods for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> Scene


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> Scene


        Return a UsdPhysicsScene holding the prim adhering to this schema at
        ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdPhysicsScene(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetGravityDirectionAttr() -> Attribute: 
        """
        GetGravityDirectionAttr() -> Attribute


        Gravity direction vector in simulation world space.


        Will be normalized before use. A zero vector is a request to use the
        negative upAxis. Unitless.

        Declaration

        ``vector3f physics:gravityDirection = (0, 0, 0)``

        C++ Type

        GfVec3f

        Usd Type

        SdfValueTypeNames->Vector3f
        """
    @staticmethod
    def GetGravityMagnitudeAttr() -> Attribute: 
        """
        GetGravityMagnitudeAttr() -> Attribute


        Gravity acceleration magnitude in simulation world space.


        A negative value is a request to use a value equivalent to earth
        gravity regardless of the metersPerUnit scaling used by this scene.
        Units: distance/second/second.

        Declaration

        ``float physics:gravityMagnitude = -inf``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class SphericalJoint(Joint, pxr.UsdGeom.Imageable, pxr.Usd.Typed, pxr.Usd.SchemaBase, Boost.Python.instance):
    """
    Predefined spherical joint type (Removes linear degrees of freedom,
    cone limit may restrict the motion in a given range.) It allows two
    limit values, which when equal create a circular, else an elliptic
    cone limit around the limit axis.

    For any described attribute *Fallback* *Value* or *Allowed* *Values*
    below that are text/tokens, the actual token is published and defined
    in UsdPhysicsTokens. So to set an attribute to the value"rightHanded",
    use UsdPhysicsTokens->rightHanded as the value.
    """
    @staticmethod
    def CreateAxisAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateAxisAttr(defaultValue, writeSparsely) -> Attribute


        See GetAxisAttr() , and also Create vs Get Property Methods for when
        to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateConeAngle0LimitAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateConeAngle0LimitAttr(defaultValue, writeSparsely) -> Attribute


        See GetConeAngle0LimitAttr() , and also Create vs Get Property Methods
        for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def CreateConeAngle1LimitAttr(defaultValue, writeSparsely) -> Attribute: 
        """
        CreateConeAngle1LimitAttr(defaultValue, writeSparsely) -> Attribute


        See GetConeAngle1LimitAttr() , and also Create vs Get Property Methods
        for when to use Get vs Create.


        If specified, author ``defaultValue`` as the attribute's default,
        sparsely (when it makes sense to do so) if ``writeSparsely`` is
        ``true`` - the default for ``writeSparsely`` is ``false`` .


        Parameters
        ----------
        defaultValue : VtValue

        writeSparsely : bool
        """
    @staticmethod
    def Define(*args, **kwargs) -> None: 
        """
        **classmethod** Define(stage, path) -> SphericalJoint


        Attempt to ensure a *UsdPrim* adhering to this schema at ``path`` is
        defined (according to UsdPrim::IsDefined() ) on this stage.


        If a prim adhering to this schema at ``path`` is already defined on
        this stage, return that prim. Otherwise author an *SdfPrimSpec* with
        *specifier* == *SdfSpecifierDef* and this schema's prim type name for
        the prim at ``path`` at the current EditTarget. Author *SdfPrimSpec* s
        with ``specifier`` == *SdfSpecifierDef* and empty typeName at the
        current EditTarget for any nonexistent, or existing but not *Defined*
        ancestors.

        The given *path* must be an absolute prim path that does not contain
        any variant selections.

        If it is impossible to author any of the necessary PrimSpecs, (for
        example, in case *path* cannot map to the current UsdEditTarget 's
        namespace) issue an error and return an invalid *UsdPrim*.

        Note that this method may return a defined prim whose typeName does
        not specify this schema class, in case a stronger typeName opinion
        overrides the opinion at the current EditTarget.


        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def Get(*args, **kwargs) -> None: 
        """
        **classmethod** Get(stage, path) -> SphericalJoint


        Return a UsdPhysicsSphericalJoint holding the prim adhering to this
        schema at ``path`` on ``stage`` .


        If no prim exists at ``path`` on ``stage`` , or if the prim at that
        path does not adhere to this schema, return an invalid schema object.
        This is shorthand for the following:

        .. code-block:: text

          UsdPhysicsSphericalJoint(stage->GetPrimAtPath(path));



        Parameters
        ----------
        stage : Stage

        path : Path
        """
    @staticmethod
    def GetAxisAttr() -> Attribute: 
        """
        GetAxisAttr() -> Attribute


        Cone limit axis.



        Declaration

        ``uniform token physics:axis ="X"``

        C++ Type

        TfToken

        Usd Type

        SdfValueTypeNames->Token

        Variability

        SdfVariabilityUniform

        Allowed Values

        X, Y, Z
        """
    @staticmethod
    def GetConeAngle0LimitAttr() -> Attribute: 
        """
        GetConeAngle0LimitAttr() -> Attribute


        Cone limit from the primary joint axis in the local0 frame toward the
        next axis.


        (Next axis of X is Y, and of Z is X.) A negative value means not
        limited. Units: degrees.

        Declaration

        ``float physics:coneAngle0Limit = -1``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetConeAngle1LimitAttr() -> Attribute: 
        """
        GetConeAngle1LimitAttr() -> Attribute


        Cone limit from the primary joint axis in the local0 frame toward the
        second to next axis.


        A negative value means not limited. Units: degrees.

        Declaration

        ``float physics:coneAngle1Limit = -1``

        C++ Type

        float

        Usd Type

        SdfValueTypeNames->Float
        """
    @staticmethod
    def GetSchemaAttributeNames(*args, **kwargs) -> None: 
        """
        **classmethod** GetSchemaAttributeNames(includeInherited) -> list[TfToken]


        Return a vector of names of all pre-declared attributes for this
        schema class and all its ancestor classes.


        Does not include attributes that may be authored by custom/extended
        methods of the schemas involved.


        Parameters
        ----------
        includeInherited : bool
        """
    @staticmethod
    def _GetStaticTfType(*args, **kwargs) -> None: 
        """
        **classmethod** _GetStaticTfType() -> Type
        """
    __instance_size__ = 40
    pass
class Tokens(Boost.Python.instance):
    acceleration = 'acceleration'
    angular = 'angular'
    boundingCube = 'boundingCube'
    boundingSphere = 'boundingSphere'
    colliders = 'colliders'
    convexDecomposition = 'convexDecomposition'
    convexHull = 'convexHull'
    distance = 'distance'
    drive = 'drive'
    drive_MultipleApplyTemplate_PhysicsDamping = 'drive:__INSTANCE_NAME__:physics:damping'
    drive_MultipleApplyTemplate_PhysicsMaxForce = 'drive:__INSTANCE_NAME__:physics:maxForce'
    drive_MultipleApplyTemplate_PhysicsStiffness = 'drive:__INSTANCE_NAME__:physics:stiffness'
    drive_MultipleApplyTemplate_PhysicsTargetPosition = 'drive:__INSTANCE_NAME__:physics:targetPosition'
    drive_MultipleApplyTemplate_PhysicsTargetVelocity = 'drive:__INSTANCE_NAME__:physics:targetVelocity'
    drive_MultipleApplyTemplate_PhysicsType = 'drive:__INSTANCE_NAME__:physics:type'
    force = 'force'
    kilogramsPerUnit = 'kilogramsPerUnit'
    limit = 'limit'
    limit_MultipleApplyTemplate_PhysicsHigh = 'limit:__INSTANCE_NAME__:physics:high'
    limit_MultipleApplyTemplate_PhysicsLow = 'limit:__INSTANCE_NAME__:physics:low'
    linear = 'linear'
    meshSimplification = 'meshSimplification'
    none = 'none'
    physicsAngularVelocity = 'physics:angularVelocity'
    physicsApproximation = 'physics:approximation'
    physicsAxis = 'physics:axis'
    physicsBody0 = 'physics:body0'
    physicsBody1 = 'physics:body1'
    physicsBreakForce = 'physics:breakForce'
    physicsBreakTorque = 'physics:breakTorque'
    physicsCenterOfMass = 'physics:centerOfMass'
    physicsCollisionEnabled = 'physics:collisionEnabled'
    physicsConeAngle0Limit = 'physics:coneAngle0Limit'
    physicsConeAngle1Limit = 'physics:coneAngle1Limit'
    physicsDensity = 'physics:density'
    physicsDiagonalInertia = 'physics:diagonalInertia'
    physicsDynamicFriction = 'physics:dynamicFriction'
    physicsExcludeFromArticulation = 'physics:excludeFromArticulation'
    physicsFilteredGroups = 'physics:filteredGroups'
    physicsFilteredPairs = 'physics:filteredPairs'
    physicsGravityDirection = 'physics:gravityDirection'
    physicsGravityMagnitude = 'physics:gravityMagnitude'
    physicsInvertFilteredGroups = 'physics:invertFilteredGroups'
    physicsJointEnabled = 'physics:jointEnabled'
    physicsKinematicEnabled = 'physics:kinematicEnabled'
    physicsLocalPos0 = 'physics:localPos0'
    physicsLocalPos1 = 'physics:localPos1'
    physicsLocalRot0 = 'physics:localRot0'
    physicsLocalRot1 = 'physics:localRot1'
    physicsLowerLimit = 'physics:lowerLimit'
    physicsMass = 'physics:mass'
    physicsMaxDistance = 'physics:maxDistance'
    physicsMergeGroup = 'physics:mergeGroup'
    physicsMinDistance = 'physics:minDistance'
    physicsPrincipalAxes = 'physics:principalAxes'
    physicsRestitution = 'physics:restitution'
    physicsRigidBodyEnabled = 'physics:rigidBodyEnabled'
    physicsSimulationOwner = 'physics:simulationOwner'
    physicsStartsAsleep = 'physics:startsAsleep'
    physicsStaticFriction = 'physics:staticFriction'
    physicsUpperLimit = 'physics:upperLimit'
    physicsVelocity = 'physics:velocity'
    rotX = 'rotX'
    rotY = 'rotY'
    rotZ = 'rotZ'
    transX = 'transX'
    transY = 'transY'
    transZ = 'transZ'
    x = 'X'
    y = 'Y'
    z = 'Z'
    pass
class _CanApplyResult(Boost.Python.instance):
    @property
    def whyNot(self) -> None:
        """
        :type: None
        """
    __instance_size__ = 56
    pass
def GetStageKilogramsPerUnit(*args, **kwargs) -> None:
    pass
def MassUnitsAre(*args, **kwargs) -> None:
    pass
def SetStageKilogramsPerUnit(*args, **kwargs) -> None:
    pass
def StageHasAuthoredKilogramsPerUnit(*args, **kwargs) -> None:
    pass
__MFB_FULL_PACKAGE_NAME = 'usdPhysics'
