@pdftron/webviewer-bim-client/dist/oda/visualize/visualizejs.d.ts

Addon for WebViewer that allows you to view, annotate, and collaborate on 3D models.

///////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance").
// All rights reserved.
//
// This software and its documentation and related materials are owned by
// the Alliance. The software may only be incorporated into application
// programs owned by members of the Alliance, subject to a signed
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable
// trade secrets of the Alliance and its suppliers. The software is also
// protected by copyright law and international treaty provisions. Application
// programs incorporating this software must include the following statement
// with their copyright notices:
//
//   This application incorporates Open Design Alliance software pursuant to a
//   license agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance.
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////

declare namespace VisualizeJS {

type OdTvScale = [sx: number, sy: number, sz: number]

type Point2 = [x: number, y: number]

type Point3 = [x: number, y: number, z: number]

type Vector2 = [x: number, y: number]

type Vector3 = [x: number, y: number, z: number]

type OdGsDCPoint = [x: number, y: number]

type Rect = [xmin: number, ymin: number, xmax: number, ymax: number]

/**
* This structure defines request record fields.
**/
class RequestRecord {
  begin:string;
  end:string;
    delete():void;
}

/**
* This class represents points (locations) in 3D space. 
**/
class Point3d {
  static createFromArray(p:Point3):Point3d;
  static kOrigin:Point3;
  constructor();
  x:number;
  y:number;
  z:number;
  /**
* Sets this point to the product of xfm * point, and returns a reference to this point.
**/
setToProduct(m:Matrix3d, p:Point3d):Point3d;
  /**
* Sets this point to the result of the matrix multiplication of xfm * this point.
**/
transformBy(m:Matrix3d):Point3d;
  /**
* Sets this point to point + vect, and returns a reference to this point.
**/
setToSum(p:Point3d, v:Vector3d):Point3d;
  /**
* Returns the distance from this point to the specified point.
**/
distanceTo(p:Point3d):number;
  /**
* Returns this point as a vector.
**/
asVector():Vector3d;
  /**
* Rotates this point about the specified basePoint and axis of rotation by the specified angle. 
**/
rotateBy(angle:number, vect:Vector3d):Point3d;
  rotateByBasePoint(angle:number, vect:Vector3d, basePoint:Point3d):Point3d;
  /**
* Scales this point by the scale factor about the basepoint.
**/
scaleBy(factor:number, basePoint:Point3d):Point3d;
  /**
* Sets the parameters for this point according to the arguments
**/
set(x:number, y:number, z:number):Point3d;
  add(v:Point3d):Point3d;
  sub(v:Point3d):Point3d;
  translate(v:Vector3d):Point3d;
  toArray():any;
    delete():void;
}

/**
* This class represents vectors in 3D space. 
**/
class Vector3d {
  static createFromArray(vector:Vector3):Vector3d;
  static kIdentity:Vector3;
  static kXAxis:Vector3;
  static kYAxis:Vector3;
  static kZAxis:Vector3;
  constructor();
  x:number;
  y:number;
  z:number;
  /**
* Sets this vector to vector1 + vector1, and returns a reference to this vector.
**/
setToSum(v1:Vector3d, v2:Vector3d):Vector3d;
  /**
* Mirrors the entity about the plane passing through the
**/
mirror():Vector3d;
  /**
* Mirrors the entity about the plane passing through the
**/
mirror(normalToPlane:Vector3d):Vector3d;
  /**
* Negates this vector (-x, -y, -z), and returns a reference to this vector.
**/
negate():Vector3d;
  /**
* Sets the length of this vector.
**/
setLength(length:number):void;
  /**
* Returns the length of this vector.
**/
length():number;
  /**
* Returns the square of the length of this vector.
**/
lengthSqrd():number;
  /**
* Rotates this vector the specified angle
**/
rotateBy(angle:number, vect:Vector3d):Vector3d;
  /**
* Applies the 3D transformation matrix to this vector.
**/
transformBy(m:Matrix3d):Vector3d;
  /**
* Returns the dot product of this vector and the specified vector.
**/
dotProduct(v:Vector3d):number;
  /**
* Returns the cross product of this vector and the specified vector.
**/
crossProduct(v:Vector3d):Vector3d;
  /**
* Sets this vector to the specified arguments, 
**/
set(x:number, y:number, z:number):Vector3d;
  /**
* Returns this vector as a point.
**/
asPoint():Point3d;
  /**
* Sets this vector to the product matrix * vect and returns
**/
setToProduct(v:Vector3d, scale:number):Vector3d;
  add(v:Vector3d):Vector3d;
  sub(v:Vector3d):Vector3d;
  /**
* Returns the unit vector codirectional with this vector.
**/
normal():Vector3d;
  /**
* Returns the angle to the specified vector.
**/
angleTo(v:Vector3d):number;
  /**
* Returns the angle to the specified vector.
**/
angleToWithRef(v:Vector3d, ref:Vector3d):number;
  /**
* Sets this vector to the unit vector codirectional with this vector,
**/
normalize():Vector3d;
  /**
* Returns true if and only if vect is identical to this vector,
**/
isEqualTo(v:Vector3d):boolean;
  toArray():any;
    delete():void;
}

class OdTvExtendedView {
  roll(rollAngle:number):any;
  rollWithCenter(rollAngle:number, center:Point3):any;
  orbit(xOrbit:number, yOrbit:number):any;
  orbitWithCenter(xOrbit:number, yOrbit:number, center:Point3):any;
  zoomIn():any;
  zoomOut():any;
  setAnimationEnabled(enable:boolean):any;
  setAnimationDuration(duration:number):any;
  getAnimationEnabled():any;
  getAnimationDuration():any;
  resetAnimation():any;
  setZoomScale(zoomScale:number):any;
  setView(position:Point3, target:Point3, upVector:Vector3, fieldWidth:number, fieldHeight:number, isPerspective:boolean):any;
    delete():void;
}

/**
* This class represents infinite planes in 3D space.
**/
class OdTvPlane {
  static kXYPlane:OdTvPlane;
  /**
* Default constructor for the OdGePlane class. Constructs an infinite plane coincident with the XY plane.
**/
constructor();
  /**
* Sets the parameters for this plane according to the arguments. 
**/
set(point:Point3, normal:Vector3):OdTvPlane;
  /**
* Sets the parameters for this plane according to the arguments. 
**/
set3ptr(uPnt:Point3, origin:Point3, vPnt:Point3):OdTvPlane;
  /**
* Sets the parameters for this plane according to the arguments. 
**/
set4double(a:number, b:number, c:number, d:number):OdTvPlane;
  /**
* Sets the parameters for this plane according to the arguments. 
**/
setUV(origin:Point3, uAxis:Point3, vAxis:Point3):OdTvPlane;
  normal():any;
  getOrigin():Point3;
  getUAxis():Point3;
  getVAxis():Point3;
    delete():void;
}

/**
* This class represents 3D bounding boxes as minimum and maximum 3d points.
**/
class Extents3d {
  /**
* Default constructor for the OdGeExtents3d class.
**/
constructor();
  /**
* Returns the minimum point of this OdGeExtents3d object.
**/
min():Point3;
  /**
* Returns the maximum point of this OdGeExtents3d object.
**/
max():Point3;
  /**
* Returns a center point of this OdGeExtents3d object.
**/
center():Point3;
  /**
* Sets the minimum and maximum points for this OdGeExtents3d object to
**/
comparingSet(pt1:Point3, pt2:Point3):void;
  /**
* Sets the minimum and maximum points for this OdGeExtents3d object.
**/
set(min:Point3, max:Point3):void;
  /**
* Updates the extents of this OdGeExtents3d object with the specified point.
**/
addPoint(point:Point3):Extents3d;
  /**
* Updates the extents of this OdGeExtents3d object with the specified array of points.
**/
addExt(extents:Extents3d):Extents3d;
  /**
* Checks whether this OdGeExtents3d object contains valid extents.
**/
isValidExtents():boolean;
  /**
* Applies the 3D transformation matrix to the extents.
**/
transformBy(xfm:Matrix3d):void;
  /**
* Updates the extents of this OdGeExtents3d object by the specified vector.
**/
expandBy(vect:Vector3):void;
    delete():void;
}

/**
* The base interface class for working with Visualize SDK mapper definition objects.
**/
class OdTvMapperDef {
  /**
* Creates a new mapper definition object with default parameters.
**/
constructor();
  /**
* Retrieves the current type of the automatic transformation for the mapper definition object.
**/
autoTransform():AutoTransform;
  /**
* Retrieves the current type of the mapper definition object.
**/
getType():MapperType;
  /**
* Retrieves the current projection type of the mapper definition object.
**/
projection():Projection;
  /**
* Sets new rotation angles for the mapper definition object.
**/
rotate(x:number, y:number, z:number):void;
  /**
* Sets new scale factors for the mapper definition object. 
**/
scale(x:number, y:number, z:number):void;
  /**
* Sets a new automatic transformation type for the mapper definition object.
**/
setAutoTransform(autoTransform:AutoTransform):void;
  /**
* Sets the mapper object as the default.
**/
setDefault():void;
  /**
* Sets a new projection type for the mapper definition object.
**/
setProjection(projection:Projection):void;
  /**
* Applies a new transformation matrix for the mapper definition object.
**/
setTransform(tm:Matrix3d):void;
  /**
* Retrieves the current transformation matrix for the mapper definition object.
**/
transform():Matrix3d;
  /**
* Sets new translation parameters for the mapper definition object.
**/
translate(x:number, y:number, z:number):void;
    delete():void;
}

/**
* The base interface class for working with Visualize SDK hatch pattern line definition objects.
**/
class OdTvHatchPatternLineDef {
  /**
* Creates a new hatch pattern line definition object with default parameters.
**/
constructor();
  /**
* Retrieves the current line angle of the hatch pattern line definition object.
**/
lineAngle():number;
  /**
* Sets a new line angle value for the hatch pattern line definition object.
**/
setLineAngle(dAngle:number):void;
  /**
* Retrieves the current base point of the hatch pattern line definition object.
**/
basePoint():VectorOdTvPoint2d;
  /**
* Sets a new base point for the hatch pattern line definition object.
**/
setBasePoint(pt:VectorOdTvPoint2d):void;
  /**
* Retrieves the current offset vector of the hatch pattern line definition object.
**/
patternOffset():Vector2;
  /**
* Sets a new offset vector for the hatch pattern line definition object.
**/
setPatternOffset(offset:Vector2):void;
  /**
* Retrieves the current dash array of the hatch pattern line definition object.
**/
dashes():OdArrayDouble;
  /**
* Sets a new dash array for the hatch pattern line definition object.
**/
setDashes(dash:OdArrayDouble):void;
    delete():void;
}

/**
* The base interface class for working with Visualize SDK hatch pattern definition objects.
**/
class OdTvHatchPatternDef {
  /**
* Creates a new hatch pattern definition object with default parameters.
**/
constructor();
  /**
* Retrieves the current hatch pattern line object of the hatch pattern definition object.
**/
patternLines():any;
  /**
* Sets a new hatch pattern line object for the hatch pattern definition object.
**/
setPatternLines(hatchPattern:Array<undefined>):void;
  /**
* Retrieves the current deviation value of the hatch pattern definition object.
**/
deviation():number;
  /**
* Sets a new deviation value for the hatch pattern definition object.
**/
setDeviation(d:number):void;
  /**
* Retrieves the current pattern scale value of the hatch pattern definition object.
**/
patternScale():number;
  /**
* Sets a new pattern scale value for the hatch pattern definition object.
**/
setPatternScale(dScale:number):void;
  /**
* Sets the "is draft" flag of the hatch pattern.
**/
setDraft(bValue:boolean):void;
  /**
* Gets the "is draft" flag of the hatch pattern.
**/
isDraft():boolean;
  /**
* Sets the "is external" flag of the hatch pattern.
**/
setExternal(bValue:boolean):void;
  /**
* Gets the "is external" flag of the hatch pattern.
**/
isExternal():boolean;
  /**
* Sets the flag that forces the initial position of the pattern to the center of the shell.
**/
setAlignedToCenter(bValue:boolean):void;
  /**
* Gets the flag that forces the initial position of the pattern to the center of the shell.
**/
isAlignedToCenter():boolean;
  /**
* Sets the flag that forces the pattern to be skipped when rendering, regardless of its content.
**/
setEmpty(bValue:boolean):void;
  /**
* Gets the flag that forces the pattern to be skipped when rendering, regardless of its content.
**/
isEmpty():boolean;
  /**
* Sets the flag that forces use of a solid fill instead of a pattern while rendering.
**/
setSolid(bValue:boolean):void;
  /**
* Gets the flag that forces use of a solid fill instead of pattern while rendering.
**/
isSolid():boolean;
  /**
* Sets the flag that disables a solid background fill on the same face while rendering, so only the pattern and edges are drawn.
**/
setDisabledBackgroundFill(bValue:boolean):void;
  /**
* Gets the flag that disables a solid background fill on the same face while rendering, so only the pattern and edges are drawn.
**/
isDisabledBackgroundFill():boolean;
    delete():void;
}

class View {
  constructor();
  active:boolean;
  renderMode:RenderMode;
  visualStyle:OdTvVisualStyleId;
  viewPosition:Point3;
  viewTarget:Point3;
  upVector:Vector3;
  viewXVector:Vector3;
  viewYVector:Vector3;
  viewZVector:Vector3;
  viewFieldWidth:number;
  viewFieldHeight:number;
  perspective:boolean;
  viewingMatrix:Matrix3d;
  projectionMatrix:Matrix3d;
  eyeToWorldMatrix:Matrix3d;
  worldToDeviceMatrix:Matrix3d;
  vportRect:Rect;
  borderWidth:number;
  borderColor:any;
  sceneExtents:Extents3d;
  name:string;
  lensLength:number;
  /**
* Returns the current value of the 'screenToWorld' property as an
**/
screenToWorld():Matrix3d;
  /**
* Returns a matrix translation between specified coordinate systems.
**/
getTransform(from:CoordSys, to:CoordSys):Matrix3d;
  /**
* Transforms vectors between specified coordinate systems. Vector coordinates are
**/
transformVectors(from:CoordSys, to:CoordSys, vcts:any):any;
  /**
* Transforms points between specified coordinate systems. Point coordinates
**/
transformPoints(from:CoordSys, to:CoordSys, pts:any):any;
  select(dcPoints:any, opt:OdTvSelectionOptions, model:TvModel):OdTvSelectionSet;
  selectCrossing(dcPoints:any, model:TvModel):OdTvSelectionSet;
  selectWindow(dcPoints:any, model:TvModel):OdTvSelectionSet;
  selectFence(dcPoints:any, model:TvModel):OdTvSelectionSet;
  selectWPoly(dcPoints:any, model:TvModel):OdTvSelectionSet;
  selectCPoly(dcPoints:any, model:TvModel):OdTvSelectionSet;
  selectPoint(dcPoints:any, model:TvModel):OdTvSelectionSet;
  highlight(itr:OdTvSelectionSetIterator, bDoIt:boolean):void;
  /**
* Highlights a given item path and highlight style.
**/
highlight(id:OdTvEntityId, path:OdTvSubItemPath, bDoIt:boolean, highLightStyleId:number):void;
  highlightAll(set:OdTvSelectionSet, bDoIt:boolean):void;
  /**
* Sets options for an active view.
**/
setView(position:Point3, target:Point3, upVector:Vector3, fieldWidth:number, fieldHeight:number, isParallel:boolean):void;
  set2dMode(bVal:boolean):void;
  get2dMode():boolean;
  setBackground(backgroundId:OdTvGsViewBackgroundId):void;
  getBackground():OdTvGsViewBackgroundId;
  pointInView(screenPoint:VectorOdTvPoint2d):boolean;
  setViewport(lowerLeft:VectorOdTvPoint2d, upperRight:VectorOdTvPoint2d):OdTvResult;
  getViewport():any;
  setBorderVisibility(bVisible:boolean):void;
  getBorderVisibility():boolean;
  isEnableFrontClip():boolean;
  getFrontClip():number;
  setFrontClip(bEnable:boolean, frontClip:number):void;
  isEnableBackClip():boolean;
  getBackClip():number;
  setBackClip(bEnable:boolean, backClip:number):void;
  setAmbientLightColor(color:OdTvColorDef):void;
  getAmbientLightColor():OdTvColorDef;
  /**
* Add sibling view (the current view will copy own parameters to the added view)
**/
addSibling(view:View):void;
  /**
* Returns the view which controls the parameters of the current view
**/
getSiblingOwner():View;
  dolly(x:number, y:number, z:number):void;
  viewDcCorners():any;
  addModel(sceneModelId:TvModel):boolean;
  eraseModel(sceneModelId:TvModel):boolean;
  eraseAllModels():OdTvResult;
  numModels():number;
  modelAt(modelIndex:number):TvModel;
  /**
* Add cutting plane to the view.
**/
addCuttingPlane(plane:OdTvPlane):OdTvResult;
  /**
* Return the plane object associated with the given cutting plane
**/
getCuttingPlane(idPlane:number):OdTvPlane;
  /**
* Update the plane object associated with the given cutting plane
**/
updateCuttingPlane(idPlane:number, plane:OdTvPlane):OdTvResult;
  /**
* Returns the number of cutting planes
**/
numCuttingPlanes():number;
  /**
* Remove the cutting plane with the given idPlane
**/
removeCuttingPlane(idPlane:number):OdTvResult;
  /**
* Remove all cutting planes
**/
removeCuttingPlanes():OdTvResult;
  /**
* Set filling parameters of the cutting planes.
**/
setEnableCuttingPlaneFill(bEnable:boolean, r:number, g:number, b:number):OdTvResult;
  /**
* Returns the filling parameters of the cutting planes.
**/
getCuttingPlaneFillEnabled():boolean;
  /**
* Set filling pattern parameters of the cutting planes.
**/
setCuttingPlaneFillPatternEnabled(bEnable:boolean, style:CuttingPlaneFillStyle, r:number, g:number, b:number):OdTvResult;
  /**
* Returns the filling parameters of the cutting planes pattern.
**/
getCuttingPlaneFillPatternEnabled():boolean;
  /**
* Starts the view interactivity mode. 
**/
beginInteractivity(frameRateInHz:number):void;
  /**
* Retrieves whether the view is currently in interactive mode.
**/
isInInteractivity():boolean;
  /**
* Retrieves the current frame rate value (FPS) for the view interactivity mode.
**/
getInteractivityFrameRate():number;
  /**
* Stops the view interactivity mode. 
**/
endInteractivity():void;
  /**
* Retrieves the current intensity of the defalt light.
**/
defaultLightingIntensity():number;
  /**
* Sets a new default light intensity for the view object.
**/
setDefaultLightingIntensity(dIntensity:number):OdTvResult;
  /**
* Retrieves the current default light color of the view object.
**/
defaultLightingColor():OdTvColorDef;
  /**
* Sets a new default light color for the view object.
**/
setDefaultLightingColor(color:OdTvColorDef):OdTvResult;
  /**
* Enables default lighting for the view object.
**/
enableDefaultLighting(bEnable:boolean, lightType:DefaultLightingType):OdTvResult;
  /**
* Retrieves the current value of the default lighting flag. If the flag is equal to true, the default lighting is enabled; otherwise it is disabled.
**/
defaultLightingEnabled():boolean;
  /**
* Retrieves the default lighting type for the view object.
**/
defaultLightingType():DefaultLightingType;
  /**
* Returns the user defined default light direction
**/
userDefinedLightDirection():Vector3;
  /**
* Sets the user defined default light direction
**/
setUserDefinedLightDirection(lightDirection:Vector3):OdTvResult;
  /**
* Runs the collision detection 'all with all' procedure inside the view object.
**/
collideAllWithAll(modelId:TvModel, collidedWho:OdTvCollidedResult, collidedWithWhom:OdTvCollidedResult, level:SelectionLevel, bIntersectionOnly:boolean, tolerance:number):any;
  /**
* Runs the collision detection 'all with all' procedure inside the view object.
**/
collideAllWithAll(modelId:TvModel, result:OdTvCollidedPairResult, options:OdTvCollisionOptions):any;
  /**
* Runs the collision detection 'a few with all' procedure inside the view object.
**/
collideFewWithAll(inputSet:OdTvSelectionSet, modelId:TvModel, collidedFromInput:OdTvCollidedResult, level:SelectionLevel, bIntersectionOnly:boolean, tolerance:number):any;
  /**
* Runs the collision detection 'a few with all' or 'a few with themself' procedure inside the view object.
**/
collideFewWithAll(inputSet:OdTvSelectionSet, modelId:TvModel, result:OdTvCollidedPairResult, options:OdTvCollisionOptions):any;
  /**
* Runs the collision detection 'a few with a few' procedure inside the view object.
**/
collideFewWithFew(inputSet:OdTvSelectionSet, collisionWithSet:OdTvSelectionSet, collidedFromInput:OdTvCollidedResult, level:SelectionLevel, bIntersectionOnly:boolean, tolerance:number):any;
  /**
* Runs the collision detection 'a few with a few' procedure inside the view object.
**/
collideFewWithFew(inputSet:OdTvSelectionSet, collisionWithSet:OdTvSelectionSet, result:OdTvCollidedPairResult, options:OdTvCollisionOptions):any;
  /**
* Allows to overrule a screen-space ambient occlusion (SSAO) in current View.
**/
setSSAOEnabled(bEnable:boolean):void;
  /**
* Returns the overrule flag for a screen-space ambient occlusion in current View.
**/
getSSAOEnabled():boolean;
  /**
* Specifies whether a view should adjust lens length to match all parameters in the setView() method.
**/
setAdjustLensLength(bAdjust:boolean):void;
  /**
* Checks whether view should adjust lens length to match all parameters the setView() method.
**/
getAdjustLensLength():boolean;
  /**
* Retrieves focal length of this View object.
**/
focalLength():number;
  /**
* Checks whether a view intersects with the specified extents.
**/
isExtentsInView(extents:Extents3d):boolean;
  /**
* Sets the flag that determines whether the data on hidden layers in this view object
**/
setTakeIntoAccountDataAtHidenLayersInExtents(bTakeIntoAccount:boolean):void;
  /**
* Retrieves the current value of the flag that determines whether the data on hidden layers in this view object
**/
getTakeIntoAccountDataAtHidenLayersInExtents():boolean;
  /**
* Set a new lineweight mode to the view object.
**/
setLineWeightMode(lwMode:OdTvGsViewLineWeightMode):void;
  /**
* Retrieves the current lineweight mode value for the view object.
**/
getLineWeightMode():OdTvGsViewLineWeightMode;
  /**
* Set a new lineweight scale value to the view object.
**/
setLineWeightScale(dScale:number):void;
  /**
* Retrieves the current lineweight scale value for the view object.
**/
getLineWeightScale():number;
  /**
* Sets a new array of lineweights for the view object.
**/
setLineWeightEnum(lineweights:any, altLineWeights:any):void;
  transformScreenToWorld(x:number, y:number):Point3;
  transformWorldToScreen(x:number, y:number, z:number):Point3;
  /**
* Sets the normal 3D clipping for this View object.
**/
setNormal3DClipping(normalBundary:OdTvNormalClipBoundary):void;
  /**
* Sets the inverted 3D clipping for this View object.
**/
setInverted3DClipping(invertedBundary:OdTvInvertedClipBoundary):void;
  /**
* Sets the extended 3D clipping for this View object.
**/
setExtended3DClipping(extendedBundary:OdTvExtendedClipBoundary):void;
  /**
* Sets the complex 3D clipping for this View object.
**/
setComplex3DClipping(complexBundary:OdTvComplexClipBoundary):void;
  /**
* Sets the planar 3D clipping for this View object.
**/
setPlanar3DClipping(planarBundary:OdTvPlanarClipBoundary):void;
  /**
* Returns the current 3D clipping boundary for this View object.
**/
get3DClipping():any;
  /**
* Removes the 3D clipping from this View object.
**/
remove3DClipping():void;
  /**
* Sets the hatch scale for the section of the 3D clipping.
**/
setHatchScaleFor3DClippingSection(dScale:number):void;
  /**
* Returns the hatch scale for the section of the 3D clipping.
**/
getHatchScaleFor3DClippingSection():number;
  /**
* Scales the camera to completely include a specified WCS box inside the view frustum.
**/
zoomExtents(minPt:Point3, maxPt:Point3):void;
  /**
* Scales the camera to completely include a specified WCS box inside the view frustum.
**/
zoomExtents(minPt:Point3, maxPt:Point3, bCacheIfNonSetup:boolean):void;
    delete():void;
}

class Viewer {
  /**
* Currenly recreates singleton viewer object and returns it (Module.Viewer.create() method).
**/
static create():Viewer;
  /**
* Destroys a singleton viewer.
**/
static destroy():void;
  /**
* Iterates through all available devices and resizes them.
**/
static resize(rc:OdGsDCRect):void;
  activeView:View;
  enableAntiaiasing:boolean;
  lineSmoothing:boolean;
  vertexSnapping:boolean;
  edgeSnapping:boolean;
  shadows:boolean;
  groundShadow:boolean;
  fxaaAntiAliasing3d:boolean;
  fxaaAntiAliasing2d:boolean;
  fxaaQuality:number;
  memoryLimit:number;
  /**
* Creates a block with the specified name.
**/
createBlock(name:string):OdTvBlockId;
  /**
* Remove a the specified block object from the database.
**/
removeBlock(id:OdTvBlockId):void;
  /**
* Returns an active viewport index.
**/
activeViewportId():number;
  /**
* Returns this view's options.
**/
getViewString():string;
  /**
* Returns view options.
**/
getViewData():any;
  /**
* Returns a volume of the view.
**/
getVolume():Extents3d;
  /**
* Zooms view before sizing the frame.
**/
zoomWindow(xMin:number, yMin:number, xMax:number, yMax:number):void;
  /**
* Zooms field of view with a given 'factor' at the specified center in screen coordinates.
**/
zoomAt(factor:number, scrx:number, scry:number):void;
  /**
* Moves view and zooms view's field to fit model extents.
**/
zoomExtents():void;
  /**
* Moves view and zooms view's field to fit model extents.
**/
zoomExtents(force:boolean):void;
  /**
* Scales the camera to completely include a specified WCS box inside the view frustum.
**/
zoomExtents(minPt:Point3, maxPt:Point3):void;
  /**
* Clear current zoom extents cache
**/
clearViewExtentsCache():void;
  /**
* Moves camera parallel to view plane on specified vector in screen coordinates.
**/
pan(scrdx:number, scrdy:number):void;
  /**
* Rotates camera by specified angle in radians around corresponding view CS axes.
**/
orbit(xAng:number, yAng:number, zAng:number):void;
  /**
* Updates the GL frame buffer after view and/or geometry changes.
**/
update():void;
  /**
* Iterates through all available devices and resizes them.
**/
resize(xmin:number, xmax:number, ymin:number, ymax:number):void;
  /**
* Writes current database to the vsfx format.
**/
saveVsfxWrapper(writeBlock:any):any;
  /**
* Internal implementation used by APIs of the Viewer.parseStreamVSFX() function.
**/
parseVsfx(arrayBuffer:Uint8Array):DatabaseStreamStatus;
  /**
* Attach all call back for work in partial mode
**/
attachPartialResolver(objectHandler:any):void;
  /**
* Internal implementation used by APIs of the Viewer.parseStreamVSFX() function.
**/
parseVsfxInPartialMode(requestId:number, arrayBuffer:Uint8Array):boolean;
  /**
* Internal implementation used by APIs of the Viewer.parseStream() function.
**/
parseStream(arrayBuffer:Uint8Array):number;
  /**
* Internal implementation used by APIs of the Viewer.parseFile() function.
**/
parseFile(arrayBuffer:Uint8Array):any;
  /**
* Internal implementation used by APIs of the Viewer.appendFile() function.
**/
appendFile(arrayBuffer:Uint8Array):any;
  /**
* Adds a file to client file system.
**/
addEmbeddedFile(name:string, arrayBuffer:Uint8Array):any;
  /**
* Selects an active viewport by the specified screen point.  
**/
selectVport(x:number, y:number):View;
  /**
* Checks whether the animation is currently running for the active extended view.
**/
isRunningAnimation():boolean;
  /**
* Sets default view position.
**/
setDefaultViewPosition(pos:DefaultViewPosition):void;
  /**
* Sets default view position and starts animation to show the view change.
**/
setDefaultViewPositionWithAnimation(pos:DefaultViewPosition):void;
  /**
* Mouse up event handler.
**/
onMouseUp(x:number, y:number):void;
  /**
* Mouse down event handler.
**/
onMouseDown(x:number, y:number):void;
  /**
* Mouse move event handler.
**/
onMouseMove(x:number, y:number):void;
  /**
* Mouse double click
**/
onMouseDoubleClick(x:number, y:number):void;
  /**
* Checks whether the text input is in process.
**/
isInputText():boolean;
  /**
* Input text to edit item.
**/
inputText(text:string, textSize:number):void;
  /**
* Cancels current action.
**/
cancelAction():void;
  /**
* Sets current action.
**/
startAction(name:string):void;
  /**
* Returns name of the current action.
**/
getCurrentActionName():string;
  /**
* Set transport, for sending commands to client.
**/
setTransport(func:any):void;
  /**
* Returns an array of viewports.
**/
viewports():any;
  /**
* Returns a background color as [R,G,B] or [R,G,B,A].
**/
getBackgroundColor():any;
  /**
* Sets a background color.
**/
setBackgroundColor(rgba:any):void;
  /**
* Returns an iterator to iterate through existing models in the database.
**/
getModelIterator():OdTvModelsIterator;
  /**
* Searches for a model with the specified name.
**/
getModelByName(name:string):TvModel;
  /**
* Creates a model with the specified name.
**/
createModel(name:string):TvModel;
  /**
* Returns an iterator to iterate through existing layers in the database.
**/
getLayersIterator():OdTvLayersIterator;
  /**
* Searches for a layer with the specified name.
**/
findLayer(name:string):OdTvLayerId;
  /**
* Creates a layer with the specified name.
**/
createLayer(name:string):OdTvLayerId;
  /**
* Returns an iterator to iterate through existing materials in the database.
**/
getMaterialsIterator():OdTvMaterialsIterator;
  /**
* Searches for a material with the specified name.
**/
findMaterial(name:string):OdTvMaterialId;
  /**
* Creates a material with the specified name.
**/
createMaterial(name:string):OdTvMaterialId;
  /**
* Returns an iterator to iterate through existing visual styles in the database.
**/
getVisualStylesIterator():OdTvVisualStylesIterator;
  /**
* Searches for a visual style with the specified name.
**/
findVisualStyle(name:string):OdTvVisualStyleId;
  /**
* Creates a visual style with the specified name.
**/
createVisualStyle(name:string):OdTvVisualStyleId;
  /**
* Creates a block with the specified name.
**/
createTextStyle(name:string):OdTvTextStyleId;
  /**
* Searches for a text style with the specified name.
**/
findTextStyle(name:string):OdTvTextStyleId;
  /**
* Returns an iterator to iterate through existing text styles in the database.
**/
getTextStylesIterator():OdTvTextStylesIterator;
  /**
* Returns an iterator to iterate through existing graphics system devices in the database.
**/
getDevicesIterator():OdTvGsDevicesIterator;
  /**
* Returns an active graphics system device.
**/
getActiveDevice():OdTvGsDevice;
  /**
* Registers a custom big font for the file.
**/
addBigFontWithIndex(fontFileName:string, code:OdCodePageForBigFont):void;
  /**
* Returns an iterator to iterate through existing raster images in the database.
**/
getRasterImagesIterator():OdTvRasterImagesIterator;
  /**
* Creates a raster image with the specified name and path to an image file.
**/
createRasterImage(name:string, pathToFile:string):OdTvRasterImageId;
  /**
* Searches for a raster image with the specified name.
**/
findRasterImage(name:string):OdTvRasterImageId;
  /**
* Returns a smart pointer to an iterator object to get sequential access to animation container objects in the database.
**/
getAnimationContainersIterator():OdTvAnimationContainersIterator;
  /**
* Searches for a Animation container object with the specified name.
**/
findAnimationContainer(name:string):OdTvAnimationContainerId;
  /**
* Creates a new Animation container object.
**/
createAnimationContainer(name:string):OdTvAnimationContainerId;
  /**
* Remove an animation container object with the given ID.
**/
removeAnimationContainer(id:OdTvAnimationContainerId):void;
  /**
* Returns a smart pointer to an iterator to get sequential access to Animation action objects in the database.
**/
getAnimationActionsIterator():OdTvAnimationActionsIterator;
  /**
* Searches for a Animation action object with the specified name.
**/
findAnimationAction(name:string):OdTvAnimationActionId;
  /**
* Creates a new Animation action object.
**/
createAnimationAction(name:string):OdTvAnimationActionId;
  /**
* Removes an Animation action object with the given ID.
**/
removeAnimationAction(id:OdTvAnimationActionId):void;
  /**
* Returns an iterator to iterate through existing blocks in the database.
**/
getBlockIterator():OdTvBlocksIterator;
  /**
* Creates a block with the specified name.
**/
createBlock(name:string):OdTvBlockId;
  /**
* Searches for a block with the specified name.
**/
findBlock(name:string):OdTvBlockId;
  /**
* Returns an iterator to iterate through existing linetypes in the database.
**/
getLinetypeIterator():OdTvLinetypesIterator;
  /**
* Creates a local database and fills it with default values.
**/
createLocalDatabase():void;
  clear():void;
  /**
* Regenerates all views.
**/
regenAll():void;
  /**
* Regenerates an active view.
**/
regenActiveView():void;
  /**
* Regenerates only those graphic objects that are visible in the device window.
**/
regenVisible():void;
  /**
* Returns the array of visual styles for the current database.
**/
getVisualStyles():any;
  /**
* Returns the name of the active visual style.
**/
getActiveVisualStyle():string;
  /**
* Sets the active visual style by name.
**/
setActiveVisualStyle(name:string):void;
  /**
* Converts the specified screen point to a world coordinates system (WCS) point.
**/
screenToWorld(x:number, y:number):Point3;
  /**
* Converts the specified point from the eye coordinate system to a world coordinates system (WCS) point.
**/
toEyeToWorld(x:number, y:number, z:number):Point3;
  /**
* Performs selection for active model and view. Automatically detects selection mode.
**/
select(xMin:number, yMin:number, xMax:number, yMax:number):void;
  /**
* Unselects selected objects. Unselected objects are unhighlighted.
**/
unselect():void;
  /**
* Returns an array of handles of server-side database objects that corresponding to
**/
getSelected():OdTvSelectionSet;
  /**
* Sets the selection that identifies selected objects.
**/
setSelected(set:OdTvSelectionSet):void;
  /**
* Specifies whether to enable automatical selection. Automatical
**/
setEnableAutoSelect(tVal:boolean):void;
  /**
* Indicates whether automatical selection is enabled. Automatical
**/
getEnableAutoSelect():boolean;
  /**
* Sets a visual style for selected entities.
**/
setVisualStyleForSelected(vsId:OdTvVisualStyleId):void;
  /**
* Isolates selected objects.
**/
isolateSelectedObjects():void;
  /**
* Isolates selected objects.
**/
isolateSelectedObjects(bPerSession:boolean):void;
  /**
* Hides selected objects.
**/
hideSelectedObjects():void;
  /**
* Hides selected objects.
**/
hideSelectedObjects(bPerSession:boolean):void;
  /**
* Unisolates all objects.
**/
unisolateSelectedObjects():void;
  /**
* Unisolates all objects.
**/
unisolateSelectedObjects(bPerSession:boolean):void;
  /**
* Returns active model.
**/
getActiveModel():TvModel;
  /**
* Zooms camera to entity extents.
**/
zoomToEntity(id:OdTvEntityId):void;
  /**
* Zooms camera to sum extents.
**/
zoomToObjects(set:OdTvSelectionSet):void;
  explode(index:number):void;
  /**
* Gets a service model that stores markup geometry.
**/
getMarkupModel():TvModel;
  /**
* Gets a markup controller.
**/
getMarkupController():OdMarkupController;
  /**
* Adds or updates partial view indexes for models of the database.
**/
addPartialViewIndexes(bUpdateExisting:boolean, bExtendedMode:boolean):void;
  /**
* Checks that the database has partial indexes.
**/
hasPartialViewIndexes(bCheckExtents:boolean):boolean;
  /**
* Gets extents box of an active view.
**/
getActiveExtents():Extents3d;
  /**
* Gets an active extended view.
**/
getActiveTvExtendedView():OdTvExtendedView;
  /**
* Gets an overlay model that is rendered on top of the main scene directly.
**/
getOverlayModel():TvModel;
  /**
* Starts animation in a current view.
**/
startAnimation():void;
  /**
* Checks whether the animation for non-interactive view changes is enabled.
**/
getEnableAnimation():boolean;
  /**
* Enables or disables the animation of non-interactive view changes.
**/
setEnableAnimation(val:boolean):void;
  /**
* Retrieves the current value of the FPS show flag that determines whether the FPS information is displayed while rendering.
**/
getEnableFPS():boolean;
  /**
* Sets a new value of the FPS show flag that determines whether the FPS information is displayed while rendering.
**/
setEnableFPS(val:boolean):void;
  /**
* Checks whether the WCS axis triad is switched on.
**/
getEnableWCS():boolean;
  /**
* Switches on or off the WCS (the axis triad).
**/
setEnableWCS(val:boolean):void;
  /**
* Selects the specified entity and highlights it.
**/
setSelectedEntity(entity:OdTvEntityId):void;
  /**
* Gets units for vsf files obtained by importing dwg/dxf.
**/
getUnit():string;
  /**
* Returns an iterator to iterate through existing CDA (Common Data Access) tree storages in the database.
**/
getCDATreeIterator():OdTvCDATreeStoragesIterator;
  getSnapPoint(screenX:number, screenY:number, hitRadius:number):any;
  getExperimentalFunctionalityFlag(name:string):boolean;
  setExperimentalFunctionalityFlag(name:string, value:boolean):void;
  /**
* Searches device for a view by its name.
**/
getViewByName(name:string):any;
  getResolveHandleFromCdaNode(node:OdTvCDATreeNodePtr):string;
  /**
* Returns a smart pointer to an iterator object to get sequential access to highlight style objects in the database.
**/
getHighlightStylesIterator():OdTvHighlightStylesIterator;
  /**
* Searches for a highlight style object with a specified name in the database.
**/
findHighlightStyle(name:string):OdTvHighlightStyleId;
  /**
* Creates a highlight style object as a default highlight style object and returns the appropriate ID.
**/
createHighlightStyle(name:string):OdTvHighlightStyleId;
  /**
* Removes a highlight style object with the specified identifier from the database.
**/
removeHighlightStyle(id:OdTvHighlightStyleId):void;
  /**
* Creates a view background object and returns the appropriate ID.
**/
createBackground(name:string, bgType:BackgroundTypes):OdTvGsViewBackgroundId;
  /**
* Removes a view background object with the specified identifier from the database.
**/
removeBackground(id:OdTvGsViewBackgroundId):void;
  /**
* Removes all view backgrounds objects from the database.
**/
clearBackgrounds():void;
  /**
* Searches for a view background object with a specified name in the database.
**/
findBackground(name:string):OdTvGsViewBackgroundId;
  /**
* Returns a smart pointer to an iterator object to get sequential access to view background objects in the database.
**/
getBackgroundsIterator():OdTvGsViewBackgroundsIterator;
  onRequestResponseComplete(requestID:number):void;
  getHeapInformation():HeapInformation;
  /**
* Returns the OdTvEntityId that matches the original database handle.
**/
getEntityByOriginalHandle(originalDatabaseHandle:string):OdTvEntityId;
  /**
* Calculates coefficient for converting 'From' units to 'To' units.
**/
getUnitsConversionCoef(unitsFrom:Units, unitsTo:Units):number;
  /**
* Calculates coefficient for converting 'From' units to 'To' units.
**/
getUnitsConversionCoefWithUserDefined(unitsFrom:Units, unitsTo:Units, userDefCoefToMeters_uFrom:number, userDefCoefToMeters_uTo:number):number;
    delete():void;
}

/**
* This class represents a rotation quaternion in 3D space.
**/
class Quaternion {
  /**
* Default constructor for the OdGeQuaternion class.
**/
constructor();
  x:number;
  y:number;
  z:number;
  w:number;
  /**
* Set components for the quaternion and returns a reference to it.
**/
setCoords(ww:number, xx:number, yy:number, zz:number):Quaternion;
  /**
* Set components for the quaternion and returns a reference to it.
**/
setMatrix(matrix:Matrix3d):Quaternion;
  /**
* Calculates 3D rotation matrix that represents this quaternion.
**/
getMatrix():Matrix3d;
  /**
* Rotates specified 3D point using this quaternion.
**/
rotatePoint(sourcePoint:Point3):Point3;
  /**
* Rotates specified 3D point using this quaternion.
**/
rotateVector(vector:Vector3):Point3;
  mult(scale:number):any;
  scale(scale:number):any;
  add(quat:Quaternion):any;
  sub(quat:Quaternion):any;
  /**
* Returns the norm of this quaternion.
**/
norm():number;
  /**
* Sets this quaternion to the unit quaternion and returns a reference to this quaternion
**/
normalize():Quaternion;
  /**
* Returns the dot product of this quaternion and the specified quaternion.
**/
dotProduct(quat:Quaternion):number;
  /**
* Performs spherical linear interpolation, introduced by Ken Shoemake in the context of quaternion interpolation.
**/
slerp(q:Quaternion, t:number, bUseShortestPath:boolean):Quaternion;
    delete():void;
}

/**
* This class represents tolerances for vectors or points coincidence.  
**/
class OdGeTol {
  /**
* Constructor for the OdGeTol class.
**/
constructor(arg0:number);
  /**
* Constructor for the OdGeTol class.
**/
constructor(arg0:number, arg1:number);
  /**
* Returns the equalPoint tolerance.
**/
equalPoint():number;
  /**
* Returns the equalVector tolerance.
**/
equalVector():number;
  /**
* Sets the equalPoint tolerance to a specified value.
**/
setEqualPoint(val:number):void;
  /**
* Sets the equalVector tolerance to a specified value.
**/
setEqualVector(val:number):void;
    delete():void;
}

/**
* This class represents 2D device coordinate rectangles.
**/
class OdGsDCRect {
  /**
* Default constructor for the OdGsDCRect class.
**/
constructor();
  /**
* Default constructor for the OdGsDCRect class.
**/
constructor(arg0:OdGsDCPoint, arg1:OdGsDCPoint);
  /**
* Default constructor for the OdGsDCRect class.
**/
constructor(arg0:number, arg1:number, arg2:number, arg3:number);
  min:any;
  max:any;
  /**
* Sets this rectangle object to the null rectangle.
**/
set_null():void;
  /**
* Checks whether this rectangle object is the null rectangle.
**/
is_null():boolean;
  /**
* Checks whether this rectangle object is inside the specified rectangle object.
**/
within(dcRect:OdGsDCRect):boolean;
  /**
* Moves this rectangle in the provided direction.
**/
offset(x:number, y:number):void;
  /**
* Makes a new rectangle as a result of intersection between this rectangle and the passed rectangle.
**/
intersectWith(dcRect:OdGsDCRect, bValidate:boolean):void;
  /**
* Normalizes this rectangle by setting valid values to minimum and maximum points.
**/
normalize():void;
  /**
* Checks whether the specified rectangle object does not intersect this rectangle.
**/
isDisjoint(r:OdGsDCRect):boolean;
    delete():void;
}

/**
* This class represents 3D transformation matrices that define affine
**/
class Matrix3d {
  /**
* Returns the matrix which maps the initial coordinate system defined by
**/
static alignCoordSys(fromOrigin:Point3, fromXAxis:Vector3, fromYAxis:Vector3, fromZAxis:Vector3, toOrigin:Point3, toXAxis:Vector3, toYAxis:Vector3, toZAxis:Vector3):Matrix3d;
  /**
* Returns the matrix that parallely projects entities onto the specified plane
**/
static projection(projectionPlane:OdTvPlane, projectDir:Vector3):Matrix3d;
  /**
* Returns the matrix that rotates entities by an angle about an axis passing
**/
static rotation(angle:number, axis:Vector3, center:Point3):Matrix3d;
  /**
* Default constructor for objects of the OdGeMatrix3d class.
**/
constructor();
  /**
* Returns the determinant of this matrix.
**/
det():number;
  /**
* Returns the origin, X-axis, Y-axis and Z-axis of the coordinate system to
**/
getCoordSystem(origin:Point3, xAxis:Vector3, yAxis:Vector3, zAxis:Vector3):void;
  /**
* Returns the origin of the coordinate system to which this matrix maps the
**/
getCsOrigin():Point3;
  /**
* Returns the X-axis of the coordinate system to which this matrix maps the
**/
getCsXAxis():Vector3;
  /**
* Returns the Y-axis of the coordinate system to which this matrix maps the
**/
getCsYAxis():Vector3;
  /**
* Returns the Z-axis of the coordinate system to which this matrix maps the
**/
getCsZAxis():Vector3;
  /**
* Sets this matrix to its inversion.
**/
invert():Matrix3d;
  /**
* Returns true if and only if another matrix is identical to this one within
**/
isEqualTo(matrix:Matrix3d, tol:OdGeTol):boolean;
  /**
* Indicates whether the matrix can be used for perspective projections.
**/
isPerspective(tol:OdGeTol):boolean;
  /**
* Checks whether the column vectors of the linear part of this
**/
isScaledOrtho(tol:OdGeTol):boolean;
  /**
* Checks whether this matrix is singular.
**/
isSingular(tol:OdGeTol):boolean;
  /**
* Returns true if and only if the columns vectors of the linear part of this
**/
isUniScaledOrtho(tol:OdGeTol):boolean;
  /**
* Returns the largest absolute value of the linear part of this matrix.
**/
norm():number;
  /**
* Sets this matrix to the product of this matrix and rightSide, and returns a
**/
postMultBy(rightSide:Matrix3d):Matrix3d;
  /**
* Sets this matrix to the product of leftSide and this matrix, and returns a
**/
preMultBy(leftSide:Matrix3d):Matrix3d;
  /**
* Returns the scale factor of this matrix.
**/
scale():number;
  /**
* Sets this matrix to the matrix which maps the WCS to the coordinate system
**/
setCoordSystem(origin:Point3, xAxis:Vector3, yAxis:Vector3, zAxis:Vector3):Matrix3d;
  /**
* Sets this matrix to the matrix which maps the initial coordinate system
**/
setToAlignCoordSys(fromOrigin:Point3, fromXAxis:Vector3, fromYAxis:Vector3, fromZAxis:Vector3, toOrigin:Point3, toXAxis:Vector3, toYAxis:Vector3, toZAxis:Vector3):Matrix3d;
  /**
* Sets this matrix to the identity matrix, and returns a reference to this
**/
setToIdentity():Matrix3d;
  /**
* Sets this matrix to the identity matrix, and returns a reference to this
**/
setToIdentity():Matrix3d;
  /**
* Sets this matrix to the product of matrix1 and matrix2, and returns a
**/
setToProduct(matrix1:Matrix3d, matrix2:Matrix3d):Matrix3d;
  /**
* Sets this matrix to the matrix which is parallely projected onto the
**/
setToProjection(projectionPlane:OdTvPlane, projectDir:Vector3):Matrix3d;
  /**
* Sets this matrix to the matrix which is rotated by a specified angle about
**/
setToRotation(angle:number, axis:Vector3, center:Point3):Matrix3d;
  /**
* Sets any values within tol of 0 to 0.
**/
validateZero(tol:OdGeTol):void;
  /**
* Sets this matrix to its transpose, and returns a reference to this matrix.
**/
transposeIt():Matrix3d;
  /**
* Returns the transpose of this matrix.
**/
transpose():Matrix3d;
  /**
* Sets the translation part of the matrix to the specified vector.
**/
setTranslation(vect:Vector3):Matrix3d;
  /**
* Sets this matrix to the matrix which is scaled by a scale factor about the
**/
setToScaling(scale:number, center:Point3):Matrix3d;
  set(row:number, col:number, value:number):any;
  /**
* Sets this matrix to the matrix which maps the WCS to the plane coordinate
**/
setToWorldToPlane(normal:Vector3):Matrix3d;
  get(row:number, col:number):any;
    delete():void;
}

/**
* The base interface class for the iterator of Visualize SDK entity objects.
**/
class OdTvEntitiesIterator {
  /**
* Retrieves the entity that is currently referenced by the iterator object.
**/
getEntity():OdTvEntityId;
  /**
* Searches the entity defined through its identifier and moves the iterator to this entity if found.
**/
seek(entityId:OdTvEntityId):boolean;
  /**
* Determines whether the traversal through the iterator was completed.
**/
done():boolean;
  /**
* Steps to the next value in the iterator object. 
**/
step():boolean;
    delete():void;
}

/**
* The base interface class for getting access to Visualize SDK model objects.
**/
class TvModel {
  constructor();
  /**
* Retrieves whether the link object identifier is NULL or not.
**/
isNull():boolean;
  /**
* Appends an entity object to the model and returns the identifier of the appended entity.
**/
appendEntity(name:string):OdTvEntityId;
  /**
* Appends an insert entity object to the model and returns the identifier of the appended insert entity.
**/
appendInsert(blockId:OdTvBlockId, name:string):OdTvEntityId;
  /**
* Appends a light object to the model and returns the identifier of the appended light object.
**/
appendLight(name:string):OdTvEntityId;
  /**
* Appends a camera object to the model and returns the identifier of the appended camera object.
**/
appendCamera(name:string):OdTvEntityId;
  /**
* Appends a camera object to the model and returns the identifier of the appended camera object.
**/
appendCamera(name:string, bNeedSaveInFile:boolean):OdTvEntityId;
  /**
* Removes an entity object, specified by its identifier, from the model.
**/
removeEntity(id:OdTvEntityId):void;
  /**
* Removes all entities that the model contains.
**/
clearEntities():void;
  /**
* Searches for an entity using an entity handle.
**/
findEntity(handel:string):OdTvEntityId;
  /**
* Retrieves the current database handle associated with the object. 
**/
getDatabaseHandle():string;
  /**
* Isolates a specified entity in the model.
**/
isolate(id:OdTvEntityId, per_session:boolean):void;
  /**
* Isolates specified geometry (or a sub-entity) in the model.
**/
isolateByGeometry(geometryId:OdTvGeometryDataId, per_session:boolean):void;
  /**
* Isolates objects in a selection set of the model.
**/
isolateBySelectionSet(selectionSetPtr:OdTvSelectionSet, per_session:boolean):void;
  /**
* Hides a specified entity in the model.
**/
hide(id:OdTvEntityId, per_session:boolean):void;
  /**
* Hides specified geometry (or a sub-entity) in descendants of the model.
**/
hideByGeometry(geometryId:OdTvGeometryDataId, per_session:boolean):void;
  /**
* Hides objects in a selection set of descendants of the model.
**/
hideBySelectionSet(selectionSetPtr:OdTvSelectionSet, per_session:boolean):void;
  /**
* Unisolates an entity in the model.
**/
unIsolate():void;
  /**
* Unisolates an entity in the model.
**/
unIsolate(per_session:boolean):void;
  /**
* Retrieves the name of the model.
**/
getName():string;
  /**
* Sets the name of the model.
**/
setName(name:string):void;
  /**
* Retrieves a smart pointer to the entities iterator. 
**/
getEntitiesIterator():OdTvEntitiesIterator;
  /**
* Sets new extents for the model.
**/
setExtents(ext:Extents3d):void;
  /**
* Retrieves the current extents of the specified type for the model. 
**/
getExtents():Extents3d;
  /**
* Sets the selectability property value for the entity. 
**/
setSelectability(selectability:OdTvSelectabilityDef):void;