import * as Core from "@intelligentgraphics/ig.gfx.core";
import { AttachPointType, MathTypes } from "@intelligentgraphics/ig.gfx.core";
import { SnapMode } from "../../Types";
/**
 * This abstract class combines all abstract information there is for a snap match.
 * The abstract isValid member (implemented in the child classes) should return true if the conditions for the snap match is set
 *
 * The first point passed to the constructor should always be the currently moving element!
 */
export declare abstract class SnapMatch {
    /** The maximum distance between two points to allow for a snap match */
    static maxDistance: number;
    /** The maximum rotation difference between two points to allow for a snap match. given in radians */
    static maxRotation: number;
    /** Maximal distance for a precice snap match */
    static preciseDistance: number;
    /** The center of rotation around which the first component will have to rotate for this snapping */
    centerOfRotation: Core.Float3;
    /** The position difference, i.e. the translation to be applied for this match */
    positionDifference: Core.Float3;
    /** The distance between the two matching points */
    distance: number;
    /** The rotation difference, i.e. the rotation to be applied for this match (only in y direction). given in radians. */
    rotationDifference: number;
    /** The Id of the first component */
    firstId: string;
    /** The type of the first point */
    firstType: AttachPointType;
    /** The key of the first point */
    firstKey: string;
    /** The foreign key of the first point */
    firstForeignKey: string;
    /** The Id of the second component */
    secondId: string;
    /** The type of the second point */
    secondType: AttachPointType;
    /** The key of the second point */
    secondKey: string;
    /** The foreign key of the second point */
    secondForeignKey: string;
    secondRootId: string;
    /** The component that has the actions that belong to this snap. */
    actionHolders: string[];
    /** The snapMode for this match */
    snapMode: SnapMode;
    /** The distance in the xy plane, excluding the y component  */
    xzDistance: number;
    /** True if collision with the snapped to object is not an issue (i.e. child snapping) */
    canIntersectSnappedTo: boolean;
    hasGhostModeRepresentation: boolean;
    representation: string;
    /**
     * The constructor of the SnapMode class. It calculates the common attributes of a snap match.
     * @param firstPoint the first point
     * @param secondPoint the second point
     * @param firstId the first id
     * @param secondId the second id
     */
    constructor(firstPoint: Core.Point, secondPoint: Core.Point, firstId: string, secondId: string);
    /**
     * Returns true if the match is a valid match, i.e. the constraints for this type of match are met.
     */
    abstract isValid(): boolean;
    /**
     * @returns true if the distance of the match is small enough to count as a precise match
     */
    isPrecise(): boolean;
    /**
     * Adapts the previous transformation to execute the snap match taking care of rotation center and angle
     * @param previous
     * @returns the new transformation
     */
    adaptTransformation(previous: MathTypes.Transformation): MathTypes.Transformation;
    getActions(): Core.IGXM.ISingleAction[];
}
