import { AsyncHook, SyncHook } from "@intelligentgraphics/ig.utilities";
import { Interactor, Touch } from "./Interactor";
import { Material } from "./Material";
import { Bounds } from "./Math/Bounds";
import { CollisionInformation, ColorRGB, Direction, EGhostMode, Float3, WorldCoordinates, IAbstractBounds, LocalCoordinates, LocalRotation, ComponentId, Wall } from "./Types";
import * as IGXC from "./IGXC";
import * as IGXM from "./IGXM";
import { Point, AttachPointType } from "./AttachPoint";
import * as RenderBehaviours from "./RenderBehaviours";
import { IRegionManager } from "./RegionManager";
import { vec3 } from "./Math/Vector";
import { Transformation } from "./Math/MathTypes";
import { WriterOptions } from "./IGXCWriter";
import { ELoadGeometryPreviews } from "./State";
import { ProcessIGXCChanges } from "./Loader";
export declare const GhostPostfix: string;
export declare const PlatformPostfix: string;
export declare const RootPostfix: string;
export interface IDetailedHitInfo {
    /** gfxId of the uptraversed root component */
    rootComponentId: string;
    /** the uptraversed root component */
    rootComponent: any;
    /** gfxId of the IG component containing the hit mesh */
    componentId: string;
    /** the component containing the hit mesh */
    intersectedComponent: any;
    /** the mesh which was actually hit */
    intersectedMesh: any;
    /** distance from hit point to camera */
    distanceToCamera: number;
    /** world posiion of the hit point */
    hitPoint: vec3;
}
export interface IWallInfo {
    Left: number;
    Down: number;
    Angle: number;
    WallPaperWidth: number;
    Height: number;
    Thickness: number;
    Duplicate: boolean;
    LeftRoom: boolean;
    RightRoom: boolean;
    Front: boolean;
    Id: any;
}
export interface IComponentData {
    actions?: IGXM.ISingleAction[];
    /**
     * if component has animation and is at minimum once started, start/end status are being saved in this property
     */
    animationPosition?: "Start" | "End";
    /**
     * The progress number of the components interactors in the range of 0 <= progress <= 1
     *
     * @type {number}
     */
    animationProgress?: number;
    aoMapTransform?: number[];
    aoMapUrl?: string;
    categories?: ReadonlyArray<string>;
    comId?: string;
    computeNormals?: boolean;
    evaluator?: string;
    evaluatorParameters?: any;
    freeFormDeformation?: IDeformationData;
    geometry?: string;
    geometryParameters?: Record<string, any>;
    geometryNormalMapUrl?: string;
    geometryStatus?: "preview" | "default";
    ghostDisplayMode?: EGhostMode;
    hasAnimations?: boolean;
    interactor?: string;
    interactorParameters?: any;
    layer?: string;
    material?: string;
    materialCategory?: string;
    multiArticleConfiguration?: Record<string, string>;
    orderNumber?: string;
    platformNode?: boolean;
    platformUsage?: PlatformUsageType;
    points?: IGXC.AttachPoint[];
    productHash?: string;
    selectable?: "Parent" | "Self" | "None";
    transform?: IGXC.Transform;
    wallInfo?: IWallInfo;
}
export declare type PlatformUsageType = "AttachPoints" | "Measure" | "SubPlatformParent" | "SelectionBox" | "Dimensioning";
export interface IDeformationData {
    progress: number;
}
export interface IProcessIGXCOptions {
    computeNormals?: boolean;
    loadMode?: ELoadGeometryPreviews;
}
export declare type GfxLoadStatus = "previewLoaded" | "finalLoaded";
export interface APIHooks {
    afterGfxLoad: AsyncHook<[ComponentId, GfxLoadStatus]>;
    afterRootTransformationChange: SyncHook<[ComponentId]>;
    /**
     * Called when the progress of an animation changes with the root id and the progress value.
     *
     * The progress value will be in the range of 0 <= progress <= 1
     *
     * @type {SyncHook<[ComponentId, number]>}
     */
    afterAnimationProgressChange: SyncHook<[ComponentId, number]>;
}
/**
 *
 * *** API DEFINITION AND PARTIAL IMPLEMENTATION ***
 *
 * API defines an implementation-independent API to be used by the Interactor and Evaluator scripts.
 *
 * API consists of low-level functions that need to be implemented by any Driver library, and
 * high-level functions that are implemented by low-level and/or high-level functions.
 *
 * Low-level functions are in this file provided as empty, exception-throwing bodies. Any API
 * implementation must implement the whole set of functions by overloading the predefined empty functions.
 *
 * The key concept of API is a Component. Basically a Component consists of
 *
 * (1) a ComponentId, a hierarchical path that identifies the component
 *
 * (2) graphical attributes that typically can be mapped 11 to regular scene graphs, such as
 *     transform, bbox, children, etc.
 *
 * (3) other attributes that may be stored in a general key-value dictionary
 *
 * Copyright (C) 2013 - 2016 intelligentgraphics Gmbh. All rights reserved.
 *
 */
export declare abstract class _API {
    /** handle for requested animation frame, used in postprocecssing */
    protected animationFrameHandle: number;
    /** Default exception for abstract, i.e. un-implemented, functions. */
    static Exception: string;
    abstract RegionManager: IRegionManager;
    Hooks: APIHooks;
    constructor();
    /**
     * Default handler if a component was accessed that does not exist.
     *
     * @param componentId The id that could not be mapped to a component.
     * @param result The default result to be returned.
     *
     * @returns The passed result.
     */
    NoSuchComponent<T>(componentId: string, result: T): T;
    /** Postfix for the root objects.
     * @deprecated
     */
    ROOT_POSTFIX: string;
    /** Postfix for the ghost objects.
     * @deprecated
     */
    GHOST_POSTFIX: string;
    /** Conversion from Deg to Radiant.
     * @deprecated
     */
    DEG2RAD: number;
    /** Conversion from Radiant to Deg.
     * @deprecated
     */
    RAD2DEG: number;
    /** Primary selection color */
    PRIMARY_BBOX_COLOR: {
        r: number;
        g: number;
        b: number;
    };
    /** Secondary selection color */
    SECONDARY_BBOX_COLOR: {
        r: number;
        g: number;
        b: number;
    };
    /** The global dictionary of known materials. */
    Materials: {
        [name: string]: Material;
    };
    GeometryLinks: {
        [name: string]: string;
    };
    /**
     * The platform the application is running on.
     * Available values: "iOS".
     */
    Platform: string;
    /** Enumeration of available callback names. */
    CALLBACKS: {
        INSERTED: string;
        NEIGHBOR_ADDING: string;
        NEIGHBOR_ADDED: string;
        SNAPPED: string;
    };
    RenderBehaviour: RenderBehaviours.Direct;
    /** Factor to control speed of interactions, to be redefined in Drivers on demand */
    MotionScale: number;
    /** Log component life cycle. */
    Log_LifeCycle: boolean;
    /** Log interaction. */
    Log_Interaction: boolean;
    /** Log events on abstract level. */
    Log_Events: boolean;
    /** Log events on detail level (only if Log_Events is true) */
    Log_EventsDetailed: boolean;
    /** Log events on touch level */
    Log_EventsTouches: boolean;
    /** Log highlighting. */
    Log_Highlighting: boolean;
    /** Log material handling. */
    Log_Material: boolean;
    abstract CreateSuperRoot(): string;
    /**
     * Loads a JSON file containing a dictionary that maps material names to IGX material
     * descriptions. The materials will be added to the local, strictly monotonic increasing
     * repository of materials. Existing materials with identical name, will be overridden.
     *
     * @param url The URL to be loaded.
     * @param callback To be invoked after loading the materials. Gets True on success.
     */
    abstract LoadMaterials(url: string, callback?: (loaded: boolean) => void): Promise<boolean>;
    /**
     * Like LoadMaterials, but parses an already loaded Object containing a dictionary that maps
     * material names to IGX material descriptions. The materials will be added to the local,
     * strictly monotonic increasing repository of materials. Existing materials with identical
     * name, will be overridden. Since this process is synchronous, the callback parameter is
     * replaced with a boolean return value.
     *
     * @param matObj The material dictionary.
     * @returns True on success.
     */
    abstract AddMaterials(matObj: Record<string, any>): Promise<boolean>;
    DeleteComponent(componentId: string): void;
    /**
     * Removes an object (recursively).
     *
     * @param componentId Id of the component to be remove.
     */
    abstract RemoveComponent(componentId: string): void;
    /**
     * Returns the order number of the Component.
     *
     * @param componentId Component id.
     *
     * @returns The order number, or null.
     */
    abstract GetOrderNumber(componentId: string): string | null;
    /**
     * Assigns a commercial instance id to the Component.
     *
     * @param componentId Component id.
     * @param commercialId The commercial id.
     */
    abstract SetCommercialId(componentId: string, commercialId: string): void;
    /**
     * Gets the commercial instance id to the Component.
     *
     * @param componentId Component id.
     *
     * @returns The commercial id.
     */
    abstract GetCommercialId(componentId: string): string | null;
    /**
     * Returns all root components.
     *
     * @returns The corresponding ids, or null/empty array.
     */
    abstract GetRoots(): string[];
    /**
     * Returns the immediate parent.
     *
     * @param componentId Id of a Component, e.g. a Product.
     *
     * @returns The Id of the parent, or null/undefined.
     */
    abstract GetParent(componentId: string): string | null;
    /**
     * Adds a child (hierarchy).
     *
     * @param componentId Id of a Component, e.g. a Product.
     * @param description An IGXC sub set containing a (hierarchical)
     * structure definition. The root object in that description must
     * have the Path . All path values will be re-written to the dynamically
     * created path of the added child root.
     *
     * @param redraw if set to false, do not redraw the scene after adding the child
     * @returns The id of the added child root, or null/undefined in case of error.
     */
    AddChild(componentId: ComponentId, description: IGXC.Scene, redraw?: boolean): Promise<string>;
    /**
     * Returns the immediate childen.
     *
     * @param componentId Id of a Component, e.g. a Product.
     *
     * @returns Array of children ids, or null/empty array.
     */
    abstract GetChildren(componentId: string): string[];
    /**
     * Returns the id of the immediate neighbor with the specified local Id.
     *
     * @param componentId Id of a Component, e.g. a Product.
     * @param localId Local path of the requested object.
     *
     * @returns The Id of the neighbor, if existing, or null.
     */
    GetNeighbor(componentId: string, localId: string): string | null;
    /**
     * Returns an array of the immediate sub products.
     *
     * @param componentId = null Component id. If null, the function is applied to the root objects.
     * @param category = null Specifies a list of Categories to be used as a filter. If specified, only
     * Products will be considered that match at least one of the given Categories.
     *
     * @returns The Ids of the found Products, or empty array, or null in case of error.
     */
    abstract GetProducts(componentId: string, category: string): string[];
    /**
     * Get position and rotation of a (sub-) component in the world
     * Use Webgl lib specific matrix transformations for implementing efficiently
     *
     * @param componentId
     *
     */
    abstract GetBasicWorldTransformation(componentId: string, setPositionCompatibility?: boolean): Transformation;
    /**
     * Returns an array of the sub components, either the immediate
     * ones or all.
     *
     * @param componentId Component id. If null, the function is applied to the root objects.
     * @param recurse = false Controls if only immediate or all sub components should be returned.
     *
     * @returns The Ids of the found Components, or empty array, or null in case of error.
     */
    GetComponents(componentId: string, recurse: boolean): string[];
    /**
     * Gets the native representation of a Component.
     *
     * @param componentId Component id.
     *
     * @returns The native component, or null.
     */
    abstract GetComponent(componentId: string): any | null;
    TraverseComponent(componentId: string, cb: (componentId: string) => void): void;
    abstract GetComponentData(componentId: string): IComponentData;
    abstract SetComponentData<K extends keyof IComponentData>(componentId: string, key: K, value: IComponentData[K]): void;
    abstract SetComponentData(componentId: string, key: string, value: any): void;
    /**
     * Checks the validity of Component.
     *
     * @param componentId Component id.
     *
     * @returns true if this is a valid component id, or false.
     */
    abstract IsValid(componentId: string): boolean;
    /**
     * Sets the selection mode of the Component.
     *
     * @param componentId Component id.
     * @param mode The selection mode: 'None', 'Parent', 'Self'
     */
    abstract SetSelectionMode(componentId: string, mode: "None" | "Parent" | "Self"): void;
    /**
     * Returns the selection mode of the Component.
     *
     * @param componentId Component id.
     *
     * @returns The selection mode: 'None', 'Parent', 'Self'
     */
    abstract GetSelectionMode(componentId: string): string;
    /**
     * Returns the interactor of the Component, and its parameters.
     *
     * @param componentId Component id.
     *
     * @returns The type (key: Type) and the parameters (if any), or null.
     */
    abstract GetInteractor(componentId: string): {} | null;
    /**
     * Updates an interactor parameter of the Component.
     *
     * @param componentId Component id.
     * @param key The interactor parameter key.
     * @param value The value to be assigned to this parameter.
     */
    abstract UpdateInteractor(componentId: string, key: string, value: any): void;
    /**
     * Returns the evaluator of the Component, and its parameters.
     *
     * @param componentId Component id.
     *
     * @returns The type (key: Type) and the parameters (if any), or null.
     */
    abstract GetEvaluator(componentId: string): {} | null;
    /**
     * Updates an evaluator parameter of the Component.
     *
     * @param componentId Component id.
     * @param key The evaluator parameter key.
     * @param value The value to be assigned to this parameter.
     */
    abstract UpdateEvaluator(componentId: string, key: string, value: any): void;
    /**
     * Set the visibility of a component.
     *
     * @param componentId Component id.
     * @param visible The visibility to be set.
     */
    abstract SetVisibility(componentId: string, visible: boolean): void;
    /**
     * Get the visibility of a component.
     *
     * @param componentId Component id.
     *
     * @returns The current visibility.
     */
    abstract GetVisibility(componentId: string): boolean;
    /**
     * Highlights the component with the specified color.
     * If color is null, un-highlight the component.
     *
     * @param componentId Component id.
     * @param visible The visibility to be set.
     * @param noRedraw If set to true, suppress redraw.
     */
    abstract Highlight(componentId: string, color: ColorRGB | null, noRedraw?: boolean): void;
    /**
     * Sets up the ghost representation. Use mode None to remove the ghost.
     *
     * @param componentId Component id, must be a root component.
     * @param mode The mode for the creation (or removal) of the ghost.
     */
    abstract SetupGhost(componentId: string, mode: EGhostMode, addOnlyOne: boolean): void;
    /**
     * Gets the ghost id for the passed component id.
     *
     * @param componentId Component id, must be a root component.
     *
     * @returns The ghost's component id, or null.
     */
    abstract GetGhostIds(componentId: string): string[];
    /**
     * Sets the hash of the Component. The hash covers the whole geometric
     * representation of the sub tree of a root component. This should normally ONLY
     * be used by APILoadUpdate().
     *
     * @param componentId Component id.
     * @param hash a hash value.
     *
     * @returns
     */
    abstract SetHash(componentId: string, hash: string): void;
    /**
     * Returns the hash of the Component.
     *
     * @param componentId Component id.
     *
     * @returns The hash, or null.
     */
    abstract GetHash(componentId: string): string | null;
    /**
     * Sets a (new) geometry to the Component.
     *
     * @param componentId Component id.
     * @param geometry The scoped geometry id.
     * @param url The url of the geometry file.
     */
    abstract SetGeometry(componentId: string, geometry: string, url: string): void;
    /**
     * Returns the geometry of the Component.
     *
     * @param componentId Component id.
     *
     * @returns The geometry, or null.
     */
    abstract GetGeometry(componentId: string): string | null;
    /**
     * Sets a deformation value for the Component's geometry.
     *
     * @param componentId Component id.
     * @param progress The deformation progress value, from 0 (no deformation) to 1 (fully deformed).
     */
    abstract SetDeformation(componentId: string, progress: number): void;
    /**
     * Returns the layer of the Component.
     *
     * @param componentId Component id.
     *
     * @returns The layer, or null.
     */
    abstract GetLayer(componentId: string): string | null;
    /**
     * Sets the material of an object (tree).
     *
     * @param componentId Component id.
     * @param category Material category.
     * @param Material object or name of a loaded material.
     */
    SetCategoryMaterial(componentId: string, category: string, material: string | Material): Promise<void>;
    /**
     * Sets the materials of an object (tree).
     *
     * @param componentId Component id.
     * @param categories Material categories, each with a material.
     * @param materials Materials.
     */
    SetCategoryMaterials(componentId: string, categories: Record<string, string | Material>, materialDefinitions?: Record<string, Material>): Promise<void>;
    /**
     * Sets the material of an object.
     *
     * @param componentId Component id.
     * @param Material object or name of a loaded material.
     */
    abstract SetMaterial(componentId: string, description: string | Material): Promise<void>;
    /**
     * Gets the material of an object.
     *
     * @param componentId Component id.
     *
     * @returns The fully qualified material name, if available.
     */
    abstract GetMaterial(componentId: string): string | null;
    /**
     * Returns the (inherited) material category of the Component.
     *
     * @param componentId Component id.
     *
     * @returns The category or null.
     */
    abstract GetMaterialCategory(componentId: string): string | null;
    /**
     * Returns the product categories of the Product.
     *
     * @param componentId Component id.
     * @param categories An array of categories.
     */
    abstract SetCategories(componentId: string, categories: string[]): void;
    /**
     * Returns the product categories of the Product.
     *
     * @param componentId Component id.
     *
     * @returns The categories or empty array.
     */
    GetCategories(componentId: string): readonly string[];
    /**
     * Returns the (recursive) bounding box of the Component.
     *
     * @param componentId Component id. If null, the cummulated box of the root objects will be returned.
     *
     * @param context 'Local', 'World', 'WorldFastButNotPrecise' (uses cached local bounds transformed by world matrix)
     *
     * @param considerScaleForLocalContext: (default true) if set to true, also consider the scale of the bounds.
     * Not used if world bounds are calculated.
     *
     * @returns { Bounds }.
     */
    abstract GetBounds(componentId: string | null | undefined, context: "Local" | "World" | "WorldFastButNotPrecise", considerScaleForLocalContext?: boolean): Bounds;
    /**
     * Sets the position of an object.
     *
     * @param componentId Component id.
     * @param { x float, y: float, z: float }: Position of an object.
     */
    abstract SetPosition(componentId: string, position: Float3): void;
    /**
     * Returns the position of an object.
     *
     * @param string componentId Component id.
     *
     * @returns object { x float, y: float, z: float }: The position.
     */
    abstract GetPosition(componentId: string): Float3;
    /**
     * Sets the center of rotation.
     * DEPRECATED: was never implemented correctly
     *
     * @param componentId Component id.
     * @param { x float, y: float, z: float }: The center of rotation.
     */
    SetRotationCenter(componentId: string, center: Float3): void;
    /**
     * Sets the rotation angle (degrees) of an object around the x axis.
     *
     * @param componentId Component id.
     * @param angle The rotation angle around the x axis in degrees.
     */
    abstract SetXRotation(componentId: string, degrees: number): void;
    /**
     * Returns the rotation angle (degrees) of an object around the x axis.
     *
     * @param componentId Component id.
     *
     * @returns The rotation angle around the x axis in degrees.
     */
    abstract GetXRotation(componentId: string): number;
    /**
     * Sets the rotation angle (degrees) of an object around the y axis.
     *
     * @param componentId Component id.
     * @param angle The rotation around on the y axis in degrees.
     */
    abstract SetYRotation(componentId: string, degrees: number): void;
    /**
     * Returns the rotation angle (degrees) of an object around the y axis.
     *
     * @param componentId Component id.
     *
     * @returns The rotation angle around the y axis in degrees.
     */
    GetYRotation(componentId: string): number;
    /**
     * Sets the rotation angle (degrees) of an object around the z axis.
     *
     * @param componentId Component id.
     * @param angle The rotation angle around the z axis in degrees.
     */
    abstract SetZRotation(componentId: string, degrees: number): void;
    /**
     * Returns the rotation angle of an object around the z axis.
     *
     * @param componentId Component id.
     *
     * @returns float The rotation angle around the z axis in degrees.
     */
    abstract GetZRotation(componentId: string): number;
    /**
     * Sets the scaling of an object.
     *
     * @param componentId Component id.
     * @param scaling new scaling for the object.
     */
    abstract SetScaling(componentId: string, scaling: Float3): void;
    /**
     * Returns the scaling of an object.
     *
     * @param componentId Component id.
     *
     * @returns { scaling: {x, y, z} }
     */
    abstract GetScaling(componentId: string): Float3;
    /**
     * Returns attachment points of an object.
     *
     * @param componentId Component id.
     * @param key Own key or null.
     * @param foreign Foreign key or null.
     * @param type Point type or null.
     *
     * @returns Array of points, or null
     */
    abstract GetPoints(componentId: string, key?: string | null, foreign?: string | null, type?: AttachPointType | null): Point[];
    /**
     * Sets directly the attachment points.
     *
     * @param componentId Component id.
     * @param points Attachment points in IGXC style.
     */
    abstract SetIGXCPoints(componentId: string, points: IGXC.AttachPoint[]): void;
    /**
     * Gets directly the attachment points.
     *
     * @param componentId Component id.
     *
     * @returns The attachment points (in IGXC style) if any.
     */
    abstract GetIGXCPoints(componentId: string): IGXC.AttachPoint[];
    /**
     * Controls selection box behavior.
     */
    AutoDeselectComponent: boolean;
    /**
     * Enables/disables standard highlighting behaviour.
     * Set it to false to handle highlighting yourself.
     */
    AutoHighlightComponent: boolean;
    /**
     * Selects a component as primary, exlusive selection. Will highlight it but NOT call SelectHandler() though.
     *
     * @param componentId The id of the component to be selected.
     */
    abstract SelectComponent(componentId: string | null, shouldNotHighlight?: boolean): void;
    /**
     * Get primaryly selected component.
     *
     * @returns Selected component or null.
     */
    abstract GetSelectedComponent(): string | null;
    /**
     * Sets up a secondary selection and finally calls Select2Handler().
     *
     * @param componentIds The id of the components to be selected.
     */
    abstract SelectComponents2(componentIds?: string[], ignoreHandler?: boolean, shouldNotHighlight?: boolean): void;
    /**
     * Get secondary selected components.
     *
     * @returns Selected components.
     */
    abstract GetSelectedComponents2(): string[];
    /**
     * Shows the component behavior by moving the interactive
     *    component in one of two positions.
     *
     * @param productIds The Ids of the Component (or all, if null) to be manipulated.
     * @param position Either "Start" or "End".
     */
    abstract ShowBehavior(componentIds: string[], position: "Start" | "End"): void;
    /**
     * Called when a component was hit before any further processing.
     *
     * @param componentId The id of the hit component (or null).
     *
     * @returns If false, the run-time should not process the pick operation any further.
     */
    PickHandler(componentId: string): boolean;
    /**
     * Called when a component is going to be selected.
     *
     * @param componentId The id of the component to be selected (or null).
     *
     * @returns If false, the run-time should not process the select operation any further.
     */
    SelectHandler(componentId: string | null): boolean;
    /**
     * Called when secondary selection has changed.
     */
    Select2Handler(): void;
    /**
     * Called when an object was deleted. The object with the passed id is already gone!
     */
    DeleteHandler(componentId: string): void;
    /**
     * Called when an interaction was done.
     */
    InteractionDoneHandler(): void;
    /**
     * Called after loading of a geometry.
     *
     * @param complete True if the last geometry was loaded.
     */
    LoadGeometryHandler(complete: boolean): void;
    /**
     * Called after an error happended when loading a geometry.
     *
     * @param url The url that caused a load error.
     *
     * @returns void
     */
    LoadGeometryErrorHandler(url: string): void;
    /**
     * The handler will be called before and after API.Highlight().
     * @param componentId Component Id for which API.Highlight() was called.
     * @param before True if before highlighting is changed, false after then.
     */
    HighlightHandler(componentId: string, before: boolean): void;
    /**
     * Called to print a Log message
     *
     * @param message The log message
     *
     * @returns void
     */
    LogHandler(message: string): void;
    /**
     * Sends a message to the log handler.
     *
     * @returns void
     */
    Log(message: string): void;
    /**
     * Redraws the scene in all associated cameras/views.
     * @param force enforce redraw
     * @param updatePostprocessing used internally for resetting postprocessing
     * @returns void
     */
    RedrawScene(force?: boolean, updatePostprocessing?: boolean): void;
    protected abstract RenderInternal(): void;
    /**
     * Called during RedrawScene().
     *
     * @returns void
     */
    abstract RedrawSceneHandler(): void;
    /**
     * Gets the current WC position of a component.
     * @param componentId The component.
     * @returns The WC position.
     */
    GetWorldPosition(componentId: string): Float3;
    /**
     * Creates the root interactor.
     *
     * @param constructor The Interactor's constructor.
     * @param { id string, etc. }: The interactor parameters.
     *
     * @returns the created Interactor
     */
    abstract CreateRootInteractor<T extends new (params: any) => Interactor>(constructor: T, parameters: {}): Interactor;
    /**
     * Creates the root interactor.
     *
     * @param classId The Interactor's class.
     * @param { id string, etc. }: The interactor parameters.
     *
     * @returns the created Interactor
     */
    abstract CreateRootInteractor(classId: string, parameters: {}): Interactor;
    /**
     * Gets the root interactor.
     *
     * @returns the current root interactor
     */
    abstract GetRootInteractor(): Interactor | null;
    /**
     * Creates the root interactor.
     *
     * @param constructor The Interactor's constructor.
     * @param { id string, etc. }: The interactor parameters.
     *
     * @returns the created Interactor
     */
    abstract CreateInteractor<T extends new (params: any) => Interactor>(constructor: T, parameters: {}): Interactor;
    /**
     * Creates an interactor.
     *
     * @param classId The Interactor's class.
     * @param { id string, etc. }: The construction parameters.
     *
     * @returns the created Interactor
     */
    abstract CreateInteractor(classId: string, parameters: {}): Interactor;
    /**
     * Gets the distance from the specified WC point along the given direction, and return
     * the closest intersection if any.
     * @param point The point from where to start.
     * @param direction The ray-cast direction.
     * @returns The closest distance, or -1.
     */
    abstract GetDistance(point: WorldCoordinates, direction: Direction): number;
    /** Gets the collected primary and secondary selection. */
    GetAllSelectedComponents(): string[];
    /** Checks if a component is either primarily or secondarly selected.
     * @param componentId Component id.
     * @returns True if selected
     */
    IsSelected(componentId: string): boolean;
    /**
     * Assigns a material description to the specified Products, i.e. for every
     * Product it will be assigned recursively to all components (including the Product
     * itself) that fit the specified Category.
     *
     * @param productIds The Ids of the Products to be manipulated. If null, the Root objects will be used.
     * @param category The Category to which the material should apply.
     * @param description The material description.
     *
     * @returns void
     */
    AssignMaterial(productIds: string[], category: string, description: Material): void;
    /**
     * Changes the visibility of a layer.
     *
     * @param productIds The Ids of the Products to be manipulated. If array is null, the roots are used.
     * @param layer The layer to be manipulated.
     * @param visible The new visibility of that layer.
     *
     * @returns void
     */
    SetLayerVisibility(componentIds: string[], layer: string, visible: boolean): void;
    /**
     * Collects all material categories in the scene.
     *
     * @returns Array of categories, possibly empty.
     */
    GetAllMaterialCategories(): string[];
    /**
     * Collects all layers in the scene.
     *
     * @returns Array of layers, possibly empty.
     */
    GetAllLayers(): string[];
    /**
     * Checks the availability of a Callback.
     *
     * @returns Fully qualified Callback name if available, otherwise null.
     */
    GetEvaluatorCallback(componentId: string, callback: string): string | null;
    /**
     * Dumps a component to IGXC representation, if needed recursively.
     *
     * @param componentId The component where the dump starts.
     *
     * @param options Writer options.
     *
     * @returns An IGXC scene representation.
     */
    GetAsIGXC(componentId: string, options?: WriterOptions): IGXC.Scene;
    /**
     * Dumps a merged IGXC representation by combining the IGXCs of the passed components.
     *
     * @param componentIds An array of components to be processed. If null, the roots are considered.
     * If component ids are provided they must be root-level sub objects (__.).
     *
     * @param options Writer options.
     *
     * @returns An IGXC scene representation.
     */
    GetMergedIGXC(componentIds: string[], options?: WriterOptions): IGXC.Scene;
    IsPreviewIGXCLoadPossibleAndNeccessary(igxc: IGXC.Scene, componentId?: string): boolean;
    LoadIGXC(componentId: string, url: string, options?: IProcessIGXCOptions): Promise<ProcessIGXCChanges>;
    abstract ProcessIGXC(componentId: string, data: IGXC.Scene, igxcBasePath?: string, options?: IProcessIGXCOptions): Promise<ProcessIGXCChanges>;
    /** Gets the area distance. The area must be defined by two points
     * lying in one plane with regard to the specified direction.
     * @param point1 The first point.
     * @param point2 The second point.
     * @direction Must be one of the following: Down, Up.
     */
    GetAreaDistance(point1: Float3, point2: Float3, direction: "Up" | "Down"): number;
    /**
     * Get the component (root) that is located under the touch event
     * @param touch: the touch
     * @param ignoreComponents: ids of components to be ignored in raycasting
     * @returns The component id
     */
    abstract GetHitComponent(touch: Touch, ignoreComponents?: string[]): string | null;
    /**
     * Get componendId, hitPoint, mesh and distance to camera that is located under the touch event
     * @param touch: the touch
     * @param ignoreComponents: ids of components to be ignored in raycasting
     * @returns object with detailed informations
     */
    abstract GetDetailedHitInfos(touch: Touch, ignoreComponents?: string[]): IDetailedHitInfo[];
    /**
     * Check for a collision of the two components. If second is null, check all roots
     * @param firstComponent: the first component
     * @param secondComponent: the second component (or null)
     * @param geometric: descend to children to check for intersection?
     * @param error: the amount of overlap that is allowed for the collision
     */
    abstract GetCollision(firstComponent: string, secondComponent: string, geometric: boolean, error: number): CollisionInformation;
    /**
     * Check for a collision of the two components. If second is null, check all roots
     * @param firstComponent: the first component
     * @param secondComponent: the second component (or null)
     * @param geometric: descend to children to check for intersection?
     * @param error: the amount of overlap that is allowed for the collision
     */
    abstract GetCollisionInfo(firstComponent: string, firstTrafo: Transformation, secondComponent: string, secondTrafo: Transformation, geometric: boolean, error?: number): CollisionInformation;
    /**
     * Invalidates data (caches, ghosts etc.) associated with the componentId
     * @param components
     * @constructor
     */
    abstract InvalidateComponent(componentId: string): void;
    /**
     * Create the Wall information from the componentId.
     * @param wallId the component id of a wall
     */
    abstract SetupWall(wallId: string): Wall;
    /**
     * Gets an abstract bounds representation for the given component.
     * If passed localBounds, those bounds will be used for computation of the points and planes of the abstract bounds
     * instead of the bounds of the id
     * @param id
     * @param transformation
     * @param localBounds
     * @param ignoreComponentsWithLayerNames
     */
    abstract GetAbstractBounds(id: string, transformation?: Transformation, localBounds?: Bounds, ignoreComponentsWithLayerNames?: string[]): IAbstractBounds;
    /**
     * Gets an abstract bounding box considering error margin and being cached
     * @param componentId
     * @param ignoreComponentsWithLayerNames
     */
    abstract GetCollisionBounds(componentId: string, ignoreComponentsWithLayerNames?: string[]): IAbstractBounds;
    /**
     * Get the actions that belong to the component
     * @param id
     * @constructor
     */
    abstract GetActions(id: string): IGXM.ISingleAction[];
    /**
     * Create a platform for the given (already existing) component id
     *
     * @abstract
     * @param {string}    componentId   e.g. t1__.   gfxId
     * @param {boolean}   onlyOneGhost  e.g. true    only use one ghost, use existing if it already exists
     * @returns {string}
     *
     * @memberOf _API
     */
    abstract SetupPlatform(componentId: string, onlyOneGhost: boolean): string;
    /**
     * Return all plattform ids for a given component, eg
     *
     * @abstract
     * @param { string } componentId e.g.  "t1__."
     * @returns { Array<string> }    e.g. ["t1__pf1", "t1__pf2", "t1__pf66"]
     *
     * @memberOf _API
     */
    abstract GetPlatformIds(componentId: string): string[];
    /**
     * For component with componentId set local position and rotation for the attachpoint with the specified key.
     * @param componentId
     * @param key
     * @param position
     * @param rotation
     * @constructor
     */
    abstract SetPoint(componentId: ComponentId, key: string, position: LocalCoordinates, rotation: LocalRotation): void;
    /**
     * Combines setting position and rotation
     * @param componentId
     * @param transformation
     */
    abstract SetTransformation(componentId: string, transformation: Transformation): void;
    protected abstract GetComponentOrThrow(componentId: string): any;
}
