Autodesk.AutoCAD.es6.js

var Autodesk;
((Autodesk => {
    //
    ///////////////////////////////////////////////////////////////////////////////
    //
    //                 (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    ///////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="JSGeometry.ts"/>
    /**
    * For Internal Use
    * Create AutoCAD namespace
    *
    */
    ((AutoCAD => {
        /**
        * This enum wraps the Acad::PromptStatus ObjectARX class.
        *
        */
        ((PromptStatus => {
            PromptStatus[PromptStatus["None"] = 5000] = "None";
            PromptStatus[PromptStatus["OK"] = 5100] = "OK";
            PromptStatus[PromptStatus["Modeless"] = 5027] = "Modeless";
            PromptStatus[PromptStatus["Error"] = -5001] = "Error";
            PromptStatus[PromptStatus["Cancel"] = -5002] = "Cancel";
            PromptStatus[PromptStatus["Rejected"] = -5003] = "Rejected";
            PromptStatus[PromptStatus["Failed"] = -5004] = "Failed";
            PromptStatus[PromptStatus["Keyword"] = -5005] = "Keyword";
            PromptStatus[PromptStatus["Direct"] = -5999] = "Direct";
        }))(AutoCAD.PromptStatus || (AutoCAD.PromptStatus = {}));
        const PromptStatus = AutoCAD.PromptStatus;
        ;

        /**
        * This JSAPI enum wraps resbuf type. This enumeration provides values that
        * describe the value data type of a system variable.
        *
        */
        ((ResultValueType => {
            ResultValueType[ResultValueType["RTNONE"] = 5000] = "RTNONE";
            ResultValueType[ResultValueType["RTREAL"] = 5001] = "RTREAL";
            ResultValueType[ResultValueType["RTPOINT"] = 5002] = "RTPOINT";
            ResultValueType[ResultValueType["RTSHORT"] = 5003] = "RTSHORT";
            ResultValueType[ResultValueType["RTANG"] = 5004] = "RTANG";
            ResultValueType[ResultValueType["RTSTR"] = 5005] = "RTSTR";
            ResultValueType[ResultValueType["RTORINT"] = 5008] = "RTORINT";
            ResultValueType[ResultValueType["RT3DPOINT"] = 5009] = "RT3DPOINT";
            ResultValueType[ResultValueType["RTLONG"] = 5010] = "RTLONG";
        }))(AutoCAD.ResultValueType || (AutoCAD.ResultValueType = {}));
        const ResultValueType = AutoCAD.ResultValueType;
        ;

        /**
        * This enum lists the drag status for jigging.
        *
        */
        ((DragStatus => {
            DragStatus[DragStatus["kModeless"] = -17] = "kModeless";
            DragStatus[DragStatus["kNoChange"] = -6] = "kNoChange";
            DragStatus[DragStatus["kCancel"] = -4] = "kCancel";
            DragStatus[DragStatus["kOther"] = -3] = "kOther";
            DragStatus[DragStatus["kNull"] = -1] = "kNull";
            DragStatus[DragStatus["kNormal"] = 0] = "kNormal";
            DragStatus[DragStatus["kKW1"] = 1] = "kKW1";
            DragStatus[DragStatus["kKW2"] = 2] = "kKW2";
            DragStatus[DragStatus["kKW3"] = 3] = "kKW3";
            DragStatus[DragStatus["kKW4"] = 4] = "kKW4";
            DragStatus[DragStatus["kKW5"] = 5] = "kKW5";
            DragStatus[DragStatus["kKW6"] = 6] = "kKW6";
            DragStatus[DragStatus["kKW7"] = 7] = "kKW7";
            DragStatus[DragStatus["kKW8"] = 8] = "kKW8";
            DragStatus[DragStatus["kKW9"] = 9] = "kKW9";
        }))(AutoCAD.DragStatus || (AutoCAD.DragStatus = {}));
        const DragStatus = AutoCAD.DragStatus;
        ;

        /**
        * This enum lists the cursor types that may be used while dragging.
        *
        */
        ((DragCursor => {
            DragCursor[DragCursor["Normal"] = 0] = "Normal";
            DragCursor[DragCursor["None"] = 1] = "None";
            DragCursor[DragCursor["Selection"] = 2] = "Selection";
        }))(AutoCAD.DragCursor || (AutoCAD.DragCursor = {}));
        const DragCursor = AutoCAD.DragCursor;
        ;

        /**
        * This enum wraps the AcEdJig::CursorType ObjectARX enum. It gives the type of cursor that are available.
        *
        */
        ((CursorType => {
            CursorType[CursorType["kNoSpecialCursor"] = -1] = "kNoSpecialCursor";
            CursorType[CursorType["kCrosshair"] = 0] = "kCrosshair";
            CursorType[CursorType["kRectCursor"] = 1] = "kRectCursor";
            CursorType[CursorType["kRubberBand"] = 2] = "kRubberBand";
            CursorType[CursorType["kNotRotated"] = 3] = "kNotRotated";
            CursorType[CursorType["kTargetBox"] = 4] = "kTargetBox";
            CursorType[CursorType["kRotatedCrosshair"] = 5] = "kRotatedCrosshair";
            CursorType[CursorType["kInvisible"] = 7] = "kInvisible";
            CursorType[CursorType["kEntitySelect"] = 8] = "kEntitySelect";
            CursorType[CursorType["kParallelogram"] = 9] = "kParallelogram";
            CursorType[CursorType["kEntitySelectNoPersp"] = 10] = "kEntitySelectNoPersp";
            CursorType[CursorType["kPkfirstOrGrips"] = 11] = "kPkfirstOrGrips";
        }))(AutoCAD.CursorType || (AutoCAD.CursorType = {}));
        const CursorType = AutoCAD.CursorType;
        ;

        /**
        * This enum lists the transient cursor types that are available. They are the operating system cursors.
        *
        */
        AutoCAD.TransientCursorType = {
            "kNone": "None",
            "kArrow": "Arrow",
            "kIbeam": "Ibeam",
            "kWait": "Wait",
            "kCross": "Cross",
            "kUpArrow": "UpArrow",
            "kSizeNWSE": "SizeNWSE",
            "kSizeNESW": "SizeNESW",
            "kSizeWE": "SizeWE",
            "kSizeNS": "SizeNS",
            "kSizeAll": "SizeAll",
            "kNo": "No",
            "kHand": "Hand",
            "kAppStarting": "AppStarting",
            "kHelp": "Help"
        };

        /**
        * This enum wraps the AcEdJig::UserInputControls ObjectARX class.
        * Returns the bitwise OR'd value of all user input control settings in effect at the present time for this particular jig.
        *
        */
        ((UserInputControls => {
            UserInputControls[UserInputControls["kGovernedByOrthoMode"] = 0x000001] = "kGovernedByOrthoMode";
            UserInputControls[UserInputControls["kNullResponseAccepted"] = 0x000002] = "kNullResponseAccepted";
            UserInputControls[UserInputControls["kDontEchoCancelForCtrlC"] = 0x000004] = "kDontEchoCancelForCtrlC";
            UserInputControls[UserInputControls["kDontUpdateLastPoint"] = 0x000008] = "kDontUpdateLastPoint";
            UserInputControls[UserInputControls["kNoDwgLimitsChecking"] = 0x000010] = "kNoDwgLimitsChecking";
            UserInputControls[UserInputControls["kNoZeroResponseAccepted"] = 0x000020] = "kNoZeroResponseAccepted";
            UserInputControls[UserInputControls["kNoNegativeResponseAccepted"] = 0x000040] = "kNoNegativeResponseAccepted";
            UserInputControls[UserInputControls["kAccept3dCoordinates"] = 0x000080] = "kAccept3dCoordinates";
            UserInputControls[UserInputControls["kAcceptMouseUpAsPoint"] = 0x000100] = "kAcceptMouseUpAsPoint";
            UserInputControls[UserInputControls["kAnyBlankTerminatesInput"] = 0x000200] = "kAnyBlankTerminatesInput";
            UserInputControls[UserInputControls["kInitialBlankTerminatesInput"] = 0x000400] = "kInitialBlankTerminatesInput";
            UserInputControls[UserInputControls["kAcceptOtherInputString"] = 0x000800] = "kAcceptOtherInputString";
            UserInputControls[UserInputControls["kGovernedByUCSDetect"] = 0x001000] = "kGovernedByUCSDetect";
            UserInputControls[UserInputControls["kNoZDirectionOrtho"] = 0x002000] = "kNoZDirectionOrtho";
            UserInputControls[UserInputControls["kImpliedFaceForUCSChange"] = 0x004000] = "kImpliedFaceForUCSChange";
            UserInputControls[UserInputControls["kUseBasePointElevation"] = 0x008000] = "kUseBasePointElevation";
            UserInputControls[UserInputControls["kDisableDirectDistanceInput"] = 0x010000] = "kDisableDirectDistanceInput";
        }))(AutoCAD.UserInputControls || (AutoCAD.UserInputControls = {}));
        const UserInputControls = AutoCAD.UserInputControls;
        ;

        /**
        * This enum lists the return result from Task Dialog
        *
        */
        ((TaskDialogResult => {
            TaskDialogResult[TaskDialogResult["kRetOk"] = 1] = "kRetOk";
            TaskDialogResult[TaskDialogResult["kRetCancel"] = 2] = "kRetCancel";
            TaskDialogResult[TaskDialogResult["kRetAbort"] = 3] = "kRetAbort";
            TaskDialogResult[TaskDialogResult["kRetRetry"] = 4] = "kRetRetry";
            TaskDialogResult[TaskDialogResult["kRetIgnore"] = 5] = "kRetIgnore";
            TaskDialogResult[TaskDialogResult["kRetYes"] = 6] = "kRetYes";
            TaskDialogResult[TaskDialogResult["kRetNo"] = 7] = "kRetNo";
            TaskDialogResult[TaskDialogResult["kRetClose"] = 8] = "kRetClose";
            TaskDialogResult[TaskDialogResult["kRetHelp"] = 9] = "kRetHelp";
            TaskDialogResult[TaskDialogResult["kRetTryAgain"] = 10] = "kRetTryAgain";
            TaskDialogResult[TaskDialogResult["kRetContinue"] = 11] = "kRetContinue";
            TaskDialogResult[TaskDialogResult["kRetTimeout"] = 32000] = "kRetTimeout";
        }))(AutoCAD.TaskDialogResult || (AutoCAD.TaskDialogResult = {}));
        const TaskDialogResult = AutoCAD.TaskDialogResult;

        /**
        * This enum lists the button that can be set for Task Dialog
        *
        */
        ((TaskDialogButton => {
            TaskDialogButton[TaskDialogButton["kButtonOk"] = 0x0001] = "kButtonOk";
            TaskDialogButton[TaskDialogButton["kButtonYes"] = 0x0002] = "kButtonYes";
            TaskDialogButton[TaskDialogButton["kButtonNo"] = 0x0004] = "kButtonNo";
            TaskDialogButton[TaskDialogButton["kButtonCancel"] = 0x0008] = "kButtonCancel";
            TaskDialogButton[TaskDialogButton["kButtonRetry"] = 0x0010] = "kButtonRetry";
            TaskDialogButton[TaskDialogButton["kButtonClose"] = 0x0020] = "kButtonClose";
        }))(AutoCAD.TaskDialogButton || (AutoCAD.TaskDialogButton = {}));
        const TaskDialogButton = AutoCAD.TaskDialogButton;

        /**
        * This enum lists the flag associated with AutoCAD command.
        *
        */
        ((CommandFlag => {
            CommandFlag[CommandFlag["MODAL"] = 0x00000000] = "MODAL";
            CommandFlag[CommandFlag["TRANSPARENT"] = 0x00000001] = "TRANSPARENT";
            CommandFlag[CommandFlag["USEPICKSET"] = 0x00000002] = "USEPICKSET";
            CommandFlag[CommandFlag["REDRAW"] = 0x00000004] = "REDRAW";
            CommandFlag[CommandFlag["NOPERSPECTIVE"] = 0x00000008] = "NOPERSPECTIVE";
            CommandFlag[CommandFlag["NOMULTIPLE"] = 0x00000010] = "NOMULTIPLE";
            CommandFlag[CommandFlag["NOTILEMODE"] = 0x00000020] = "NOTILEMODE";
            CommandFlag[CommandFlag["NOPAPERSPACE"] = 0x00000040] = "NOPAPERSPACE";
            CommandFlag[CommandFlag["NOOEM"] = 0x00000100] = "NOOEM";
            CommandFlag[CommandFlag["UNDEFINED"] = 0x00000200] = "UNDEFINED";
            CommandFlag[CommandFlag["INPROGRESS"] = 0x00000400] = "INPROGRESS";
            CommandFlag[CommandFlag["DEFUN"] = 0x00000800] = "DEFUN";
            CommandFlag[CommandFlag["LISPASCMD"] = 0x00001000] = "LISPASCMD";
            CommandFlag[CommandFlag["NONEWSTACK"] = 0x00010000] = "NONEWSTACK";
            CommandFlag[CommandFlag["NOINTERNALLOCK"] = 0x00020000] = "NOINTERNALLOCK";
            CommandFlag[CommandFlag["DOCREADLOCK"] = 0x00080000] = "DOCREADLOCK";
            CommandFlag[CommandFlag["DOCEXCLUSIVELOCK"] = 0x00100000] = "DOCEXCLUSIVELOCK";
            CommandFlag[CommandFlag["SESSION"] = 0x00200000] = "SESSION";
            CommandFlag[CommandFlag["INTERRUPTIBLE"] = 0x00400000] = "INTERRUPTIBLE";
            CommandFlag[CommandFlag["NOHISTORY"] = 0x00800000] = "NOHISTORY";
            CommandFlag[CommandFlag["NO_UNDO_MARKER"] = 0x01000000] = "NO_UNDO_MARKER";
            CommandFlag[CommandFlag["NOBEDIT"] = 0x02000000] = "NOBEDIT";
            CommandFlag[CommandFlag["NOACTIONRECORDING"] = 0x04000000] = "NOACTIONRECORDING";
            CommandFlag[CommandFlag["ACTIONMACRO"] = 0x08000000] = "ACTIONMACRO";
            CommandFlag[CommandFlag["RELAXASSOC"] = 0x10000000] = "RELAXASSOC";
            CommandFlag[CommandFlag["CORE"] = 0x20000000] = "CORE";
            CommandFlag[CommandFlag["NOINFERCONSTRAINT"] = 0x40000000] = "NOINFERCONSTRAINT";
            CommandFlag[CommandFlag["TEMPSHOWDYNDIM"] = 0x80000000] = "TEMPSHOWDYNDIM";
        }))(AutoCAD.CommandFlag || (AutoCAD.CommandFlag = {}));
        const CommandFlag = AutoCAD.CommandFlag;
        ;

        /**
        * For Internal use
        *
        */
        AutoCAD.Int32MinValue = -(0x8000);
        AutoCAD.Int32MaxValue = 0x7FFF;

        //TODO: remove in future when Typescript is used for inheritance
        /**
        * For Internal use
        *
        */
        AutoCAD.extend = (subClass, baseClass) => {
            function inheritance() {
            }
            inheritance.prototype = baseClass.prototype;
            subClass.prototype = new inheritance();
        };

        /**
        * This JSAPI enum wraps the AcGiMapper::Projection ObjectARX enum.
        * This enumeration provides values that describe the mapping projection of the mapper.
        *
        */
        ((Enum_Projection => {
            Enum_Projection[Enum_Projection["Parallel"] = 0] = "Parallel";
            Enum_Projection[Enum_Projection["Perspective"] = 1] = "Perspective";
        }))(AutoCAD.Enum_Projection || (AutoCAD.Enum_Projection = {}));
        const Enum_Projection = AutoCAD.Enum_Projection;
        ;

        /**
        * This function tests whether the number passed is a valid float
        * @param n of type float
        * @returns boolean
        */
        function isNumber(n) {
            return !isNaN(parseFloat(n)) && isFinite(n) && typeof (n) !== 'string';
        }
        AutoCAD.isNumber = isNumber;
        ;

        /**
        * This function tests whether the number passed is a Integer
        * @param value is a number
        * @returns boolean
        */
        function isInteger(value) {
            return !isNaN(parseInt(value)) && (parseFloat(value) == parseInt(value));
        }
        AutoCAD.isInteger = isInteger;

        /**
        * This is ErrorStatus defined for Shaping Layer.
        * IMPORTANT: the following enum values have to match the JsErrorStatus defined in %crxapps%\AcJsCoreStub\AcJsCoreStubDefs.h
        */
        ((ErrorStatus => {
            ErrorStatus[ErrorStatus["eJsOk"] = 0] = "eJsOk";
            ErrorStatus[ErrorStatus["eJsInvalidArguments"] = 1] = "eJsInvalidArguments";
            ErrorStatus[ErrorStatus["eJsFail"] = 2] = "eJsFail";
            ErrorStatus[ErrorStatus["eJsUnknownError"] = 256] = "eJsUnknownError";
            ErrorStatus[ErrorStatus["eJsInvalidInputJsonArgs"] = 257] = "eJsInvalidInputJsonArgs";
            ErrorStatus[ErrorStatus["eJsUnSupportedSysVarValueType"] = 258] = "eJsUnSupportedSysVarValueType";
            ErrorStatus[ErrorStatus["eJsUnknownCallback"] = 259] = "eJsUnknownCallback";
            ErrorStatus[ErrorStatus["eJsInvalidTooltipId"] = 260] = "eJsInvalidTooltipId";
            ErrorStatus[ErrorStatus["eJsUnknownFunctionName"] = 261] = "eJsUnknownFunctionName";
            ErrorStatus[ErrorStatus["eJsUnknownCompleteCallback"] = 262] = "eJsUnknownCompleteCallback";
            ErrorStatus[ErrorStatus["eJsUnknownErrorCallback"] = 263] = "eJsUnknownErrorCallback";
            ErrorStatus[ErrorStatus["eJsNoDocument"] = 264] = "eJsNoDocument";
            ErrorStatus[ErrorStatus["eJsSyncFunction"] = 265] = "eJsSyncFunction";
            ErrorStatus[ErrorStatus["eJsAsyncFunction"] = 266] = "eJsAsyncFunction";
            ErrorStatus[ErrorStatus["eJsFailGetCurGsView"] = 267] = "eJsFailGetCurGsView";
            ErrorStatus[ErrorStatus["eJsFailGetSysVar"] = 268] = "eJsFailGetSysVar";
            ErrorStatus[ErrorStatus["eJsFailGetDrawable"] = 269] = "eJsFailGetDrawable";
            ErrorStatus[ErrorStatus["eJsInvalidTransientId"] = 270] = "eJsInvalidTransientId";
            ErrorStatus[ErrorStatus["eJsFailCreateJig"] = 271] = "eJsFailCreateJig";
            ErrorStatus[ErrorStatus["eJsJigPromptSet"] = 272] = "eJsJigPromptSet";
            ErrorStatus[ErrorStatus["eJsNotSupportedInPaperSpace"] = 273] = "eJsNotSupportedInPaperSpace";
            ErrorStatus[ErrorStatus["eJsCommandLineBusy"] = 274] = "eJsCommandLineBusy";
            ErrorStatus[ErrorStatus["eJsNotAvailableInLockedViewport"] = 275] = "eJsNotAvailableInLockedViewport";
            ErrorStatus[ErrorStatus["eJsCancel"] = 276] = "eJsCancel";
        }))(AutoCAD.ErrorStatus || (AutoCAD.ErrorStatus = {}));
        const ErrorStatus = AutoCAD.ErrorStatus;
        ;

        /*
        * Creates a container object which holds Viewport related properties
        * @param position of type Acad.Position3d
        * @param target of type Acad.Position3d
        * @param upVector of type Acad.Vector3d
        * @param fieldWidth of type double
        * @param fieldHeight of type double
        * @param projection of type Acad.Enum_Projection
        * @return a container object of type Acad.ViewProperties
        *
        */
        const ViewProperties = ((() => {
            function ViewProperties(position, target, upVector, fieldWidth, fieldHeight, projection) {
                if (!isNumber(fieldWidth)) {
                    throw TypeError('fieldWidth should be a double value');
                }
                if (!isNumber(fieldHeight)) {
                    throw TypeError('fieldHeight should be a double value');
                }
                if (!(position instanceof Acad.Point3d)) {
                    throw TypeError('position should be of type Acad.Point3d');
                }
                if (!(target instanceof Acad.Point3d)) {
                    throw TypeError('target should be of type Acad.Point3d');
                }
                if (!(upVector instanceof Acad.Vector3d)) {
                    throw TypeError('upVector should be of type Acad.Vector3d');
                }
                if (!(projection === Acad.Enum_Projection.Parallel || projection === Acad.Enum_Projection.Perspective)) {
                    throw TypeError('projection should be  Acad.Enum_Projection.Parallel or Acad.Enum_Projection.Perspective ');
                }
                this.position = position;
                this.target = target;
                this.upVector = upVector;
                this.fieldWidth = fieldWidth;
                this.fieldHeight = fieldHeight;
                this.projection = projection;
            }
            return ViewProperties;
        }))();
        AutoCAD.ViewProperties = ViewProperties;
        ;

        /*
        * This is also used as a base class, designed to achieve Promise Pattern
        *
        */
        const Promise = ((() => {
            function Promise() {
            }
            /*
            * This is the function used to register callback
            * @param success Function pointer call at the time of success/cancel.
            * @param error Function pointer call at the time of error.
            * @throws TypeError
            *
            */
            Promise.prototype.then = function (success, error) {
                if (typeof (success) == 'function')
                    this.success = success;
                else
                    throw TypeError('success function pointer should be of type function');

                if (typeof (error) == 'function')
                    this.error = error;
                else
                    throw TypeError('error function pointer should be of type function');
            };
            return Promise;
        }))();
        AutoCAD.Promise = Promise;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));

var Acad = Autodesk.AutoCAD;
var Autodesk;
((Autodesk => {
    //
    ///////////////////////////////////////////////////////////////////////////////
    //
    //                 (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    ///////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="Acad.ts"/>
    /**
    * This class wraps AcGePoint2d ObjectARX class. It represents a point in 2-dimensional space. It can be viewed as a structure consisting of two doubles.
    * @param coordinates x, y.
    * @throws TypeError
    *
    */
    ((AutoCAD => {
        const Point2d = ((() => {
            function Point2d(x, y) {
                if (typeof x == 'number')
                    this.x = x;
                else
                    throw TypeError("x is not number");

                if (typeof y == 'number')
                    this.y = y;
                else
                    throw TypeError("y is not number");
            }
            return Point2d;
        }))();
        AutoCAD.Point2d = Point2d;

        /**
        * This class wraps AcGePoint3d ObjectARX class. It represents a point in 3D space. It can be viewed as a structure consisting of three doubles.
        * @param coordinates x, y, and z.
        * @throws TypeError
        *
        */
        const Point3d = ((() => {
            function Point3d(x, y, z) {
                if (typeof x == 'number')
                    this.x = x;
                else
                    throw TypeError("x is not number");

                if (typeof y == 'number')
                    this.y = y;
                else
                    throw TypeError("y is not number");

                if (typeof z == 'number')
                    this.z = z;
                else
                    throw TypeError("z is not number");
            }
            return Point3d;
        }))();
        AutoCAD.Point3d = Point3d;

        /**
        * This class wraps the AcGeVector2d ObjectARX class.
        * Vector2d represents a vector in 2D space. It can be viewed as a structure consisting of two doubles.
        * @param coordinates x, y.
        * @throws TypeError
        *
        */
        const Vector2d = ((() => {
            function Vector2d(x, y) {
                if (typeof x == 'number')
                    this.x = x;
                else
                    throw TypeError("x is not number");

                if (typeof y == 'number')
                    this.y = y;
                else
                    throw TypeError("y is not number");
            }
            return Vector2d;
        }))();
        AutoCAD.Vector2d = Vector2d;

        /**
        * This class wraps the AcGeVector3d ObjectARX class.
        * Vector3d represents a vector in 3D space. It can be viewed as a structure consisting of 3 doubles.
        * @param coordinates x, y, and z correspondingly.
        * @throws TypeError
        *
        */
        const Vector3d = ((() => {
            function Vector3d(x, y, z) {
                if (typeof x == 'number')
                    this.x = x;
                else
                    throw TypeError("x is not number");

                if (typeof y == 'number')
                    this.y = y;
                else
                    throw TypeError("y is not number");

                if (typeof z == 'number')
                    this.z = z;
                else
                    throw TypeError("z is not number");
            }
            return Vector3d;
        }))();
        AutoCAD.Vector3d = Vector3d;

        /**
        * This class wraps the lowerLeft and upperRight Point2d objects.
        * @param lowerLeft point of type Acad.Point2d
        * @param upperRight point of type Acad.Point2d
        * @throws TypeError
        *
        */
        const Rectangle2d = ((() => {
            function Rectangle2d(lowerLeft, upperRight) {
                if (lowerLeft instanceof Acad.Point2d)
                    this.lowerLeft = lowerLeft;
                else
                    throw TypeError("lowerLeft should be of Acad.Point2d type.");

                if (upperRight instanceof Acad.Point2d)
                    this.upperRight = upperRight;
                else
                    throw TypeError("upperRight should be of Acad.Point2d type.");
            }
            return Rectangle2d;
        }))();
        AutoCAD.Rectangle2d = Rectangle2d;

        /**
        * @class Acad.Bounds3d,
        * The object represents the 3d geometric extents of an entity
        * Its similar to AcDbExtents, with minimum and maximum points
        * @param minPt3d is the minimum point of the extents
        * @param maxPt3d is the maximum point of the extents
        * @throws TypeError
        *
        */
        const Bounds3d = ((() => {
            function Bounds3d(minPt3d, maxPt3d) {
                if (minPt3d instanceof Acad.Point3d)
                    this.minPoint3d = minPt3d;
                else
                    throw TypeError("minPt3d should be of Acad.Point3d type.");

                if (maxPt3d instanceof Acad.Point3d)
                    this.maxPoint3d = maxPt3d;
                else
                    throw TypeError("maxPt3d should be of Acad.Point3d type.");
            }
            return Bounds3d;
        }))();
        AutoCAD.Bounds3d = Bounds3d;

        //TODO: check compatibility with previous js
        /**
        * This class wraps the AcGeMatrix3d ObjectARX class.
        * Class Matrix3d represents an affine transformation of 3D space, including translation.
        *
        */
        const Matrix3d = ((() => {
            function Matrix3d() {
                const matrix = new Array(4);
                for (let i = 0; i < matrix.length; i++)
                    matrix[i] = new Array(4);
                return matrix;
            }
            return Matrix3d;
        }))();
        AutoCAD.Matrix3d = Matrix3d;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //
    ///////////////////////////////////////////////////////////////////////////////
    //
    //                 (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    ///////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="Acad.ts"/>
    ///<reference path="Application.ts"/>
    ((AutoCAD => {
        /**
        * @class Acad.TransientManager
        * This is the controller object that is used to create and manage the
        * transients.
        */
        const TransientManager = ((() => {
            class TransientManager {
                constructor() {
                    this.transients = [];
                    this.transientid = 1;
                    this.IsRegisteredForEvents = false;
                }

                /**
                * This function is for internal use.
                *
                */
                transientManager_event(eventArgs) {
                    if (!eventArgs) {
                        return;
                    }

                    const id = eventArgs.id;

                    const index = this.getIndex(id);
                    if (index == -1) {
                        return;
                    }

                    const transient = this.transients[index];
                    eventArgs.transient = transient;
                    transient.dispatchEvent(eventArgs.eventname, eventArgs);
                }

                /**
                * The addTransient function is used to add an Acad.Transient object to the AutoCAD transient manager.
                * The XML data represents an AcGiDrawable object defined by the transient.xsd schema.
                * @param transient is of type Acad.Transient.
                * @param xmlData is of type string.
                * @param onComplete is a function type called on successful completion of this method.
                * @param onError is a function type called if an error occurs.
                *
                */
                addTransient(transient, xmlData) {
                    if (!this.IsRegisteredForEvents) {
                        const obj = this;
                        AutoCAD.TransientManagerInterop.addHandler_mouseChanged(eventArgs => {
                            obj.transientManager_event(eventArgs);
                        });
                        this.IsRegisteredForEvents = true;
                    }

                    if (this.getIndex(transient.getId()) != -1) {
                        return;
                    }

                    this.transients.push(transient);

                    return AutoCAD.TransientManagerInterop.addTransient(transient.getId(), xmlData);
                }

                /**
                * The updateTransient function is used to update an Acad.Transient object in the AutoCAD transient manager.
                * The XML data represents an AcGiDrawable object defined by the transient.xsd schema.
                * @param transientId is of type int.
                * @param xmlData is of type string.
                * @param onComplete is a function type called on successful completion of this method.
                * @param onError is a function type called if an error occurs.
                *
                */
                updateTransient(transientId, xmlData) {
                    return AutoCAD.TransientManagerInterop.updateTransient(transientId, xmlData);
                }

                /**
                * The eraseTransient function is used erase the the Acad.Transient object from the AutoCAD transient manager.
                * @param transientId is of type int.
                * @param onComplete is a function type called on successful completion of this method.
                * @param onError is a function type called if an error occurs.
                *
                */
                eraseTransient(transientId) {
                    return AutoCAD.TransientManagerInterop.eraseTransient(transientId);
                }

                /**
                * The eraseTransients function is used erase Acad.Transient objects from the AutoCAD transient manager.
                * @param transientIds is of type Array int.
                * @param onComplete is a function type called on successful completion of this method.
                * @param onError is a function type called if an error occurs.
                *
                */
                eraseTransients(transientIds) {
                    return AutoCAD.TransientManagerInterop.eraseTransients(transientIds);
                }

                /**
                * The showTransients function is used show or hide the Acad.Transient objects in
                * the AutoCAD transient manager.
                * @param transientIds is of type Array int.
                * @param bShow is of type bool.
                * @param onComplete is a function type called on successful completion of this method.
                * @param onError is a function type called if an error occurs.
                *
                */
                showTransients(transientIds, bShow) {
                    return AutoCAD.TransientManagerInterop.showTransients(transientIds, bShow);
                }

                /**
                * The getCursor function is used to get the current cursor assigned to the Acad.Transient object.
                * It is returned in the cursor property of the object in the onComplete method.
                * This is the optional 'cursor' attribute in the transient XML schema.
                * @param transientId is of type int.
                * @param onComplete is a function type called on successful completion of this method.
                * @param onError is a function type called if an error occurs.
                *
                */
                getCursor(transientId) {
                    return AutoCAD.TransientManagerInterop.getCursor(transientId);
                }

                /**
                * This function is a private API for internal use.
                *
                */
                generateImage(imgtype, imgId, imgPostedBy, imgMessage) {
                    const jsonStr = exec(JSON.stringify({ functionName: 'Ac_Transientmanager_generateimage', invokeAsCommand: false, functionParams: { type: imgtype, id: imgId, postedby: imgPostedBy, message: imgMessage } }));
                    return jsonStr;
                }

                /**
                * This function is for internal use.
                * generate id from stub layer
                *
                */
                getNewId() {
                    return AutoCAD.TransientManagerInterop.getNewTransientId();
                }

                /**
                * This function is for internal use.
                *
                */
                getIndex(id) {
                    for (let i = 0, len = this.transients.length; i < len; i++) {
                        if (this.transients[i].getId() === id) {
                            return i;
                        }
                    }
                    return -1;
                }

                /**
                * This function is for internal use.
                *
                */
                setEventHandlingBehavior(id, eventname, bFilter) {
                    AutoCAD.TransientManagerInterop.setEventHandlingBehavior(id, eventname, bFilter);
                }

                complete() {
                }

                error() {
                }
            }

            return TransientManager;
        }))();
        AutoCAD.TransientManager = TransientManager;

        /**
        * @class Acad.TransientManager
        * This is the controller object that is used to create and manage the
        * transients.
        */
        const Transient = ((() => {
            class Transient {
                constructor() {
                    this.eventname = {
                        mousemove: "mousemove",
                        mouseleave: "mouseleave",
                        lbuttondown: "lbuttondown",
                        lbuttonup: "lbuttonup",
                        lbuttondblclk: "lbuttondblclk",
                        rbuttondown: "rbuttondown",
                        rbuttonup: "rbuttonup",
                        rbuttondblclk: "rbuttondblclk",
                        mbuttondown: "mbuttondown",
                        mbuttonup: "mbuttonup",
                        mbuttondblclk: "mbuttondblclk",
                        mousewheel: "mousewheel"
                    };
                    this.id = Acad.Application.activedocument.transientManager.getNewId();
                    this.eventobject = new Acad.EventObject();
                }

                /**
                * This function is used to add a callback.
                * @param eventname is the event for which fn would be called.
                * @param fn is a callback function, which is called when an event occurs.
                *
                */
                addEventListener(eventname, fn) {
                    this.eventobject.addEventListener(eventname, fn);
                }

                /**
                * This function is used to remove a callback.
                * @param eventname is the event for which fn would be called.
                * @param fn is a callback function, which would not be called further for the given eventname.
                *
                */
                removeEventListener(eventname, fn) {
                    this.eventobject.removeEventListener(eventname, fn);
                }

                /**
                * The getId function is used get the assigned transient id.
                * @return int.
                *
                */
                getId() {
                    return this.id;
                }

                /**
                * This function is for internal use.
                *
                */
                dispatchEvent(eventname, args) {
                    this.eventobject.dispatchEvent(eventname, args);
                }

                setEventHandlingBehavior(eventname, bFilter) {
                    Acad.Application.activedocument.transientManager.setEventHandlingBehavior(this.id, eventname, bFilter);
                }
            }

            return Transient;
        }))();
        AutoCAD.Transient = Transient;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //
    ///////////////////////////////////////////////////////////////////////////////
    //
    //                 (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    ///////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="Acad.ts"/>
    ///<reference path="Transient.ts"/>
    ((AutoCAD => {
        /**
        * @class Acad.OSet,
        * The object contains a collection of object identifiers.
        * Its similar to ads_name, and valid only while you are working on a drawing
        * with AutoCAD, and they are invalid when exiting from AutoCAD or switching to
        * another drawing.
        */
        const OSet = ((() => {
            class OSet {
                constructor() {
                    this.dbObjects = [];
                }

                getIndex(id) {
                    for (let i = 0, len = this.dbObjects.length; i < len; i++) {
                        if (this.dbObjects[i] == id) {
                            return i;
                        }
                    }

                    return -1;
                }

                /**
                * The method will add the input object id to the collection.
                * @param Input object id.
                */
                add(id) {
                    if (!id) {
                        return;
                    }

                    if (typeof id === "string" || typeof id === "number") {
                        this.dbObjects.push(id);
                    } else if (id instanceof Array) {
                        this.dbObjects = this.dbObjects.concat(id);
                    } else if (id instanceof OSet) {
                        for (let i = 0, len = id.getCount(); i < len; i++) {
                            this.dbObjects.push(id.getId(i));
                        }
                    }
                }

                /**
                * The method will remove the input object id from the collection.
                * @param Input id.
                */
                remove(id) {
                    const index = this.getIndex(id);
                    if (index !== -1) {
                        this.dbObjects.splice(index, 1);
                    }
                }

                /**
                * The method will remove all the ids from the collection.
                */
                clear() {
                    this.dbObjects = [];
                }

                /**
                * The method will return the number of items in the collection.
                * @return Returns the number of items in the collection.
                */
                getCount() {
                    return this.dbObjects.length;
                }

                /**
                * The method will return the id given the index of the item in the collection.
                * @param Input index, it should be more than or equal to 0 and less than the number of items in the collection.
                * @return Returns the id at the given index.
                */
                getId(index) {
                    return this.dbObjects[index];
                }

                /**
                * The method will return the index of the input id, in the collection.
                * @param Input id.
                * @return Returns the index of the input id if it is present, otherwise returns -1.
                */
                indexOf(id) {
                    return this.getIndex(id);
                }

                /**
                * The method can be used to test if the id is present in the collection.
                * @param Input id.
                * @return Returns true if the id is present in the collection, otherwise returns false.
                */
                contains(id) {
                    return this.getIndex(id) != -1;
                }

                /**
                * The method will return all the ids in the collection.
                * @return Returns an array that contains all the ids in the collection.
                */
                getAllIds() {
                    let ids = [];
                    ids = ids.concat(this.dbObjects);
                    return ids;
                }
            }

            return OSet;
        }))();
        AutoCAD.OSet = OSet;

        /**
        * @class Acad.DBEntity,
        * The object represents a database resident entity
        * Its similar to AcDbEntity, and valid only while you are working on a drawing
        * with AutoCAD, and is invalid when exiting from AutoCAD or switching to
        * another drawing.
        * @param id is the object identifier
        */
        const DBEntity = ((() => {
            class DBEntity {
                constructor(id) {
                    if (!id) {
                        throw TypeError(" id is mandatory for new DBEntity");
                    }

                    this.entityId = id;
                }

                get id() {
                    return this.entityId;
                }

                set id(val) {
                    throw Error(" You are not allowed to set this property");
                }

                /**
                * Returns the object geometric extents defined by min and max points.
                * @return object of type Acad.Bounds3d
                */
                getExtents() {
                    const obj = Acad.DBEntityInterop.getExtents(this.entityId);
                    const minPoint = new Acad.Point3d(obj.minPoint3d.x, obj.minPoint3d.y, obj.minPoint3d.z);
                    const maxPoint3d = new Acad.Point3d(obj.maxPoint3d.x, obj.maxPoint3d.y, obj.maxPoint3d.z);
                    const result = new Acad.Bounds3d(minPoint, maxPoint3d);
                    return result;
                }

                /**
                * Returns all the properties of this DBEntity.
                * @return the properties map(name-value pair).
                */
                getProperties() {
                    const propArray = Acad.DBEntityInterop.getProperties(this.entityId);

                    const resultObj = {};
                    for (let i = 0; i < propArray.length; ++i) {
                        resultObj[propArray[i].key] = propArray[i].value;
                    }

                    return resultObj;
                }
            }

            return DBEntity;
        }))();
        AutoCAD.DBEntity = DBEntity;

        /**
        * @class Acad.TaskDialog,
        * The object represents a task dialog
        */
        ((TaskDialog => {
            /**
            * Show a custom task dialog.
            * @param strWindowTitle is the string for dialog title.
            * @param strMainInstruction is the string for main instruction in the dialog.
            * @param strContentText is the string for content text in the dialog.
            * @param nCommonButtons is the integer flag which specifies buttons displayed in the dialog.
            * It can be bitwise OR values of enum Acad.TaskDialogButton, such as Acad.TaskDialogButton.kButtonOk | Acad.TaskDialogButton.kButtonCancel.
            * @returns the promise object, the then argument can be used. Success callback will return result in enum Acad.TaskDialogResult.
            */
            function showTaskDialog(strWindowTitle, strMainInstruction, strContentText, nCommonButtons) {
                if (typeof (strWindowTitle) !== 'string') {
                    throw TypeError('strWindowTitle should be of type string');
                }

                if (typeof (strMainInstruction) !== 'string') {
                    throw TypeError('strMainInstruction should be of type string');
                }

                if (typeof (strContentText) !== 'string') {
                    throw TypeError('strContentText should be of type string');
                }

                if (!(Acad.isInteger(nCommonButtons))) {
                    throw TypeError('nCommonButtons should be of type integer');
                }

                return AutoCAD.ApplicationInterop.showTaskDialog(strWindowTitle, strMainInstruction, strContentText, nCommonButtons);
            }
            TaskDialog.showTaskDialog = showTaskDialog;
            ;

            /**
            * Show a task dialog with confirmation message to delete.
            * @param strTitle is the string for dialog title: "<strTitle> - Delete <strTitle>".
            * @param strMessage is the string for message in the dialog: "Are you sure you want to delete <strMessage> ?"
            * @returns the promise object, the then argument can be used. Success callback will return result in enum Acad.TaskDialogResult.
            */
            function showDeleteConfirmationTaskDialog(strTitle, strMessage) {
                if (typeof (strTitle) !== 'string') {
                    throw TypeError('strTitle should be of type string');
                }

                if (typeof (strMessage) !== 'string') {
                    throw TypeError('strMessage should be of type string');
                }

                return AutoCAD.ApplicationInterop.showDeleteConfirmationTaskDialog(strTitle, strMessage);
            }
            TaskDialog.showDeleteConfirmationTaskDialog = showDeleteConfirmationTaskDialog;
            ;
        }))(AutoCAD.TaskDialog || (AutoCAD.TaskDialog = {}));
        const TaskDialog = AutoCAD.TaskDialog;
        ;

        /**
        * For Internal Use
        *
        */
        const EventObject = ((() => {
            class EventObject {
                constructor() {
                    this.listeners = {};
                }

                addEventListener(eventname, listener) {
                    if (typeof this.listeners[eventname] == "undefined") {
                        this.listeners[eventname] = [];
                    }

                    let isAdded = false;
                    if (this.listeners[eventname] instanceof Array) {
                        const listeners = this.listeners[eventname];
                        for (let i = 0, len = listeners.length; i < len; ++i) {
                            if (listeners[i] === listener) {
                                isAdded = true;
                                break;
                            }
                        }
                    }

                    if (!isAdded) {
                        this.listeners[eventname].push(listener);
                    }
                }

                removeEventListener(eventname, listener) {
                    if (this.listeners[eventname] instanceof Array) {
                        const listeners = this.listeners[eventname];
                        for (var i = 0, len = listeners.length; i < len; ++i) {
                            if (listeners[i] === listener) {
                                break;
                            }
                        }

                        listeners.splice(i, 1);
                    }
                }

                dispatchEvent(eventname, args) {
                    if (this.listeners[eventname] instanceof Array) {
                        const listeners = this.listeners[eventname];
                        for (let i = 0, len = listeners.length; i < len; i++) {
                            listeners[i](eventname, args);
                        }
                    }
                }

                count(eventname) {
                    if (this.listeners[eventname] instanceof Array) {
                        const listeners = this.listeners[eventname];
                        return listeners.length;
                    }

                    return 0;
                }
            }

            return EventObject;
        }))();
        AutoCAD.EventObject = EventObject;

        const MenuItem = ((() => {
            function MenuItem(text, id, isChecked, isEnabled, items) {
                this.text = text;
                this.id = id || 0;
                this.isChecked = isChecked || false;
                this.isEnabled = isEnabled || true;
                this.items = items || null;

                if (typeof this.id != 'number')
                    throw TypeError("id is not number");

                if (typeof this.text != 'string')
                    throw TypeError("text is not string");

                if (typeof this.isChecked != 'boolean')
                    throw TypeError("isChecked is not boolean");

                if (typeof this.isEnabled != 'boolean')
                    throw TypeError("isEnabled is not boolean");

                if (this.items && !(this.items instanceof Array))
                    throw new TypeError("items should be of Array type.");
            }
            return MenuItem;
        }))();
        AutoCAD.MenuItem = MenuItem;

        const Menu = ((() => {
            function Menu(items) {
                if (items instanceof Array)
                    this.items = items;
                else
                    throw new TypeError("items should be of Array type.");
            }
            return Menu;
        }))();
        AutoCAD.Menu = Menu;

        /**
        * @class Acad.Application, its a singleton. The class
        * provides services for accessing the active document object.
        */
        ((Application => {
            /**
            * This method can be used inside a command to ensure that all pending events are dispatched to
            * your code before the command ends. You may want to do this if you called executeCommand and you
            * want to make sure that your event handlers are called.
            */
            function doEvents() {
                return Acad.ApplicationInterop.doEvents();
            }
            Application.doEvents = doEvents;

            /**
            * The function can be used to show a HTML dialog with the specified URL.
            * @returns the promise object, the then argument can be used.
            */
            function showHTMLDialog(location, opts) {
                return Acad.ApplicationInterop.showHTMLDialog(location, opts);
            }
            Application.showHTMLDialog = showHTMLDialog;

            /**
            * The method can be used to launch a modal dialog with
            * the specified url
            * @param value is the url to be rendered.
            *
            */
            function showModalDialog(value) {
                Acad.ApplicationInterop.showModalDialog(value);
            }
            Application.showModalDialog = showModalDialog;

            /**
            * The method is used to open a HTML document window in
            * AutoCAD.
            * @param t is the title of the window.
            * @param u is the URL address to the HTML document.
            *
            */
            function addDocWindow(t, u) {
                Acad.ApplicationInterop.addDocWindow(t, u);
            }
            Application.addDocWindow = addDocWindow;

            /**
            * The method can be used to set the commit state of the modal dialog.
            * It is analogous to the OK or Cancel return value of a dialog.
            * Calling this method dismisses the HTML dialog.
            * @param value is the bool value of the commit state
            *
            */
            function modalDialogCommit(value) {
                Acad.ApplicationInterop.modalDialogCommit(value);
            }
            Application.modalDialogCommit = modalDialogCommit;

            /**
            * The method can be used to launch a palette with
            * the specified url
            * @param strPaletteName is the palette name .
            * @param uriOfHtmlPage is the url to be rendered.
            *
            */
            function addPalette(strPaletteName, uriOfHtmlPage) {
                if (typeof (strPaletteName) !== 'string') {
                    throw TypeError('strPaletteName should be of type string');
                }

                if (typeof (uriOfHtmlPage) !== 'string') {
                    throw TypeError('uriOfHtmlPage should be of type string');
                }

                Acad.ApplicationInterop.addPalette(strPaletteName, uriOfHtmlPage);
            }
            Application.addPalette = addPalette;

            function displayContextMenu(x, y, menu) {
                if (menu.items.length <= 0) {
                    throw TypeError('Menu items are empty');
                }

                return AutoCAD.ApplicationInterop.displayContextMenu(x, y, menu);
            }
            Application.displayContextMenu = displayContextMenu;
            ;

            /**
            * This function is for internal use.
            *
            */
            function oncomplete() {
            }

            /**
            * This function is for internal use.
            *
            */
            function onerror() {
            }
            ((activedocument => {
                const dbobjects = {};
                activedocument.eventname = { "modified": "modified", "erased": "erased" };
                let bIsRegisteredForNotification = false;

                //registerCallback('Ac_activedocument_databaseobject_event', activedocument_databaseobject_event);
                /**
                * This returns a transient manager object.
                */
                activedocument.transientManager = new Acad.TransientManager();

                /**
                * This function is for internal use.
                *
                */
                function objectModifiedCallback(eventArgs) {
                    const id = eventArgs.id;
                    const eventname = Acad.Application.activedocument.eventname.modified;
                    const eventobj = dbobjects[id];
                    if (eventobj) {
                        eventobj.dispatchEvent(eventname, eventArgs);
                    }
                }

                /**
                * This function is for internal use.
                *
                */
                function objectErasedCallback(eventArgs) {
                    const id = eventArgs.id;
                    const eventname = Acad.Application.activedocument.eventname.erased;
                    const eventobj = dbobjects[id];
                    if (eventobj) {
                        eventobj.dispatchEvent(eventname, eventArgs);
                    }
                }

                /**
                * This function is for internal use.
                *
                */
                function oncomplete() {
                }

                /**
                * This function is for internal use.
                *
                */
                function onerror() {
                }

                /**
                * The method can be used to subscribe to object event notifications
                * for an object.
                * @param oset is the object to be observed.
                * @param Input event for receiving notification. It can be one of the values in Acad.Application.activedocument.eventname.
                * @param Input event handler, the event handler will called when the respective event occurs.
                * @throws Error
                */
                function startObserving(oset, eventname, fn) {
                    if (!fn) {
                        throw Error("startObserving(): Invalid listener");
                    }

                    if (!eventname || ((eventname != this.eventname.modified && eventname != this.eventname.erased))) {
                        throw Error("startObserving(): Invalid eventname");
                    }

                    if (!oset) {
                        throw Error("startObserving(): Invalid oset");
                    }

                    if (!(oset instanceof Acad.OSet)) {
                        throw new TypeError("startObserving(): oset should be of type Acad.OSet");
                    }

                    const osetCount = oset.getCount();
                    if (osetCount <= 0) {
                        throw Error("startObserving(): Empty oset");
                    }

                    if (!bIsRegisteredForNotification) {
                        Acad.ActiveDocumentInterop.addHandler_objectModified(objectModifiedCallback);
                        Acad.ActiveDocumentInterop.addHandler_objectErased(objectErasedCallback);
                        bIsRegisteredForNotification = true;
                    }

                    let objId;
                    for (let i = 0, len = oset.getCount(); i < len; i++) {
                        objId = oset.getId(i);
                        let eventobject = dbobjects[objId];
                        if (!eventobject) {
                            eventobject = new Acad.EventObject();

                            // Augument the object with a new property
                            eventobject.objId = objId;
                            dbobjects[objId] = eventobject;
                        }
                        eventobject.addEventListener(eventname, fn);
                    }

                    Acad.ActiveDocumentInterop.addObjectReactor(oset.getAllIds());
                }
                activedocument.startObserving = startObserving;

                /**
                * The method can be used to unsubscribe from receiving object event
                * notifications for the respective object.
                * @param oset is the object from which to stop receiving notifications.
                * @param Input event to stop receiving notifications.
                * @param Input event handler that was passed to startObserving method.
                * @throws Error
                */
                function stopObserving(oset, eventname, fn) {
                    if (!fn) {
                        throw Error("stopObserving(): Invalid listener");
                    }

                    if (!eventname || ((eventname != this.eventname.modified && eventname != this.eventname.erased))) {
                        throw Error("stopObserving(): Invalid eventname");
                    }

                    if (!oset) {
                        throw Error("stopObserving(): Invalid oset");
                    }

                    if (!(oset instanceof Acad.OSet)) {
                        throw new TypeError("stopObserving(): oset should be of type Acad.OSet");
                    }

                    const osetCount = oset.getCount();
                    if (osetCount <= 0) {
                        throw Error("stopObserving(): Empty oset");
                    }

                    const ids = [];
                    for (let i = 0; i < osetCount; i++) {
                        const objId = oset.getId(i);
                        const eventobject = dbobjects[objId];
                        if (eventobject) {
                            eventobject.removeEventListener(eventname, fn);
                            if (eventobject.count(this.eventname.modified) <= 0 && eventobject.count(this.eventname.erased) <= 0) {
                                ids.push(objId);
                                dbobjects[objId] = undefined;
                            }
                        }
                    }

                    if (ids.length <= 0) {
                        return;
                    }

                    Acad.ActiveDocumentInterop.removeObjectReactor(oset.getAllIds());
                }
                activedocument.stopObserving = stopObserving;

                /**
                * This function can be used to get the array of handles from the OSet.
                * @param Input oset that contains the object ids.
                * @returns the promise object, the then argument can be used.
                */
                function getHandle(oset) {
                    if (!oset) {
                        throw Error("getHandle(): Invalid oset");
                    }

                    if (!(oset instanceof AutoCAD.OSet)) {
                        throw new TypeError("getHandle(): oset should be of type Acad.OSet");
                    }

                    const osetCount = oset.getCount();
                    if (osetCount <= 0) {
                        throw Error("getHandle(): Empty oset");
                    }

                    return Acad.ActiveDocumentInterop.getHandles(oset.getAllIds());
                }
                activedocument.getHandle = getHandle;

                /**
                * This function can be used to get the array of object ids from the handles.
                * @param Input array containing the handles.
                * @returns the promise object, the then argument can be used.
                */
                function getObjectSet(handles) {
                    if (!handles) {
                        throw Error("getObjectSet(): Invalid handles");
                    }

                    if (!(handles instanceof Array)) {
                        throw Error("getObjectSet(): Invalid handles");
                    }

                    if (handles.length <= 0) {
                        throw Error("getObjectSet(): empty handles");
                    }

                    const result = new Acad.Promise();
                    return Acad.ActiveDocumentInterop.getObjectSet(handles);
                }
                activedocument.getObjectSet = getObjectSet;

                /**
                * The method can be used to capture an image of the current document.
                * The image is returned as a base64 encoded bitmap.
                * @param values are the width and height of the final image.
                * @returns the promise object, the then argument can be used.
                *
                */
                function capturePreview(w, h) {
                    const result = new Acad.Promise();

                    return Acad.ActiveDocumentInterop.capturePreview(w, h);
                }
                activedocument.capturePreview = capturePreview;

                /**
                * This function can be used to highlight the list of entities represented by the given OSet.
                * @param Input oset that contains the object ids.
                */
                function highlight(oset) {
                    if (!oset) {
                        throw Error("highlight(): Invalid oset");
                    }

                    if (!(oset instanceof Acad.OSet)) {
                        throw new TypeError("highlight(): oset should be of type Acad.OSet");
                    }

                    const osetCount = oset.getCount();
                    if (osetCount <= 0) {
                        throw Error("highlight(): Empty oset");
                    }
                    Acad.ActiveDocumentInterop.highlight(oset.getAllIds());
                }
                activedocument.highlight = highlight;

                /**
                * This function can be used to unhighlight the list of entities represented by the given OSet.
                * @param Input oset that contains the object ids.
                */
                function unhighlight(oset) {
                    if (!oset) {
                        throw Error("unhighlight(): Invalid oset");
                    }
                    if (!(oset instanceof Acad.OSet)) {
                        throw new TypeError("unhighlight(): oset should be of type Acad.OSet");
                    }

                    const osetCount = oset.getCount();
                    if (osetCount <= 0) {
                        throw Error("unhighlight(): Empty oset");
                    }

                    Acad.ActiveDocumentInterop.unhighlight(oset.getAllIds());
                }
                activedocument.unhighlight = unhighlight;
            }))(Application.activedocument || (Application.activedocument = {}));
            const activedocument = Application.activedocument;
        }))(AutoCAD.Application || (AutoCAD.Application = {}));
        const Application = AutoCAD.Application;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
const __extends = this.__extends || ((d, b) => {
    for (const p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function __() { this.constructor = d; }
    __.prototype = b.prototype;
    d.prototype = new __();
});
var Autodesk;
((Autodesk => {
    //
    ///////////////////////////////////////////////////////////////////////////////
    //
    //                 (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    ///////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="Acad.ts"/>
    ((AutoCAD => {
        /**
        * This is the base class for types that represent optional parameters for prompts.
        * @param messageAndKeywords is the prompt message along with Keywords
        *
        */
        const PromptOptions = ((() => {
            class PromptOptions {
                constructor(messageAndKeywords) {
                    this.messageAndKeywords = messageAndKeywords;
                    this.globalKeywords = "";
                    this.appendKeywordsToMessage = true;
                }

                /**
                * This method sets the prompt message to the first part of the messageAndKeywords string and sets the display keywords to the latter part of the same string.
                * The display keywords portion of messageAndKeywords must be surrounded by an opening square bracket ("[") at the beginning and a closing square bracket
                * ("]") at the end. The keywords in this list must be delimited by a forward slash character ("/").
                * Each display keyword specified in messageAndKeywords must also be matched by a keyword in the same position in the globalKeywords string.
                * Keywords in globalKeywords must be delimited by a single space.
                * @param messageAndKeywords is the prompt message along with Keywords
                * @param globalKeywords
                * @throws Error
                *
                */
                setMessageAndKeywords(messageAndKeywords, globalKeywords) {
                    if (!messageAndKeywords) {
                        throw new Error('messageAndKeywords must be non-empty string');
                    }

                    if (globalKeywords) {
                        const startKeywords = messageAndKeywords.lastIndexOf("[");
                        const endKeywords = messageAndKeywords.lastIndexOf("]");
                        if (startKeywords >= 0 && endKeywords > startKeywords + 1) {
                            const displayKeywordsText = messageAndKeywords.substr(startKeywords + 1, (endKeywords - startKeywords - 1)).trim();
                            if (displayKeywordsText) {
                                if (displayKeywordsText.split('/').length != globalKeywords.split(' ').length) {
                                    throw new Error('Number of global and local keywords is not equal.');
                                }
                            } else {
                                throw new Error('Keyword list is empty.');
                            }
                        } else {
                            throw new Error('Keyword list is empty.');
                        }
                    } else {
                        const start = messageAndKeywords.lastIndexOf('[');
                        const end = messageAndKeywords.lastIndexOf(']');

                        if (start >= 0 && end > start + 1) {
                            throw new Error('Global keywords are missing');
                        }
                    }

                    this.messageAndKeywords = messageAndKeywords;
                    this.globalKeywords = globalKeywords;
                }
            }

            return PromptOptions;
        }))();
        AutoCAD.PromptOptions = PromptOptions;

        /**
        * This is the base class for command prompt options used in various types of data acquisition.
        * @param messageAndKeywords is the prompt message along with Keywords.
        *
        */
        const PromptEditorOptions = ((_super => {
            __extends(PromptEditorOptions, _super);

            class PromptEditorOptions {
                constructor(messageAndKeywords) {
                    _super.call(this, messageAndKeywords);

                    this._allowNone = true;
                    this._allowArbitraryInput = false;
                    this._allowNegative = true;
                    this._allowZero = true;
                    this._useDashedLine = false;
                    this._limitsChecked = true;
                    this._only2d = false;
                }

                get allowNone() {
                    return this._allowNone;
                }

                set allowNone(x) {
                    this._allowNone = x;
                }

                get allowArbitraryInput() {
                    return this._allowArbitraryInput;
                }

                set allowArbitraryInput(x) {
                    this._allowArbitraryInput = x;
                }

                get allowNegative() {
                    return this._allowNegative;
                }

                set allowNegative(x) {
                    this._allowNegative = x;
                }

                get allowZero() {
                    return this._allowZero;
                }

                set allowZero(x) {
                    this._allowZero = x;
                }

                get useDashedLine() {
                    return this._useDashedLine;
                }

                set useDashedLine(x) {
                    this._useDashedLine = x;
                }

                get limitsChecked() {
                    return this._limitsChecked;
                }

                set limitsChecked(x) {
                    this._limitsChecked = x;
                }

                get only2d() {
                    return this._only2d;
                }

                set only2d(x) {
                    this._only2d = x;
                }
            }

            return PromptEditorOptions;
        }))(PromptOptions);
        AutoCAD.PromptEditorOptions = PromptEditorOptions;

        /**
        * This is the base class for types that represent optional parameters for numerical prompts.
        * @param messageAndKeywords is the prompt message along with Keywords.
        *
        */
        const PromptNumericalOptions = ((_super => {
            __extends(PromptNumericalOptions, _super);

            class PromptNumericalOptions {
                constructor(messageAndKeywords) {
                    _super.call(this, messageAndKeywords);
                    this._useDefaultValue = false;
                }

                get useDefaultValue() {
                    return this._useDefaultValue;
                }

                set useDefaultValue(x) {
                    this._useDefaultValue = x;
                }
            }

            return PromptNumericalOptions;
        }))(PromptEditorOptions);
        AutoCAD.PromptNumericalOptions = PromptNumericalOptions;

        /**
        * This class represents optional parameters for a prompt for an integer.
        * @param messageAndKeywords is the prompt message along with Keywords.
        * @param lowerLimit is lower limit of input.
        * @param upperLimit is upper limit of input.
        * @throws TypeError
        *
        */
        const PromptIntegerOptions = ((_super => {
            __extends(PromptIntegerOptions, _super);

            class PromptIntegerOptions {
                constructor(messageAndKeywords, lowerLimit, upperLimit) {
                    _super.call(this, messageAndKeywords);
                    this._defaultValue = 0;
                    this.lowerLimit = lowerLimit || Acad.Int32MinValue;
                    this.upperLimit = upperLimit || Acad.Int32MaxValue;
                }

                get defaultValue() {
                    return this._defaultValue;
                }

                set defaultValue(x) {
                    if (Acad.isInteger(x)) {
                        this._defaultValue = x;
                    } else {
                        throw new TypeError('Default value should be of Integer Type');
                    }
                }
            }

            return PromptIntegerOptions;
        }))(PromptNumericalOptions);
        AutoCAD.PromptIntegerOptions = PromptIntegerOptions;

        /**
        * This class represents optional parameters for a prompt for a double.
        * @param messageAndKeywords is the prompt message along with Keywords
        * @throws TypeError
        *
        */
        const PromptDoubleOptions = ((_super => {
            __extends(PromptDoubleOptions, _super);

            class PromptDoubleOptions {
                constructor(messageAndKeywords) {
                    _super.call(this, messageAndKeywords);
                    this._defaultValue = 0.0;
                }

                get defaultValue() {
                    return this._defaultValue;
                }

                set defaultValue(x) {
                    if (Acad.isNumber(x)) {
                        this._defaultValue = x;
                    } else {
                        throw new TypeError('Default value should be Number.');
                    }
                }
            }

            return PromptDoubleOptions;
        }))(PromptNumericalOptions);
        AutoCAD.PromptDoubleOptions = PromptDoubleOptions;

        /**
        * This class represents optional parameters for prompt for distance.
        * @param messageAndKeywords is the prompt message along with Keywords.
        * @throws TypeError
        *
        */
        const PromptDistanceOptions = ((_super => {
            __extends(PromptDistanceOptions, _super);

            class PromptDistanceOptions {
                constructor(messageAndKeywords) {
                    _super.call(this, messageAndKeywords);

                    /**
                    * Gets or sets whether the base point is to be used.
                    * @Type boolean
                    */
                    this.useBasePoint = false;
                    this.useDashedLine = false;
                    this._defaultValue = 0.0;
                    this._basePoint = new Acad.Point3d(0, 0, 0);
                }

                get basePoint() {
                    return this._basePoint;
                }

                set basePoint(x) {
                    if (x instanceof Acad.Point3d) {
                        this._basePoint = x;
                    } else {
                        throw new TypeError('Point should be of Point3d type.');
                    }
                }

                get defaultValue() {
                    return this._defaultValue;
                }

                set defaultValue(x) {
                    if (Acad.isNumber(x)) {
                        this._defaultValue = x;
                    } else {
                        throw new TypeError('Default value should be Number.');
                    }
                }
            }

            return PromptDistanceOptions;
        }))(PromptNumericalOptions);
        AutoCAD.PromptDistanceOptions = PromptDistanceOptions;

        /**
        * This class represents optional parameters for a corner prompt.
        * @param messageAndKeywords is the prompt message along with Keywords.
        * @param basePoint is input base point
        * @throws TypeError
        *
        */
        const PromptCornerOptions = ((_super => {
            __extends(PromptCornerOptions, _super);
            function PromptCornerOptions(messageAndKeywords, basePoint) {
                _super.call(this, messageAndKeywords);

                if (basePoint != undefined) {
                    if (basePoint instanceof Acad.Point3d) {
                        this._basePoint = basePoint;
                    } else {
                        throw new TypeError('Point should be of Point3d type.');
                    }
                } else {
                    throw new TypeError('Point should be of Point3d type.');
                    this._basePoint = undefined;
                }
            }
            return PromptCornerOptions;
        }))(PromptEditorOptions);
        AutoCAD.PromptCornerOptions = PromptCornerOptions;

        /**
        * This class represents optional parameters for a prompt for point.
        * @param messageAndKeywords is the prompt message along with Keywords.
        *
        */
        const PromptPointOptions = ((_super => {
            __extends(PromptPointOptions, _super);
            function PromptPointOptions(messageAndKeywords) {
                _super.call(this, messageAndKeywords, new Acad.Point3d(0, 0, 0));

                this.useBasePoint = false;
            }
            return PromptPointOptions;
        }))(PromptCornerOptions);
        AutoCAD.PromptPointOptions = PromptPointOptions;

        /**
        * This class represents optional parameters for a prompt for string.
        * @param messageAndKeywords is the prompt message along with Keywords.
        * @throws TypeError
        *
        */
        const PromptStringOptions = ((_super => {
            __extends(PromptStringOptions, _super);

            class PromptStringOptions {
                constructor(messageAndKeywords) {
                    _super.call(this, messageAndKeywords);

                    this._defaultValue = "";
                    this.allowSpaces = false;
                    this.useDefaultValue = false;
                }

                get defaultValue() {
                    return this._defaultValue;
                }

                set defaultValue(x) {
                    if (typeof (x) == 'string') {
                        this._defaultValue = x;
                    } else {
                        throw new TypeError('Default value should be String.');
                    }
                }
            }

            return PromptStringOptions;
        }))(PromptEditorOptions);
        AutoCAD.PromptStringOptions = PromptStringOptions;

        /**
        * This class represents optional parameters for a prompt for an angle.
        * @param messageAndKeywords is the prompt message along with Keywords
        * @throws TypeError
        *
        */
        const PromptAngleOptions = ((_super => {
            __extends(PromptAngleOptions, _super);

            class PromptAngleOptions {
                constructor(messageAndKeywords) {
                    _super.call(this, messageAndKeywords);

                    this._basePoint = new Acad.Point3d(0, 0, 0);
                    this._defaultValue = 0.0;
                    this.useBasePoint = false;
                    this.useAngleBase = false;
                    this.useDefaultValue = false;
                }

                get basePoint() {
                    return this._basePoint;
                }

                set basePoint(point) {
                    if (point instanceof Acad.Point3d) {
                        this._basePoint = point;
                    } else {
                        throw new TypeError('Point should be of Point3d type.');
                    }
                }

                get defaultValue() {
                    return this._defaultValue;
                }

                set defaultValue(x) {
                    if (Acad.isNumber(x)) {
                        this._defaultValue = x;
                    } else {
                        throw new TypeError('Default value should be Number.');
                    }
                }
            }

            return PromptAngleOptions;
        }))(PromptEditorOptions);
        AutoCAD.PromptAngleOptions = PromptAngleOptions;

        /**
        * This class represents optional parameters for a prompt for a keyword.
        * @param messageAndKeywords is the prompt message along with Keywords
        *
        */
        const PromptKeywordOptions = ((_super => {
            __extends(PromptKeywordOptions, _super);
            function PromptKeywordOptions(messageAndKeywords) {
                _super.call(this, messageAndKeywords);
            }
            return PromptKeywordOptions;
        }))(PromptEditorOptions);
        AutoCAD.PromptKeywordOptions = PromptKeywordOptions;

        /**
        * This class represents optional parameters for a prompt for an entity.
        * @param messageAndKeywords is the prompt message along with Keywords.
        *
        */
        const PromptEntityOptions = ((_super => {
            __extends(PromptEntityOptions, _super);

            class PromptEntityOptions {
                constructor(messageAndKeywords) {
                    _super.call(this, messageAndKeywords);
                    this._rejectMessage = "";
                    this._allowedClasses = undefined;

                    /**
                    * Gets or sets whether the prompt allows selection of entities on locked layer.
                    * @Type boolean
                    *
                    */
                    this.allowObjectOnLockedLayer = false;
                }

                get rejectMessage() {
                    return this._rejectMessage;
                }

                set rejectMessage(x) {
                    if (typeof (x) == 'string') {
                        this._rejectMessage = x;
                    } else {
                        throw Error('Please provide reject message of string type.');
                    }
                }

                get allowedClasses() {
                    return this._allowedClasses;
                }

                set allowedClasses(x) {
                    throw Error('Please use addAllowedClass() function to modify it.');
                }

                /**
                * This method adds type to the internal list of classes allowed for the selection. If exactMatch is true, then only objects of the exact class type are allowed.
                * Otherwise, objects of the specified type and of any derived types are allowed. If type is already in the class list, the value of exactMatch is applied to the existing class entry.
                * @param className name of allowed class
                * @param exactMatch boolean for exact type
                * @throws Error
                *
                */
                addAllowedClass(newclassName, exactMatch) {
                    if (this._rejectMessage == undefined)
                        throw Error('Use SetRejectMessage first.');

                    if (typeof (exactMatch) != 'boolean')
                        throw Error('Type of exactMatch should be boolean.');

                    if (this._allowedClasses == undefined) {
                        this._allowedClasses = new Array();
                    }

                    for (const index in this._allowedClasses) {
                        const obj = this._allowedClasses[index];
                        if (obj.className == newclassName) {
                            obj.exactMatch = exactMatch;
                            return;
                        }
                    }

                    // Add the allowed classes
                    const allowed = { "className": newclassName, "exactMatch": exactMatch };
                    this._allowedClasses.push(allowed);
                }

                /**
                * This method removes the class indicated by type from the internal list of classes allowed for this selection.
                * @param className name of class
                *
                */
                removeAllowedClass(className) {
                    if (className) {
                        for (const index in this._allowedClasses) {
                            const obj = this._allowedClasses[index];
                            if (obj.hasOwnProperty('className') && obj['className'] == className) {
                                this._allowedClasses.splice(index, 1);
                                return;
                            }
                        }
                    }
                }
            }

            return PromptEntityOptions;
        }))(PromptEditorOptions);
        AutoCAD.PromptEntityOptions = PromptEntityOptions;

        /**
        * This class represents optional parameters for a prompt for a nested entity.
        * @param messageAndKeywords is the prompt message along with Keywords
        * @param nonInteractivePickPoint is the Point3d
        * @param useNonInteractivePickPoint is boolean
        * @throws TypeError
        *
        */
        const PromptNestedEntityOptions = ((_super => {
            __extends(PromptNestedEntityOptions, _super);

            class PromptNestedEntityOptions {
                constructor(messageAndKeywords) {
                    _super.call(this, messageAndKeywords);

                    /**
                    * Gets or sets whether the prompt should attempt a non-interactive pick.
                    * @Type boolean
                    */
                    this.useNonInteractivePickPoint = false;
                    this._nonInteractivePickPoint = new Acad.Point3d(0, 0, 0);
                }

                get nonInteractivePickPoint() {
                    return this._nonInteractivePickPoint;
                }

                set nonInteractivePickPoint(point) {
                    if (point instanceof Acad.Point3d) {
                        this._nonInteractivePickPoint = point;
                    } else {
                        throw new TypeError('nonInteractivePickPoint should be of Point3d type.');
                    }
                }
            }

            return PromptNestedEntityOptions;
        }))(PromptEditorOptions);
        AutoCAD.PromptNestedEntityOptions = PromptNestedEntityOptions;

        /**
        * This is the base class for jig prompt options.
        * @param messageAndKeywords is the prompt message along with Keywords.
        * @throw TypeError
        *
        */
        const JigPromptOptions = ((_super => {
            __extends(JigPromptOptions, _super);

            class JigPromptOptions {
                constructor(messageAndKeywords) {
                    _super.call(this, messageAndKeywords);
                    this._specialCursorType = 0;
                    this._userInputControls = 0;
                    this._useDefaultValue = false;
                }

                get specialCursorType() {
                    return this._specialCursorType;
                }

                set specialCursorType(x) {
                    const col = Acad.CursorType;
                    let isValid = false;
                    for (const name in col) {
                        if (name == x) {
                            this._specialCursorType = x;
                            isValid = true;
                            break;
                        }
                    }

                    if (!isValid) {
                        throw new TypeError('Type of specialCursorType should be Acad.CursorType.');
                    }
                }

                get userInputControls() {
                    return this._userInputControls;
                }

                set userInputControls(x) {
                    if (Acad.isInteger(x))
                        this._userInputControls = x;
                    else
                        throw new TypeError('Type of userInputControls should be Acad.UserInputControls.');
                }

                get useDefaultValue() {
                    return this._useDefaultValue;
                }

                set useDefaultValue(x) {
                    if (typeof (x) == 'boolean')
                        this._useDefaultValue = x;
                    else
                        throw new TypeError('Type of useDefaultValue should be boolean.');
                }
            }

            return JigPromptOptions;
        }))(PromptOptions);
        AutoCAD.JigPromptOptions = JigPromptOptions;

        /**
        * This is the base class for jig prompt options used in various types of data acquisition.
        * @param messageAndKeywords is the prompt message along with Keywords.
        * @throws TypeError
        */
        const JigPromptGeometryOptions = ((_super => {
            __extends(JigPromptGeometryOptions, _super);

            class JigPromptGeometryOptions {
                constructor(messageAndKeywords) {
                    _super.call(this, messageAndKeywords);
                    this._basePoint = new Acad.Point3d(0, 0, 0);
                    this._useBasePoint = true;
                }

                get basePoint() {
                    return this._basePoint;
                }

                set basePoint(x) {
                    if (x instanceof Acad.Point3d) {
                        this._basePoint = x;
                        this._useBasePoint = true;
                    } else {
                        throw new TypeError('Point should be of Point3d type.');
                    }
                }

                get useBasePoint() {
                    return this._useBasePoint;
                }

                set useBasePoint(x) {
                    if (typeof (x) == 'boolean')
                        this._useBasePoint = x;
                    else
                        throw Error('Type of useBasePoint should be boolean.');
                }
            }

            return JigPromptGeometryOptions;
        }))(JigPromptOptions);
        AutoCAD.JigPromptGeometryOptions = JigPromptGeometryOptions;

        /**
        * This class represents optional parameters for prompt for distance during jigging.
        * @param messageAndKeywords is the prompt message along with Keywords.
        * @throws TypeError
        *
        */
        const JigPromptDistanceOptions = ((_super => {
            __extends(JigPromptDistanceOptions, _super);

            class JigPromptDistanceOptions {
                constructor(messageAndKeywords) {
                    _super.call(this, messageAndKeywords);
                    this._defaultValue = 0.0;
                }

                get defaultValue() {
                    return this._defaultValue;
                }

                set defaultValue(x) {
                    if (Acad.isNumber(x)) {
                        this._defaultValue = x;
                    } else {
                        throw new TypeError('Default value should be Number.');
                    }
                }
            }

            return JigPromptDistanceOptions;
        }))(JigPromptGeometryOptions);
        AutoCAD.JigPromptDistanceOptions = JigPromptDistanceOptions;

        /**
        * This class represents optional parameters for prompt for angle during jigging.
        * @param messageAndKeywords is the prompt message along with Keywords.
        * @throws TypeError
        */
        const JigPromptAngleOptions = ((_super => {
            __extends(JigPromptAngleOptions, _super);

            class JigPromptAngleOptions {
                constructor(messageAndKeywords) {
                    _super.call(this, messageAndKeywords);
                    this._defaultValue = 0.0;
                    //  super.useBasePoint = true;
                }

                get defaultValue() {
                    return this._defaultValue;
                }

                set defaultValue(x) {
                    if (Acad.isNumber(x)) {
                        this._defaultValue = x;
                    } else {
                        throw new TypeError('Default value should be Number.');
                    }
                }

                get useBasePoint() {
                    return this._useBasePoint;
                }

                set useBasePoint(x) {
                    throw Error("useBasePoint is read-only property");
                }
            }

            return JigPromptAngleOptions;
        }))(JigPromptGeometryOptions);
        AutoCAD.JigPromptAngleOptions = JigPromptAngleOptions;

        /**
        * This class represents optional parameters for prompt for point during jigging.
        * @param messageAndKeywords is the prompt message along with Keywords.
        * @throws TypeError
        */
        const JigPromptPointOptions = ((_super => {
            __extends(JigPromptPointOptions, _super);

            class JigPromptPointOptions {
                constructor(messageAndKeywords) {
                    _super.call(this, messageAndKeywords);
                    this._defaultValue = new Acad.Point3d(0, 0, 0);
                }

                get defaultValue() {
                    return this._defaultValue;
                }

                set defaultValue(x) {
                    if (x instanceof Acad.Point3d) {
                        this._defaultValue = x;
                    } else {
                        throw new TypeError('Point should be of Point3d type.');
                    }
                }
            }

            return JigPromptPointOptions;
        }))(JigPromptGeometryOptions);
        AutoCAD.JigPromptPointOptions = JigPromptPointOptions;

        /**
        * This class represents optional parameters for prompt for string during jigging.
        * @param messageAndKeywords is the prompt message along with Keywords.
        * @throws TypeError
        */
        const JigPromptStringOptions = ((_super => {
            __extends(JigPromptStringOptions, _super);

            class JigPromptStringOptions {
                constructor(messageAndKeywords) {
                    _super.call(this, messageAndKeywords);
                    this._defaultValue = "";
                }

                get defaultValue() {
                    return this._defaultValue;
                }

                set defaultValue(x) {
                    if (typeof (x) == 'string')
                        this._defaultValue = x;
                    else
                        throw new TypeError('Default value should be String.');
                }
            }

            return JigPromptStringOptions;
        }))(JigPromptOptions);
        AutoCAD.JigPromptStringOptions = JigPromptStringOptions;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //
    ///////////////////////////////////////////////////////////////////////////////
    //
    //                 (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    ///////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="Acad.ts"/>
    ((AutoCAD => {
        /**
        * This is the base class for classes that hold the result of a prompt operation.
        * @param retCode The status result of the prompt operation.
        * @param stringResult The optional string result of the prompt operation.
        * This value is set when Status is PromptStatus.Keyword or a prompt that returns a string as its primary result.
        *
        */
        const PromptResults = ((_super => {
            __extends(PromptResults, _super);
            function PromptResults(retCode, stringResult) {
                if (typeof stringResult === "undefined") { stringResult = ""; }
                _super.call(this);
                this.status = retCode;
                this.stringResult = stringResult;
            }
            return PromptResults;
        }))(Acad.Promise);
        AutoCAD.PromptResults = PromptResults;
        ;

        /**
        * This class holds the result of a prompt that returns an integer as its primary result.
        * @param retCode The status result of the prompt operation.
        * @param stringResult The optional string result of the prompt operation.
        * @param value The integer that the user entered.
        *
        */
        const PromptIntegerResult = ((_super => {
            __extends(PromptIntegerResult, _super);
            function PromptIntegerResult(retCode, stringResult, value) {
                _super.call(this, retCode, stringResult);
                if (retCode == Acad.PromptStatus.OK)
                    this.value = value;
            }
            return PromptIntegerResult;
        }))(PromptResults);
        AutoCAD.PromptIntegerResult = PromptIntegerResult;
        ;

        /**
        * This class holds the result of a prompt that returns a double as its primary result.
        * @param retCode The status result of the prompt operation.
        * @param stringResult The optional string result of the prompt operation.
        * @param value The double that the user entered.
        *
        */
        const PromptDoubleResult = ((_super => {
            __extends(PromptDoubleResult, _super);
            function PromptDoubleResult(retCode, stringResult, value) {
                _super.call(this, retCode, stringResult);
                if (retCode == Acad.PromptStatus.OK)
                    this.value = value;
            }
            return PromptDoubleResult;
        }))(PromptResults);
        AutoCAD.PromptDoubleResult = PromptDoubleResult;
        ;

        /**
        * This class holds the result of a prompt that returns a point as its primary result.
        * @param retCode The status result of the prompt operation.
        * @param stringResult The optional string result of the prompt operation.
        * @param point The point that the user entered.
        * @throws TypeError
        *
        */
        const PromptPointResult = ((_super => {
            __extends(PromptPointResult, _super);
            function PromptPointResult(retCode, stringResult, point) {
                _super.call(this, retCode, stringResult);
                if (retCode == Acad.PromptStatus.OK) {
                    if (point instanceof Acad.Point3d)
                        this.value = point;
                    else
                        throw new TypeError("Point should be of Point3d type.");
                }
            }
            return PromptPointResult;
        }))(PromptResults);
        AutoCAD.PromptPointResult = PromptPointResult;
        ;

        /**
        * This class holds the result of a prompt that returns an entity as its primary result.
        * @param retCode The status result of the prompt operation.
        * @param stringResult The optional string result of the prompt operation.
        * @param objectId The entity that the user picked.
        * @param point The point that was used to pick the entity.
        * @throws TypeError
        *
        */
        const PromptEntityResult = ((_super => {
            __extends(PromptEntityResult, _super);
            function PromptEntityResult(retCode, stringResult, objectId, point) {
                _super.call(this, retCode, stringResult);
                this.objectId = objectId;
                if (point instanceof Acad.Point3d)
                    this.pickedPoint = point;
                else
                    throw new TypeError("Point should be of Point3d type.");
            }
            return PromptEntityResult;
        }))(PromptResults);
        AutoCAD.PromptEntityResult = PromptEntityResult;
        ;

        /**
        * This class holds the result of a prompt that returns a nested entity as its primary result.
        * @param retCode The status result of the prompt operation.
        * @param stringResult the optional string result of the prompt operation.
        * @param objectId The entity that the user picked.
        * @param point The point that was used to pick the entity.
        * @param xform The transformation matrix that is applied to the picked object by its containers.
        * @param objectIds Collection of nested enities object Ids.
        * @throws TypeError
        *
        */
        const PromptNestedEntityResult = ((_super => {
            __extends(PromptNestedEntityResult, _super);
            function PromptNestedEntityResult(retCode, stringResult, objectId, point, xform, objectIds) {
                _super.call(this, retCode, stringResult, objectId, point);
                if (xform instanceof Acad.Matrix3d) {
                    for (let i = 0; i < 4; ++i) {
                        for (let j = 0; j < 4; ++j)
                            this.matrix[i][j] = xform[i][j];
                    }
                } else
                    throw new TypeError("matrix should be of Matrix3d type.");

                if (objectIds instanceof Array)
                    this.containers = objectIds;
                else
                    throw new TypeError("objectIds should be of Array type.");
            }
            return PromptNestedEntityResult;
        }))(PromptEntityResult);
        AutoCAD.PromptNestedEntityResult = PromptNestedEntityResult;
        ;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //
    ///////////////////////////////////////////////////////////////////////////////
    //
    //                 (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    ///////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="Acad.ts"/>
    ///<reference path="PromptResults.ts"/>
    ((AutoCAD => {
        /**
        * This class provides optional parameters to a selection set prompt.
        *
        */
        const PromptSelectionOptions = ((() => {
            function PromptSelectionOptions() {
                this.allowDuplicates = false;
                this.messageForAdding = "";
                this.messageForRemoval = "";
                this.singlePickInSpace = false;
                this.selectEverythingInAperture = false;
                this.singleOnly = false;
                this.rejectObjectsOnLockedLayers = false;
                this.rejectObjectsFromNonCurrentSpace = false;
                this.rejectPaperspaceViewport = false;
            }
            return PromptSelectionOptions;
        }))();
        AutoCAD.PromptSelectionOptions = PromptSelectionOptions;
        ;

        /*
        * This is the base class for a selected object.
        *
        */
        const SelectedObject = ((() => {
            function SelectedObject() {
                this.objectId = undefined;
                this.gsMarker = undefined;
            }
            return SelectedObject;
        }))();
        AutoCAD.SelectedObject = SelectedObject;

        /**
        * This class represents the result of a prompt for a selection of objects.
        * @param status is the status result of the prompt operation.
        * @param objectIds is the array of SelectedObject.
        * @throws TypeError
        *
        */
        const PromptSelectionResult = ((_super => {
            __extends(PromptSelectionResult, _super);
            function PromptSelectionResult(status, objectIds) {
                _super.call(this, status);
                if (objectIds instanceof Array)
                    this.value = objectIds;
                else
                    throw new TypeError("objectIds should be of Array type.");
            }
            return PromptSelectionResult;
        }))(Acad.PromptResults);
        AutoCAD.PromptSelectionResult = PromptSelectionResult;
        ;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //
    ///////////////////////////////////////////////////////////////////////////////
    //
    //                 (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    ///////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="Acad.ts"/>
    ///<reference path="Application.ts"/>
    /**
    * This class represents system variable collection
    *
    */
    ((AutoCAD => {
        ((SystemVariableCollection => {
            SystemVariableCollection.systemVariables = {};
            const eventname = { "SysVarsChanged": "SysVarsChanged" };
            const sysvarToCallback = {};
            let isRegistered = false;

            /**
            * This function is for internal use.
            *
            */
            function addReactor(sysvars) {
                if (!isRegistered) {
                    // This is the common callback for stub side. This callback will call the respective callbacks for the registered collections
                    Acad.SysVarCollectionInterop.addHandler_sysVarChanged(systemVariableCollectionCallback);
                    isRegistered = true;
                }

                if (name == undefined) {
                    throw Error("Please provide name of System Variables.");
                }

                Acad.SysVarCollectionInterop.addSysVarReactor(sysvars);
            }

            /**
            * This function is for internal use.
            *
            */
            function removeReactor(sysvars) {
                Acad.SysVarCollectionInterop.removeSysVarReactor(sysvars);
            }

            function parseSysVarValue(sysVarValue) {
                let rawValue;
                switch (sysVarValue.type) {
                    case Acad.ResultValueType.RTPOINT:
                        var pt = JSON.parse(sysVarValue.value);
                        rawValue = new Acad.Point2d(pt.x, pt.y);
                        break;
                    case Acad.ResultValueType.RT3DPOINT:
                        var pt = JSON.parse(sysVarValue.value);
                        rawValue = new Acad.Point3d(pt.x, pt.y, pt.z);
                        break;
                    case Acad.ResultValueType.RTANG:
                    case Acad.ResultValueType.RTLONG:
                    case Acad.ResultValueType.RTORINT:
                    case Acad.ResultValueType.RTREAL:
                    case Acad.ResultValueType.RTSHORT:
                        rawValue = JSON.parse(sysVarValue.value);
                        break;
                    default:
                        rawValue = sysVarValue.value;
                        break;
                }
                return rawValue;
            }

            /*
            *Inside this internal function we call the registered callbacks with the respective sysvar changes they are intereseted in.
            */
            function systemVariableCollectionCallback(changedSysvars) {
                for (var i = 0; i < changedSysvars.length; ++i) {
                    changedSysvars[i].oldvalue = parseSysVarValue(changedSysvars[i].oldvalue);
                    changedSysvars[i].newvalue = parseSysVarValue(changedSysvars[i].newvalue);
                }

                // Construct callbackToSysvar Map
                const callbackToSysvar = {};

                // Using callbacks directly as keys for the map is expensive. So, this array is used for some book keeping.
                // The index of the callback in the array is used as the key instead.
                const callbackArray = [];

                for (var i = 0; i < changedSysvars.length; ++i) {
                    const sysvar = changedSysvars[i];
                    const callbacks = sysvarToCallback[sysvar.name];

                    for (let j = 0; j < callbacks.length; ++j) {
                        var callback = callbacks[j];
                        if (callback.acad_sysvar_callback_index == undefined) {
                            //create a new entry in callbackArray and callbackToSysvar map
                            const index = callbackArray.length;

                            callback.acad_sysvar_callback_index = index;
                            callbackArray.push(callback);

                            callbackToSysvar[index] = [];
                            callbackToSysvar[index].push(sysvar);
                        } else {
                            callbackToSysvar[callback.acad_sysvar_callback_index].push(sysvar);
                        }
                    }
                }

                for (var i = 0; i < callbackArray.length; ++i) {
                    var callback = callbackArray[i];
                    const args = callbackToSysvar[callback.acad_sysvar_callback_index];

                    //remove temporary augmented property "acad_sysvar_callback_index"
                    delete callback.acad_sysvar_callback_index;

                    callback(eventname.SysVarsChanged, args);
                }
            }

            /**
            * This function is used to add callback for collection of sysVars.
            * @param sysvars is comma seperated list of sysVars for which notification will be sent.
            * @param callback is a callback function, which is called when an event occurs.
            * @throws TypeError
            * @throws Error
            *
            */
            function addEventListener(sysvars, callback) {
                if (typeof sysvars != 'string')
                    throw TypeError("sysvars should be of type string.");

                if (typeof callback != 'function')
                    throw TypeError("callback should be of type function.");

                // Register callback
                const sysvarNames = sysvars.split(",");

                //Check if we have added reactor all of these sysVars. If so we can avoid call into stub
                //or pass only required sysVars into stub - optimization.The newSysvarNames variable will
                //capture the sysVars for which reactor is not yet added.
                const newSysvarNames = [];

                for (var i = 0; i < sysvarNames.length; ++i) {
                    if (sysvarToCallback[sysvarNames[i]] == undefined)
                        newSysvarNames.push(sysvarNames[i]);
                }

                if (newSysvarNames.length > 0) {
                    let strNewSysvarNames = "";
                    for (var i = 0; i < newSysvarNames.length; ++i)
                        strNewSysvarNames += `${newSysvarNames[i]},`;

                    strNewSysvarNames = strNewSysvarNames.substring(0, strNewSysvarNames.length - 1);

                    try {
                        addReactor(strNewSysvarNames);
                    } catch (e) {
                        throw Error("Error occured during registering sysvars");
                    }
                }

                for (var i = 0; i < newSysvarNames.length; ++i)
                    sysvarToCallback[newSysvarNames[i]] = [];

                for (var i = 0; i < sysvarNames.length; ++i) {
                    if (!sysvarToCallback[sysvarNames[i]].includes(callback))
                        sysvarToCallback[sysvarNames[i]].push(callback);
                }
            }
            SystemVariableCollection.addEventListener = addEventListener;

            /**
            * This function is used to remove callback.
            * @param sysvars is comma seperated list of sysVars for which callback would be removed.
            * @param callback is a callback function, which would not be called further for given eventname.
            * @throws TypeError
            * @throws Error
            *
            */
            function removeEventListener(sysvars, callback) {
                if (typeof sysvars != 'string')
                    throw TypeError("sysvars should be of type string.");

                if (typeof callback != 'function')
                    throw TypeError("callback should be of type function.");

                const sysvarNames = sysvars.split(",");
                const sysvarsToUnregister = [];

                for (const i in sysvarNames) {
                    const sysvarName = sysvarNames[i];
                    if (sysvarToCallback[sysvarName] != undefined) {
                        const index = sysvarToCallback[sysvarName].indexOf(callback);

                        if (index != -1) {
                            sysvarToCallback[sysvarName].splice(index, 1);

                            if (sysvarToCallback[sysvarName].length == 0) {
                                try {
                                    removeReactor(sysvarName);
                                    delete sysvarToCallback[sysvarName];
                                } catch (e) {
                                    throw Error("Error occured during unregistering sysvars");
                                }
                            }
                        }
                    }
                }
            }
            SystemVariableCollection.removeEventListener = removeEventListener;

            /**
            * This function returns the system variable
            * @param name is name of system variable.
            *
            */
            function getSystemVariable(name) {
                if (name == undefined)
                    throw Error("Please provide name of System Variable.");

                if (SystemVariableCollection.systemVariables.hasOwnProperty(name)) {
                    return SystemVariableCollection.systemVariables[name];
                }

                const sysVarInterop = Acad.SysVarCollectionInterop.getSysVar(name);

                const sysVar = new AutoCAD.SystemVariable(sysVarInterop.name, sysVarInterop.valueType, sysVarInterop.value, sysVarInterop.isActive, sysVarInterop.minimum, sysVarInterop.maximum);
                SystemVariableCollection.systemVariables[name] = sysVar;
                return sysVar;
            }
            SystemVariableCollection.getSystemVariable = getSystemVariable;
        }))(AutoCAD.SystemVariableCollection || (AutoCAD.SystemVariableCollection = {}));
        const SystemVariableCollection = AutoCAD.SystemVariableCollection;

        /**
        * This class represent system variable
        * @param sName is the name of system variable.
        * @param type is type of resource buffer.
        * @param sValue is the value of system variable .
        * @param active indicates whether the system varibale is active or not.
        * @param min is minimum value of system variable.
        * @param max is maximum value of system variable.
        *
        */
        const SystemVariable = ((() => {
            class SystemVariable {
                constructor(sName, type, sValue, active, min, max) {
                    this.eventObject = new Acad.EventObject();
                    this.isReactorAdded = false;
                    this._name = sName;
                    this._valueType = type;
                    this._value = sValue;
                    this._isActive = active;
                    this._minimum = min;
                    this._maximum = max;
                }

                get name() {
                    return this._name;
                }

                set name(x) {
                    throw Error("name is read-only property");
                }

                get valueType() {
                    return this._valueType;
                }

                set valueType(x) {
                    throw Error("valueType is read-only property");
                }

                get minimum() {
                    return this._minimum;
                }

                set minimum(x) {
                    throw Error("minimum is read-only property");
                }

                get maximum() {
                    return this._maximum;
                }

                set maximum(x) {
                    throw Error("maximum is read-only property");
                }

                get isActive() {
                    const jsonObj = Acad.SysVarCollectionInterop.getSysVar(this._name);
                    this._isActive = jsonObj.isActive;
                    return this._isActive;
                }

                set isActive(x) {
                    throw Error("isActive is read-only property");
                }

                get value() {
                    const jsonObj = Acad.SysVarCollectionInterop.getSysVar(this._name);
                    switch (this._valueType) {
                        case Acad.ResultValueType.RTPOINT:
                            var pt = JSON.parse(jsonObj.value);
                            this._value = new Acad.Point2d(pt.x, pt.y);
                            break;
                        case Acad.ResultValueType.RT3DPOINT:
                            var pt = JSON.parse(jsonObj.value);
                            this._value = new Acad.Point3d(pt.x, pt.y, pt.z);
                            break;
                        case Acad.ResultValueType.RTANG:
                        case Acad.ResultValueType.RTLONG:
                        case Acad.ResultValueType.RTORINT:
                        case Acad.ResultValueType.RTREAL:
                        case Acad.ResultValueType.RTSHORT:
                            this._value = JSON.parse(jsonObj.value);
                            break;
                        default:
                            this._value = jsonObj.value;
                            break;
                    }
                    return this._value;
                }

                set value(valToSet) {
                    this.checkIfValidValue(valToSet);

                    let strVal;
                    if (typeof valToSet != "string")
                        strVal = JSON.stringify(valToSet);
                    else
                        strVal = valToSet;

                    const typedValueInterop = {
                        value: strVal,
                        type: this._valueType
                    };

                    const ret = Acad.SysVarCollectionInterop.setSysVarValue(this._name, typedValueInterop);
                }

                checkIfValidValue(val) {
                    switch (this._valueType) {
                        case Acad.ResultValueType.RTSHORT:
                        case Acad.ResultValueType.RTLONG:
                            if (!(Acad.isInteger(val)))
                                throw TypeError("value is not Integer type.");
                            break;
                        case Acad.ResultValueType.RTREAL:
                        case Acad.ResultValueType.RTANG:
                            if (typeof val != 'number')
                                throw TypeError("value is not number.");
                            break;
                        case Acad.ResultValueType.RTSTR:
                            if (typeof val != 'string')
                                throw TypeError("value is not string.");
                            break;
                        case Acad.ResultValueType.RTPOINT:
                            if (!(val instanceof Acad.Point2d))
                                throw TypeError("Point should be of Point2d type.");
                            break;
                        case Acad.ResultValueType.RT3DPOINT:
                            if (!(val instanceof Acad.Point3d))
                                throw TypeError("Point should be of Point3d type.");
                            break;
                        default:
                            break;
                    }
                }

                /**
                * This function is used to set system variable value using command.
                * @remarks This is asynchronous function call. It will not return error if the value is not set successfully.
                * @remarks You should check if the value is set successfully in the listener callback function.
                * @param sValue is value of system variable.
                * @throws Error
                * @throws TypeError
                */
                postValue(sValue) {
                    this.checkIfValidValue(sValue);

                    let strVal;
                    if (typeof sValue != "string")
                        strVal = JSON.stringify(sValue);
                    else
                        strVal = sValue;

                    const typedValueInterop = {
                        value: strVal,
                        type: this._valueType
                    };

                    return Acad.SysVarCollectionInterop.postSysVarValue(this._name, typedValueInterop);
                }
            }

            return SystemVariable;
        }))();
        AutoCAD.SystemVariable = SystemVariable;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //
    ///////////////////////////////////////////////////////////////////////////////
    //
    //                 (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    ///////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="Acad.ts"/>
    ///<reference path="PromptOptions.ts"/>
    ((AutoCAD => {
        /**
        * This class represents base jig class
        * @param updateCallback is of type function and is the callback for update during jigging.
        * @param options is of type Acad.JigPromptPointOptions, Acad.JigPromptDistanceOptions, Acad.JigPromptAngleOptions or Acad.JigPromptStringOptions.
        *
        */
        const Jig = ((() => {
            class Jig {
                constructor(updateCallback, options) {
                    if (typeof (updateCallback) != 'function') {
                        throw TypeError("updateCallback should be function type.");
                    }

                    if (!((options instanceof Acad.JigPromptPointOptions) || (options instanceof Acad.JigPromptDistanceOptions) || (options instanceof Acad.JigPromptAngleOptions) || (options instanceof Acad.JigPromptStringOptions))) {
                        throw TypeError("options should be of type Acad.JigPromptPointOptions, Acad.JigPromptDistanceOptions, Acad.JigPromptAngleOptions or Acad.JigPromptStringOptions.");
                    }

                    this._onUpdate = updateCallback;
                    this._jigOptions = options;

                    const obj = this;
                    AutoCAD.JigInterop.setHandler_updateEvent(eventArgs => {
                        obj.UpdateEventCallback(eventArgs);
                    });
                }

                // Create a callback handler which delegate callback notifications..
                UpdateEventCallback(eventArgs) {
                    if (!eventArgs) {
                        return;
                    }

                    const args = {};
                    args[eventArgs.keyName] = eventArgs.keyValue.value;

                    this._onUpdate(args);
                }

                get onUpdate() {
                    return this._onUpdate;
                }

                set onUpdate(val) {
                    throw Error("onUpdate is read-only property");
                }

                get jigOptions() {
                    return this._jigOptions;
                }

                set jigOptions(val) {
                    throw Error("jigOptions is read-only property");
                }
            }

            return Jig;
        }))();
        AutoCAD.Jig = Jig;

        /**
        * This class represents jig class for drawing transient jigging
        * @param updateCallback is of type function and is the callback for update of transient during jigging.
        * @param options is of type Acad.JigPromptPointOptions, Acad.JigPromptDistanceOptions, Acad.JigPromptAngleOptions or Acad.JigPromptStringOptions.
        *
        */
        const DrawJig = ((_super => {
            __extends(DrawJig, _super);

            class DrawJig {
                constructor(updateCallback, options) {
                    _super.call(this, updateCallback, options);
                }

                /**
                * Add or update transient entity during jigging.
                * @param xmlData is of type string and is the XML for the drawable transient.
                * @param onComplete is a function type called on successful completion of this method.
                * @param onError is a function type called if an error occurs.
                *
                */
                update(xmlData) {
                    if (typeof (xmlData) !== 'string') {
                        throw TypeError('xmlData should be of type string');
                    }
                    ;
                    return AutoCAD.JigInterop.update(xmlData);
                }
            }

            return DrawJig;
        }))(Jig);
        AutoCAD.DrawJig = DrawJig;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //
    ///////////////////////////////////////////////////////////////////////////////
    //
    //                 (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    ///////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="Acad.ts"/>
    ///<reference path="Application.ts"/>
    ((AutoCAD => {
        /**
        * @class Acad.DataItemCollectionManager
        * This is the controller object that is used to create and manage the
        * dataItemCollectionSet.
        */
        ((DataItemCollectionManager => {
            DataItemCollectionManager.dataItemCollectionSet = new Array();
            let handlerAdded = handlerAdded || false;
            const eventName = {
                "collectionChanged": "collectionChanged",
                "itemsChanged": "itemsChanged",
                "reset": "reset"
            };

            /**
            * This asynchronous method can be used to get a known collection.
            * @method DataItemCollectionManager.getKnownCollection
            * @param colName is the name of the collection to get
            * @param onComplete is a function type called on successful completion of this method.
            * @param onError is a function type called if an error occurs.
            * @return Acad.DataItemCollection
            */
            function getKnownCollection(colName) {
                if (!handlerAdded) {
                    handlerAdded = true;
                    AutoCAD.DataItemCollectionManagerInterop.addHandler_resetEvent(reset_event);
                    AutoCAD.DataItemCollectionManagerInterop.addHandler_collectionChangedEvent(collectionchanged_event);
                    AutoCAD.DataItemCollectionManagerInterop.addHandler_itemsChangedEvent(itemschanged_event);
                }

                if (typeof (colName) !== 'string')
                    throw TypeError('collection name should be of type string');

                const promise = new Autodesk.JavaScript.Promise();

                let collection;

                if (DataItemCollectionManager.dataItemCollectionSet[colName] == undefined) {
                    // Create the collection if it does not exist and cache it.
                    collection = new AutoCAD.DataItemCollection(colName);

                    DataItemCollectionManager.dataItemCollectionSet[colName] = collection;

                    AutoCAD.DataItemCollectionManagerInterop.getKnownCollection(colName).then(retvalue => {
                        const obj = retvalue;

                        if (obj.retCode !== Acad.ErrorStatus.eJsOk) {
                            if (obj.retErrorString == undefined)
                                promise.error(obj.retCode);
                            else
                                promise.error(obj.retCode, obj.retErrorString);
                            return;
                        }
                        if (obj) {
                            const thisColl = DataItemCollectionManager.dataItemCollectionSet[obj.collectionName];
                            for (let index = 0; index < obj.dataItems.length; ++index) {
                                thisColl.dataItems.push(new AutoCAD.DataItem(obj.dataItems[index].id, obj.dataItems[index].name));
                            }
                            promise.success(thisColl);
                        }
                    }, (retCode, retErrorString) => {
                        delete DataItemCollectionManager.dataItemCollectionSet[colName];
                        if (retErrorString == undefined)
                            promise.error(retCode);
                        else
                            promise.error(retCode, retErrorString);
                    });
                } else {
                    // use the cached collection.
                    collection = DataItemCollectionManager.dataItemCollectionSet[colName];

                    //setTimeout(function(){promise.success(collection);},100);
                    promise.then = (success, error) => {
                        success(collection);
                    };
                }
                return promise;
            }
            DataItemCollectionManager.getKnownCollection = getKnownCollection;

            /**
            * This Function is for internal use
            * Callback for reset event
            * 1. Updates cache dataItemCollectionSet
            * 2. Dispatches the event to respective EventObjects
            */
            function reset_event(args) {
                const obj = args;

                if (!obj) {
                    return;
                }

                const eventname = eventName["reset"];
                const collection = DataItemCollectionManager.dataItemCollectionSet[obj.collectionName];
                if (!collection) {
                    return;
                }
                const dataItems = collection.dataItems;

                // Clear the dataItem array.
                dataItems.length = 0;

                // Add newItems to the dataItems array.
                const dataitems = obj.dataItems;
                const newItemsCount = dataitems.length;
                for (let i = 0; i < newItemsCount; i++) {
                    dataItems[i] = new AutoCAD.DataItem(dataitems[i].id, dataitems[i].name);
                }
                collection.dispatchEvent(eventname, dataItems);
            }

            /**
            * This Function is for internal use
            * Callback for collectionchanged_event
            * 1. Updates cache dataItemCollectionSet
            * 2. Dispatches the event to respective EventObjects
            */
            function collectionchanged_event(args) {
                const obj = args;

                if (!obj) {
                    return;
                }
                const collection = DataItemCollectionManager.dataItemCollectionSet[obj.collectionName];
                if (!collection) {
                    return;
                }
                const dataItems = collection.dataItems;
                const eventname = eventName["collectionChanged"];

                // Remove oldItems from the dataItems array first.
                const olditems = obj.oldItems;
                const oldItemsCount = olditems.length;
                for (var i = 0; i < oldItemsCount; i++) {
                    const dataItemsCount = dataItems.length;
                    for (let j = 0; j < dataItemsCount; j++) {
                        if (dataItems[j].id == olditems[i].id) {
                            dataItems.splice(j, 1);
                            break;
                        }
                    }
                }

                // Add newItems to the dataItems array.
                const newitems = obj.newItems;
                const newItemsCount = newitems.length;
                const startIndex = collection.dataItems.length;

                for (var i = 0; i < newItemsCount; i++) {
                    dataItems[i + startIndex] = new AutoCAD.DataItem(newitems[i].id, newitems[i].name);
                }
                collection.dispatchEvent(eventname, dataItems);
            }

            /**
            * This Function is for internal use
            * Callback for itemschanged_event
            * 1. Updates cache dataItemCollectionSet
            * 2. Dispatches the event to respective EventObjects
            */
            function itemschanged_event(args) {
                const obj = args;

                if (!obj) {
                    return;
                }
                const collection = DataItemCollectionManager.dataItemCollectionSet[obj.collectionName];
                if (!collection) {
                    return;
                }
                const dataItems = collection.dataItems;
                const eventname = eventName["itemsChanged"];

                // Update changed items in the dataItems array.
                const changeditems = obj.changedItems;
                const changedItemsCount = changeditems.length;
                for (let i = 0; i < changedItemsCount; i++) {
                    const dataItemsCount = dataItems.length;
                    for (let j = 0; j < dataItemsCount; j++) {
                        if (dataItems[j].id == changeditems[i].id) {
                            // At position j, assign the changeditems values to dataItems values.
                            dataItems[j].name = changeditems[i].name;
                            break;
                        }
                    }
                }

                //inform about the changed items
                collection.dispatchEvent(eventname, changeditems);
            }
        }))(AutoCAD.DataItemCollectionManager || (AutoCAD.DataItemCollectionManager = {}));
        const DataItemCollectionManager = AutoCAD.DataItemCollectionManager;
        ;

        /**
        * @class Acad.DataItemCollection
        * This is the controller object that is used to create and manage the
        * dataItemCollection.
        */
        const DataItemCollection = ((() => {
            class DataItemCollection {
                constructor(colName) {
                    this.eventname = {
                        "collectionChanged": "collectionChanged",
                        "itemsChanged": "itemsChanged",
                        "reset": "reset"
                    };
                    this.colName = colName;
                    this.dataItems = new Array();
                    this.eventobject = new AutoCAD.EventObject();
                }

                /*
                *This method can be used to add event listeners for the DataItemCollection
                *@method Acad.DataItemCollection.addEventListener
                *@param eventname is the name of the event to register for. It can be one of the events in Acad.DataItemCollection.eventname
                *@param fn is the callback that is called when the event is triggered
                */
                addEventListener(eventname, fn) {
                    if (arguments.length != 2) {
                        throw Error('addEventListener() expects 2 arguments');
                    }

                    if (!this.eventname.hasOwnProperty(eventname))
                        throw TypeError('invalid eventname');

                    if (typeof (fn) !== 'function')
                        throw TypeError('event callback should be of type function');

                    this.eventobject.addEventListener(eventname, fn);
                }

                /*
                *This method can be used to remove event listeners for the DataItemCollection
                *@method Acad.DataItemCollection.removeEventListener
                *@param eventname is the name of the event to de-register. It can be one of the events in Acad.DataItemCollection.eventname
                *@param fn is the callback that is to be de-registered
                */
                removeEventListener(eventname, fn) {
                    if (arguments.length != 2) {
                        throw Error('removeEventListener() expects 2 arguments');
                    }

                    if (!this.eventname.hasOwnProperty(eventname))
                        throw TypeError('invalid eventname');

                    if (typeof (fn) !== 'function')
                        throw TypeError('event callback should be of type function');

                    this.eventobject.removeEventListener(eventname, fn);
                }

                /*
                *This method can be used to get the name of the DataItemCollection
                *@method Acad.DataItemCollection.getName
                *@returns a string containing the name of the collection
                */
                getName() {
                    return this.colName;
                }

                /*
                * This Function is for internal use
                */
                dispatchEvent(eventname, args) {
                    this.eventobject.dispatchEvent(eventname, args);
                }
            }

            return DataItemCollection;
        }))();
        AutoCAD.DataItemCollection = DataItemCollection;
        ;

        /**
        * @class Acad.DataItem
        * This is the controller object that is used to create and manage the
        * dataItem.
        */
        const DataItem = ((() => {
            class DataItem {
                constructor(id, name) {
                    this.id = id;
                    this.name = name;
                }

                /**
                * Returns all the properties of this DataItem.
                * @return the properties map(name-value pair).
                */
                getProperties() {
                    const response = AutoCAD.DataItemInterop.getProperties(this.id);

                    const obj = response;
                    if (obj.retCode !== Acad.ErrorStatus.eJsOk) {
                        throw Error(obj.retErrorString);
                    }
                    const properties = {};
                    for (let i = 0; i < obj.propertyPairs.length; i++) {
                        properties[obj.propertyPairs[i].key] = obj.propertyPairs[i].value;
                    }
                    return properties;
                }
            }

            return DataItem;
        }))();
        AutoCAD.DataItem = DataItem;
        ;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //
    ///////////////////////////////////////////////////////////////////////////////
    //
    //                 (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    ///////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="Acad.ts"/>
    ///<reference path="PromptOptions.ts"/>
    ///<reference path="PromptResults.ts"/>
    ///<reference path="JsSelectionSet.ts"/>
    ///<reference path="Jig.ts"/>
    ((AutoCAD => {
        ((Editor => {
            /**
            * The getInteger function is used to get the integer from user.
            * @param opts is of type PromptIntegerOptions
            * @return PromptIntegerResult.
            * @throws TypeError
            *
            */
            function getInteger(options) {
                if (!(options instanceof Acad.PromptIntegerOptions))
                    throw TypeError("Input parameter should be PromptIntegerOptions type.");

                return AutoCAD.EditorInterop.getInteger(options);
            }
            Editor.getInteger = getInteger;
            ;

            /**
            * The getDouble function is used to get the double from user.
            * @param options is of type PromptDoubleOptions
            * @return PromptDoubleResult.
            * @throws TypeError
            *
            */
            function getDouble(options) {
                if (!(options instanceof Acad.PromptDoubleOptions))
                    throw TypeError("Input parameter should be PromptDoubleOptions type.");

                return AutoCAD.EditorInterop.getDouble(options);
            }
            Editor.getDouble = getDouble;
            ;

            /**
            * The getDistance function is used to get user input for a linear distance.
            * @param options is of type PromptDistanceOptions.
            * @return PromptDoubleResult.
            * @throws TypeError
            *
            */
            function getDistance(options) {
                if (!(options instanceof Acad.PromptDistanceOptions))
                    throw TypeError("Input parameter should be PromptDistanceOptions type.");

                return AutoCAD.EditorInterop.getDistance(options);
            }
            Editor.getDistance = getDistance;
            ;

            /**
            * The getAngle function is used to get user input for an angle, taking into account the current value of the ANGBASE system variable.
            * @param options is of type PromptAngleOptions.
            * @return PromptDoubleResult.
            * @throws TypeError
            *
            */
            function getAngle(options) {
                if (!(options instanceof Acad.PromptAngleOptions))
                    throw TypeError("Input parameter should be PromptAngleOptions type.");

                return AutoCAD.EditorInterop.getAngle(options);
            }
            Editor.getAngle = getAngle;
            ;

            /**
            * Gets user input for a keyword.
            * Wraps the acedGetKword() ObjectARX function.
            * The AutoCAD user can enter the keyword from the keyboard. The list of keywords that GetKeywords() accepts is set by a prior call to GetInteger().
            * If the user enters a string not specified in the call to GetInteger(), AutoCAD displays an error message and tries again (and redisplays prompt, if one was specified).
            * If the user types only [Return], GetKeywords() returns an empty string ("") unless the call to GetInteger() also disallowed null input.
            * @param options is of type PromptKeywordOptions
            * @return PromptResult.
            * @throws TypeError
            *
            */
            function getKeywords(options) {
                if (!(options instanceof Acad.PromptKeywordOptions))
                    throw TypeError("Input parameter should be PromptKeywordOptions type.");

                return AutoCAD.EditorInterop.getKeywords(options);
            }
            Editor.getKeywords = getKeywords;
            ;

            /**
            * The getPoint function is used to get user input for a point.
            * @param opts is of type PromptPointOptions.
            * @return PromptPointResult.
            * @throws TypeError
            *
            */
            function getPoint(options) {
                if (!(options instanceof Acad.PromptPointOptions))
                    throw TypeError("Input parameter should be PromptPointOptions type.");

                return AutoCAD.EditorInterop.getPoint(options);
            }
            Editor.getPoint = getPoint;
            ;

            /**
            * The getCorner function is used to Gets user input for the corner of a rectangle.
            * @param opts is of type PromptCornerOptions.
            * @return PromptPointResult.
            * @throws TypeError
            *
            */
            function getCorner(options) {
                if (!(options instanceof Acad.PromptCornerOptions))
                    throw TypeError("Input parameter should be PromptCornerOptions type.");

                return AutoCAD.EditorInterop.getCorner(options);
            }
            Editor.getCorner = getCorner;
            ;

            /**
            * The getString function is used to Gets user input for string.
            * @param opts is of type PromptStringOptions.
            * @return PromptStringResult.
            * @throws TypeError
            *
            */
            function getString(options) {
                if (!(options instanceof Acad.PromptStringOptions))
                    throw TypeError("Input parameter should be PromptStringOptions type.");

                return AutoCAD.EditorInterop.getString(options);
            }
            Editor.getString = getString;

            /**
            * The getSelection function returns the selection set obtained.
            * @param opts is of type PromptSelectionOptions.
            * @return PromptSelectionResult.
            * @throws TypeError
            *
            */
            function getSelection(options) {
                if (!(options instanceof Acad.PromptSelectionOptions))
                    throw TypeError("Input parameter should be PromptSelectionOptions type.");

                return AutoCAD.EditorInterop.getSelection(options);
            }
            Editor.getSelection = getSelection;
            ;

            /**
            * Prompts the user to select an entity by specifying a point.
            * Pauses for user input and returns both an entity name and the point that is used to select the entity.
            * GetEntity() does not return the names of nongraphical objects.
            * @param opts is of type PromptEntityOptions.
            * @return PromptEntityResult.
            * @throws TypeError
            *
            */
            function getEntity(options) {
                if (!(options instanceof Acad.PromptEntityOptions))
                    throw TypeError("Input parameter should be PromptEntityOptions type.");

                return AutoCAD.EditorInterop.getEntity(options);
            }
            Editor.getEntity = getEntity;
            ;

            /**
            * Gets the name of an entity selected by the user and the point used to select the entity.
            * @param opts is of type PromptNestedEntityOptions.
            * @return PromptNestedEntityResult.
            * @throws TypeError
            *
            */
            function getNestedEntity(options) {
                if (!(options instanceof Acad.PromptNestedEntityOptions))
                    throw TypeError("Input parameter should be PromptNestedEntityOptions type.");

                return AutoCAD.EditorInterop.getNestedEntity(options);
            }
            Editor.getNestedEntity = getNestedEntity;
            ;

            /**
            * This method returns false if the host busy processing other commands else returns true.
            * @return boolean.
            * @throws TypeError
            *
            */
            function isQuiescent() {
                return AutoCAD.EditorInterop.isQuiescent();
            }
            Editor.isQuiescent = isQuiescent;
            ;

            /**
            * This method cancels the last command
            * @throws Error
            *
            */
            function cancelCommand() {
                const retCode = AutoCAD.EditorInterop.cancelCommand();
                if (retCode != Acad.ErrorStatus.eJsOk) {
                    throw Error("Error in cancel command");
                }
                return retCode;
            }
            Editor.cancelCommand = cancelCommand;
            ;

            function executeCommandWorker(commands, onSuccess, onError) {
                const count = commands.length;
                if (count < 1) {
                    throw Error('Acad.Editor.executeCommand should be called with atleast one parameter');
                }
                for (let i = 0; i < count; i++) {
                    if (typeof (commands[i]) !== 'string') {
                        throw TypeError('Arguments to Acad.Editor.executeCommand should be of type string');
                    }
                }
                if (onSuccess == null)
                    onSuccess = "";
                if (onError == null)
                    onError = "";

                const retCode = AutoCAD.EditorInterop.executeCommand(commands, onSuccess, onError);
                if (retCode != Acad.ErrorStatus.eJsOk) {
                    throw Error("Error: execute command failed.");
                }
            }

            /**
            * This method accepts variable number of string arguments which is the commands passed to Native environment and it waits for the commnd operation to complete.
            * @param AutoCAD commands as string arguments
            * @throws TypeError
            *
            */
            function executeCommand() {
                const commands = [];
                for (let _i = 0; _i < (arguments.length - 0); _i++) {
                    commands[_i] = arguments[_i + 0];
                }
                executeCommandWorker(commands, null, null);
            }
            Editor.executeCommand = executeCommand;
            ;

            /**
            * This method accpets variable number of string arguments which is the commands passed to Native environment and it doesnot waits for the commnd operation to complete.It follows promise pattern
            * to receive success and callbacks from native in async fashion
            * @param AutoCAD commands as string arguments
            * @throws TypeError
            *
            */
            let callbackCounter = 0;
            function executeCommandAsync() {
                const commands = [];
                for (let _i = 0; _i < (arguments.length - 0); _i++) {
                    commands[_i] = arguments[_i + 0];
                }
                const promise = new Autodesk.JavaScript.Promise();
                callbackCounter++;
                const onSuccessName = `ac_eca_onSuccess${callbackCounter.toString()}`;
                const onErrorName = `ac_eca_onError${callbackCounter.toString()}`;

                const onSuccess = result => {
                    unregisterCallback(onSuccessName);
                    unregisterCallback(onErrorName);

                    if (typeof (promise.success) == 'function') {
                        promise.success(result);
                    }
                };
                const onError = result => {
                    unregisterCallback(onSuccessName);
                    unregisterCallback(onErrorName);
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                };

                registerCallback(onSuccessName, onSuccess);
                registerCallback(onErrorName, onError);
                executeCommandWorker(commands, onSuccessName, onErrorName);
                return promise;
            }
            Editor.executeCommandAsync = executeCommandAsync;
            ;

            /**
            * This method registers an AutoCAD command.
            * @param groupName is a string that specifies the command group name to add the command to.
            * @param globalName is a string that specifies the global and untranslated name of the command to add.
            * @param localName is a string that specifies the local and translated name of the command to add.
            * @param flags is an integer that specifies the flag associated with the command.
            * The flags should be either Acad.CommandFlag.TRANSPARENT or Acad.CommandFlag.MODAL,
            * and can be logically ORd with other flags in Acad.CommandFlag.
            * @param jsFunc will be executed when this command is invoked.
            * @throws TypeError
            *
            */
            function addCommand(groupName, globalName, localName, flags, jsFunc) {
                if (typeof (groupName) !== 'string') {
                    throw TypeError('groupName should be of type string');
                }

                if (typeof (globalName) !== 'string') {
                    throw TypeError('globalName should be of type string');
                }

                if (typeof (localName) !== 'string') {
                    throw TypeError('localName should be of type string');
                }

                if (!(Acad.isInteger(flags))) {
                    throw TypeError('flags should be of type integer');
                }

                if (typeof (jsFunc) !== 'function') {
                    throw TypeError("jsFunc should be of type function");
                }
                unregisterCallback(jsFunc);
                //syncronously execute the adding of the command, this registers
                //the command with Autocad. autocad will fire a synchronous event,
                //identified by globalName when the command is typed
                const retCode = AutoCAD.EditorInterop.addCommand(groupName, globalName, localName, flags);
                console.log(retCode);
                if (retCode != Acad.ErrorStatus.eJsOk) {
                    //throw Error("Error: add command failed.");
                }

                //now register a callback with the globalName so that js gets called when the command
                //is invoked
                
                registerCallback(`${groupName}.${globalName}`, jsFunc);
            }
            Editor.addCommand = addCommand;
            ;

            /**
            * Drag a transient entity during jigging.
            * @param jig is of type Acad.DrawJig.
            * @throws TypeError
            * @return dragStatus of type Acad.DragStatus in success function callback
            *
            */
            function drag(jig) {
                if (!(jig instanceof Acad.DrawJig))
                    throw TypeError("jig should be of type DrawJig.");

                if (jig.jigOptions instanceof Acad.JigPromptPointOptions) {
                    return AutoCAD.EditorInterop.dragPoint(jig.jigOptions);
                } else if (jig.jigOptions instanceof Acad.JigPromptDistanceOptions) {
                    return AutoCAD.EditorInterop.dragDistance(jig.jigOptions);
                } else if (jig.jigOptions instanceof Acad.JigPromptAngleOptions) {
                    return AutoCAD.EditorInterop.dragAngle(jig.jigOptions);
                } else if (jig.jigOptions instanceof Acad.JigPromptStringOptions) {
                    return AutoCAD.EditorInterop.dragString(jig.jigOptions);
                } else {
                    throw TypeError("Options should be one of type Acad.JigPromptPointOptions, Acad.JigPromptDistanceOptions, Acad.JigPromptAngleOptions or Acad.JigPromptStringOptions.");
                }
                return undefined;
            }
            Editor.drag = drag;
        }))(AutoCAD.Editor || (AutoCAD.Editor = {}));
        var Editor = AutoCAD.Editor;

        /**
        * This function is for internal use
        *
        */
        function promptExecAsync(param) {
            const promptResult = new Acad.PromptResults(Acad.PromptStatus.OK);
            execAsync(JSON.stringify(param), result => {
                if (typeof (promptResult.success) == 'function') {
                    promptResult.success(result);
                }
            }, result => {
                if (typeof (promptResult.error) == 'function')
                    promptResult.error(result);
            });

            return promptResult;
        }
        AutoCAD.promptExecAsync = promptExecAsync;
        ;

        ((Editor => {
            ((CurrentViewport => {
                /**
                * This method sets the camera parameters needed to define the transformation from world space to
                * normalized device coordinates. All values are specified in the world space coordinate system.
                * Ensure that the camera position and target are distinct. As well, the specified upVector cannot be parallel
                * to the eye vector (computed as the vector from the target to the position). fieldWidth and fieldHeight
                * help define the transformation from view space to normalized device coordinates
                * setView is not supported in Paper Space.
                * @param position of type Acad.Point3d
                * @param target of type Acad.Point3d
                * @param upVector of type Acad.Vector3d
                * @param fieldWidth of type float
                * @param fieldHeight of type float
                * @param projection (Parallel or Perspective )
                * @param animate is boolean
                *
                */
                function setView(position, target, upVector, fieldWidth, fieldHeight, projection, animate) {
                    if (!Acad.isNumber(fieldWidth) || !(fieldWidth > 0)) {
                        throw TypeError('fieldWidth should be a double value and greater than 0');
                    }
                    if (!Acad.isNumber(fieldHeight) || !(fieldHeight > 0)) {
                        throw TypeError('fieldHeight should be a double value and greater than 0');
                    }
                    if (!(position && target && upVector)) {
                        throw Error('position/target/upVector are mandatory.');
                    }
                    if (!(position instanceof Acad.Point3d)) {
                        throw TypeError('position should be of type Acad.Point3d');
                    }
                    if (!(target instanceof Acad.Point3d)) {
                        throw TypeError('target should be of type Acad.Point3d');
                    }
                    if (!(upVector instanceof Acad.Vector3d)) {
                        throw TypeError('upVector should be of type Acad.Vector3d');
                    }
                    if (animate && (typeof (animate) !== 'boolean')) {
                        throw TypeError('animate flag should be boolean');
                    }
                    if (projection && (projection !== Acad.Enum_Projection.Parallel && projection !== Acad.Enum_Projection.Perspective)) {
                        throw TypeError('projection should be  Acad.Enum_Projection.Parallel or Acad.Enum_Projection.Perspective ');
                    }
                    if (!AutoCAD.CurrentViewportInterop.setView(position, target, upVector, fieldWidth, fieldHeight, projection, animate))
                        throw Error("setView failed.");
                }
                CurrentViewport.setView = setView;
                ;

                /**
                * Translates the camera target and position by the specified camera space dolly vector. All other camera parameters
                * are left unaffected. The basis of camera space is as follows: positive Y is along the up vector,
                * positive Z is along the eye vector from the camera position to the camera target, and X is the cross product of those two vectors.
                *
                * @param Input camera space dolly vector of type Acad.Vector3d
                * @param animate is boolean
                *
                */
                function dolly(dollyVector, animate) {
                    if (!(dollyVector)) {
                        throw Error('dollyVector is mandatory.');
                    }
                    if (!(dollyVector instanceof Acad.Vector3d)) {
                        throw TypeError('dollyVector should be of type Acad.Vector3d');
                    }
                    if (animate && (typeof (animate) !== 'boolean')) {
                        throw TypeError('animate flag should be boolean');
                    }
                    if (!AutoCAD.CurrentViewportInterop.dolly(dollyVector, animate))
                        throw Error("Dolly failed.");
                }
                CurrentViewport.dolly = dolly;
                ;

                /**
                * Rotates the camera�s up vector about the eye vector by the specified amount in radians. Positive angles correspond to a clockwise rotation when viewed from the camera position to the camera target
                * roll is not supported in Paper Space.
                * @param rollAngle of type double
                * @param animate is boolean
                *
                */
                function roll(rollAngle, animate) {
                    if (!Acad.isNumber(rollAngle)) {
                        throw TypeError('rollAngle should be a double value');
                    }
                    if (animate && (typeof (animate) !== 'boolean')) {
                        throw TypeError('animate flag should be boolean');
                    }
                    if (!AutoCAD.CurrentViewportInterop.roll(rollAngle, animate))
                        throw Error("Roll failed!");
                }
                CurrentViewport.roll = roll;
                ;

                /**
                * Orbits the camera. During orbit, the camera target and distance from position to target remain fixed; the camera position moves along the surface of a sphere described by these constraints.
                * The angleX and angleY parameters are in radians and correspond to angles traversed on this sphere along the cross product of the up vector and the eye vector (X) and along the up vector (Y).
                * The angleX component of the orbit is performed before the angleY component
                * orbit is not supported in Paper Space.
                * @param angleX of type double
                * @param angleY of type double
                * @param animate is boolean
                *
                */
                function orbit(angleX, angleY, animate) {
                    if (!(Acad.isNumber(angleX) && Acad.isNumber(angleY))) {
                        throw TypeError('angleX/angleY should be a double value');
                    }
                    if (animate && (typeof (animate) !== 'boolean')) {
                        throw TypeError('animate flag should be boolean');
                    }
                    if (!AutoCAD.CurrentViewportInterop.orbit(angleX, angleY, animate))
                        throw Error("Orbit failed!");
                }
                CurrentViewport.orbit = orbit;
                ;

                /**
                * Pans the camera. During pan, the camera position and distance from position to target remain fixed; the camera target moves along the surface of a
                * sphere described by these constraints. The angleX and angleY parameters are in radians and correspond to angles traversed on this sphere along the cross product
                * of the up vector and the eye vector (angleX) and along the up vector (angleY). The angleX component of the pan is performed before the angleY component.
                * pan is not supported in Paper Space.
                * @param angleX of type double
                * @param angleY of type double
                * @param animate is boolean
                *
                */
                function pan(angleX, angleY, animate) {
                    if (!(Acad.isNumber(angleX) && Acad.isNumber(angleY))) {
                        throw TypeError('angleX/angleY should be a double value');
                    }
                    if (animate && (typeof (animate) !== 'boolean')) {
                        throw TypeError('animate flag should be boolean');
                    }
                    if (!AutoCAD.CurrentViewportInterop.pan(angleX, angleY, animate))
                        throw Error("Pan failed.");
                }
                CurrentViewport.pan = pan;
                ;

                /**
                * Modifies the current view such that the input bounding box defined by the two extents points is completely within the view.
                * @param minPoint should represent the corner of the box that is defined by the three smallest component values of type Acad.Point3d.
                * @param maxPoint should represent the corner of the box that is defined by the three largest component values of type Acad.Point3d.
                * @param animate is boolean
                */
                function zoomExtents(minPoint, maxPoint, animate) {
                    if (!(minPoint && maxPoint)) {
                        throw Error('minPoint/maxPoint are mandatory.');
                    }
                    if (!(minPoint instanceof Acad.Point3d)) {
                        throw TypeError('minPoint should be of type Acad.Point3d');
                    }
                    if (!(maxPoint instanceof Acad.Point3d)) {
                        throw TypeError('maxPoint should be of type Acad.Point3d');
                    }
                    if (!(maxPoint.x >= minPoint.x && maxPoint.y >= minPoint.y && maxPoint.z >= minPoint.z)) {
                        throw TypeError('maxPoint should be greater than or equal to minPoint');
                    }
                    if (animate && (typeof (animate) !== 'boolean')) {
                        throw TypeError('animate flag should be boolean');
                    }
                    if (!AutoCAD.CurrentViewportInterop.zoomExtents(minPoint, maxPoint, animate))
                        throw Error("ZoomExtents failed.");
                }
                CurrentViewport.zoomExtents = zoomExtents;
                ;

                /**
                * Changes the viewing field (the focal length) of the camera to give the effect of dynamically moving in or out of a scene.
                * The camera position and target are not changed. The specified factor must be positive
                * @param zoomFactor is of type double
                * @param animate is boolean
                */
                function zoom(zoomFactor, animate) {
                    if (!Acad.isNumber(zoomFactor) || !(zoomFactor > 0)) {
                        throw TypeError('zoomFactor should be a double value and greater than 0');
                    }
                    if (animate && (typeof (animate) !== 'boolean')) {
                        throw TypeError('animate flag should be boolean');
                    }
                    if (!AutoCAD.CurrentViewportInterop.zoom(zoomFactor, animate))
                        throw Error("Zoom failed.");
                }
                CurrentViewport.zoom = zoom;
                ;

                /**
                * Modifies the current view such that the new window displays the region defined by the input screen coordinates.
                * The aspect ratio is automatically maintained.
                * @param lowerLeft Input screen coordinate of the lower-left point of the new zoom window of type Acad.Point2d
                * @param upperRight Input screen coordinate of the upper-right point of the new zoom window of type Acad.Point2d
                * @param animate is boolean
                */
                function zoomWindow(lowerLeft, upperRight, animate) {
                    if (!(lowerLeft && upperRight)) {
                        throw Error('lowerLeft/upperRight are mandatory.');
                    }
                    if (!(lowerLeft instanceof Acad.Point2d)) {
                        throw TypeError('lowerLeft should be of type Acad.Point2d');
                    }
                    if (!(upperRight instanceof Acad.Point2d)) {
                        throw TypeError('upperRight should be of type Acad.Point2d');
                    }
                    if (!(Acad.isInteger(lowerLeft.x) && Acad.isInteger(lowerLeft.y) && Acad.isInteger(upperRight.x) && Acad.isInteger(upperRight.y))) {
                        throw TypeError('lowerLeft/upperRight screen coordinates should be integer');
                    }

                    if (animate && (typeof (animate) !== 'boolean')) {
                        throw TypeError('animate flag should be boolean');
                    }
                    if (!AutoCAD.CurrentViewportInterop.zoomWindow(lowerLeft, upperRight, animate))
                        throw Error("ZoomWindow failed.");
                }
                CurrentViewport.zoomWindow = zoomWindow;
                ;

                /*
                * Returns the 2D point pt on the screen
                * @param Input point to grab of type Acad.Point3d
                * @return 2D point pt on the screen of type Acad.Point2d
                */
                function pointToScreen(inputPoint) {
                    if (!(inputPoint)) {
                        throw Error('inputPoint is mandatory.');
                    }
                    if (!(inputPoint instanceof Acad.Point3d)) {
                        throw TypeError('inputPoint should be of type Acad.Point3d');
                    }
                    const jsonObj = AutoCAD.CurrentViewportInterop.pointToScreen(inputPoint);
                    return new Acad.Point2d(jsonObj.x, jsonObj.y);
                }
                CurrentViewport.pointToScreen = pointToScreen;
                ;

                /*
                * Returns the 3D point pt on the World Coordinate System
                * @param Input point is the screen point of type Acad.Point2d
                * @return 3D point on the World Coordinate System of type Acad.Point3d
                */
                function pointToWorld(inputPoint) {
                    if (!(inputPoint)) {
                        throw Error('inputPoint is mandatory.');
                    }
                    if (!(inputPoint instanceof Acad.Point2d)) {
                        throw TypeError('inputPoint should be of type Acad.Point2d');
                    }
                    const jsonObj = AutoCAD.CurrentViewportInterop.pointToWorld(inputPoint);
                    return new Acad.Point3d(jsonObj.x, jsonObj.y, jsonObj.z);
                }
                CurrentViewport.pointToWorld = pointToWorld;
                ;

                /*
                * Converts a UCS point to UCS
                * @param Input point is the UCS point of type Acad.Point3d
                * @return a WCS point of type Acad.Point3d
                */
                function ucsToWorld(inputPoint) {
                    if (!(inputPoint)) {
                        throw Error('inputPoint is mandatory.');
                    }
                    if (!(inputPoint instanceof Acad.Point3d)) {
                        throw TypeError('inputPoint should be of type Acad.Point3d');
                    }
                    const jsonObj = AutoCAD.CurrentViewportInterop.ucsToWorld(inputPoint);
                    return new Acad.Point3d(jsonObj.x, jsonObj.y, jsonObj.z);
                }
                CurrentViewport.ucsToWorld = ucsToWorld;
                ;

                /*
                * Converts a WCS point to UCS
                * @param Input point is the WCS point of type Acad.Point3d
                * @return a UCS point of type Acad.Point3d
                */
                function worldToUCS(inputPoint) {
                    if (!(inputPoint)) {
                        throw Error('inputPoint is mandatory.');
                    }
                    if (!(inputPoint instanceof Acad.Point3d)) {
                        throw TypeError('inputPoint should be of type Acad.Point3d');
                    }
                    const jsonObj = AutoCAD.CurrentViewportInterop.worldToUCS(inputPoint);
                    return new Acad.Point3d(jsonObj.x, jsonObj.y, jsonObj.z);
                }
                CurrentViewport.worldToUCS = worldToUCS;
                ;

                /*
                * This method retrieves the extents of the viewport in normalized device coordinates.
                * @return Acad.Rectangle2d object which has lowerLeft and upperRight as Acad.Point2d objects
                */
                function getViewport() {
                    const jsonObj = AutoCAD.CurrentViewportInterop.getViewport();
                    return new Acad.Rectangle2d(new Acad.Point2d(jsonObj.lowerLeft.x, jsonObj.lowerLeft.y), new Acad.Point2d(jsonObj.upperRight.x, jsonObj.upperRight.y));
                }
                CurrentViewport.getViewport = getViewport;
                ;

                /**
                * The Methods which returns the position, target , upVector, fieldWidth and fieldHeight of current viewport.
                * @return fieldHeight of type float
                */
                function getViewProperties() {
                    const jsonObj = AutoCAD.CurrentViewportInterop.getViewProperties();
                    const position = new Acad.Point3d(jsonObj.position.x, jsonObj.position.y, jsonObj.position.z);
                    const target = new Acad.Point3d(jsonObj.target.x, jsonObj.target.y, jsonObj.target.z);
                    const upVector = new Acad.Vector3d(jsonObj.upVector.x, jsonObj.upVector.y, jsonObj.upVector.z);
                    const fieldWidth = jsonObj.fieldWidth;
                    const fieldHeight = jsonObj.fieldHeight;
                    const projection = jsonObj.projection;
                    return new Acad.ViewProperties(position, target, upVector, fieldWidth, fieldHeight, projection);
                }
                CurrentViewport.getViewProperties = getViewProperties;
                ;

                Object.defineProperty(CurrentViewport, "position", {
                    get() {
                        const position = AutoCAD.CurrentViewportInterop.get_position();
                        return new Acad.Point3d(position.x, position.y, position.z);
                    },
                    set(val) {
                        throw Error(" You are not allowed to set this property");
                    }
                });

                Object.defineProperty(CurrentViewport, "target", {
                    get() {
                        const target = AutoCAD.CurrentViewportInterop.get_target();
                        return new Acad.Point3d(target.x, target.y, target.z);
                    },
                    set(val) {
                        throw Error(" You are not allowed to set this property");
                    }
                });

                Object.defineProperty(CurrentViewport, "upVector", {
                    get() {
                        const upVector = AutoCAD.CurrentViewportInterop.get_upVector();
                        return new Acad.Vector3d(upVector.x, upVector.y, upVector.z);
                    },
                    set(val) {
                        throw Error(" You are not allowed to set this property");
                    }
                });

                Object.defineProperty(CurrentViewport, "fieldWidth", {
                    get() {
                        return AutoCAD.CurrentViewportInterop.get_fieldWidth();
                    },
                    set(val) {
                        throw Error(" You are not allowed to set this property");
                    }
                });

                Object.defineProperty(CurrentViewport, "fieldHeight", {
                    get() {
                        return AutoCAD.CurrentViewportInterop.get_fieldHeight();
                    },
                    set(val) {
                        throw Error(" You are not allowed to set this property");
                    }
                });

                Object.defineProperty(CurrentViewport, "projection", {
                    get() {
                        return AutoCAD.CurrentViewportInterop.get_projection();
                    },
                    set(val) {
                        throw Error(" You are not allowed to set this property");
                    }
                });
            }))(Editor.CurrentViewport || (Editor.CurrentViewport = {}));
            const CurrentViewport = Editor.CurrentViewport;
        }))(AutoCAD.Editor || (AutoCAD.Editor = {}));
        var Editor = AutoCAD.Editor;
        ;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
//Common declarations referenced by generated code
var Autodesk;
((Autodesk => {
    ((JavaScript => {
        const Promise = ((() => {
            class Promise {
                then(success_, error_) {
                    this.success = success_;
                    this.error = error_;
                }
            }

            return Promise;
        }))();
        JavaScript.Promise = Promise;
        ((ErrorStatus => {
            ErrorStatus[ErrorStatus["eOk"] = 0] = "eOk";
        }))(JavaScript.ErrorStatus || (JavaScript.ErrorStatus = {}));
        const ErrorStatus = JavaScript.ErrorStatus;
    }))(Autodesk.JavaScript || (Autodesk.JavaScript = {}));
    const JavaScript = Autodesk.JavaScript;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //---start of generated typescript---
    //
    //////////////////////////////////////////////////////////////////////////////
    //
    // (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    //////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ((AutoCAD => {
        let Flags;
        ((Flags => {
            Flags[Flags["RequiresDocument"] = 1] = "RequiresDocument";
        }))(Flags || (Flags = {}));
        ;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //---start of generated typescript---
    //
    //////////////////////////////////////////////////////////////////////////////
    //
    // (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    //////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="CommonTypes.ts"/>
    ((AutoCAD => {
        ((ActiveDocumentInterop => {
            function addObjectReactor(strObjIds) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_ActiveDocumentInterop.addObjectReactor',
                    functionParams: { strObjIds }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            ActiveDocumentInterop.addObjectReactor = addObjectReactor;
            function removeObjectReactor(strObjIds) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_ActiveDocumentInterop.removeObjectReactor',
                    functionParams: { strObjIds }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            ActiveDocumentInterop.removeObjectReactor = removeObjectReactor;
            function getHandles(objIds) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_ActiveDocumentInterop.getHandles',
                    functionParams: { objIds }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            ActiveDocumentInterop.getHandles = getHandles;
            function getObjectSet(objHandles) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_ActiveDocumentInterop.getObjectSet',
                    functionParams: { objHandles }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            ActiveDocumentInterop.getObjectSet = getObjectSet;
            function capturePreview(nWidth, nHeight) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_ActiveDocumentInterop.capturePreview',
                    functionParams: { nWidth, nHeight }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            ActiveDocumentInterop.capturePreview = capturePreview;

            function highlight(objIds) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_ActiveDocumentInterop.highlight',
                    functionParams: { objIds }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            ActiveDocumentInterop.highlight = highlight;

            function unhighlight(objIds) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_ActiveDocumentInterop.unhighlight',
                    functionParams: { objIds }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            ActiveDocumentInterop.unhighlight = unhighlight;

            let objectModified_handlers = null;

            //called by native code: fires event to callback supplied by the user
            function objectModifiedCallback(args) {
                const obj = JSON.parse(args);

                //unpack all event arguments
                const objectModifiedEventArgs = obj.objectModifiedEventArgs;

                for (let i = 0; i < objectModified_handlers.length; ++i)
                    objectModified_handlers[i](objectModifiedEventArgs);
            }

            //allows user to supply a callback
            function addHandler_objectModified(userFunction) {
                const separator = (typeof (apiVersion) == 'function' && apiVersion() > 2) ? '.' : '_';
                if (objectModified_handlers == null) {
                    objectModified_handlers = new Array();
                    registerCallback(`Ac_ActiveDocumentInterop${separator}objectModified`, objectModifiedCallback);
                }
                objectModified_handlers.push(userFunction);
            }
            ActiveDocumentInterop.addHandler_objectModified = addHandler_objectModified;

            let objectErased_handlers = null;

            //called by native code: fires event to callback supplied by the user
            function objectErasedCallback(args) {
                const obj = JSON.parse(args);

                //unpack all event arguments
                const objectErasedEventArgs = obj.objectErasedEventArgs;

                for (let i = 0; i < objectErased_handlers.length; ++i)
                    objectErased_handlers[i](objectErasedEventArgs);
            }

            //allows user to supply a callback
            function addHandler_objectErased(userFunction) {
                const separator = (typeof (apiVersion) == 'function' && apiVersion() > 2) ? '.' : '_';
                if (objectErased_handlers == null) {
                    objectErased_handlers = new Array();
                    registerCallback(`Ac_ActiveDocumentInterop${separator}objectErased`, objectErasedCallback);
                }
                objectErased_handlers.push(userFunction);
            }
            ActiveDocumentInterop.addHandler_objectErased = addHandler_objectErased;
        }))(AutoCAD.ActiveDocumentInterop || (AutoCAD.ActiveDocumentInterop = {}));
        const ActiveDocumentInterop = AutoCAD.ActiveDocumentInterop;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //---start of generated typescript---
    //
    //////////////////////////////////////////////////////////////////////////////
    //
    // (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    //////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="CommonTypes.ts"/>
    ((AutoCAD => {
        ((ApplicationInterop => {
            function doEvents() {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_ApplicationInterop.doEvents',
                    functionParams: {}
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            ApplicationInterop.doEvents = doEvents;
            function showTaskDialog(strWindowTitle, strMainInstruction, strContentText, nCommonButtons) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_ApplicationInterop.showTaskDialog',
                    functionParams: { strWindowTitle, strMainInstruction, strContentText, nCommonButtons }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            ApplicationInterop.showTaskDialog = showTaskDialog;
            function showDeleteConfirmationTaskDialog(strTitle, strMessage) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_ApplicationInterop.showDeleteConfirmationTaskDialog',
                    functionParams: { strTitle, strMessage }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            ApplicationInterop.showDeleteConfirmationTaskDialog = showDeleteConfirmationTaskDialog;
            function showHTMLDialog(url, options) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_ApplicationInterop.showHTMLDialog',
                    functionParams: { url, options }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            ApplicationInterop.showHTMLDialog = showHTMLDialog;
            function showModalDialog(url) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_ApplicationInterop.showModalDialog',
                    functionParams: { url }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            ApplicationInterop.showModalDialog = showModalDialog;
            function addDocWindow(title, url) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_ApplicationInterop.addDocWindow',
                    functionParams: { title, url }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            ApplicationInterop.addDocWindow = addDocWindow;
            function modalDialogCommit(value) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_ApplicationInterop.modalDialogCommit',
                    functionParams: { value }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            ApplicationInterop.modalDialogCommit = modalDialogCommit;
            function addPalette(paletteName, url) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_ApplicationInterop.addPalette',
                    functionParams: { paletteName, url }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            ApplicationInterop.addPalette = addPalette;

            function showTooltip(position, tooltip) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_ApplicationInterop.showTooltip',
                    functionParams: { position, tooltip }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            ApplicationInterop.showTooltip = showTooltip;

            function hideTooltip(tooltipId) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_ApplicationInterop.hideTooltip',
                    functionParams: { tooltipId }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            ApplicationInterop.hideTooltip = hideTooltip;
            function displayContextMenu(x, y, menu) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_ApplicationInterop.displayContextMenu',
                    functionParams: { x, y, menu }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            ApplicationInterop.displayContextMenu = displayContextMenu;

            let applicationReadyEvent_handlers = null;

            //called by native code: fires event to callback supplied by the user
            function applicationReadyEventCallback(args) {
                const obj = JSON.parse(args);

                for (let i = 0; i < applicationReadyEvent_handlers.length; ++i)
                    applicationReadyEvent_handlers[i]();
            }

            //allows user to supply a callback
            function addHandler_applicationReadyEvent(userFunction) {
                const separator = (typeof (apiVersion) == 'function' && apiVersion() > 2) ? '.' : '_';
                if (applicationReadyEvent_handlers == null) {
                    applicationReadyEvent_handlers = new Array();
                    registerCallback(`Ac_ApplicationInterop${separator}applicationReadyEvent`, applicationReadyEventCallback);
                }
                applicationReadyEvent_handlers.push(userFunction);
            }
            ApplicationInterop.addHandler_applicationReadyEvent = addHandler_applicationReadyEvent;
        }))(AutoCAD.ApplicationInterop || (AutoCAD.ApplicationInterop = {}));
        const ApplicationInterop = AutoCAD.ApplicationInterop;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //---start of generated typescript---
    //
    //////////////////////////////////////////////////////////////////////////////
    //
    // (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    //////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="CommonTypes.ts"/>
    ((AutoCAD => {
        ((CurrentViewportInterop => {
            function dolly(dollyVector, animate) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.dolly',
                    functionParams: { dollyVector, animate }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.dolly = dolly;

            function roll(rollAngle, animate) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.roll',
                    functionParams: { rollAngle, animate }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.roll = roll;

            function orbit(angleX, angleY, animate) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.orbit',
                    functionParams: { angleX, angleY, animate }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.orbit = orbit;

            function pan(angleX, angleY, animate) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.pan',
                    functionParams: { angleX, angleY, animate }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.pan = pan;

            function zoomExtents(minPoint, maxPoint, animate) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.zoomExtents',
                    functionParams: { minPoint, maxPoint, animate }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.zoomExtents = zoomExtents;

            function zoom(zoomFactor, animate) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.zoom',
                    functionParams: { zoomFactor, animate }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.zoom = zoom;

            function zoomWindow(lowerLeft, upperRight, animate) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.zoomWindow',
                    functionParams: { lowerLeft, upperRight, animate }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.zoomWindow = zoomWindow;

            function pointToScreen(inputPoint) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.pointToScreen',
                    functionParams: { inputPoint }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.pointToScreen = pointToScreen;

            function pointToWorld(inputPoint) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.pointToWorld',
                    functionParams: { inputPoint }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.pointToWorld = pointToWorld;

            function ucsToWorld(inputPoint) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.ucsToWorld',
                    functionParams: { inputPoint }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.ucsToWorld = ucsToWorld;

            function worldToUCS(inputPoint) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.worldToUCS',
                    functionParams: { inputPoint }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.worldToUCS = worldToUCS;

            function setView(position, target, upVector, fieldWidth, fieldHeight, projection, animate) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.setView',
                    functionParams: { position, target, upVector, fieldWidth, fieldHeight, projection, animate }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.setView = setView;

            function getViewport() {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.getViewport',
                    functionParams: {}
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.getViewport = getViewport;

            function getViewProperties() {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.getViewProperties',
                    functionParams: {}
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.getViewProperties = getViewProperties;

            function get_position() {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.get_position',
                    functionParams: {}
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.get_position = get_position;

            function get_target() {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.get_target',
                    functionParams: {}
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.get_target = get_target;

            function get_upVector() {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.get_upVector',
                    functionParams: {}
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.get_upVector = get_upVector;

            function get_fieldWidth() {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.get_fieldWidth',
                    functionParams: {}
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.get_fieldWidth = get_fieldWidth;

            function get_fieldHeight() {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.get_fieldHeight',
                    functionParams: {}
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.get_fieldHeight = get_fieldHeight;

            function get_projection() {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.get_projection',
                    functionParams: {}
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.get_projection = get_projection;

            function getViewport3D(viewprop) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.getViewport3D',
                    functionParams: { viewprop }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.getViewport3D = getViewport3D;

            function convertViewport3D(viewport3d) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_CurrentViewportInterop.convertViewport3D',
                    functionParams: { viewport3d }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            CurrentViewportInterop.convertViewport3D = convertViewport3D;
        }))(AutoCAD.CurrentViewportInterop || (AutoCAD.CurrentViewportInterop = {}));
        const CurrentViewportInterop = AutoCAD.CurrentViewportInterop;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //---start of generated typescript---
    //
    //////////////////////////////////////////////////////////////////////////////
    //
    // (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    //////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="CommonTypes.ts"/>
    ((AutoCAD => {
        ((DataItemCollectionManagerInterop => {
            function getKnownCollection(colName) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_DataItemCollectionManagerInterop.getKnownCollection',
                    functionParams: { colName }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            DataItemCollectionManagerInterop.getKnownCollection = getKnownCollection;

            let resetEvent_handlers = null;

            //called by native code: fires event to callback supplied by the user
            function resetEventCallback(args) {
                const obj = JSON.parse(args);

                //unpack all event arguments
                const eventArgs = obj.eventArgs;

                for (let i = 0; i < resetEvent_handlers.length; ++i)
                    resetEvent_handlers[i](eventArgs);
            }

            //allows user to supply a callback
            function addHandler_resetEvent(userFunction) {
                const separator = (typeof (apiVersion) == 'function' && apiVersion() > 2) ? '.' : '_';
                if (resetEvent_handlers == null) {
                    resetEvent_handlers = new Array();
                    registerCallback(`Ac_DataItemCollectionManagerInterop${separator}resetEvent`, resetEventCallback);
                }
                resetEvent_handlers.push(userFunction);
            }
            DataItemCollectionManagerInterop.addHandler_resetEvent = addHandler_resetEvent;

            let collectionChangedEvent_handlers = null;

            //called by native code: fires event to callback supplied by the user
            function collectionChangedEventCallback(args) {
                const obj = JSON.parse(args);

                //unpack all event arguments
                const eventArgs = obj.eventArgs;

                for (let i = 0; i < collectionChangedEvent_handlers.length; ++i)
                    collectionChangedEvent_handlers[i](eventArgs);
            }

            //allows user to supply a callback
            function addHandler_collectionChangedEvent(userFunction) {
                const separator = (typeof (apiVersion) == 'function' && apiVersion() > 2) ? '.' : '_';
                if (collectionChangedEvent_handlers == null) {
                    collectionChangedEvent_handlers = new Array();
                    registerCallback(`Ac_DataItemCollectionManagerInterop${separator}collectionChangedEvent`, collectionChangedEventCallback);
                }
                collectionChangedEvent_handlers.push(userFunction);
            }
            DataItemCollectionManagerInterop.addHandler_collectionChangedEvent = addHandler_collectionChangedEvent;

            let itemsChangedEvent_handlers = null;

            //called by native code: fires event to callback supplied by the user
            function itemsChangedEventCallback(args) {
                const obj = JSON.parse(args);

                //unpack all event arguments
                const eventArgs = obj.eventArgs;

                for (let i = 0; i < itemsChangedEvent_handlers.length; ++i)
                    itemsChangedEvent_handlers[i](eventArgs);
            }

            //allows user to supply a callback
            function addHandler_itemsChangedEvent(userFunction) {
                const separator = (typeof (apiVersion) == 'function' && apiVersion() > 2) ? '.' : '_';
                if (itemsChangedEvent_handlers == null) {
                    itemsChangedEvent_handlers = new Array();
                    registerCallback(`Ac_DataItemCollectionManagerInterop${separator}itemsChangedEvent`, itemsChangedEventCallback);
                }
                itemsChangedEvent_handlers.push(userFunction);
            }
            DataItemCollectionManagerInterop.addHandler_itemsChangedEvent = addHandler_itemsChangedEvent;
        }))(AutoCAD.DataItemCollectionManagerInterop || (AutoCAD.DataItemCollectionManagerInterop = {}));
        const DataItemCollectionManagerInterop = AutoCAD.DataItemCollectionManagerInterop;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //---start of generated typescript---
    //
    //////////////////////////////////////////////////////////////////////////////
    //
    // (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    //////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="CommonTypes.ts"/>
    ((AutoCAD => {
        ((DataItemInterop => {
            function getProperties(id) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_DataItemInterop.getProperties',
                    functionParams: { id }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            DataItemInterop.getProperties = getProperties;
        }))(AutoCAD.DataItemInterop || (AutoCAD.DataItemInterop = {}));
        const DataItemInterop = AutoCAD.DataItemInterop;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //---start of generated typescript---
    //
    //////////////////////////////////////////////////////////////////////////////
    //
    // (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    //////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="CommonTypes.ts"/>
    ((AutoCAD => {
        ((DBEntityInterop => {
            function getExtents(entityId) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_DBEntityInterop.getExtents',
                    functionParams: { entityId }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            DBEntityInterop.getExtents = getExtents;

            function getProperties(entityId) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_DBEntityInterop.getProperties',
                    functionParams: { entityId }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            DBEntityInterop.getProperties = getProperties;
        }))(AutoCAD.DBEntityInterop || (AutoCAD.DBEntityInterop = {}));
        const DBEntityInterop = AutoCAD.DBEntityInterop;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //---start of generated typescript---
    //
    //////////////////////////////////////////////////////////////////////////////
    //
    // (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    //////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="CommonTypes.ts"/>
    ((AutoCAD => {
        ((EditorInterop => {
            function captureView() {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_EditorInterop.captureView',
                    functionParams: {}
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            EditorInterop.captureView = captureView;

            function restoreView(viewId) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_EditorInterop.restoreView',
                    functionParams: { viewId }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            EditorInterop.restoreView = restoreView;

            function executeCommand(commands, onSuccess, onError) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_EditorInterop.executeCommand',
                    functionParams: { commands, onSuccess, onError }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            EditorInterop.executeCommand = executeCommand;

            function addCommand(groupName, globalName, localName, flags) {
                         
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_EditorInterop.addCommand',
                    functionParams: { groupName, globalName, localName, flags }
                }));
                
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            EditorInterop.addCommand = addCommand;

            function cancelCommand() {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_EditorInterop.cancelCommand',
                    functionParams: {}
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            EditorInterop.cancelCommand = cancelCommand;

            function isQuiescent() {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_EditorInterop.isQuiescent',
                    functionParams: {}
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            EditorInterop.isQuiescent = isQuiescent;
            function getInteger(promptOpts) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.getInteger',
                    functionParams: { promptOpts }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.getInteger = getInteger;
            function getDouble(promptOpts) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.getDouble',
                    functionParams: { promptOpts }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.getDouble = getDouble;
            function getDistance(promptOpts) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.getDistance',
                    functionParams: { promptOpts }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.getDistance = getDistance;
            function getAngle(promptOpts) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.getAngle',
                    functionParams: { promptOpts }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.getAngle = getAngle;
            function getKeywords(promptOpts) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.getKeywords',
                    functionParams: { promptOpts }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.getKeywords = getKeywords;
            function getString(promptOpts) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.getString',
                    functionParams: { promptOpts }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.getString = getString;
            function getPoint(promptOpts) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.getPoint',
                    functionParams: { promptOpts }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.getPoint = getPoint;
            function getCorner(promptOpts) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.getCorner',
                    functionParams: { promptOpts }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.getCorner = getCorner;
            function getEntity(promptOpts) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.getEntity',
                    functionParams: { promptOpts }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.getEntity = getEntity;
            function getNestedEntity(promptOpts) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.getNestedEntity',
                    functionParams: { promptOpts }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.getNestedEntity = getNestedEntity;
            function getSelection(promptOpts) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.getSelection',
                    functionParams: { promptOpts }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.getSelection = getSelection;
            function dragDistance(jigOptions) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.dragDistance',
                    functionParams: { jigOptions }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.dragDistance = dragDistance;
            function dragAngle(jigOptions) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.dragAngle',
                    functionParams: { jigOptions }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.dragAngle = dragAngle;
            function dragString(jigOptions) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.dragString',
                    functionParams: { jigOptions }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.dragString = dragString;
            function dragPoint(jigOptions) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.dragPoint',
                    functionParams: { jigOptions }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.dragPoint = dragPoint;
            function getFileNameForOpen(options) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.getFileNameForOpen',
                    functionParams: { options }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.getFileNameForOpen = getFileNameForOpen;
            function getFileNameForSave(options) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_EditorInterop.getFileNameForSave',
                    functionParams: { options }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            EditorInterop.getFileNameForSave = getFileNameForSave;

            let commandEndedEvent_handlers = null;

            //called by native code: fires event to callback supplied by the user
            function commandEndedEventCallback(args) {
                const obj = JSON.parse(args);

                //unpack all event arguments
                const command = obj.command;

                for (let i = 0; i < commandEndedEvent_handlers.length; ++i)
                    commandEndedEvent_handlers[i](command);
            }

            //allows user to supply a callback
            function addHandler_commandEndedEvent(userFunction) {
                const separator = (typeof (apiVersion) == 'function' && apiVersion() > 2) ? '.' : '_';
                if (commandEndedEvent_handlers == null) {
                    commandEndedEvent_handlers = new Array();
                    registerCallback(`Ac_EditorInterop${separator}commandEndedEvent`, commandEndedEventCallback);
                }
                commandEndedEvent_handlers.push(userFunction);
            }
            EditorInterop.addHandler_commandEndedEvent = addHandler_commandEndedEvent;
        }))(AutoCAD.EditorInterop || (AutoCAD.EditorInterop = {}));
        const EditorInterop = AutoCAD.EditorInterop;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //---start of generated typescript---
    //
    //////////////////////////////////////////////////////////////////////////////
    //
    // (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    //////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="CommonTypes.ts"/>
    ((AutoCAD => {
        ((JigInterop => {
            function update(xmlData) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_JigInterop.update',
                    functionParams: { xmlData }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            JigInterop.update = update;

            let updateEvent_handler = null;

            //called by native code: fires event to callback supplied by the user
            function updateEventCallback(args) {
                const obj = JSON.parse(args);

                //unpack all event arguments
                const eventArgs = obj.eventArgs;

                //call the one and only event handler for this singlecast event
                updateEvent_handler(eventArgs);
            }

            //allows user to supply a callback
            function setHandler_updateEvent(userFunction) {
                const separator = (typeof (apiVersion) == 'function' && apiVersion() > 2) ? '.' : '_';
                if (updateEvent_handler == null) {
                    registerCallback(`Ac_JigInterop${separator}updateEvent`, updateEventCallback);
                }
                updateEvent_handler = userFunction;
            }
            JigInterop.setHandler_updateEvent = setHandler_updateEvent;
        }))(AutoCAD.JigInterop || (AutoCAD.JigInterop = {}));
        const JigInterop = AutoCAD.JigInterop;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //---start of generated typescript---
    //
    //////////////////////////////////////////////////////////////////////////////
    //
    // (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    //////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="CommonTypes.ts"/>
    ((AutoCAD => {
        ((Logger => {
            function get_isLoggingEnabled() {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_Logger.get_isLoggingEnabled',
                    functionParams: {}
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            Logger.get_isLoggingEnabled = get_isLoggingEnabled;
            function logFatal(msg) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_Logger.logFatal',
                    functionParams: { msg }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            Logger.logFatal = logFatal;
            function logError(msg) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_Logger.logError',
                    functionParams: { msg }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            Logger.logError = logError;
            function logWarn(msg) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_Logger.logWarn',
                    functionParams: { msg }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            Logger.logWarn = logWarn;
            function logInfo(msg) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_Logger.logInfo',
                    functionParams: { msg }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            Logger.logInfo = logInfo;
            function logDebug(msg) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_Logger.logDebug',
                    functionParams: { msg }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            Logger.logDebug = logDebug;
            function logTrace(msg) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_Logger.logTrace',
                    functionParams: { msg }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            Logger.logTrace = logTrace;

            function get_logLevel() {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_Logger.get_logLevel',
                    functionParams: {}
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            Logger.get_logLevel = get_logLevel;
            function set_logLevel(value) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_Logger.set_logLevel',
                    functionParams: { value }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            Logger.set_logLevel = set_logLevel;
        }))(AutoCAD.Logger || (AutoCAD.Logger = {}));
        const Logger = AutoCAD.Logger;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //---start of generated typescript---
    //
    //////////////////////////////////////////////////////////////////////////////
    //
    // (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    //////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="CommonTypes.ts"/>
    ((AutoCAD => {
        ((SecureFileInterop => {
            function getContents(guid) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_SecureFileInterop.getContents',
                    functionParams: { guid }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            SecureFileInterop.getContents = getContents;

            function getFileSize(guid) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_SecureFileInterop.getFileSize',
                    functionParams: { guid }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            SecureFileInterop.getFileSize = getFileSize;

            function setContents(guid, contents) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_SecureFileInterop.setContents',
                    functionParams: { guid, contents }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            SecureFileInterop.setContents = setContents;

            function release(guid) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_SecureFileInterop.release',
                    functionParams: { guid }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            SecureFileInterop.release = release;
        }))(AutoCAD.SecureFileInterop || (AutoCAD.SecureFileInterop = {}));
        const SecureFileInterop = AutoCAD.SecureFileInterop;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //---start of generated typescript---
    //
    //////////////////////////////////////////////////////////////////////////////
    //
    // (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    //////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="CommonTypes.ts"/>
    ((AutoCAD => {
        ((SysVarCollectionInterop => {
            function getSysVar(varName) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_SysVarCollectionInterop.getSysVar',
                    functionParams: { varName }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            SysVarCollectionInterop.getSysVar = getSysVar;

            function setSysVarValue(varName, sysVarValueInterop) {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_SysVarCollectionInterop.setSysVarValue',
                    functionParams: { varName, sysVarValueInterop }
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            SysVarCollectionInterop.setSysVarValue = setSysVarValue;
            function postSysVarValue(varName, sysVarValueInterop) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_SysVarCollectionInterop.postSysVarValue',
                    functionParams: { varName, sysVarValueInterop }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            SysVarCollectionInterop.postSysVarValue = postSysVarValue;
            function addSysVarReactor(varNames) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_SysVarCollectionInterop.addSysVarReactor',
                    functionParams: { varNames }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            SysVarCollectionInterop.addSysVarReactor = addSysVarReactor;
            function removeSysVarReactor(varNames) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_SysVarCollectionInterop.removeSysVarReactor',
                    functionParams: { varNames }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            SysVarCollectionInterop.removeSysVarReactor = removeSysVarReactor;

            let sysVarChanged_handlers = null;

            //called by native code: fires event to callback supplied by the user
            function sysVarChangedCallback(args) {
                const obj = JSON.parse(args);

                //unpack all event arguments
                const sysVarsChanged = obj.sysVarsChanged;

                for (let i = 0; i < sysVarChanged_handlers.length; ++i)
                    sysVarChanged_handlers[i](sysVarsChanged);
            }

            //allows user to supply a callback
            function addHandler_sysVarChanged(userFunction) {
                const separator = (typeof (apiVersion) == 'function' && apiVersion() > 2) ? '.' : '_';
                if (sysVarChanged_handlers == null) {
                    sysVarChanged_handlers = new Array();
                    registerCallback(`Ac_SysVarCollectionInterop${separator}sysVarChanged`, sysVarChangedCallback);
                }
                sysVarChanged_handlers.push(userFunction);
            }
            SysVarCollectionInterop.addHandler_sysVarChanged = addHandler_sysVarChanged;
        }))(AutoCAD.SysVarCollectionInterop || (AutoCAD.SysVarCollectionInterop = {}));
        const SysVarCollectionInterop = AutoCAD.SysVarCollectionInterop;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));
var Autodesk;
((Autodesk => {
    //---start of generated typescript---
    //
    //////////////////////////////////////////////////////////////////////////////
    //
    // (C) Copyright 2012 by Autodesk, Inc.
    //
    // The information contained herein is confidential, proprietary to Autodesk,
    // Inc., and considered a trade secret as defined in section 499C of the
    // penal code of the State of California.  Use of this information by anyone
    // other than authorized employees of Autodesk, Inc. is granted only under a
    // written non-disclosure agreement, expressly prescribing the scope and
    // manner of such use.
    //
    //////////////////////////////////////////////////////////////////////////////
    // Include TS files
    ///<reference path="CommonTypes.ts"/>
    ((AutoCAD => {
        ((TransientManagerInterop => {
            function addTransient(id, xmlData) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_TransientManagerInterop.addTransient',
                    functionParams: { id, xmlData }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            TransientManagerInterop.addTransient = addTransient;
            function updateTransient(id, xmlData) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_TransientManagerInterop.updateTransient',
                    functionParams: { id, xmlData }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            TransientManagerInterop.updateTransient = updateTransient;
            function eraseTransient(id) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_TransientManagerInterop.eraseTransient',
                    functionParams: { id }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            TransientManagerInterop.eraseTransient = eraseTransient;
            function eraseTransients(ids) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_TransientManagerInterop.eraseTransients',
                    functionParams: { ids }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            TransientManagerInterop.eraseTransients = eraseTransients;

            function getNewTransientId() {
                const jsonStr = exec(JSON.stringify({
                    functionName: 'Ac_TransientManagerInterop.getNewTransientId',
                    functionParams: {}
                }));
                const jsonObj = JSON.parse(jsonStr);

                if (jsonObj.retCode == undefined)
                    throw TypeError("Internal error: retCode is not present.");
                if (jsonObj.retCode != Autodesk.JavaScript.ErrorStatus.eOk) {
                    throw jsonObj;
                }
                if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                    return jsonObj.retValue;
                } else {
                    if (jsonObj.retValue)
                        return JSON.parse(jsonObj.retValue);
                    return jsonObj;
                }
            }
            TransientManagerInterop.getNewTransientId = getNewTransientId;
            function showTransients(ids, bShow) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_TransientManagerInterop.showTransients',
                    functionParams: { ids, bShow }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            TransientManagerInterop.showTransients = showTransients;
            function getCursor(transientId) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_TransientManagerInterop.getCursor',
                    functionParams: { transientId }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            TransientManagerInterop.getCursor = getCursor;
            function setEventHandlingBehavior(id, eventName, bFilter) {
                const promise = new Autodesk.JavaScript.Promise();
                execAsync(JSON.stringify({
                    functionName: 'Ac_TransientManagerInterop.setEventHandlingBehavior',
                    functionParams: { id, eventName, bFilter }
                }), result => {
                    if (typeof (promise.success) == 'function') {
                        const resObj = JSON.parse(result);
                        if (typeof (apiVersion) == 'function' && apiVersion() > 2) {
                            promise.success(resObj.retValue);
                        } else {
                            if (resObj.hasOwnProperty("retValue"))
                                promise.success(resObj.retValue);
                            else
                                promise.success(resObj);
                        }
                    }
                }, result => {
                    if (typeof (promise.error) == 'function') {
                        const error = JSON.parse(result);

                        if (error.retCode == undefined)
                            throw TypeError("Internal error: retCode is not present.");

                        if (error.retCode == Autodesk.JavaScript.ErrorStatus.eOk)
                            throw "Internal error: retCode is eOk in error callback.";

                        if (error.retErrorString == undefined)
                            promise.error(error.retCode);
                        else
                            promise.error(error.retCode, error.retErrorString);
                    }
                });
                return promise;
            }
            TransientManagerInterop.setEventHandlingBehavior = setEventHandlingBehavior;

            let mouseChanged_handlers = null;

            //called by native code: fires event to callback supplied by the user
            function mouseChangedCallback(args) {
                const obj = JSON.parse(args);

                //unpack all event arguments
                const eventArgs = obj.eventArgs;

                for (let i = 0; i < mouseChanged_handlers.length; ++i)
                    mouseChanged_handlers[i](eventArgs);
            }

            //allows user to supply a callback
            function addHandler_mouseChanged(userFunction) {
                const separator = (typeof (apiVersion) == 'function' && apiVersion() > 2) ? '.' : '_';
                if (mouseChanged_handlers == null) {
                    mouseChanged_handlers = new Array();
                    registerCallback(`Ac_TransientManagerInterop${separator}mouseChanged`, mouseChangedCallback);
                }
                mouseChanged_handlers.push(userFunction);
            }
            TransientManagerInterop.addHandler_mouseChanged = addHandler_mouseChanged;
        }))(AutoCAD.TransientManagerInterop || (AutoCAD.TransientManagerInterop = {}));
        const TransientManagerInterop = AutoCAD.TransientManagerInterop;
    }))(Autodesk.AutoCAD || (Autodesk.AutoCAD = {}));
    const AutoCAD = Autodesk.AutoCAD;
}))(Autodesk || (Autodesk = {}));

// SIG // Begin signature block
// SIG // MIIZNgYJKoZIhvcNAQcCoIIZJzCCGSMCAQExCzAJBgUr
// SIG // DgMCGgUAMGcGCisGAQQBgjcCAQSgWTBXMDIGCisGAQQB
// SIG // gjcCAR4wJAIBAQQQEODJBs441BGiowAQS9NQkAIBAAIB
// SIG // AAIBAAIBAAIBADAhMAkGBSsOAwIaBQAEFKD+CygGHBtR
// SIG // HVJoGbhUBHRCyLEUoIIUMDCCA+4wggNXoAMCAQICEH6T
// SIG // 6/t8xk5Z6kuad9QG/DswDQYJKoZIhvcNAQEFBQAwgYsx
// SIG // CzAJBgNVBAYTAlpBMRUwEwYDVQQIEwxXZXN0ZXJuIENh
// SIG // cGUxFDASBgNVBAcTC0R1cmJhbnZpbGxlMQ8wDQYDVQQK
// SIG // EwZUaGF3dGUxHTAbBgNVBAsTFFRoYXd0ZSBDZXJ0aWZp
// SIG // Y2F0aW9uMR8wHQYDVQQDExZUaGF3dGUgVGltZXN0YW1w
// SIG // aW5nIENBMB4XDTEyMTIyMTAwMDAwMFoXDTIwMTIzMDIz
// SIG // NTk1OVowXjELMAkGA1UEBhMCVVMxHTAbBgNVBAoTFFN5
// SIG // bWFudGVjIENvcnBvcmF0aW9uMTAwLgYDVQQDEydTeW1h
// SIG // bnRlYyBUaW1lIFN0YW1waW5nIFNlcnZpY2VzIENBIC0g
// SIG // RzIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
// SIG // AQCxrLNJVEuXHBIK2CV5kSJXKm/cuCbEQ3Nrwr8uUFr7
// SIG // FMJ2jkMBJUO0oeJF9Oi3e8N0zCLXtJQAAvdN7b+0t0Qk
// SIG // a81fRTvRRM5DEnMXgotptCvLmR6schsmTXEfsTHd+1Fh
// SIG // AlOmqvVJLAV4RaUvic7nmef+jOJXPz3GktxK+Hsz5HkK
// SIG // +/B1iEGc/8UDUZmq12yfk2mHZSmDhcJgFMTIyTsU2sCB
// SIG // 8B8NdN6SIqvK9/t0fCfm90obf6fDni2uiuqm5qonFn1h
// SIG // 95hxEbziUKFL5V365Q6nLJ+qZSDT2JboyHylTkhE/xni
// SIG // RAeSC9dohIBdanhkRc1gRn5UwRN8xXnxycFxAgMBAAGj
// SIG // gfowgfcwHQYDVR0OBBYEFF+a9W5czMx0mtTdfe8/2+xM
// SIG // gC7dMDIGCCsGAQUFBwEBBCYwJDAiBggrBgEFBQcwAYYW
// SIG // aHR0cDovL29jc3AudGhhd3RlLmNvbTASBgNVHRMBAf8E
// SIG // CDAGAQH/AgEAMD8GA1UdHwQ4MDYwNKAyoDCGLmh0dHA6
// SIG // Ly9jcmwudGhhd3RlLmNvbS9UaGF3dGVUaW1lc3RhbXBp
// SIG // bmdDQS5jcmwwEwYDVR0lBAwwCgYIKwYBBQUHAwgwDgYD
// SIG // VR0PAQH/BAQDAgEGMCgGA1UdEQQhMB+kHTAbMRkwFwYD
// SIG // VQQDExBUaW1lU3RhbXAtMjA0OC0xMA0GCSqGSIb3DQEB
// SIG // BQUAA4GBAAMJm495739ZMKrvaLX64wkdu0+CBl03X6ZS
// SIG // nxaN6hySCURu9W3rWHww6PlpjSNzCxJvR6muORH4KrGb
// SIG // sBrDjutZlgCtzgxNstAxpghcKnr84nodV0yoZRjpeUBi
// SIG // JZZux8c3aoMhCI5B6t3ZVz8dd0mHKhYGXqY4aiISo1EZ
// SIG // g362MIIEozCCA4ugAwIBAgIQDs/0OMj+vzVuBNhqmBsa
// SIG // UDANBgkqhkiG9w0BAQUFADBeMQswCQYDVQQGEwJVUzEd
// SIG // MBsGA1UEChMUU3ltYW50ZWMgQ29ycG9yYXRpb24xMDAu
// SIG // BgNVBAMTJ1N5bWFudGVjIFRpbWUgU3RhbXBpbmcgU2Vy
// SIG // dmljZXMgQ0EgLSBHMjAeFw0xMjEwMTgwMDAwMDBaFw0y
// SIG // MDEyMjkyMzU5NTlaMGIxCzAJBgNVBAYTAlVTMR0wGwYD
// SIG // VQQKExRTeW1hbnRlYyBDb3Jwb3JhdGlvbjE0MDIGA1UE
// SIG // AxMrU3ltYW50ZWMgVGltZSBTdGFtcGluZyBTZXJ2aWNl
// SIG // cyBTaWduZXIgLSBHNDCCASIwDQYJKoZIhvcNAQEBBQAD
// SIG // ggEPADCCAQoCggEBAKJjCzlEuLsjp0RJuw7/ofBhClOT
// SIG // sJjbrSwPSsVu/4Y8U1UPFc4EPyv9qZaW2b5heQtbyUyG
// SIG // duXgQ0sile7CK0PBn9hotI5AT+6FOLkRxSPyZFjwFTJv
// SIG // TlehroikAtcqHs1L4d1j1ReJMluwXplaqJ0oUA4X7pbb
// SIG // YTtFUR3PElYLkkf8q672Zj1HrHBy55LnX80QucSDZJQZ
// SIG // vSWA4ejSIqXQugJ6oXeTW2XD7hd0vEGGKtwITIySjJEt
// SIG // nndEH2jWqHR32w5bMotWizO92WPISZ06xcXqMwvS8aMb
// SIG // 9Iu+2bNXizveBKd6IrIkri7HcMW+ToMmCPsLvalPmQjh
// SIG // EChyqs0CAwEAAaOCAVcwggFTMAwGA1UdEwEB/wQCMAAw
// SIG // FgYDVR0lAQH/BAwwCgYIKwYBBQUHAwgwDgYDVR0PAQH/
// SIG // BAQDAgeAMHMGCCsGAQUFBwEBBGcwZTAqBggrBgEFBQcw
// SIG // AYYeaHR0cDovL3RzLW9jc3Aud3Muc3ltYW50ZWMuY29t
// SIG // MDcGCCsGAQUFBzAChitodHRwOi8vdHMtYWlhLndzLnN5
// SIG // bWFudGVjLmNvbS90c3MtY2EtZzIuY2VyMDwGA1UdHwQ1
// SIG // MDMwMaAvoC2GK2h0dHA6Ly90cy1jcmwud3Muc3ltYW50
// SIG // ZWMuY29tL3Rzcy1jYS1nMi5jcmwwKAYDVR0RBCEwH6Qd
// SIG // MBsxGTAXBgNVBAMTEFRpbWVTdGFtcC0yMDQ4LTIwHQYD
// SIG // VR0OBBYEFEbGaaMOShQe1UzaUmMXP142vA3mMB8GA1Ud
// SIG // IwQYMBaAFF+a9W5czMx0mtTdfe8/2+xMgC7dMA0GCSqG
// SIG // SIb3DQEBBQUAA4IBAQB4O7SRKgBM8I9iMDd4o4QnB28Y
// SIG // st4l3KDUlAOqhk4ln5pAAxzdzuN5yyFoBtq2MrRtv/Qs
// SIG // JmMz5ElkbQ3mw2cO9wWkNWx8iRbG6bLfsundIMZxD82V
// SIG // dNy2XN69Nx9DeOZ4tc0oBCCjqvFLxIgpkQ6A0RH83Vx2
// SIG // bk9eDkVGQW4NsOo4mrE62glxEPwcebSAe6xp9P2ctgwW
// SIG // K/F/Wwk9m1viFsoTgW0ALjgNqCmPLOGy9FqpAa8VnCwv
// SIG // SRvbIrvD/niUUcOGsYKIXfA9tFGheTMrLnu53CAJE3Hr
// SIG // ahlbz+ilMFcsiUk/uc9/yb8+ImhjU5q9aXSsxR08f5Lg
// SIG // w7wc2AR1MIIFhTCCBG2gAwIBAgIQKcFbP6rNUmpOZ708
// SIG // Tn4/8jANBgkqhkiG9w0BAQUFADCBtDELMAkGA1UEBhMC
// SIG // VVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYD
// SIG // VQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTswOQYD
// SIG // VQQLEzJUZXJtcyBvZiB1c2UgYXQgaHR0cHM6Ly93d3cu
// SIG // dmVyaXNpZ24uY29tL3JwYSAoYykxMDEuMCwGA1UEAxMl
// SIG // VmVyaVNpZ24gQ2xhc3MgMyBDb2RlIFNpZ25pbmcgMjAx
// SIG // MCBDQTAeFw0xMjA3MjUwMDAwMDBaFw0xNTA5MjAyMzU5
// SIG // NTlaMIHIMQswCQYDVQQGEwJVUzETMBEGA1UECBMKQ2Fs
// SIG // aWZvcm5pYTETMBEGA1UEBxMKU2FuIFJhZmFlbDEWMBQG
// SIG // A1UEChQNQXV0b2Rlc2ssIEluYzE+MDwGA1UECxM1RGln
// SIG // aXRhbCBJRCBDbGFzcyAzIC0gTWljcm9zb2Z0IFNvZnR3
// SIG // YXJlIFZhbGlkYXRpb24gdjIxHzAdBgNVBAsUFkRlc2ln
// SIG // biBTb2x1dGlvbnMgR3JvdXAxFjAUBgNVBAMUDUF1dG9k
// SIG // ZXNrLCBJbmMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
// SIG // ggEKAoIBAQCoYmDrmd0Gq8ezSsDlfgaJFEFplNPNhWzM
// SIG // 2uFQaYAB/ggpQ11+N4B6ao+TqrNIWDIqt3JKhaU889nx
// SIG // l/7teWGwuOurstI2Z0bEDhXiXam/bicK2HVLyntliQ+6
// SIG // tT+nlgfN8tgB2NzM0BpE1YCnU2b6DwQw4V7BV+/F//83
// SIG // yGFOpePlumzXxNw9EKWkaq81slmmTxf7UxZgP9PGbLw8
// SIG // gLAPk4PTJI97+5BBqhkLb1YqSfWn3PNMfsNKhw/VwAN0
// SIG // dRKeM6H8SkOdz+osr+NyH86lsKQuics4fwK5uFSHQHsI
// SIG // t6Z0tqWvminRqceUi9ugRlGryh9X1ZqCqfL/ggdzYa3Z
// SIG // AgMBAAGjggF7MIIBdzAJBgNVHRMEAjAAMA4GA1UdDwEB
// SIG // /wQEAwIHgDBABgNVHR8EOTA3MDWgM6Axhi9odHRwOi8v
// SIG // Y3NjMy0yMDEwLWNybC52ZXJpc2lnbi5jb20vQ1NDMy0y
// SIG // MDEwLmNybDBEBgNVHSAEPTA7MDkGC2CGSAGG+EUBBxcD
// SIG // MCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LnZlcmlz
// SIG // aWduLmNvbS9ycGEwEwYDVR0lBAwwCgYIKwYBBQUHAwMw
// SIG // cQYIKwYBBQUHAQEEZTBjMCQGCCsGAQUFBzABhhhodHRw
// SIG // Oi8vb2NzcC52ZXJpc2lnbi5jb20wOwYIKwYBBQUHMAKG
// SIG // L2h0dHA6Ly9jc2MzLTIwMTAtYWlhLnZlcmlzaWduLmNv
// SIG // bS9DU0MzLTIwMTAuY2VyMB8GA1UdIwQYMBaAFM+Zqep7
// SIG // JvRLyY6P1/AFJu/j0qedMBEGCWCGSAGG+EIBAQQEAwIE
// SIG // EDAWBgorBgEEAYI3AgEbBAgwBgEBAAEB/zANBgkqhkiG
// SIG // 9w0BAQUFAAOCAQEA2OkGvuiY7TyI6yVTQAYmTO+MpOFG
// SIG // C8MflHSbofJiuLxrS1KXbkzsAPFPPsU1ouftFhsXFtDQ
// SIG // 8rMTq/jwugTpbJUREV0buEkLl8AKRhYQTKBKg1I/puBv
// SIG // bkJocDE0pRwtBz3xSlXXEwyYPcbCOnrM3OZ5bKx1Qiii
// SIG // vixlcGWhO3ws904ssutPFf4mV5PDi3U2Yp1HgbBK/Um/
// SIG // FLr6YAYeZaA8KY1CfQEisF3UKTwm72d7S+fJf++SOGea
// SIG // K0kumehVcbavQJTOVebuZ9V+qU0nk1lMrqve9BnQK69B
// SIG // QqNZu77vCO0wm81cfynAxkOYKZG3idY47qPJOgXKkwmI
// SIG // 2+92ozCCBgowggTyoAMCAQICEFIA5aolVvwahu2WydRL
// SIG // M8cwDQYJKoZIhvcNAQEFBQAwgcoxCzAJBgNVBAYTAlVT
// SIG // MRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjEfMB0GA1UE
// SIG // CxMWVmVyaVNpZ24gVHJ1c3QgTmV0d29yazE6MDgGA1UE
// SIG // CxMxKGMpIDIwMDYgVmVyaVNpZ24sIEluYy4gLSBGb3Ig
// SIG // YXV0aG9yaXplZCB1c2Ugb25seTFFMEMGA1UEAxM8VmVy
// SIG // aVNpZ24gQ2xhc3MgMyBQdWJsaWMgUHJpbWFyeSBDZXJ0
// SIG // aWZpY2F0aW9uIEF1dGhvcml0eSAtIEc1MB4XDTEwMDIw
// SIG // ODAwMDAwMFoXDTIwMDIwNzIzNTk1OVowgbQxCzAJBgNV
// SIG // BAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjEf
// SIG // MB0GA1UECxMWVmVyaVNpZ24gVHJ1c3QgTmV0d29yazE7
// SIG // MDkGA1UECxMyVGVybXMgb2YgdXNlIGF0IGh0dHBzOi8v
// SIG // d3d3LnZlcmlzaWduLmNvbS9ycGEgKGMpMTAxLjAsBgNV
// SIG // BAMTJVZlcmlTaWduIENsYXNzIDMgQ29kZSBTaWduaW5n
// SIG // IDIwMTAgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw
// SIG // ggEKAoIBAQD1I0tepdeKuzLp1Ff37+THJn6tGZj+qJ19
// SIG // lPY2axDXdYEwfwRof8srdR7NHQiM32mUpzejnHuA4Jnh
// SIG // 7jdNX847FO6G1ND1JzW8JQs4p4xjnRejCKWrsPvNamKC
// SIG // TNUh2hvZ8eOEO4oqT4VbkAFPyad2EH8nA3y+rn59wd35
// SIG // BbwbSJxp58CkPDxBAD7fluXF5JRx1lUBxwAmSkA8taEm
// SIG // qQynbYCOkCV7z78/HOsvlvrlh3fGtVayejtUMFMb32I0
// SIG // /x7R9FqTKIXlTBdOflv9pJOZf9/N76R17+8V9kfn+Bly
// SIG // 2C40Gqa0p0x+vbtPDD1X8TDWpjaO1oB21xkupc1+NC2J
// SIG // AgMBAAGjggH+MIIB+jASBgNVHRMBAf8ECDAGAQH/AgEA
// SIG // MHAGA1UdIARpMGcwZQYLYIZIAYb4RQEHFwMwVjAoBggr
// SIG // BgEFBQcCARYcaHR0cHM6Ly93d3cudmVyaXNpZ24uY29t
// SIG // L2NwczAqBggrBgEFBQcCAjAeGhxodHRwczovL3d3dy52
// SIG // ZXJpc2lnbi5jb20vcnBhMA4GA1UdDwEB/wQEAwIBBjBt
// SIG // BggrBgEFBQcBDARhMF+hXaBbMFkwVzBVFglpbWFnZS9n
// SIG // aWYwITAfMAcGBSsOAwIaBBSP5dMahqyNjmvDz4Bq1EgY
// SIG // LHsZLjAlFiNodHRwOi8vbG9nby52ZXJpc2lnbi5jb20v
// SIG // dnNsb2dvLmdpZjA0BgNVHR8ELTArMCmgJ6AlhiNodHRw
// SIG // Oi8vY3JsLnZlcmlzaWduLmNvbS9wY2EzLWc1LmNybDA0
// SIG // BggrBgEFBQcBAQQoMCYwJAYIKwYBBQUHMAGGGGh0dHA6
// SIG // Ly9vY3NwLnZlcmlzaWduLmNvbTAdBgNVHSUEFjAUBggr
// SIG // BgEFBQcDAgYIKwYBBQUHAwMwKAYDVR0RBCEwH6QdMBsx
// SIG // GTAXBgNVBAMTEFZlcmlTaWduTVBLSS0yLTgwHQYDVR0O
// SIG // BBYEFM+Zqep7JvRLyY6P1/AFJu/j0qedMB8GA1UdIwQY
// SIG // MBaAFH/TZafC3ey78DAJ80M5+gKvMzEzMA0GCSqGSIb3
// SIG // DQEBBQUAA4IBAQBWIuY0pMRhy0i5Aa1WqGQP2YyRxLvM
// SIG // DOWteqAif99HOEotbNF/cRp87HCpsfBP5A8MU/oVXv50
// SIG // mEkkhYEmHJEUR7BMY4y7oTTUxkXoDYUmcwPQqYxkbdxx
// SIG // kuZFBWAVWVE5/FgUa/7UpO15awgMQXLnNyIGCb4j6T9E
// SIG // mh7pYZ3MsZBc/D3SjaxCPWU21LQ9QCiPmxDPIybMSyDL
// SIG // kB9djEw0yjzY5TfWb6UgvTTrJtmuDefFmvehtCGRM2+G
// SIG // 6Fi7JXx0Dlj+dRtjP84xfJuPG5aexVN2hFucrZH6rO2T
// SIG // ul3IIVPCglNjrxINUIcRGz1UUpaKLJw9khoImgUux5Ol
// SIG // SJHTMYIEcjCCBG4CAQEwgckwgbQxCzAJBgNVBAYTAlVT
// SIG // MRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjEfMB0GA1UE
// SIG // CxMWVmVyaVNpZ24gVHJ1c3QgTmV0d29yazE7MDkGA1UE
// SIG // CxMyVGVybXMgb2YgdXNlIGF0IGh0dHBzOi8vd3d3LnZl
// SIG // cmlzaWduLmNvbS9ycGEgKGMpMTAxLjAsBgNVBAMTJVZl
// SIG // cmlTaWduIENsYXNzIDMgQ29kZSBTaWduaW5nIDIwMTAg
// SIG // Q0ECECnBWz+qzVJqTme9PE5+P/IwCQYFKw4DAhoFAKBw
// SIG // MBAGCisGAQQBgjcCAQwxAjAAMBkGCSqGSIb3DQEJAzEM
// SIG // BgorBgEEAYI3AgEEMBwGCisGAQQBgjcCAQsxDjAMBgor
// SIG // BgEEAYI3AgEVMCMGCSqGSIb3DQEJBDEWBBSI/UqHdkUS
// SIG // Hgg9VNTXVF61uC4wWjANBgkqhkiG9w0BAQEFAASCAQAs
// SIG // OtHSnEkQfJt9IxjmshozWzKuKbxRnQzXNIBTzs6dBeha
// SIG // glAN3SAyt/EVhvGQvklcdwI+BLAOB8u0xTwU6/mdjcSB
// SIG // 1TJQqOqokJSh/lW7nOT95HsfqF9j8IGuPtz5LxpM9cg6
// SIG // zQ7zaWgniLln0gGHt0fwtbHLQLdaffXfPmbn8/CExgAs
// SIG // S55MK7WmrgXTuFFwx77Uz+AKIftW8/pViE96+9MR3zFv
// SIG // xGDErgBNGBzlwfX+N4lYO65JMW89PuCdUeGCvVf7mxqc
// SIG // va7bNobOatUdMP9v0ABNtCL/+gc1o6NDFNgBwS+pAJ4+
// SIG // OUzGA3m9GyHeS1xT7IszDsDICigS03efoYICCzCCAgcG
// SIG // CSqGSIb3DQEJBjGCAfgwggH0AgEBMHIwXjELMAkGA1UE
// SIG // BhMCVVMxHTAbBgNVBAoTFFN5bWFudGVjIENvcnBvcmF0
// SIG // aW9uMTAwLgYDVQQDEydTeW1hbnRlYyBUaW1lIFN0YW1w
// SIG // aW5nIFNlcnZpY2VzIENBIC0gRzICEA7P9DjI/r81bgTY
// SIG // apgbGlAwCQYFKw4DAhoFAKBdMBgGCSqGSIb3DQEJAzEL
// SIG // BgkqhkiG9w0BBwEwHAYJKoZIhvcNAQkFMQ8XDTE1MDIw
// SIG // NjA0NDMxN1owIwYJKoZIhvcNAQkEMRYEFMayzgn7GJaU
// SIG // pV+dQXeLZq73gFeiMA0GCSqGSIb3DQEBAQUABIIBABiS
// SIG // c1JttM4EyMIbwUHJGb5OaZ9YsK5JyMpBzbOVxpbHUjt4
// SIG // X5B/fihavJ20MkSxDVNtxa//APkyT5klqWUWmW9XZfTa
// SIG // 3on8MhJw7ppNbjFdbGK75wAfimngJmYwGuiUnB9PwXqw
// SIG // Lp3NYNZHMWMvbi2/yHK51/tkNY9ECGTG/s2+qjyrESai
// SIG // 5Ho34ncZiJ5SVjzU98gKQbuKTtJma6kcioCCL/jP0GZh
// SIG // /Q6HRYYTEx9gtRjlduruAN3mg3ES3Hd0GmalXzr+ARZj
// SIG // 9bRcAKt9FuMwlfh6ChAihkCACn8VLfJ2JY7tOeaPqHG8
// SIG // Sbs80TkumsAXN+HAUCeWweFw4feJxUo=
// SIG // End signature block