@thatopen/components 2.4.11 → 3.1.1

package/dist/core/OrthoPerspectiveCamera/src/plan-mode.d.ts

@@ -1,20 +0,0 @@
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows to navigate floorplans in 2D, like many BIM tools.
- */
-export declare class PlanMode implements NavigationMode {
-    private camera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "Plan";
-    private mouseAction1?;
-    private mouseAction2?;
-    private mouseInitialized;
-    private readonly defaultAzimuthSpeed;
-    private readonly defaultPolarSpeed;
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-}

package/dist/core/OrthoPerspectiveCamera/src/projections.d.ts

@@ -1,45 +0,0 @@
-import * as THREE from "three";
-import { CameraProjection } from "./types";
-import { Event } from "../../Types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * Object to control the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
- */
-export declare class ProjectionManager {
-    /**
-     * Event that fires when the {@link CameraProjection} changes.
-     */
-    readonly onChanged: Event<THREE.PerspectiveCamera | THREE.OrthographicCamera>;
-    /**
-     * Current projection mode of the camera.
-     * Default is "Perspective".
-     */
-    current: CameraProjection;
-    /**
-     * The camera controlled by this ProjectionManager.
-     * It can be either a PerspectiveCamera or an OrthographicCamera.
-     */
-    camera: THREE.PerspectiveCamera | THREE.OrthographicCamera;
-    /** Match Ortho zoom with Perspective distance when changing projection mode */
-    matchOrthoDistanceEnabled: boolean;
-    private _component;
-    private _previousDistance;
-    constructor(camera: OrthoPerspectiveCamera);
-    /**
-     * Sets the {@link CameraProjection} of the {@link OrthoPerspectiveCamera}.
-     *
-     * @param projection - the new projection to set. If it is the current projection,
-     * it will have no effect.
-     */
-    set(projection: CameraProjection): Promise<void>;
-    /**
-     * Changes the current {@link CameraProjection} from Ortographic to Perspective
-     * and vice versa.
-     */
-    toggle(): Promise<void>;
-    private setOrthoCamera;
-    private getPerspectiveDims;
-    private setupOrthoCamera;
-    private getDistance;
-    private setPerspectiveCamera;
-}

package/dist/core/OrthoPerspectiveCamera/src/types.d.ts

@@ -1,26 +0,0 @@
-/**
- * The projection system of the camera.
- */
-export type CameraProjection = "Perspective" | "Orthographic";
-/**
- * The extensible list of supported navigation modes.
- */
-export type NavModeID = "Orbit" | "FirstPerson" | "Plan";
-/**
- * An object that determines the behavior of the camera controls and the user input (e.g. 2D floor plan mode, first person mode, etc).
- */
-export interface NavigationMode {
-    /** The unique ID of this navigation mode. */
-    id: NavModeID;
-    /**
-     * Enable or disable this navigation mode.
-     * When a new navigation mode is enabled, the previous navigation mode
-     * must be disabled.
-     *
-     * @param active - whether to enable or disable this mode.
-     * @param options - any additional data required to enable or disable it.
-     * */
-    set: (active: boolean, options?: any) => void;
-    /** Whether this navigation mode is active or not. */
-    enabled: boolean;
-}

package/dist/core/Raycasters/index.d.ts

@@ -1,43 +0,0 @@
-import { Component, Disposable, World, Event } from "../Types";
-import { SimpleRaycaster } from "./src";
-import { Components } from "../Components";
-export * from "./src";
-/**
- * A component that manages a raycaster for each world and automatically disposes it when its corresponding world is disposed. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Raycasters). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Raycasters).
- */
-export declare class Raycasters extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "d5d8bdf0-db25-4952-b951-b643af207ace";
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * A Map that stores raycasters for each world.
-     * The key is the world's UUID, and the value is the corresponding SimpleRaycaster instance.
-     */
-    list: Map<string, SimpleRaycaster>;
-    /** {@link Disposable.onDisposed} */
-    onDisposed: Event<unknown>;
-    constructor(components: Components);
-    /**
-     * Retrieves a SimpleRaycaster instance for the given world.
-     * If a SimpleRaycaster instance already exists for the world, it will be returned.
-     * Otherwise, a new SimpleRaycaster instance will be created and added to the list.
-     *
-     * @param world - The world for which to retrieve or create a SimpleRaycaster instance.
-     * @returns The SimpleRaycaster instance for the given world.
-     */
-    get(world: World): SimpleRaycaster;
-    /**
-     * Deletes the SimpleRaycaster instance associated with the given world.
-     * If a SimpleRaycaster instance exists for the given world, it will be disposed and removed from the list.
-     *
-     * @param world - The world for which to delete the SimpleRaycaster instance.
-     * @returns {void}
-     */
-    delete(world: World): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-}

package/dist/core/Raycasters/src/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./mouse";
-export * from "./simple-raycaster";

package/dist/core/Raycasters/src/mouse.d.ts

@@ -1,24 +0,0 @@
-import * as THREE from "three";
-import { Disposable, Event } from "../../Types";
-/**
- * A helper to easily get the real position of the mouse in the Three.js canvas to work with tools like the [raycaster](https://threejs.org/docs/#api/en/core/Raycaster), even if it has been transformed through CSS or doesn't occupy the whole screen.
- */
-export declare class Mouse implements Disposable {
-    dom: HTMLCanvasElement;
-    private _event?;
-    private _position;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    constructor(dom: HTMLCanvasElement);
-    /**
-     * The real position of the mouse of the Three.js canvas.
-     */
-    get position(): THREE.Vector2;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private getPositionY;
-    private getPositionX;
-    private updateMouseInfo;
-    private getDataObject;
-    private setupEvents;
-}

package/dist/core/Raycasters/src/simple-raycaster.d.ts

@@ -1,54 +0,0 @@
-import * as THREE from "three";
-import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-import { Mouse } from "./mouse";
-/**
- * A simple [raycaster](https://threejs.org/docs/#api/en/core/Raycaster) that allows to easily get items from the scene using the mouse and touch events.
- */
-export declare class SimpleRaycaster implements Disposable {
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /** The components instance to which this Raycaster belongs. */
-    components: Components;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** The position of the mouse in the screen. */
-    readonly mouse: Mouse;
-    /**
-     * A reference to the Three.js Raycaster instance.
-     * This is used for raycasting operations.
-     */
-    readonly three: THREE.Raycaster;
-    /**
-     * A reference to the world instance to which this Raycaster belongs.
-     * This is used to access the camera and meshes.
-     */
-    world: World;
-    constructor(components: Components, world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Throws a ray from the camera to the mouse or touch event point and returns
-     * the first item found. This also takes into account the clipping planes
-     * used by the renderer.
-     *
-     * @param items - the [meshes](https://threejs.org/docs/#api/en/objects/Mesh)
-     * to query. If not provided, it will query all the meshes stored in
-     * {@link Components.meshes}.
-     * @param position - the screen position to use for raycasting. If not provided,
-     * the last pointer (mouse/touch) position will be used.
-     */
-    castRay(items?: THREE.Object3D[], position?: THREE.Vector2): THREE.Intersection | null;
-    /**
-     * Casts a ray from a given origin in a given direction and returns the first item found.
-     * This method also takes into account the clipping planes used by the renderer.
-     *
-     * @param origin - The origin of the ray.
-     * @param direction - The direction of the ray.
-     * @param items - The meshes to query. If not provided, it will query all the meshes stored in {@link World.meshes}.
-     * @returns The first intersection found or `null` if no intersection was found.
-     */
-    castRayFromVector(origin: THREE.Vector3, direction: THREE.Vector3, items?: THREE.Mesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.Object3DEventMap>[]): THREE.Intersection<THREE.Object3D<THREE.Object3DEventMap>> | null;
-    private intersect;
-    private filterClippingPlanes;
-}

package/dist/core/ShadowedScene/index.d.ts

@@ -1,57 +0,0 @@
-import { SimpleScene, SimpleSceneConfig, SimpleSceneConfigManager } from "../Worlds";
-import { DistanceRenderer } from "./src";
-import { Configurable, Disposable } from "../Types";
-/**
- * Configuration interface for the {@link ShadowedScene}. Defines properties for directional and ambient lights, as well as shadows.
- */
-export interface ShadowedSceneConfig extends SimpleSceneConfig {
-    shadows: {
-        cascade: number;
-        resolution: number;
-    };
-}
-/**
- * A scene that supports efficient cast shadows. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/ShadowedScene). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/ShadowedScene).
- */
-export declare class ShadowedScene extends SimpleScene implements Disposable, Configurable<SimpleSceneConfigManager, ShadowedSceneConfig> {
-    private _distanceRenderer?;
-    /**
-     * Whether the bias property should be set automatically depending on the shadow distance.
-     */
-    autoBias: boolean;
-    protected _defaultShadowConfig: {
-        cascade: number;
-        resolution: number;
-    };
-    private _lightsWithShadow;
-    private _isComputingShadows;
-    private _shadowsEnabled;
-    private _bias;
-    /**
-     * The getter for the bias to prevent artifacts (stripes). It usually ranges between 0 and -0.005.
-     */
-    get bias(): number;
-    /**
-     * The setter for the bias to prevent artifacts (stripes). It usually ranges between 0 and -0.005.
-     */
-    set bias(value: number);
-    /**
-     * Getter to see whether the shadows are enabled or not in this scene instance.
-     */
-    get shadowsEnabled(): boolean;
-    /**
-     * Setter to control whether the shadows are enabled or not in this scene instance.
-     */
-    set shadowsEnabled(value: boolean);
-    /**
-     * Getter to get the renderer used to determine the farthest distance from the camera.
-     */
-    get distanceRenderer(): DistanceRenderer;
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<ShadowedSceneConfig>): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** Update all the shadows of the scene. */
-    updateShadows(): Promise<void>;
-    private recomputeShadows;
-}

package/dist/core/ShadowedScene/src/distance-renderer.d.ts

@@ -1,67 +0,0 @@
-import * as THREE from "three";
-import { Event, World } from "../../Types";
-import { Components } from "../../Components";
-/**
- * A base renderer to determine visibility on screen.
- */
-export declare class DistanceRenderer {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<string>;
-    /**
-     * Fires after making the visibility check to the meshes. It lists the
-     * meshes that are currently visible, and the ones that were visible
-     * just before but not anymore.
-     */
-    readonly onDistanceComputed: Event<number>;
-    /**
-     * Objects that won't be taken into account in the distance check.
-     */
-    excludedObjects: Set<THREE.Object3D<THREE.Object3DEventMap>>;
-    /**
-     * Whether this renderer is active or not. If not, it won't render anything.
-     */
-    enabled: boolean;
-    /**
-     * Render the internal scene used to determine the object visibility. Used
-     * for debugging purposes.
-     */
-    renderDebugFrame: boolean;
-    /** The components instance to which this renderer belongs. */
-    components: Components;
-    /**
-     * The scene where the distance is computed.
-     */
-    scene: THREE.Scene;
-    /**
-     * The camera used to compute the distance.
-     */
-    camera: THREE.OrthographicCamera;
-    /**
-     * The material used to compute the distance.
-     */
-    depthMaterial: THREE.ShaderMaterial;
-    /** The world instance to which this renderer belongs. */
-    readonly world: World;
-    /** The THREE.js renderer used to make the visibility test. */
-    readonly renderer: THREE.WebGLRenderer;
-    protected readonly worker: Worker;
-    private _width;
-    private _height;
-    private readonly _postQuad;
-    private readonly tempRT;
-    private readonly resultRT;
-    private readonly bufferSize;
-    private readonly _buffer;
-    protected _isWorkerBusy: boolean;
-    constructor(components: Components, world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * The function that the culler uses to reprocess the scene. Generally it's
-     * better to call needsUpdate, but you can also call this to force it.
-     * @param force if true, it will refresh the scene even if needsUpdate is
-     * not true.
-     */
-    compute: () => Promise<void>;
-    private handleWorkerMessage;
-}

package/dist/core/ShadowedScene/src/index.d.ts

@@ -1 +0,0 @@
-export * from "./distance-renderer";

package/dist/core/Types/index.d.ts

@@ -1 +0,0 @@
-export * from "./src";

package/dist/core/Types/src/async-event.d.ts

@@ -1,32 +0,0 @@
-/**
- * Simple event handler by [Jason Kleban](https://gist.github.com/JasonKleban/50cee44960c225ac1993c922563aa540). Keep in mind that if you want to remove it later, you might want to declare the callback as an object. If you want to maintain the reference to `this`, you will need to declare the callback as an arrow function.
- */
-export declare class AsyncEvent<T> {
-    /**
-     * Whether this event is active or not. If not, it won't trigger.
-     */
-    enabled: boolean;
-    /**
-     * Add a callback to this event instance.
-     * @param handler - the callback to be added to this event.
-     */
-    add(handler: T extends void ? {
-        (): Promise<void>;
-    } : {
-        (data: T): Promise<void>;
-    }): void;
-    /**
-     * Removes a callback from this event instance.
-     * @param handler - the callback to be removed from this event.
-     */
-    remove(handler: T extends void ? {
-        (): Promise<void>;
-    } : {
-        (data: T): Promise<void>;
-    }): void;
-    /** Triggers all the callbacks assigned to this event. */
-    trigger: (data?: T) => Promise<void>;
-    /** Gets rid of all the suscribed events. */
-    reset(): void;
-    private handlers;
-}

package/dist/core/Types/src/base-camera.d.ts

@@ -1,28 +0,0 @@
-import * as THREE from "three";
-import CameraControls from "camera-controls";
-import { BaseWorldItem } from "./base-world-item";
-import { CameraControllable } from "./interfaces";
-/**
- * Abstract class representing a camera in a 3D world. All cameras should use this class as a base.
- */
-export declare abstract class BaseCamera extends BaseWorldItem {
-    /**
-     * Whether the camera is enabled or not.
-     */
-    abstract enabled: boolean;
-    /**
-     * The Three.js camera instance.
-     */
-    abstract three: THREE.Camera;
-    /**
-     * Optional CameraControls instance for controlling the camera.
-     * This property is only available if the camera is controllable.
-     */
-    abstract controls?: CameraControls;
-    /**
-     * Checks whether the instance is {@link CameraControllable}.
-     *
-     * @returns True if the instance is controllable, false otherwise.
-     */
-    hasCameraControls: () => this is CameraControllable;
-}

package/dist/core/Types/src/base-renderer.d.ts

@@ -1,65 +0,0 @@
-import * as THREE from "three";
-import { Vector2 } from "three";
-import { Event } from "./event";
-import { BaseWorldItem } from "./base-world-item";
-import { Disposable, Resizeable, Updateable } from "./interfaces";
-/**
- * Abstract class representing a renderer for a 3D world. All renderers should use this class as a base.
- */
-export declare abstract class BaseRenderer extends BaseWorldItem implements Updateable, Disposable, Resizeable {
-    /**
-     * The three.js WebGLRenderer instance associated with this renderer.
-     *
-     * @abstract
-     * @type {THREE.WebGLRenderer}
-     */
-    abstract three: THREE.WebGLRenderer;
-    /** {@link Updateable.onBeforeUpdate} */
-    onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onAfterUpdate} */
-    onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<undefined>;
-    /** {@link Resizeable.onResize} */
-    readonly onResize: Event<THREE.Vector2>;
-    /**
-     * Event that fires when there has been a change to the list of clipping
-     * planes used by the active renderer.
-     */
-    readonly onClippingPlanesUpdated: Event<unknown>;
-    /** {@link Updateable.update} */
-    abstract update(delta?: number): void | Promise<void>;
-    /** {@link Disposable.dispose} */
-    abstract dispose(): void;
-    /** {@link Resizeable.getSize} */
-    abstract getSize(): Vector2;
-    /** {@link Resizeable.resize} */
-    abstract resize(size: Vector2 | undefined): void;
-    /**
-     * The list of [clipping planes](https://threejs.org/docs/#api/en/renderers/WebGLRenderer.clippingPlanes) used by this instance of the renderer.
-     */
-    clippingPlanes: THREE.Plane[];
-    /**
-     * Updates the clipping planes and triggers the `onClippingPlanesUpdated` event.
-     *
-     * @remarks
-     * This method is typically called when there is a change to the list of clipping planes
-     * used by the active renderer.
-     */
-    updateClippingPlanes(): void;
-    /**
-     * Sets or removes a clipping plane from the renderer.
-     *
-     * @param active - A boolean indicating whether the clipping plane should be active or not.
-     * @param plane - The clipping plane to be added or removed.
-     * @param isLocal - An optional boolean indicating whether the clipping plane is local to the object. If not provided, it defaults to `false`.
-     *
-     * @remarks
-     * This method adds or removes a clipping plane from the `clippingPlanes` array.
-     * If `active` is `true` and the plane is not already in the array, it is added.
-     * If `active` is `false` and the plane is in the array, it is removed.
-     * The `three.clippingPlanes` property is then updated to reflect the current state of the `clippingPlanes` array,
-     * excluding any planes marked as local.
-     */
-    setPlane(active: boolean, plane: THREE.Plane, isLocal?: boolean): void;
-}

package/dist/core/Types/src/base-scene.d.ts

@@ -1,25 +0,0 @@
-import * as THREE from "three";
-import { Disposable } from "./interfaces";
-import { Event } from "./event";
-import { Components } from "../../Components";
-import { BaseWorldItem } from "./base-world-item";
-/**
- * Abstract class representing a base scene in the application. All scenes should use this class as a base.
- */
-export declare abstract class BaseScene extends BaseWorldItem implements Disposable {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /**
-     * Abstract property representing the three.js object associated with this scene.
-     * It should be implemented by subclasses.
-     */
-    abstract three: THREE.Object3D;
-    /** The set of directional lights managed by this scene component. */
-    directionalLights: Map<string, THREE.DirectionalLight>;
-    /** The set of ambient lights managed by this scene component. */
-    ambientLights: Map<string, THREE.AmbientLight>;
-    protected constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    deleteAllLights(): void;
-}

package/dist/core/Types/src/base-world-item.d.ts

@@ -1,23 +0,0 @@
-import { Base } from "./base";
-import { World } from "./world";
-import { Event } from "./event";
-import { Components } from "../../Components";
-/**
- * One of the elements that make a world. It can be either a scene, a camera or a renderer.
- */
-export declare abstract class BaseWorldItem extends Base {
-    readonly worlds: Map<string, World>;
-    /**
-     * Event that is triggered when a world is added or removed from the `worlds` map.
-     * The event payload contains the world instance and the action ("added" or "removed").
-     */
-    readonly onWorldChanged: Event<{
-        world: World;
-        action: "added" | "removed";
-    }>;
-    /**
-     * The current world this item is associated with. It can be null if no world is currently active.
-     */
-    currentWorld: World | null;
-    protected constructor(components: Components);
-}

package/dist/core/Types/src/base.d.ts

@@ -1,19 +0,0 @@
-import { Disposable, Hideable, Resizeable, Updateable, Configurable } from "./interfaces";
-import { Components } from "../../Components";
-/**
- * Base class of the library. Useful for finding out the interfaces something implements.
- */
-export declare abstract class Base {
-    components: Components;
-    constructor(components: Components);
-    /** Whether is component is {@link Disposable}. */
-    isDisposeable: () => this is Disposable;
-    /** Whether is component is {@link Resizeable}. */
-    isResizeable: () => this is Resizeable;
-    /** Whether is component is {@link Updateable}. */
-    isUpdateable: () => this is Updateable;
-    /** Whether is component is {@link Hideable}. */
-    isHideable: () => this is Hideable;
-    /** Whether is component is {@link Configurable}. */
-    isConfigurable: () => this is Configurable<any, any>;
-}

package/dist/core/Types/src/component-with-ui.d.ts

@@ -1,18 +0,0 @@
-import { Component } from "./component";
-import { Configurator } from "../../ConfigManager";
-import { Components } from "../../Components";
-export type ComponentUIElement = {
-    name: string;
-    id: string;
-    icon: string;
-    componentID: string;
-    get: (components: Components) => {
-        element: HTMLElement;
-        config?: Configurator;
-        dispose?: () => void;
-    };
-};
-export declare abstract class ComponentWithUI extends Component {
-    abstract name: string;
-    abstract getUI(): ComponentUIElement[];
-}

package/dist/core/Types/src/component.d.ts

@@ -1,13 +0,0 @@
-import { Base } from "./base";
-/**
- * Components are the building blocks of this library. Components are singleton elements that contain specific functionality. For instance, the Clipper Component can create, delete and handle 3D clipping planes. Components must be unique (they can't be instanced more than once per Components instance), and have a static UUID that identifies them uniquely. The can be accessed globally using the {@link Components} instance.
- */
-export declare abstract class Component extends Base {
-    /**
-     * Whether this component is active or not. The behaviour can vary depending
-     * on the type of component. E.g. a disabled dimension tool will stop creating
-     * dimensions, while a disabled camera will stop moving. A disabled component
-     * will not be updated automatically each frame.
-     */
-    abstract enabled: boolean;
-}

package/dist/core/Types/src/config-types.d.ts

@@ -1,47 +0,0 @@
-import * as THREE from "three";
-export interface BooleanSettingsControl {
-    type: "Boolean";
-    value: boolean;
-}
-export interface ColorSettingsControl {
-    type: "Color";
-    value: THREE.Color;
-}
-export interface TextSettingsControl {
-    type: "Text";
-    value: string;
-}
-export interface NumberSettingControl {
-    type: "Number";
-    interpolable: boolean;
-    min?: number;
-    max?: number;
-    value: number;
-}
-export interface SelectSettingControl {
-    type: "Select";
-    multiple: boolean;
-    options: Set<string>;
-    value: string;
-}
-export interface Vector3SettingControl {
-    type: "Vector3";
-    value: THREE.Vector3;
-}
-export interface TextSetSettingControl {
-    type: "TextSet";
-    value: Set<string>;
-}
-export interface NoControl {
-    type: "None";
-    value: any;
-}
-export type ControlEntry = BooleanSettingsControl | ColorSettingsControl | TextSettingsControl | NumberSettingControl | SelectSettingControl | Vector3SettingControl | TextSetSettingControl | NoControl;
-export interface ControlsSchema {
-    [name: string]: ControlEntry | ControlsSchema;
-}
-export declare class ControlsUtils {
-    static isEntry(item: any): boolean;
-    static copySchema<T extends ControlsSchema = ControlsSchema>(schema: T, copy?: ControlsSchema): T;
-    static copyEntry(controlEntry: ControlEntry): ControlEntry;
-}