@kitware/vtk.js 28.10.2 → 28.11.0

package/Widgets/Core/WidgetState.js

@@ -1,137 +1,128 @@
-import macro from '../../macros.js';
-
-var DEFAULT_LABEL = 'default';
+import { m as macro } from '../../macros2.js';
 
+const DEFAULT_LABEL = 'default';
 function removeObjectInArray(array, obj) {
-  var idx = array.indexOf(obj);
-
+  const idx = array.indexOf(obj);
   if (idx !== -1) {
     array.splice(idx, 1);
   }
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
 function vtkWidgetState(publicAPI, model) {
   model.classHierarchy.push('vtkWidgetState');
-  var subscriptions = [];
+  const subscriptions = [];
   model.labels = {};
-  model.nestedStates = []; // --------------------------------------------------------------------------
+  model.nestedStates = [];
+
+  // --------------------------------------------------------------------------
   // labels can be a string or an array of strings.
   // If nothing (or empty array) provided the default label will be used.
   // --------------------------------------------------------------------------
 
   publicAPI.bindState = function (nested) {
-    var labels = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [DEFAULT_LABEL];
+    let labels = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [DEFAULT_LABEL];
     model.nestedStates.push(nested);
     subscriptions.push(nested.onModified(publicAPI.modified));
-
     if (Array.isArray(labels) && labels.length) {
-      for (var i = 0; i < labels.length; i++) {
-        var label = labels[i];
-
+      for (let i = 0; i < labels.length; i++) {
+        const label = labels[i];
         if (!model.labels[label]) {
           model.labels[label] = [];
         }
-
         model.labels[label].push(nested);
       }
     } else {
       // Need to bind to a label
-      var labelToUse = Array.isArray(labels) ? DEFAULT_LABEL : labels || DEFAULT_LABEL;
-
+      const labelToUse = Array.isArray(labels) ? DEFAULT_LABEL : labels || DEFAULT_LABEL;
       if (!model.labels[labelToUse]) {
         model.labels[labelToUse] = [];
       }
-
       model.labels[labelToUse].push(nested);
     }
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.unbindState = function (nested) {
+  publicAPI.unbindState = nested => {
     while (subscriptions.length) {
       subscriptions.pop().unsubscribe();
     }
-
     removeObjectInArray(model.nestedStates, nested);
-
-    for (var i = 0; i < model.nestedStates.length; i++) {
+    for (let i = 0; i < model.nestedStates.length; i++) {
       subscriptions.push(model.nestedStates[i].onModified(publicAPI.modified));
     }
-
-    Object.keys(model.labels).forEach(function (label) {
-      var list = model.labels[label];
+    Object.keys(model.labels).forEach(label => {
+      const list = model.labels[label];
       removeObjectInArray(list, nested);
     });
-  }; // --------------------------------------------------------------------------
+  };
 
+  // --------------------------------------------------------------------------
 
-  publicAPI.unbindAll = function () {
+  publicAPI.unbindAll = () => {
     while (subscriptions.length) {
       subscriptions.pop().unsubscribe();
     }
-
     model.nestedStates = [];
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Active flag API
   // --------------------------------------------------------------------------
 
-
-  publicAPI.activate = function () {
-    return publicAPI.setActive(true);
-  };
-
-  publicAPI.deactivate = function (excludingState) {
+  publicAPI.activate = () => publicAPI.setActive(true);
+  publicAPI.deactivate = excludingState => {
     if (excludingState !== publicAPI) {
       publicAPI.setActive(false);
     }
-
-    for (var i = 0; i < model.nestedStates.length; i++) {
+    for (let i = 0; i < model.nestedStates.length; i++) {
       model.nestedStates[i].deactivate(excludingState);
     }
   };
-
-  publicAPI.activateOnly = function (subState) {
+  publicAPI.activateOnly = subState => {
     if (subState) {
       subState.setActive(true);
-    } // deactivate current state, but exclude the sub-state
-
-
+    }
+    // deactivate current state, but exclude the sub-state
     publicAPI.deactivate(subState);
-  }; // --------------------------------------------------------------------------
+  };
+
+  // --------------------------------------------------------------------------
   // Nested state methods
   // --------------------------------------------------------------------------
 
+  publicAPI.getStatesWithLabel = name => model.labels[name];
+  publicAPI.getAllNestedStates = () => model.nestedStates;
 
-  publicAPI.getStatesWithLabel = function (name) {
-    return model.labels[name];
-  };
-
-  publicAPI.getAllNestedStates = function () {
-    return model.nestedStates;
-  }; // --------------------------------------------------------------------------
+  // --------------------------------------------------------------------------
   // Clean on delete
   // --------------------------------------------------------------------------
 
-
   publicAPI.delete = macro.chain(publicAPI.unbindAll, publicAPI.delete);
-} // ----------------------------------------------------------------------------
+}
 
+// ----------------------------------------------------------------------------
 
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   active: false
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['active']);
   vtkWidgetState(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 
 var vtkWidgetState$1 = {
-  extend: extend
+  extend
 };
 
 export { vtkWidgetState$1 as default, extend };

package/Widgets/Core.js

@@ -5,11 +5,11 @@ import vtkWidgetManager from './Core/WidgetManager.js';
 import vtkWidgetState from './Core/WidgetState.js';
 
 var Core = {
-  vtkAbstractWidget: vtkAbstractWidget,
-  vtkAbstractWidgetFactory: vtkAbstractWidgetFactory,
-  vtkStateBuilder: vtkStateBuilder,
-  vtkWidgetManager: vtkWidgetManager,
-  vtkWidgetState: vtkWidgetState
+  vtkAbstractWidget,
+  vtkAbstractWidgetFactory,
+  vtkStateBuilder,
+  vtkWidgetManager,
+  vtkWidgetState
 };
 
 export { Core as default };

package/Widgets/Manipulators/AbstractManipulator.js

@@ -1,33 +1,33 @@
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 
+// ----------------------------------------------------------------------------
 // vtkAbstractManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkAbstractManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkAbstractManipulator');
-
-  publicAPI.getOrigin = function (callData) {
+  publicAPI.getOrigin = callData => {
     if (model.userOrigin) return model.userOrigin;
     if (model.useCameraFocalPoint) return callData.pokedRenderer.getActiveCamera().getFocalPoint();
     if (model.handleOrigin) return model.handleOrigin;
     if (model.widgetOrigin) return model.widgetOrigin;
     return [0, 0, 0];
   };
-
-  publicAPI.getNormal = function (callData) {
+  publicAPI.getNormal = callData => {
     if (model.userNormal) return model.userNormal;
     if (model.useCameraNormal) return callData.pokedRenderer.getActiveCamera().getDirectionOfProjection();
     if (model.handleNormal) return model.handleNormal;
     if (model.widgetNormal) return model.widgetNormal;
     return [0, 0, 1];
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
-var DEFAULT_VALUES = {
+const DEFAULT_VALUES = {
   // userOrigin: null,
   // handleOrigin: null,
   // widgetOrigin: null,
@@ -36,22 +36,28 @@ var DEFAULT_VALUES = {
   // widgetNormal: null
   useCameraFocalPoint: false,
   useCameraNormal: false
-}; // ----------------------------------------------------------------------------
+};
+
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   Object.assign(model, DEFAULT_VALUES, initialValues);
   macro.obj(publicAPI, model);
   macro.setGet(publicAPI, model, ['useCameraFocalPoint', 'useCameraNormal']);
   macro.setGetArray(publicAPI, model, ['userOrigin', 'handleOrigin', 'widgetOrigin', 'userNormal', 'handleNormal', 'widgetNormal'], 3);
   vtkAbstractManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkAbstractManipulator');
 
-var newInstance = macro.newInstance(extend, 'vtkAbstractManipulator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkAbstractManipulator$1 = {
-  extend: extend,
-  newInstance: newInstance
+  extend,
+  newInstance
 };
 
 export { vtkAbstractManipulator$1 as default, extend, newInstance };

package/Widgets/Manipulators/CPRManipulator.js

@@ -1,138 +1,122 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkPlane from '../../Common/DataModel/Plane.js';
 import vtkAbstractManipulator from './AbstractManipulator.js';
 import { mat4, vec3, mat3 } from 'gl-matrix';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 function intersectDisplayWithPlane(x, y, planeOrigin, planeNormal, renderer, glRenderWindow) {
-  var near = glRenderWindow.displayToWorld(x, y, 0, renderer);
-  var far = glRenderWindow.displayToWorld(x, y, 1, renderer);
+  const near = glRenderWindow.displayToWorld(x, y, 0, renderer);
+  const far = glRenderWindow.displayToWorld(x, y, 1, renderer);
   return vtkPlane.intersectWithLine(near, far, planeOrigin, planeNormal).x;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkCPRManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkCPRManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCPRManipulator');
-
-  publicAPI.handleEvent = function (callData, glRenderWindow) {
-    var _model$cprActor;
-
-    var mapper = (_model$cprActor = model.cprActor) === null || _model$cprActor === void 0 ? void 0 : _model$cprActor.getMapper();
-
+  publicAPI.handleEvent = (callData, glRenderWindow) => {
+    const mapper = model.cprActor?.getMapper();
     if (!mapper) {
       return {
         worldCoords: null
       };
-    } // Get normal and origin of the picking plane from the actor matrix
-
+    }
 
-    var cprActorMatrix = [];
+    // Get normal and origin of the picking plane from the actor matrix
+    const cprActorMatrix = [];
     mat4.transpose(cprActorMatrix, model.cprActor.getMatrix());
-    var worldPlaneNormal = cprActorMatrix.slice(8, 11); // 3rd column
+    const worldPlaneNormal = cprActorMatrix.slice(8, 11); // 3rd column
+    const worldPlaneOrigin = cprActorMatrix.slice(12, 15); // 4th column
 
-    var worldPlaneOrigin = cprActorMatrix.slice(12, 15); // 4th column
     // Convert world plane position to 2D position in the plane
-
-    var inversecprActorMatrix = [];
+    const inversecprActorMatrix = [];
     mat4.invert(inversecprActorMatrix, cprActorMatrix);
-    var worldPlanePicking = intersectDisplayWithPlane(callData.position.x, callData.position.y, worldPlaneOrigin, worldPlaneNormal, callData.pokedRenderer, glRenderWindow);
-    var modelPlanePicking = []; // (x, height - distance, 0)
-
+    const worldPlanePicking = intersectDisplayWithPlane(callData.position.x, callData.position.y, worldPlaneOrigin, worldPlaneNormal, callData.pokedRenderer, glRenderWindow);
+    const modelPlanePicking = []; // (x, height - distance, 0)
     vec3.transformMat4(modelPlanePicking, worldPlanePicking, inversecprActorMatrix);
-    var height = mapper.getHeight();
-    var distance = height - modelPlanePicking[1];
+    const height = mapper.getHeight();
+    const distance = height - modelPlanePicking[1];
     return publicAPI.distanceEvent(distance);
   };
-
-  publicAPI.distanceEvent = function (distance) {
-    var _model$cprActor2;
-
-    var mapper = (_model$cprActor2 = model.cprActor) === null || _model$cprActor2 === void 0 ? void 0 : _model$cprActor2.getMapper();
-
+  publicAPI.distanceEvent = distance => {
+    const mapper = model.cprActor?.getMapper();
     if (!mapper) {
       return {
         worldCoords: null
       };
     }
-
-    var height = mapper.getHeight();
-    var clampedDistance = Math.max(0, Math.min(height, distance));
-
-    var _mapper$getCenterline = mapper.getCenterlinePositionAndOrientation(clampedDistance),
-        position = _mapper$getCenterline.position,
-        orientation = _mapper$getCenterline.orientation;
-
-    var worldDirection;
-
+    const height = mapper.getHeight();
+    const clampedDistance = Math.max(0, Math.min(height, distance));
+    const {
+      position,
+      orientation
+    } = mapper.getCenterlinePositionAndOrientation(clampedDistance);
+    let worldDirection;
     if (orientation) {
-      var modelDirections = mat3.fromQuat([], orientation);
-      var baseDirections = mapper.getDirectionMatrix();
+      const modelDirections = mat3.fromQuat([], orientation);
+      const baseDirections = mapper.getDirectionMatrix();
       worldDirection = mat3.mul([], modelDirections, baseDirections);
     }
-
     model.currentDistance = clampedDistance;
     return {
       worldCoords: position,
-      worldDirection: worldDirection
+      worldDirection
     };
   };
-
-  publicAPI.handleScroll = function (nbSteps) {
-    var distance = model.currentDistance + publicAPI.getDistanceStep() * nbSteps;
+  publicAPI.handleScroll = nbSteps => {
+    const distance = model.currentDistance + publicAPI.getDistanceStep() * nbSteps;
     return publicAPI.distanceEvent(distance);
   };
-
-  publicAPI.getDistanceStep = function () {
+  publicAPI.getDistanceStep = () => {
     // Find default distanceStep from image spacing
     // This only works if the mapper in the actor already has an ImageData
     if (!model.distanceStep) {
-      var _model$cprActor3, _model$cprActor3$getM, _model$cprActor3$getM2, _model$cprActor3$getM3;
-
-      var imageSpacing = (_model$cprActor3 = model.cprActor) === null || _model$cprActor3 === void 0 ? void 0 : (_model$cprActor3$getM = _model$cprActor3.getMapper()) === null || _model$cprActor3$getM === void 0 ? void 0 : (_model$cprActor3$getM2 = _model$cprActor3$getM.getInputData(0)) === null || _model$cprActor3$getM2 === void 0 ? void 0 : (_model$cprActor3$getM3 = _model$cprActor3$getM2.getSpacing) === null || _model$cprActor3$getM3 === void 0 ? void 0 : _model$cprActor3$getM3.call(_model$cprActor3$getM2);
-
+      const imageSpacing = model.cprActor?.getMapper()?.getInputData(0)?.getSpacing?.();
       if (imageSpacing) {
-        return Math.min.apply(Math, _toConsumableArray(imageSpacing));
+        return Math.min(...imageSpacing);
       }
     }
-
     return model.distanceStep;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
+
 // currentDistance is the distance from the first point of the centerline
 // cprActor.getMapper() should be a vtkImageCPRMapper
-
-
 function defaultValues(initialValues) {
-  return _objectSpread({
+  return {
     distanceStep: 0,
     currentDistance: 0,
-    cprActor: null
-  }, initialValues);
-} // ----------------------------------------------------------------------------
+    cprActor: null,
+    ...initialValues
+  };
+}
 
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   vtkAbstractManipulator.extend(publicAPI, model, defaultValues(initialValues));
   macro.setGet(publicAPI, model, ['distance', 'currentDistance', 'cprActor']);
   macro.set(publicAPI, model, ['distanceStep']);
   vtkCPRManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkCPRManipulator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkCPRManipulator');
+
+// ----------------------------------------------------------------------------
 
 var index = {
-  intersectDisplayWithPlane: intersectDisplayWithPlane,
-  extend: extend,
-  newInstance: newInstance
+  intersectDisplayWithPlane,
+  extend,
+  newInstance
 };
 
 export { index as default, extend, intersectDisplayWithPlane, newInstance };

package/Widgets/Manipulators/LineManipulator.js

@@ -1,60 +1,63 @@
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import { s as subtract, j as cross, d as dot, w as multiplyScalar, k as add } from '../../Common/Core/Math/index.js';
 import vtkAbstractManipulator from './AbstractManipulator.js';
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 function projectDisplayToLine(x, y, lineOrigin, lineDirection, renderer, glRenderWindow) {
-  var near = glRenderWindow.displayToWorld(x, y, 0, renderer);
-  var far = glRenderWindow.displayToWorld(x, y, 1, renderer);
-  var viewDir = [0, 0, 0];
+  const near = glRenderWindow.displayToWorld(x, y, 0, renderer);
+  const far = glRenderWindow.displayToWorld(x, y, 1, renderer);
+  const viewDir = [0, 0, 0];
   subtract(far, near, viewDir);
-  var normal = [0, 0, 0];
+  const normal = [0, 0, 0];
   cross(lineDirection, viewDir, normal);
   cross(normal, viewDir, normal);
-  var numerator = dot([near[0] - lineOrigin[0], near[1] - lineOrigin[1], near[2] - lineOrigin[2]], normal);
-  var denominator = dot(normal, lineDirection);
-  var result = lineDirection.slice();
+  const numerator = dot([near[0] - lineOrigin[0], near[1] - lineOrigin[1], near[2] - lineOrigin[2]], normal);
+  const denominator = dot(normal, lineDirection);
+  const result = lineDirection.slice();
   multiplyScalar(result, numerator / denominator);
   add(lineOrigin, result, result);
   return result;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // vtkLineManipulator methods
 // ----------------------------------------------------------------------------
 
 function vtkLineManipulator(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkLineManipulator');
+  publicAPI.handleEvent = (callData, glRenderWindow) => ({
+    worldCoords: projectDisplayToLine(callData.position.x, callData.position.y, publicAPI.getOrigin(callData), publicAPI.getNormal(callData), callData.pokedRenderer, glRenderWindow)
+  });
+}
 
-  publicAPI.handleEvent = function (callData, glRenderWindow) {
-    return {
-      worldCoords: projectDisplayToLine(callData.position.x, callData.position.y, publicAPI.getOrigin(callData), publicAPI.getNormal(callData), callData.pokedRenderer, glRenderWindow)
-    };
-  };
-} // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
 function defaultValues(initialValues) {
-  return _objectSpread({}, initialValues);
-} // ----------------------------------------------------------------------------
+  return {
+    ...initialValues
+  };
+}
 
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   vtkAbstractManipulator.extend(publicAPI, model, defaultValues(initialValues));
   vtkLineManipulator(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkLineManipulator');
 
-var newInstance = macro.newInstance(extend, 'vtkLineManipulator'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 
 var vtkLineManipulator$1 = {
-  projectDisplayToLine: projectDisplayToLine,
-  extend: extend,
-  newInstance: newInstance
+  projectDisplayToLine,
+  extend,
+  newInstance
 };
 
 export { vtkLineManipulator$1 as default, extend, newInstance, projectDisplayToLine };

package/Widgets/Manipulators/PickerManipulator.d.ts

@@ -0,0 +1,48 @@
+import { IAbstractManipulatorInitialValues, vtkAbstractManipulator } from './AbstractManipulator';
+import vtkPicker from './../../Rendering/Core/Picker';
+
+/**
+ *
+ */
+export interface IPickerManipulatorInitialValues extends IAbstractManipulatorInitialValues {
+
+}
+
+export interface vtkPickerManipulator extends vtkAbstractManipulator {
+
+  /**
+	 *
+	 */
+	getPicker(): vtkPicker;
+
+  /**
+	 *
+	 */
+	setPicker(picker: vtkPicker): void;
+
+}
+
+
+/**
+ * Method use to decorate a given object (publicAPI+model) with vtkPickerManipulator characteristics.
+ *
+ * @param publicAPI object on which methods will be bounds (public)
+ * @param model object on which data structure will be bounds (protected)
+ * @param {IPickerManipulatorInitialValues} [initialValues] (default: {})
+ */
+export function extend(publicAPI: object, model: object, initialValues?: IPickerManipulatorInitialValues): void;
+
+/**
+ * Method use to create a new instance of vtkPickerManipulator
+ */
+export function newInstance(initialValues?: IPickerManipulatorInitialValues): vtkPickerManipulator;
+
+
+/**
+ * vtkPickerManipulator.
+ */
+export declare const vtkPickerManipulator: {
+	newInstance: typeof newInstance,
+	extend: typeof extend,
+};
+export default vtkPickerManipulator;