import { Operation, MotionResult, EndResult } from "./Operation";
import { ProcessFurtherOperation } from "./ProcessFurtherOperation";
/**
 * Class for checking if the position that objects will be moved / rotated to is invalid due to collisions
 * If so, it resets the position (and rotation) to the last known valid one.
 */
export declare class CollisionCheckOperation extends ProcessFurtherOperation {
    /** The ids of the objects that will be checked for invalid positions. */
    private componentIds;
    /** If set we will log collision events */
    static log: boolean;
    /**
     * The constructor. Sets the other mode that will be executed.
     * @param preceedingOperation
     * @param componentIds The ids of the involved components.
     */
    constructor(preceedingOperation: Operation, componentIds: string[]);
    protected processMotionResult(resultParam: MotionResult): MotionResult;
    /**
     * Checks if the motion result has invalid transformations
     * @param result
     * @returns {boolean}
     */
    private isMotionInvalid;
    private getCollidableComponents;
    /**
     * Checks if the transformation assigned by snapTransformations results in an invalid snap
     * @param snapTransformations the transformations of the selected components due to the snap
     * @param snapTo the component to snap to
     * @param ignoreSnapCollision if set, ignore collision with the snapped object
     * @returns {any}
     */
    private isSnapInvalid;
    /**
     * Checks if the transformation of the selected components will result in an invalid position
     * @param transformations the transformation
     * @param componentsToCheck the components we want to check collision with
     * @param error the amount of overlap allowed
     * @returns {boolean}
     */
    private isInvalid;
    /**
     * Check if a point in the passed transformation is unsupported, i.e. if it is hovering in the air unsupported
     * @param transformations
     * @param error the amount by which to reduce the bounding box to allow for errors e.g. in modeling
     * @returns {boolean}
     */
    private isSomePointUnsupported;
    /**
     * check if there is a collision of the selected components and the passed components
     * @param componentsToCheck the components against which to check for collision
     * @param transformations
     * @param error the amount by which to reduce the bounding box to allow for some overlap
     * @returns {boolean}
     */
    private isCollision;
    protected processEndResult(result: EndResult): EndResult;
    /**
     * Logs the message, if the log variable is set
     * @param message the message to be logged
     *
     */
    private log;
    /**
     * Get all valid matches from the result
     * @param resultParam
     * @returns {Array<SnapMatch>}
     */
    private validMatches;
}
