import ompl as _ompl
from collections.abc import Callable, Sequence
import enum
import types
from typing import Annotated, overload

import numpy
from numpy.typing import NDArray


class Cost:
    def __init__(self, arg: float, /) -> None: ...

    def value(self) -> float: ...

    def __repr__(self) -> "std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>": ...

class Goal:
    def __init__(self, si: SpaceInformation) -> None: ...

    def getType(self) -> GoalType: ...

    def hasType(self, type: GoalType) -> bool: ...

    def getSpaceInformation(self) -> SpaceInformation: ...

class GoalType(enum.Enum):
    GOAL_ANY = 1

    GOAL_REGION = 3

    GOAL_SAMPLEABLE_REGION = 7

    GOAL_STATE = 15

    GOAL_STATES = 23

    GOAL_LAZY_SAMPLES = 55

GOAL_ANY: GoalType = GoalType.GOAL_ANY

GOAL_REGION: GoalType = GoalType.GOAL_REGION

GOAL_SAMPLEABLE_REGION: GoalType = GoalType.GOAL_SAMPLEABLE_REGION

GOAL_STATE: GoalType = GoalType.GOAL_STATE

GOAL_STATES: GoalType = GoalType.GOAL_STATES

GOAL_LAZY_SAMPLES: GoalType = GoalType.GOAL_LAZY_SAMPLES

class MotionValidator:
    def __init__(self, arg: SpaceInformation, /) -> None: ...

    def checkMotion(self, arg0: State, arg1: State, /) -> bool: ...

    def getValidMotionCount(self) -> int: ...

    def getInvalidMotionCount(self) -> int: ...

    def getCheckedMotionCount(self) -> int: ...

    def getValidMotionFraction(self) -> float: ...

    def resetMotionCounter(self) -> None: ...

class ValidStateSampler:
    def __init__(self, si: SpaceInformation) -> None: ...

    def getName(self) -> str: ...

    def setName(self, name: str) -> None: ...

    def sample(self, state: State) -> bool: ...

    def sampleNear(self, state: State, near: State, distance: float) -> bool: ...

    def setNrAttempts(self, attempts: int) -> None: ...

    def getNrAttempts(self) -> int: ...

CONSTRAINT_PROJECTION_TOLERANCE: float = 0.0001

CONSTRAINT_PROJECTION_MAX_ITERATIONS: int = 50

class Constraint:
    def __init__(self, ambientDim: int, coDim: int, tolerance: float = 0.0001) -> None: ...

    def getAmbientDimension(self) -> int: ...

    def getManifoldDimension(self) -> int: ...

    def getCoDimension(self) -> int: ...

    def setManifoldDimension(self, k: int) -> None: ...

    def getTolerance(self) -> float: ...

    def getMaxIterations(self) -> int: ...

    def setTolerance(self, tolerance: float) -> None: ...

    def setMaxIterations(self, iterations: int) -> None: ...

    @overload
    def project(self, x: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='C')]) -> bool: ...

    @overload
    def project(self, x: State) -> bool: ...

    @overload
    def distance(self, x: Annotated[NDArray[numpy.float64], dict(shape=(None,), writable=False)]) -> float: ...

    @overload
    def distance(self, x: State) -> float: ...

    @overload
    def isSatisfied(self, x: Annotated[NDArray[numpy.float64], dict(shape=(None,), writable=False)]) -> bool: ...

    @overload
    def isSatisfied(self, x: State) -> bool: ...

class ConstraintIntersection(Constraint):
    def __init__(self, ambientDim: int, constraints: "std::__1::vector<std::__1::shared_ptr<ompl::base::Constraint>, std::__1::allocator<std::__1::shared_ptr<ompl::base::Constraint>>>") -> None: ...

class Path:
    pass

class PlannerInputStates:
    @overload
    def __init__(self, arg: Planner, /) -> None: ...

    @overload
    def __init__(self, arg: Planner, /) -> None: ...

    @overload
    def __init__(self) -> None: ...

    def clear(self) -> None: ...

    def restart(self) -> None: ...

    def update(self) -> bool: ...

    def use(self, arg: ProblemDefinition, /) -> bool: ...

    def checkValidity(self) -> None: ...

    def nextStart(self) -> State: ...

    @overload
    def nextGoal(self) -> State: ...

    @overload
    def nextGoal(self, arg: PlannerTerminationCondition, /) -> State: ...

    def haveMoreStartStates(self) -> bool: ...

    def haveMoreGoalStates(self) -> bool: ...

    def getSeenStartStatesCount(self) -> int: ...

    def getSampledGoalsCount(self) -> int: ...

class Planner:
    def __init__(self, arg0: SpaceInformation, arg1: str, /) -> None: ...

    def getSpaceInformation(self) -> SpaceInformation: ...

    def getProblemDefinition(self) -> ProblemDefinition: ...

    def setProblemDefinition(self, pdef: ProblemDefinition) -> None: ...

    def getPlannerInputStates(self) -> PlannerInputStates: ...

    @overload
    def solve(self, solveTime: float) -> PlannerStatus: ...

    @overload
    def solve(self, terminationConditionFn: Callable[[], bool], checkInterval: float = 0.0) -> PlannerStatus: ...

    def clearQuery(self) -> None: ...

    def clear(self) -> None: ...

    def getName(self) -> str: ...

    def setName(self, name: str) -> None: ...

    def getSpecs(self) -> "ompl::base::PlannerSpecs": ...

    def params(self) -> "ompl::base::ParamSet": ...

    def getPlannerProgressProperties(self) -> "std::__1::map<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>, std::__1::function<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> ()>, std::__1::less<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>>, std::__1::allocator<std::__1::pair<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> const, std::__1::function<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>> ()>>>>": ...

class PlannerDataVertex:
    def __init__(self, st: State, tag: int = 0) -> None: ...

    def getTag(self) -> int: ...

    def setTag(self, tag: int) -> None: ...

    def getState(self) -> State: ...

class PlannerDataEdge:
    def __init__(self) -> None: ...

class PlannerData:
    def __init__(self, si: SpaceInformation) -> None: ...

    def addVertex(self, st: PlannerDataVertex) -> int: ...

    def addStartVertex(self, v: PlannerDataVertex) -> int: ...

    def addGoalVertex(self, v: PlannerDataVertex) -> int: ...

    def removeVertex(self, st: PlannerDataVertex) -> bool: ...

    def removeVertexByIndex(self, vIndex: int) -> bool: ...

    def addEdge(self, v1: int, v2: int, edge: PlannerDataEdge = ..., weight: Cost = ...) -> bool: ...

    def removeEdge(self, v1: int, v2: int) -> bool: ...

    def clear(self) -> None: ...

    def decoupleFromPlanner(self) -> None: ...

    def numEdges(self) -> int: ...

    def numVertices(self) -> int: ...

    def numStartVertices(self) -> int: ...

    def numGoalVertices(self) -> int: ...

    def vertexExists(self, v: PlannerDataVertex) -> bool: ...

    def getVertex(self, index: int) -> PlannerDataVertex: ...

    def getStartVertex(self, i: int) -> PlannerDataVertex: ...

    def getGoalVertex(self, i: int) -> PlannerDataVertex: ...

    def getStartIndex(self, i: int) -> int: ...

    def getGoalIndex(self, i: int) -> int: ...

    def isStartVertex(self, index: int) -> bool: ...

    def isGoalVertex(self, index: int) -> bool: ...

    def vertexIndex(self, v: PlannerDataVertex) -> int: ...

    def edgeExists(self, v1: int, v2: int) -> bool: ...

    def getEdge(self, v1: int, v2: int) -> PlannerDataEdge: ...

    def getEdges(self, v: int) -> list[int]: ...

    def getIncomingEdges(self, v: int) -> list[int]: ...

    def computeEdgeWeights(self) -> None: ...

    def printGraphviz(self) -> str: ...

    def printGraphML(self) -> str: ...

    def printPLY(self, asIs: bool = False) -> str: ...

    def getSpaceInformation(self) -> SpaceInformation: ...

    def hasControls(self) -> bool: ...

class PlannerDataStorage:
    def __init__(self) -> None: ...

    def store(self, pd: PlannerData, filename: str) -> bool:
        """Store the PlannerData structure to the given filename."""

    def load(self, filename: str, pd: PlannerData) -> bool:
        """Load the PlannerData structure from the given filename."""

class PlannerStatus:
    @overload
    def __init__(self) -> None: ...

    @overload
    def __init__(self, arg: PlannerStatus.PlannerStatusType, /) -> None: ...

    @overload
    def __init__(self, arg0: bool, arg1: bool, /) -> None: ...

    def getStatus(self) -> PlannerStatus.PlannerStatusType: ...

    @property
    def StatusType(self) -> PlannerStatus.PlannerStatusType: ...

    def asString(self) -> str: ...

    def __bool__(self) -> bool: ...

    def __int__(self) -> int: ...

    @overload
    def __eq__(self, arg: PlannerStatus.PlannerStatusType, /) -> bool: ...

    @overload
    def __eq__(self, arg: PlannerStatus, /) -> bool: ...

    def __repr__(self) -> str: ...

    class PlannerStatusType(enum.Enum):
        UNKNOWN = 0

        INVALID_START = 1

        INVALID_GOAL = 2

        UNRECOGNIZED_GOAL_TYPE = 3

        TIMEOUT = 4

        APPROXIMATE_SOLUTION = 5

        EXACT_SOLUTION = 6

        CRASH = 7

        ABORT = 8

        INFEASIBLE = 9

        TYPE_COUNT = 10

    UNKNOWN: PlannerStatus.PlannerStatusType = PlannerStatus.PlannerStatusType.UNKNOWN

    INVALID_START: PlannerStatus.PlannerStatusType = PlannerStatus.PlannerStatusType.INVALID_START

    INVALID_GOAL: PlannerStatus.PlannerStatusType = PlannerStatus.PlannerStatusType.INVALID_GOAL

    UNRECOGNIZED_GOAL_TYPE: PlannerStatus.PlannerStatusType = PlannerStatus.PlannerStatusType.UNRECOGNIZED_GOAL_TYPE

    TIMEOUT: PlannerStatus.PlannerStatusType = PlannerStatus.PlannerStatusType.TIMEOUT

    APPROXIMATE_SOLUTION: PlannerStatus.PlannerStatusType = PlannerStatus.PlannerStatusType.APPROXIMATE_SOLUTION

    EXACT_SOLUTION: PlannerStatus.PlannerStatusType = PlannerStatus.PlannerStatusType.EXACT_SOLUTION

    CRASH: PlannerStatus.PlannerStatusType = PlannerStatus.PlannerStatusType.CRASH

    ABORT: PlannerStatus.PlannerStatusType = PlannerStatus.PlannerStatusType.ABORT

    INFEASIBLE: PlannerStatus.PlannerStatusType = PlannerStatus.PlannerStatusType.INFEASIBLE

    TYPE_COUNT: PlannerStatus.PlannerStatusType = PlannerStatus.PlannerStatusType.TYPE_COUNT

class PlannerTerminationCondition:
    @overload
    def __init__(self, fn: Callable[[], bool]) -> None: ...

    @overload
    def __init__(self, fn: Callable[[], bool], period: float) -> None: ...

    def __call__(self) -> bool: ...

    def terminate(self) -> None: ...

    def eval(self) -> bool: ...

def plannerNonTerminatingCondition() -> PlannerTerminationCondition: ...

def plannerAlwaysTerminatingCondition() -> PlannerTerminationCondition: ...

def plannerOrTerminationCondition(c1: PlannerTerminationCondition, c2: PlannerTerminationCondition) -> PlannerTerminationCondition: ...

def plannerAndTerminationCondition(c1: PlannerTerminationCondition, c2: PlannerTerminationCondition) -> PlannerTerminationCondition: ...

@overload
def timedPlannerTerminationCondition(duration: float) -> PlannerTerminationCondition: ...

@overload
def timedPlannerTerminationCondition(duration: float, interval: float) -> PlannerTerminationCondition: ...

def exactSolnPlannerTerminationCondition(pdef: ProblemDefinition) -> PlannerTerminationCondition: ...

class StateSampler:
    def __init__(self, space: StateSpace) -> None: ...

    def sampleUniform(self, arg: State, /) -> None: ...

    def sampleUniformNear(self, arg0: State, arg1: State, arg2: float, /) -> None: ...

    def sampleGaussian(self, arg0: State, arg1: State, arg2: float, /) -> None: ...

class CompoundStateSampler(StateSampler):
    def __init__(self, space: StateSpace) -> None:
        """Construct a CompoundStateSampler for the given state space."""

    def addSampler(self, arg0: StateSampler, arg1: float, /) -> None: ...

    def sampleUniform(self, arg: State, /) -> None: ...

    def sampleUniformNear(self, arg0: State, arg1: State, arg2: float, /) -> None: ...

    def sampleGaussian(self, arg0: State, arg1: State, arg2: float, /) -> None: ...

class SubspaceStateSampler(StateSampler):
    def __init__(self, space: StateSpace, subspace: StateSpace, weight: float) -> None:
        """
        Construct a SubspaceStateSampler for the given state space and subspace.
        """

    def sampleUniform(self, arg: State, /) -> None: ...

    def sampleUniformNear(self, arg0: State, arg1: State, arg2: float, /) -> None: ...

    def sampleGaussian(self, arg0: State, arg1: State, arg2: float, /) -> None: ...

class ProblemDefinition:
    def __init__(self, arg: SpaceInformation, /) -> None: ...

    def clone(self) -> ProblemDefinition: ...

    def getSpaceInformation(self) -> SpaceInformation: ...

    def addStartState(self, arg: State, /) -> None: ...

    def hasStartState(self, arg0: State, arg1: int, /) -> bool: ...

    def clearStartStates(self) -> None: ...

    def getStartStateCount(self) -> int: ...

    @overload
    def getStartState(self, arg: int, /) -> State: ...

    @overload
    def getStartState(self, arg: int, /) -> State: ...

    def setGoal(self, arg: Goal, /) -> None: ...

    def clearGoal(self) -> None: ...

    def getGoal(self) -> Goal: ...

    def getInputStates(self) -> list[State]: ...

    def setStartAndGoalStates(self, start: State, goal: State, threshold: float = 2.220446049250313e-16) -> None: ...

    def setGoalState(self, goal: State, threshold: float = 2.220446049250313e-16) -> None: ...

    def hasOptimizationObjective(self) -> bool: ...

    def getOptimizationObjective(self) -> OptimizationObjective: ...

    def setOptimizationObjective(self, arg: OptimizationObjective, /) -> None: ...

    def getIntermediateSolutionCallback(self) -> "std::__1::function<void (ompl::base::Planner const*, std::__1::vector<ompl::base::State const*, std::__1::allocator<ompl::base::State const*>> const&, ompl::base::Cost)>": ...

    def setIntermediateSolutionCallback(self, arg: "std::__1::function<void (ompl::base::Planner const*, std::__1::vector<ompl::base::State const*, std::__1::allocator<ompl::base::State const*>> const&, ompl::base::Cost)>", /) -> None: ...

    @overload
    def isTrivial(self, arg0: int, arg1: float, /) -> bool: ...

    @overload
    def isTrivial(self) -> bool: ...

    def isStraightLinePathValid(self) -> Path: ...

    def fixInvalidInputStates(self, arg0: float, arg1: float, arg2: int, /) -> bool: ...

    def hasSolution(self) -> bool: ...

    def hasExactSolution(self) -> bool: ...

    def hasApproximateSolution(self) -> bool: ...

    def getSolutionDifference(self) -> float: ...

    def hasOptimizedSolution(self) -> bool: ...

    def getSolutionPath(self) -> Path: ...

    def getSolution(self, arg: "ompl::base::PlannerSolution", /) -> bool: ...

    @overload
    def addSolutionPath(self, path: Path, approximate: bool = False, difference: float = -1.0, plannerName: str = 'Unknown') -> None: ...

    @overload
    def addSolutionPath(self, arg: "ompl::base::PlannerSolution", /) -> None: ...

    def getSolutionCount(self) -> int: ...

    def getSolutions(self) -> list["ompl::base::PlannerSolution"]: ...

    def clearSolutionPaths(self) -> None: ...

    def hasSolutionNonExistenceProof(self) -> bool: ...

    def clearSolutionNonExistenceProof(self) -> None: ...

    def getSolutionNonExistenceProof(self) -> "ompl::base::SolutionNonExistenceProof": ...

    def setSolutionNonExistenceProof(self, arg: "ompl::base::SolutionNonExistenceProof", /) -> None: ...

    def print(self) -> None: ...

    def __repr__(self) -> str: ...

class ProjectionMatrix:
    def __init__(self) -> None: ...

    @property
    def mat(self) -> Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')]: ...

    @mat.setter
    def mat(self, arg: Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')], /) -> None: ...

    @overload
    @staticmethod
    def ComputeRandom(from: int, to: int, scale: Sequence[float]) -> Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')]: ...

    @overload
    @staticmethod
    def ComputeRandom(from: int, to: int) -> Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')]: ...

    @overload
    def computeRandom(self, from: int, to: int, scale: Sequence[float]) -> None: ...

    @overload
    def computeRandom(self, from: int, to: int) -> None: ...

    def project(self, from: float, to: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='C')]) -> None: ...

    def print(self) -> None: ...

    def __repr__(self) -> str: ...

class ProjectionEvaluator:
    def __init__(self, space: StateSpace) -> None: ...

    def setCellSizes(self, dim: int, cellSize: float) -> None: ...

    def mulCellSizes(self, factor: float) -> None:
        """Multiply the cell sizes by a factor"""

    def userConfigured(self) -> bool: ...

    @overload
    def getCellSizes(self) -> list[float]: ...

    @overload
    def getCellSizes(self, dim: int) -> float: ...

    def checkCellSizes(self) -> None: ...

    def inferCellSizes(self) -> None: ...

    def checkBounds(self) -> None: ...

    def hasBounds(self) -> bool: ...

    def setBounds(self, bounds: RealVectorBounds) -> None: ...

    def getBounds(self) -> RealVectorBounds: ...

    def inferBounds(self) -> None: ...

    @overload
    def computeCoordinates(self, projection: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='C')], coord: Annotated[NDArray[numpy.int32], dict(shape=(None,), order='C')]) -> None: ...

    @overload
    def computeCoordinates(self, state: State, coord: Annotated[NDArray[numpy.int32], dict(shape=(None,), order='C')]) -> None: ...

    @overload
    def params(self) -> "ompl::base::ParamSet": ...

    @overload
    def params(self) -> "ompl::base::ParamSet": ...

class SubspaceProjectionEvaluator(ProjectionEvaluator):
    def __init__(self, space: StateSpace, index: int, projToUse: ProjectionEvaluator | None = None) -> None: ...

    def setup(self) -> None: ...

    def getDimension(self) -> int: ...

    def project(self, state: State, projection: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='C')]) -> None: ...

class SpaceInformation:
    def __init__(self, arg: StateSpace, /) -> None: ...

    def isValid(self, arg: State, /) -> bool: ...

    def getStateSpace(self) -> StateSpace: ...

    def getStateDimension(self) -> int: ...

    def getSpaceMeasure(self) -> float: ...

    def equalStates(self, arg0: State, arg1: State, /) -> bool: ...

    def satisfiesBounds(self, arg: State, /) -> bool: ...

    def distance(self, arg0: State, arg1: State, /) -> float: ...

    def enforceBounds(self, arg: State, /) -> None: ...

    def printState(self, arg: State, /) -> None: ...

    @overload
    def setStateValidityChecker(self, svc: Callable[[State], bool]) -> None: ...

    @overload
    def setStateValidityChecker(self, svc: StateValidityChecker) -> None: ...

    def getStateValidityChecker(self) -> StateValidityChecker: ...

    def setMotionValidator(self, arg: MotionValidator, /) -> None: ...

    def getMotionValidator(self) -> MotionValidator: ...

    def setStateValidityCheckingResolution(self, arg: float, /) -> None: ...

    def getStateValidityCheckingResolution(self) -> float: ...

    def allocState(self) -> State: ...

    def freeState(self, arg: State, /) -> None: ...

    def copyState(self, arg0: State, arg1: State, /) -> None: ...

    def cloneState(self, arg: State, /) -> State: ...

    def allocStateSampler(self) -> StateSampler: ...

    def allocValidStateSampler(self) -> ValidStateSampler: ...

    def setValidStateSamplerAllocator(self, arg: Callable[[SpaceInformation], ValidStateSampler], /) -> None: ...

    def clearValidStateSamplerAllocator(self) -> None: ...

    def getMaximumExtent(self) -> float: ...

    @overload
    def searchValidNearby(self, arg0: State, arg1: State, arg2: float, arg3: int, /) -> bool: ...

    @overload
    def searchValidNearby(self, arg0: ValidStateSampler, arg1: State, arg2: State, arg3: float, /) -> bool: ...

    def randomBounceMotion(self, arg0: StateSampler, arg1: State, arg2: int, arg3: Sequence[State], arg4: bool, /) -> int: ...

    @overload
    def checkMotion(self, arg0: State, arg1: State, /) -> bool: ...

    @overload
    def checkMotion(self, arg0: Sequence[State], arg1: int, arg2: int, /) -> bool: ...

    @overload
    def checkMotion(self, arg0: Sequence[State], arg1: int, /) -> bool: ...

    def getMotionStates(self, arg0: State, arg1: State, arg2: Sequence[State], arg3: int, arg4: bool, arg5: bool, /) -> int: ...

    def getCheckedMotionCount(self) -> int: ...

    def probabilityOfValidState(self, arg: int, /) -> float: ...

    def averageValidMotionLength(self, arg: int, /) -> float: ...

    def samplesPerSecond(self, arg0: float, arg1: float, arg2: float, arg3: int, /) -> None: ...

    def printSettings(self) -> None: ...

    def settings(self) -> str: ...

    def __repr__(self) -> str: ...

    def printProperties(self) -> None: ...

    def params(self) -> "ompl::base::ParamSet": ...

    def setup(self) -> None: ...

    def isSetup(self) -> bool: ...

class State:
    pass

class CompoundState(State):
    def __init__(self) -> None: ...

    def __getitem__(self, index: int) -> State: ...

    def __setitem__(self, index: int, state: State) -> None: ...

class StateSpace:
    def isCompound(self) -> bool: ...

    def isDiscrete(self) -> bool: ...

    def isHybrid(self) -> bool: ...

    def isMetricSpace(self) -> bool: ...

    def hasSymmetricDistance(self) -> bool: ...

    def hasSymmetricInterpolate(self) -> bool: ...

    def getName(self) -> str: ...

    def setName(self, name: str) -> None: ...

    def getType(self) -> int: ...

    def includes(self, other: StateSpace) -> bool: ...

    def covers(self, other: StateSpace) -> bool: ...

    def getLongestValidSegmentFraction(self) -> float: ...

    def setLongestValidSegmentFraction(self, fraction: float) -> None: ...

    def validSegmentCount(self, state1: State, state2: State) -> int: ...

    def setValidSegmentCountFactor(self, factor: int) -> None: ...

    def getValidSegmentCountFactor(self) -> int: ...

    def getLongestValidSegmentLength(self) -> float: ...

    def computeSignature(self, signature: Sequence[int]) -> None: ...

    def cloneState(self, source: State) -> State: ...

    def getSerializationLength(self) -> int: ...

    def getValueAddressAtIndex(self, state: State, index: int) -> float: ...

    def registerProjection(self, name: str, projection: ProjectionEvaluator) -> None: ...

    def registerDefaultProjection(self, projection: ProjectionEvaluator) -> None: ...

    def registerProjections(self) -> None: ...

    def getProjection(self, name: str) -> ProjectionEvaluator: ...

    def getDefaultProjection(self) -> ProjectionEvaluator: ...

    def hasProjection(self, name: str) -> bool: ...

    def hasDefaultProjection(self) -> bool: ...

    def getRegisteredProjections(self) -> dict[str, ProjectionEvaluator]: ...

    def printState(self, state: State) -> None: ...

    def printSettings(self) -> None: ...

    def __repr__(self) -> str: ...

    def printProjections(self) -> None: ...

    def sanityChecks(self, zero: float, eps: float, flags: int) -> None: ...

    def Diagram(self) -> None: ...

    def List(self) -> None: ...

    def allocSubspaceStateSampler(self, subspace: StateSpace) -> StateSampler: ...

    def getSubstateAtLocation(self, state: State, loc: "ompl::base::StateSpace::SubstateLocation") -> State: ...

    def getSubstateLocationsByName(self) -> dict[str, "ompl::base::StateSpace::SubstateLocation"]: ...

    def getCommonSubspaces(self, other: StateSpace, subspaces: Sequence[str]) -> None: ...

    def copyToReals(self, reals: Sequence[float], source: State) -> None: ...

    def copyFromReals(self, destination: State, reals: Sequence[float]) -> None: ...

class CompoundStateSpace(StateSpace):
    @overload
    def __init__(self) -> None: ...

    @overload
    def __init__(self, arg0: Sequence[StateSpace], arg1: Sequence[float], /) -> None: ...

    def isCompound(self) -> bool: ...

    def isHybrid(self) -> bool: ...

    def printState(self, arg: State, /) -> None: ...

    def printSettings(self) -> None: ...

    def computeLocations(self) -> None: ...

    def setup(self) -> None: ...

    def addSubspace(self, arg0: StateSpace, arg1: float, /) -> None: ...

    def getSubspaceCount(self) -> int: ...

    @overload
    def getSubspace(self, arg: int, /) -> StateSpace: ...

    @overload
    def getSubspace(self, arg: str, /) -> StateSpace: ...

    def hasSubspace(self, arg: str, /) -> bool: ...

    @overload
    def getSubspaceWeight(self, arg: int, /) -> float: ...

    @overload
    def getSubspaceWeight(self, arg: str, /) -> float: ...

    @overload
    def setSubspaceWeight(self, arg0: int, arg1: float, /) -> None: ...

    @overload
    def setSubspaceWeight(self, arg0: str, arg1: float, /) -> None: ...

    def getSubspaces(self) -> list[StateSpace]: ...

    def getSubspaceWeights(self) -> list[float]: ...

    def isLocked(self) -> bool: ...

    def lock(self) -> None: ...

    def allocSubspaceStateSampler(self, arg: StateSpace, /) -> StateSampler: ...

    def getDimension(self) -> int: ...

    def getMaximumExtent(self) -> float: ...

    def getMeasure(self) -> float: ...

    def enforceBounds(self, arg: State, /) -> None: ...

    def satisfiesBounds(self, arg: State, /) -> bool: ...

    def copyState(self, arg0: State, arg1: State, /) -> None: ...

    def getSerializationLength(self) -> int: ...

    def serialize(self, arg0: types.CapsuleType, arg1: State, /) -> None: ...

    def deserialize(self, arg0: State, arg1: types.CapsuleType, /) -> None: ...

    def distance(self, arg0: State, arg1: State, /) -> float: ...

    def setLongestValidSegmentFraction(self, arg: float, /) -> None: ...

    def validSegmentCount(self, arg0: State, arg1: State, /) -> int: ...

    def equalStates(self, arg0: State, arg1: State, /) -> bool: ...

    def interpolate(self, arg0: State, arg1: State, arg2: float, arg3: State, /) -> None: ...

    def allocDefaultStateSampler(self) -> StateSampler: ...

    def allocState(self) -> State: ...

    def freeState(self, arg: State, /) -> None: ...

    def getValueAddressAtIndex(self, arg0: State, arg1: int, /) -> float: ...

class StateValidityChecker:
    @overload
    def __init__(self, si: SpaceInformation) -> None: ...

    @overload
    def __init__(self, si: SpaceInformation) -> None: ...

    def isValid(self, state: State) -> bool: ...

    def clearance(self, state: State) -> float: ...

    def getSpecs(self) -> StateValidityCheckerSpecs: ...

class AllValidStateValidityChecker(StateValidityChecker):
    @overload
    def __init__(self, si: SpaceInformation) -> None: ...

    @overload
    def __init__(self, si: SpaceInformation) -> None: ...

class StateValidityCheckerSpecs:
    def __init__(self) -> None: ...

    @property
    def clearanceComputationType(self) -> ClearanceComputationType: ...

    @clearanceComputationType.setter
    def clearanceComputationType(self, arg: ClearanceComputationType, /) -> None: ...

    @property
    def hasValidDirectionComputation(self) -> bool: ...

    @hasValidDirectionComputation.setter
    def hasValidDirectionComputation(self, arg: bool, /) -> None: ...

class ClearanceComputationType(enum.Enum):
    NONE = 0

    EXACT = 1

    APPROXIMATE = 2

    BOUNDED_APPROXIMATE = 3

NONE: ClearanceComputationType = ClearanceComputationType.NONE

EXACT: ClearanceComputationType = ClearanceComputationType.EXACT

APPROXIMATE: ClearanceComputationType = ClearanceComputationType.APPROXIMATE

BOUNDED_APPROXIMATE: ClearanceComputationType = ClearanceComputationType.BOUNDED_APPROXIMATE

class GoalRegion(Goal):
    def __init__(self, si: SpaceInformation) -> None: ...

    @overload
    def isSatisfied(self, state: State) -> bool: ...

    @overload
    def isSatisfied(self, state: State, distance: float) -> bool: ...

    def setThreshold(self, threshold: float) -> None: ...

    def getThreshold(self) -> float: ...

    def print(self) -> None: ...

    def __repr__(self) -> "std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>": ...

class GoalSampleableRegion(GoalRegion):
    def __init__(self, si: SpaceInformation) -> None: ...

    def getThreshold(self) -> float: ...

    def setThreshold(self, threshold: float) -> None: ...

    def couldSample(self) -> bool: ...

    def isSatisfied(self, arg: State, /) -> bool: ...

    def isSatisfiedWithDistance(self, arg: State, /) -> tuple[bool, float]: ...

    def print(self) -> None: ...

    def __repr__(self) -> str: ...

class GoalSpace(GoalSampleableRegion):
    def __init__(self, si: SpaceInformation) -> None: ...

    def sampleGoal(self, state: State) -> None: ...

    def maxSampleCount(self) -> int: ...

    def distanceGoal(self, state: State) -> float: ...

    def print(self) -> None: ...

    def __repr__(self) -> "std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>": ...

    def setSpace(self, si: StateSpace) -> None: ...

    def getSpace(self) -> StateSpace: ...

class GoalState(GoalSampleableRegion):
    def __init__(self, si: "std::__1::shared_ptr<ompl::base::SpaceInformation>") -> None: ...

    def sampleGoal(self, state: State) -> None: ...

    def maxSampleCount(self) -> int: ...

    def distanceGoal(self, state: State) -> float: ...

    def print(self) -> None: ...

    def __repr__(self) -> "std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>": ...

    def setState(self, state: State) -> None: ...

    @overload
    def getState(self) -> State: ...

    @overload
    def getState(self) -> State: ...

class GoalStates(GoalSampleableRegion):
    def __init__(self, si: "std::__1::shared_ptr<ompl::base::SpaceInformation>") -> None:
        """Construct a GoalStates for the given SpaceInformation"""

    def sampleGoal(self, state: State) -> None: ...

    def maxSampleCount(self) -> int: ...

    def distanceGoal(self, state: State) -> float: ...

    def print(self) -> None: ...

    def __repr__(self) -> "std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>": ...

    def addState(self, state: State) -> None: ...

    def clear(self) -> None: ...

    def hasStates(self) -> bool: ...

    def getState(self, index: int) -> State: ...

    def getStateCount(self) -> int: ...

class GoalLazySamples(GoalStates):
    def __init__(self, arg0: SpaceInformation, arg1: Callable[[GoalLazySamples, State], bool], arg2: bool, arg3: float, /) -> None: ...

    def sampleGoal(self, state: State) -> None: ...

    def distanceGoal(self, state: State) -> float: ...

    def addState(self, state: State) -> None: ...

    def maxSampleCount(self) -> int: ...

    def startSampling(self) -> None: ...

    def stopSampling(self) -> None: ...

    def isSampling(self) -> bool: ...

    def samplingAttemptsCount(self) -> int:
        """Total calls to the sampler function so far."""

    def setMinNewSampleDistance(self, dist: float) -> None:
        """Require new samples to be at least this far from all existing ones."""

    def getMinNewSampleDistance(self) -> float: ...

    def setNewStateCallback(self, callback: Callable[[State], None]) -> None: ...

    def addStateIfDifferent(self, state: State, minDistance: float) -> bool: ...

    def couldSample(self) -> bool: ...

    def hasStates(self) -> bool: ...

    def getState(self, index: int) -> State: ...

    def getStateCount(self) -> int: ...

    def clear(self) -> None: ...

class OptimizationObjective:
    def __init__(self, si: SpaceInformation) -> None: ...

    def getDescription(self) -> str: ...

    def getCostThreshold(self) -> Cost: ...

    def hasCostToGoHeuristic(self) -> bool: ...

    def costToGo(self, state: State, goal: Goal) -> Cost: ...

    def getSpaceInformation(self) -> SpaceInformation: ...

    def setCostThreshold(self, cost: Cost) -> None: ...

    def setCostToGoHeuristic(self, costToGoFn: "std::__1::function<ompl::base::Cost (ompl::base::State const*, ompl::base::Goal const*)>") -> None: ...

    def __repr__(self) -> str: ...

class MultiOptimizationObjective(OptimizationObjective):
    def __init__(self, si: SpaceInformation) -> None: ...

    def addObjective(self, objective: OptimizationObjective, weight: float = 1.0) -> None: ...

    def getObjectiveCount(self) -> int: ...

    def getObjective(self, idx: int) -> OptimizationObjective: ...

    def getObjectiveWeight(self, idx: int) -> float: ...

    def setObjectiveWeight(self, idx: int, weight: float) -> None: ...

    def lock(self) -> None: ...

    def isLocked(self) -> bool: ...

class PathLengthOptimizationObjective(OptimizationObjective):
    def __init__(self, si: SpaceInformation) -> None: ...

class StateCostIntegralObjective(OptimizationObjective):
    def __init__(self, si: SpaceInformation, enableMotionCostInterpolation: bool) -> None: ...

    def isMotionCostInterpolationEnabled(self) -> bool: ...

class ConstrainedValidStateSampler(ValidStateSampler):
    pass

class ConstrainedSpaceInformation(SpaceInformation):
    def __init__(self, space: StateSpace) -> None: ...

    def getMotionStates(self, arg0: State, arg1: State, arg2: Sequence[State], arg3: int, arg4: bool, arg5: bool, /) -> int: ...

class TangentBundleSpaceInformation(ConstrainedSpaceInformation):
    def __init__(self, space: StateSpace) -> None: ...

class UniformValidStateSampler(ValidStateSampler):
    def __init__(self, arg: SpaceInformation, /) -> None: ...

    def sample(self, state: State) -> bool: ...

    def sampleNear(self, state: State, near: State, distance: float) -> bool: ...

class ObstacleBasedValidStateSampler(ValidStateSampler):
    def __init__(self, si: SpaceInformation) -> None: ...

    def sample(self, state: State) -> bool: ...

    def sampleNear(self, state: State, near: State, distance: float) -> bool: ...

class DiscreteStateSampler(StateSampler):
    def __init__(self, arg: StateSpace, /) -> None: ...

    def sampleUniform(self, arg: State, /) -> None: ...

    def sampleUniformNear(self, arg0: State, arg1: State, arg2: float, /) -> None: ...

    def sampleGaussian(self, arg0: State, arg1: State, arg2: float, /) -> None: ...

class DiscreteState(State):
    @property
    def value(self) -> int: ...

    @value.setter
    def value(self, arg: int, /) -> None: ...

class DiscreteStateSpace(StateSpace):
    def __init__(self, lowerBound: int, upperBound: int) -> None: ...

    def isDiscrete(self) -> bool: ...

    def getDimension(self) -> int: ...

    def getMaximumExtent(self) -> float: ...

    def getMeasure(self) -> float: ...

    def enforceBounds(self, arg: State, /) -> None: ...

    def satisfiesBounds(self, arg: State, /) -> bool: ...

    def getSerializationLength(self) -> int: ...

    def serialize(self, arg0: types.CapsuleType, arg1: State, /) -> None: ...

    def deserialize(self, arg0: State, arg1: types.CapsuleType, /) -> None: ...

    def copyState(self, arg0: State, arg1: State, /) -> None: ...

    def distance(self, arg0: State, arg1: State, /) -> float: ...

    def equalStates(self, arg0: State, arg1: State, /) -> bool: ...

    def interpolate(self, arg0: State, arg1: State, arg2: float, arg3: State, /) -> None: ...

    def allocDefaultStateSampler(self) -> StateSampler: ...

    def allocState(self) -> State: ...

    def printState(self, state: State) -> None:
        """Print the state to standard output"""

    def printSettings(self) -> None:
        """Print the settings of the state space to standard output"""

    def registerProjections(self) -> None: ...

    def getStateCount(self) -> int: ...

    def getLowerBound(self) -> int: ...

    def getUpperBound(self) -> int: ...

    def setBounds(self, arg0: int, arg1: int, /) -> None: ...

    def setup(self) -> None: ...

class RealVectorBounds:
    def __init__(self, arg: int, /) -> None: ...

    @overload
    def setLow(self, arg: float, /) -> None: ...

    @overload
    def setLow(self, arg0: int, arg1: float, /) -> None: ...

    @overload
    def setHigh(self, arg: float, /) -> None: ...

    @overload
    def setHigh(self, arg0: int, arg1: float, /) -> None: ...

    def resize(self, arg: int, /) -> None: ...

    def getVolume(self) -> float: ...

    def getDifference(self) -> list[float]: ...

    def check(self) -> None: ...

    @property
    def low(self) -> list[float]: ...

    @low.setter
    def low(self, arg: Sequence[float], /) -> None: ...

    @property
    def high(self) -> list[float]: ...

    @high.setter
    def high(self, arg: Sequence[float], /) -> None: ...

class RealVectorLinearProjectionEvaluator(ProjectionEvaluator):
    @overload
    def __init__(self, space: StateSpace, cellSizes: Sequence[float], projection: Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')]) -> None: ...

    @overload
    def __init__(self, space: StateSpace, cellSizes: Sequence[float], projection: Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')]) -> None: ...

    @overload
    def __init__(self, space: StateSpace, projection: Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')]) -> None: ...

    @overload
    def __init__(self, space: StateSpace, projection: Annotated[NDArray[numpy.float64], dict(shape=(None, None), order='F')]) -> None: ...

    def getDimension(self) -> int: ...

    def project(self, arg0: State, arg1: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='C')], /) -> None: ...

class RealVectorRandomLinearProjectionEvaluator(RealVectorLinearProjectionEvaluator):
    @overload
    def __init__(self, space: StateSpace, cellSizes: Sequence[float]) -> None: ...

    @overload
    def __init__(self, space: StateSpace, cellSizes: Sequence[float]) -> None: ...

    @overload
    def __init__(self, space: StateSpace, dim: int) -> None: ...

    @overload
    def __init__(self, space: StateSpace, dim: int) -> None: ...

class RealVectorOrthogonalProjectionEvaluator(ProjectionEvaluator):
    @overload
    def __init__(self, space: StateSpace, cellSizes: Sequence[float], components: Sequence[int]) -> None: ...

    @overload
    def __init__(self, space: StateSpace, cellSizes: Sequence[float], components: Sequence[int]) -> None: ...

    @overload
    def __init__(self, space: StateSpace, components: Sequence[int]) -> None: ...

    @overload
    def __init__(self, space: StateSpace, components: Sequence[int]) -> None: ...

    def getDimension(self) -> int: ...

    def defaultCellSizes(self) -> None: ...

    def project(self, arg0: State, arg1: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='C')], /) -> None: ...

class RealVectorIdentityProjectionEvaluator(ProjectionEvaluator):
    @overload
    def __init__(self, space: StateSpace, cellSizes: Sequence[float]) -> None: ...

    @overload
    def __init__(self, space: StateSpace, cellSizes: Sequence[float]) -> None: ...

    @overload
    def __init__(self, space: StateSpace) -> None: ...

    @overload
    def __init__(self, space: StateSpace) -> None: ...

    def getDimension(self) -> int: ...

    def defaultCellSizes(self) -> None: ...

    def setup(self) -> None: ...

    def project(self, arg0: State, arg1: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='C')], /) -> None: ...

class RealVectorStateSampler(StateSampler):
    def __init__(self, arg: StateSpace, /) -> None: ...

    def sampleUniform(self, arg: State, /) -> None: ...

    def sampleUniformNear(self, arg0: State, arg1: State, arg2: float, /) -> None: ...

    def sampleGaussian(self, arg0: State, arg1: State, arg2: float, /) -> None: ...

class RealVectorStateType(State):
    @overload
    def __getitem__(self, arg: int, /) -> float: ...

    @overload
    def __getitem__(self, arg: slice, /) -> list[float]: ...

    @overload
    def __setitem__(self, arg0: int, arg1: float, /) -> None: ...

    @overload
    def __setitem__(self, arg0: slice, arg1: Sequence[float], /) -> None:
        """
        Slice assignment to state values.

        WARNING: Open-ended slices like state[:] or state[1:] do NOT work because
        StateType does not know its dimension. You must use explicit bounds:
          state[0:dim] = [...]  # OK
          state[:]     = [...]  # WRONG
        """

class RealVectorStateSpace(StateSpace):
    @overload
    def __init__(self, arg: int, /) -> None: ...

    @overload
    def __init__(self) -> None: ...

    def getDimension(self) -> int: ...

    @overload
    def addDimension(self, arg0: float, arg1: float, /) -> None: ...

    @overload
    def addDimension(self, arg0: str, arg1: float, arg2: float, /) -> None: ...

    @overload
    def setBounds(self, arg: RealVectorBounds, /) -> None: ...

    @overload
    def setBounds(self, arg0: float, arg1: float, /) -> None: ...

    def getBounds(self) -> RealVectorBounds: ...

    def getDimensionName(self, arg: int, /) -> str: ...

    def getDimensionIndex(self, arg: str, /) -> int: ...

    def setDimensionName(self, arg0: int, arg1: str, /) -> None: ...

    def getMaximumExtent(self) -> float: ...

    def getMeasure(self) -> float: ...

    def enforceBounds(self, arg: State, /) -> None: ...

    def satisfiesBounds(self, arg: State, /) -> bool: ...

    def copyState(self, arg0: State, arg1: State, /) -> None: ...

    def getSerializationLength(self) -> int: ...

    def serialize(self, arg0: types.CapsuleType, arg1: State, /) -> None: ...

    def deserialize(self, arg0: State, arg1: types.CapsuleType, /) -> None: ...

    def distance(self, arg0: State, arg1: State, /) -> float: ...

    def equalStates(self, arg0: State, arg1: State, /) -> bool: ...

    def interpolate(self, arg0: State, arg1: State, arg2: float, arg3: State, /) -> None: ...

    def allocDefaultStateSampler(self) -> StateSampler: ...

    def allocState(self) -> State: ...

    def getValueAddressAtIndex(self, arg0: State, arg1: int, /) -> float: ...

    def printState(self, arg: State, /) -> None: ...

    def printSettings(self) -> None: ...

    def registerProjections(self) -> None: ...

    def setup(self) -> None: ...

class SE2StateType(State):
    def getX(self) -> float: ...

    def getY(self) -> float: ...

    def getYaw(self) -> float: ...

    def setX(self, arg: float, /) -> None: ...

    def setY(self, arg: float, /) -> None: ...

    def setXY(self, arg0: float, arg1: float, /) -> None: ...

    def setYaw(self, arg: float, /) -> None: ...

class SE2StateSpace(CompoundStateSpace):
    def __init__(self) -> None: ...

    def setBounds(self, arg: RealVectorBounds, /) -> None: ...

    def getBounds(self) -> RealVectorBounds: ...

    def allocState(self) -> State: ...

    def registerProjections(self) -> None: ...

class SE3State(State):
    def getX(self) -> float: ...

    def getY(self) -> float: ...

    def getZ(self) -> float: ...

    def setX(self, arg: float, /) -> None: ...

    def setY(self, arg: float, /) -> None: ...

    def setZ(self, arg: float, /) -> None: ...

    def setXYZ(self, arg0: float, arg1: float, arg2: float, /) -> None: ...

    def rotation(self) -> SO3State: ...

class SE3StateSpace(CompoundStateSpace):
    def __init__(self) -> None: ...

    def setBounds(self, arg: RealVectorBounds, /) -> None: ...

    def getBounds(self) -> RealVectorBounds: ...

    def allocState(self) -> State: ...

    def registerProjections(self) -> None: ...

class SO2StateSampler(StateSampler):
    def __init__(self, arg: StateSpace, /) -> None: ...

    def sampleUniform(self, arg: State, /) -> None: ...

    def sampleUniformNear(self, arg0: State, arg1: State, arg2: float, /) -> None: ...

    def sampleGaussian(self, arg0: State, arg1: State, arg2: float, /) -> None: ...

class SO2State(State):
    def setIdentity(self) -> None:
        """Set the state to the identity (zero angle)"""

    @property
    def value(self) -> float: ...

    @value.setter
    def value(self, arg: float, /) -> None: ...

class SO2StateSpace(StateSpace):
    def __init__(self) -> None: ...

    def getDimension(self) -> int: ...

    def getMaximumExtent(self) -> float: ...

    def getMeasure(self) -> float: ...

    def enforceBounds(self, arg: State, /) -> None: ...

    def satisfiesBounds(self, arg: State, /) -> bool: ...

    def getSerializationLength(self) -> int: ...

    def serialize(self, arg0: types.CapsuleType, arg1: State, /) -> None: ...

    def deserialize(self, arg0: State, arg1: types.CapsuleType, /) -> None: ...

    def copyState(self, arg0: State, arg1: State, /) -> None: ...

    def distance(self, arg0: State, arg1: State, /) -> float: ...

    def equalStates(self, arg0: State, arg1: State, /) -> bool: ...

    def interpolate(self, arg0: State, arg1: State, arg2: float, arg3: State, /) -> None: ...

    def allocDefaultStateSampler(self) -> StateSampler: ...

    def allocState(self) -> State: ...

    def printState(self, state: State) -> None: ...

    def printSettings(self) -> None: ...

    def registerProjections(self) -> None: ...

class SO3StateSampler(StateSampler):
    def __init__(self, arg: StateSpace, /) -> None: ...

    def sampleUniform(self, arg: State, /) -> None: ...

    def sampleUniformNear(self, arg0: State, arg1: State, arg2: float, /) -> None: ...

    def sampleGaussian(self, arg0: State, arg1: State, arg2: float, /) -> None: ...

class SO3State(State):
    @overload
    def setAxisAngle(self, arg0: float, arg1: float, arg2: float, arg3: float, /) -> None: ...

    @overload
    def setAxisAngle(self, arg0: float, arg1: float, arg2: float, arg3: float, /) -> None: ...

    @overload
    def setIdentity(self) -> None: ...

    @overload
    def setIdentity(self) -> None: ...

    @property
    def x(self) -> float: ...

    @x.setter
    def x(self, arg: float, /) -> None: ...

    @property
    def y(self) -> float: ...

    @y.setter
    def y(self, arg: float, /) -> None: ...

    @property
    def z(self) -> float: ...

    @z.setter
    def z(self, arg: float, /) -> None: ...

    @property
    def w(self) -> float: ...

    @w.setter
    def w(self, arg: float, /) -> None: ...

class SO3StateSpace(StateSpace):
    def __init__(self) -> None: ...

    def norm(self, arg: SO3State, /) -> float: ...

    def getDimension(self) -> int: ...

    def getMaximumExtent(self) -> float: ...

    def getMeasure(self) -> float: ...

    def enforceBounds(self, arg: State, /) -> None: ...

    def satisfiesBounds(self, arg: State, /) -> bool: ...

    def getSerializationLength(self) -> int: ...

    def serialize(self, arg0: types.CapsuleType, arg1: State, /) -> None: ...

    def deserialize(self, arg0: State, arg1: types.CapsuleType, /) -> None: ...

    def copyState(self, arg0: State, arg1: State, /) -> None: ...

    def distance(self, arg0: State, arg1: State, /) -> float: ...

    def equalStates(self, arg0: State, arg1: State, /) -> bool: ...

    def interpolate(self, arg0: State, arg1: State, arg2: float, arg3: State, /) -> None: ...

    def allocDefaultStateSampler(self) -> StateSampler: ...

    def allocState(self) -> State: ...

    def getValueAddressAtIndex(self, arg0: State, arg1: int, /) -> float: ...

    def printState(self, state: State) -> None: ...

    def printSettings(self) -> None: ...

    def registerProjections(self) -> None: ...

class SpaceTimeStateSpace(CompoundStateSpace):
    def __init__(self, spaceComponent: StateSpace, vMax: float = 1.0, timeWeight: float = 0.5) -> None: ...

    def distance(self, state1: State, state2: State) -> float: ...

    def timeToCoverDistance(self, state1: State, state2: State) -> float: ...

    def distanceSpace(self, state1: State, state2: State) -> float: ...

    def distanceTime(self, state1: State, state2: State) -> float: ...

    @staticmethod
    def getStateTime(state: State) -> float: ...

    def setTimeBounds(self, lower: float, upper: float) -> None: ...

    def getVMax(self) -> float: ...

    def setVMax(self, vMax: float) -> None: ...

    def getSpaceComponent(self) -> StateSpace: ...

    def getTimeComponent(self) -> TimeStateSpace: ...

    def isMetricSpace(self) -> bool: ...

    def getMaximumExtent(self) -> float: ...

    def updateEpsilon(self) -> None: ...

class TimeStateSampler(StateSampler):
    def __init__(self, arg: StateSpace, /) -> None: ...

    def sampleUniform(self, arg: State, /) -> None: ...

    def sampleUniformNear(self, arg0: State, arg1: State, arg2: float, /) -> None: ...

    def sampleGaussian(self, arg0: State, arg1: State, arg2: float, /) -> None: ...

class TimeState(State):
    @property
    def position(self) -> float: ...

    @position.setter
    def position(self, arg: float, /) -> None: ...

class TimeStateSpace(StateSpace):
    def __init__(self) -> None: ...

    def setBounds(self, minTime: float, maxTime: float) -> None: ...

    def getMinTimeBound(self) -> float: ...

    def getMaxTimeBound(self) -> float: ...

    def isBounded(self) -> bool: ...

    def enforceBounds(self, arg: State, /) -> None: ...

    def satisfiesBounds(self, arg: State, /) -> bool: ...

    def copyState(self, arg0: State, arg1: State, /) -> None: ...

    def getSerializationLength(self) -> int: ...

    def serialize(self, arg0: types.CapsuleType, arg1: State, /) -> None: ...

    def deserialize(self, arg0: State, arg1: types.CapsuleType, /) -> None: ...

    def distance(self, arg0: State, arg1: State, /) -> float: ...

    def equalStates(self, arg0: State, arg1: State, /) -> bool: ...

    def interpolate(self, arg0: State, arg1: State, arg2: float, arg3: State, /) -> None: ...

    def allocDefaultStateSampler(self) -> StateSampler: ...

    def allocState(self) -> State: ...

    def getValueAddressAtIndex(self, arg0: State, arg1: int, /) -> float: ...

    def printState(self, state: State) -> None: ...

    def printSettings(self) -> None: ...

    def registerProjections(self) -> None: ...

class WrapperStateSampler(StateSampler):
    def __init__(self, space: StateSpace, sampler: StateSampler) -> None:
        """Construct a wrapper sampler that delegates to a given sampler"""

    def sampleUniform(self, state: State) -> None:
        """Uniformly sample the wrapped space"""

    def sampleUniformNear(self, state: State, near: State, distance: float) -> None:
        """Uniformly sample near a state, delegated to the inner sampler"""

    def sampleGaussian(self, state: State, mean: State, stdDev: float) -> None:
        """Gaussian sample, delegated to the inner sampler"""

class WrapperProjectionEvaluator(ProjectionEvaluator):
    def __init__(self, space: WrapperStateSpace) -> None:
        """Wrap the default projection evaluator of an existing state space"""

    def setup(self) -> None:
        """Trigger any deferred initialization"""

    def getDimension(self) -> int:
        """Return the projection dimension"""

    def project(self, state: State, projection: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='C')]) -> None:
        """Project a wrapped state into the low‑dimensional space"""

class WrapperStateType(State):
    pass

class WrapperStateSpace(StateSpace):
    def __init__(self, space: StateSpace) -> None:
        """Construct a wrapper around any existing StateSpace"""

    def isCompound(self) -> bool: ...

    def isDiscrete(self) -> bool: ...

    def isHybrid(self) -> bool: ...

    def isMetricSpace(self) -> bool: ...

    def hasSymmetricDistance(self) -> bool: ...

    def hasSymmetricInterpolate(self) -> bool: ...

    def getName(self) -> "std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>": ...

    def setName(self, name: "std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>") -> None: ...

    def getType(self) -> int: ...

    def includes(self, other: StateSpace) -> bool: ...

    def covers(self, other: StateSpace) -> bool: ...

    def params(self) -> "ompl::base::ParamSet": ...

    def getLongestValidSegmentFraction(self) -> float: ...

    def setLongestValidSegmentFraction(self, fraction: float) -> None: ...

    def validSegmentCount(self, state1: State, state2: State) -> int: ...

    def setValidSegmentCountFactor(self, factor: int) -> None: ...

    def getValidSegmentCountFactor(self) -> int: ...

    def getLongestValidSegmentLength(self) -> float: ...

    def computeSignature(self, signature: "std::__1::vector<int, std::__1::allocator<int>>") -> None: ...

    def getDimension(self) -> int: ...

    def getMaximumExtent(self) -> float: ...

    def getMeasure(self) -> float: ...

    def enforceBounds(self, state: State) -> None: ...

    def satisfiesBounds(self, state: State) -> bool: ...

    def copyState(self, dest: State, src: State) -> None: ...

    def distance(self, state1: State, state2: State) -> float: ...

    def getSerializationLength(self) -> int: ...

    def serialize(self, buffer: types.CapsuleType, state: State) -> None: ...

    def deserialize(self, state: State, buffer: types.CapsuleType) -> None: ...

    def equalStates(self, s1: State, s2: State) -> bool: ...

    def interpolate(self, from: State, to: State, t: float, state: State) -> None: ...

    def allocDefaultStateSampler(self) -> StateSampler: ...

    def allocState(self) -> State: ...

    def freeState(self, state: State) -> None: ...

    def getValueAddressAtIndex(self, state: State, index: int) -> float: ...

    def getValueAddressAtLocation(self, state: State, loc: "ompl::base::StateSpace::ValueLocation") -> float: ...

    def getValueAddressAtName(self, state: State, name: "std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char>>") -> float: ...

    def copyToReals(self, reals: "std::__1::vector<double, std::__1::allocator<double>>", source: State) -> None: ...

    def copyFromReals(self, dest: State, reals: "std::__1::vector<double, std::__1::allocator<double>>") -> None: ...

    def registerProjections(self) -> None: ...

    def printState(self, state: State, out: "std::__1::basic_ostream<char, std::__1::char_traits<char>>") -> None: ...

    def printSettings(self, out: "std::__1::basic_ostream<char, std::__1::char_traits<char>>") -> None: ...

    def printProjections(self, out: "std::__1::basic_ostream<char, std::__1::char_traits<char>>") -> None: ...

    def sanityChecks(self, zero: float, eps: float, flags: int) -> None: ...

    def allocSubspaceStateSampler(self, subspace: StateSpace) -> StateSampler: ...

    def computeLocations(self) -> None: ...

    def setup(self) -> None: ...

    def getSpace(self) -> StateSpace: ...

class EmptyStateSpace(RealVectorStateSpace):
    def __init__(self) -> None: ...

    def getMeasure(self) -> float: ...

    def getDimension(self) -> int: ...

    def getMaximumExtent(self) -> float: ...

    def setup(self) -> None: ...

CONSTRAINED_STATE_SPACE_DELTA: float = 0.05

CONSTRAINED_STATE_SPACE_LAMBDA: float = 2.0

class ConstrainedMotionValidator(MotionValidator):
    @overload
    def __init__(self, si: SpaceInformation) -> None: ...

    @overload
    def __init__(self, siPtr: SpaceInformation) -> None: ...

    def checkMotion(self, s1: State, s2: State) -> bool: ...

class ConstrainedStateSpaceStateType(WrapperStateType):
    def copy(self, other: Sequence[float]) -> None: ...

    def __getitem__(self, i: int) -> float: ...

class ConstrainedStateSpace(WrapperStateSpace):
    def __init__(self, ambientSpace: StateSpace, constraint: Constraint) -> None: ...

    def setSpaceInformation(self, si: SpaceInformation) -> None: ...

    def setup(self) -> None: ...

    def clear(self) -> None: ...

    def allocState(self) -> State: ...

    def constrainedSanityChecks(self, flags: int) -> None: ...

    def sanityChecks(self) -> None: ...

    def validSegmentCount(self, s1: State, s2: State) -> int: ...

    def interpolate(self, from: State, to: State, t: float, state: State) -> None: ...

    def geodesicInterpolate(self, geodesic: Sequence[State], t: float) -> State: ...

    def setDelta(self, delta: float) -> None: ...

    def getDelta(self) -> float: ...

    def setLambda(self, lambda: float) -> None: ...

    def getLambda(self) -> float: ...

    def getAmbientDimension(self) -> int: ...

    def getManifoldDimension(self) -> int: ...

    def getConstraint(self) -> Constraint: ...

class ProjectedStateSampler(WrapperStateSampler):
    def __init__(self, space: ProjectedStateSpace, sampler: StateSampler) -> None: ...

    def sampleUniform(self, state: State) -> None: ...

    def sampleUniformNear(self, state: State, near: State, distance: float) -> None: ...

    def sampleGaussian(self, state: State, mean: State, stdDev: float) -> None: ...

class ProjectedStateSpace(ConstrainedStateSpace):
    def __init__(self, ambientSpace: StateSpace, constraint: Constraint) -> None: ...

    def allocDefaultStateSampler(self) -> StateSampler: ...

    def allocStateSampler(self) -> StateSampler: ...

    def discreteGeodesic(self, from: State, to: State, interpolate: bool = False) -> "std::__1::pair<bool, std::__1::vector<ompl::base::State*, std::__1::allocator<ompl::base::State*>>>": ...

class AtlasChart:
    def __init__(self, atlas: AtlasStateSpace, state: State) -> None: ...

    def clear(self) -> None: ...

    def getOrigin(self) -> State: ...

    def getAmbientDimension(self) -> int: ...

    def getManifoldDimension(self) -> int: ...

    def phi(self, u: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='C')]) -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order='C')]: ...

    def psi(self, u: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='C')]) -> "std::__1::pair<bool, Eigen::Matrix<double, -1, 1, 0, -1, 1>>": ...

    def psiInverse(self, x: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='C')]) -> Annotated[NDArray[numpy.float64], dict(shape=(None,), order='C')]: ...

    def inPolytope(self, u: Annotated[NDArray[numpy.float64], dict(shape=(None,), order='C')]) -> bool: ...

    def borderCheck(self, v: Annotated[NDArray[numpy.float64], dict(shape=(None,), writable=False)]) -> None: ...

    def owningNeighbor(self, x: Annotated[NDArray[numpy.float64], dict(shape=(None,), writable=False)]) -> AtlasChart: ...

    def toPolygon(self) -> "std::__1::pair<bool, std::__1::vector<Eigen::Matrix<double, -1, 1, 0, -1, 1>, std::__1::allocator<Eigen::Matrix<double, -1, 1, 0, -1, 1>>>>": ...

    def getNeighborCount(self) -> int: ...

    def estimateIsFrontier(self) -> bool: ...

    @staticmethod
    def generateHalfspace(c1: AtlasChart, c2: AtlasChart) -> None: ...

ATLAS_STATE_SPACE_SAMPLES: int = 50

ATLAS_STATE_SPACE_EPSILON: float = 0.05

ATLAS_STATE_SPACE_RHO_MULTIPLIER: int = 5

ATLAS_STATE_SPACE_ALPHA: float = 0.39269908169872414

ATLAS_STATE_SPACE_EXPLORATION: float = 0.75

ATLAS_STATE_SPACE_MAX_CHARTS_PER_EXTENSION: int = 200

ATLAS_STATE_SPACE_BACKOFF: float = 0.75

class AtlasStateSampler(StateSampler):
    def __init__(self, space: AtlasStateSpace) -> None: ...

    def sampleUniform(self, state: State) -> None: ...

    def sampleUniformNear(self, state: State, near: State, distance: float) -> None: ...

    def sampleGaussian(self, state: State, mean: State, stdDev: float) -> None: ...

class AtlasStateType(ConstrainedStateSpaceStateType):
    pass

class AtlasStateSpace(ConstrainedStateSpace):
    def __init__(self, ambientSpace: StateSpace, constraint: Constraint, separate: bool = True) -> None: ...

    def clear(self) -> None: ...

    def allocDefaultStateSampler(self) -> StateSampler: ...

    def allocStateSampler(self) -> StateSampler: ...

    def setEpsilon(self, epsilon: float) -> None: ...

    def setRho(self, rho: float) -> None: ...

    def setAlpha(self, alpha: float) -> None: ...

    def setExploration(self, exploration: float) -> None: ...

    def setMaxChartsPerExtension(self, charts: int) -> None: ...

    def setSeparated(self, separate: bool) -> None: ...

    def setBackoff(self, backoff: float) -> None: ...

    def getEpsilon(self) -> float: ...

    def getRho(self) -> float: ...

    def getAlpha(self) -> float: ...

    def getExploration(self) -> float: ...

    def getRho_s(self) -> float: ...

    def getMaxChartsPerExtension(self) -> int: ...

    def isSeparated(self) -> bool: ...

    def getChartCount(self) -> int: ...

    def getBackoff(self) -> float: ...

    def discreteGeodesic(self, from: State, to: State, interpolate: bool = False) -> "std::__1::pair<bool, std::__1::vector<ompl::base::State*, std::__1::allocator<ompl::base::State*>>>": ...

    def anchorChart(self, state: State) -> AtlasChart: ...

    def estimateFrontierPercent(self) -> float: ...

    def printPLY(self) -> str: ...

class TangentBundleStateSpace(AtlasStateSpace):
    def __init__(self, baseSpace: StateSpace, tangentSpace: Constraint) -> None: ...
