@mlightcad/data-model 1.0.0

package/lib/database/AcDbDimStyleTableRecord.js

@@ -0,0 +1,1250 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { defaults } from 'lodash-es';
+import { AcDbSymbolTableRecord } from './AcDbSymbolTableRecord';
+export var AcDbDimTextHorizontal;
+(function (AcDbDimTextHorizontal) {
+    AcDbDimTextHorizontal[AcDbDimTextHorizontal["Center"] = 0] = "Center";
+    AcDbDimTextHorizontal[AcDbDimTextHorizontal["Left"] = 1] = "Left";
+    AcDbDimTextHorizontal[AcDbDimTextHorizontal["Right"] = 2] = "Right";
+    AcDbDimTextHorizontal[AcDbDimTextHorizontal["OverFirst"] = 3] = "OverFirst";
+    AcDbDimTextHorizontal[AcDbDimTextHorizontal["OverSecond"] = 4] = "OverSecond";
+})(AcDbDimTextHorizontal || (AcDbDimTextHorizontal = {}));
+export var AcDbDimTextVertical;
+(function (AcDbDimTextVertical) {
+    AcDbDimTextVertical[AcDbDimTextVertical["Center"] = 0] = "Center";
+    AcDbDimTextVertical[AcDbDimTextVertical["Above"] = 1] = "Above";
+    AcDbDimTextVertical[AcDbDimTextVertical["Outside"] = 2] = "Outside";
+    AcDbDimTextVertical[AcDbDimTextVertical["JIS"] = 3] = "JIS";
+    AcDbDimTextVertical[AcDbDimTextVertical["Below"] = 4] = "Below";
+})(AcDbDimTextVertical || (AcDbDimTextVertical = {}));
+export var AcDbDimZeroSuppression;
+(function (AcDbDimZeroSuppression) {
+    AcDbDimZeroSuppression[AcDbDimZeroSuppression["Feet"] = 0] = "Feet";
+    AcDbDimZeroSuppression[AcDbDimZeroSuppression["None"] = 1] = "None";
+    AcDbDimZeroSuppression[AcDbDimZeroSuppression["Inch"] = 2] = "Inch";
+    AcDbDimZeroSuppression[AcDbDimZeroSuppression["FeetAndInch"] = 3] = "FeetAndInch";
+    AcDbDimZeroSuppression[AcDbDimZeroSuppression["Leading"] = 4] = "Leading";
+    AcDbDimZeroSuppression[AcDbDimZeroSuppression["Trailing"] = 8] = "Trailing";
+    AcDbDimZeroSuppression[AcDbDimZeroSuppression["LeadingAndTrailing"] = 12] = "LeadingAndTrailing";
+})(AcDbDimZeroSuppression || (AcDbDimZeroSuppression = {}));
+export var AcDbDimZeroSuppressionAngular;
+(function (AcDbDimZeroSuppressionAngular) {
+    AcDbDimZeroSuppressionAngular[AcDbDimZeroSuppressionAngular["None"] = 0] = "None";
+    AcDbDimZeroSuppressionAngular[AcDbDimZeroSuppressionAngular["Leading"] = 1] = "Leading";
+    AcDbDimZeroSuppressionAngular[AcDbDimZeroSuppressionAngular["Trailing"] = 2] = "Trailing";
+    AcDbDimZeroSuppressionAngular[AcDbDimZeroSuppressionAngular["LeadingAndTrailing"] = 3] = "LeadingAndTrailing";
+})(AcDbDimZeroSuppressionAngular || (AcDbDimZeroSuppressionAngular = {}));
+export var AcDbDimVerticalJustification;
+(function (AcDbDimVerticalJustification) {
+    AcDbDimVerticalJustification[AcDbDimVerticalJustification["Bottom"] = 0] = "Bottom";
+    AcDbDimVerticalJustification[AcDbDimVerticalJustification["Middle"] = 1] = "Middle";
+    AcDbDimVerticalJustification[AcDbDimVerticalJustification["Top"] = 2] = "Top";
+})(AcDbDimVerticalJustification || (AcDbDimVerticalJustification = {}));
+/**
+ * Objects of this class represent the records found in the dimension style table. Each of these
+ * records contains the information necessary to generate a specific appearance (that is, text
+ * above, in, or below the line; arrows, slashes, or dots at the end of the dimension line, and
+ * so on) for dimensions that reference it.
+ */
+var AcDbDimStyleTableRecord = /** @class */ (function (_super) {
+    __extends(AcDbDimStyleTableRecord, _super);
+    function AcDbDimStyleTableRecord(attrs, defaultAttrs) {
+        attrs = attrs || {};
+        defaults(attrs, AcDbDimStyleTableRecord.DEFAULT_DIM_VALUES);
+        return _super.call(this, attrs, defaultAttrs) || this;
+    }
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimpost", {
+        /**
+         * Dimension postfix. This property specifies a text prefix or suffix (or both) to the dimension
+         * measurement.
+         * For example, to establish a suffix for millimeters, set DIMPOST to mm; a distance of 19.2 units
+         * would be displayed as 19.2 mm.
+         * If tolerances are turned on, the suffix is applied to the tolerances as well as to the main
+         * dimension. Use <> to indicate placement of the text in relation to the dimension value. For
+         * example, enter <>mm to display a 5.0 millimeter radial dimension as "5.0mm". If you entered
+         * mm <>, the dimension would be displayed as "mm 5.0". Use the <> mechanism for angular
+         * dimensions.
+         */
+        get: function () {
+            return this.getAttr('dimpost');
+        },
+        set: function (value) {
+            this.setAttr('dimpost', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimapost", {
+        /**
+         * Dimension append postfix. This property specifies a text prefix or suffix (or both) to the
+         * alternate dimension measurement for all types of dimensions except angular.
+         * For instance, if the current units are Architectural, DIMALT is on, DIMALTF is 25.4 (the
+         * number of millimeters per inch), DIMALTD is 2, and DIMAPOST is set to "mm", a distance of 10
+         * units would be displayed as 10"[254.00mm].
+         * To turn off an established prefix or suffix (or both), set it to a single period (.).
+         */
+        get: function () {
+            return this.getAttr('dimapost');
+        },
+        set: function (value) {
+            this.setAttr('dimapost', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimscale", {
+        /**
+         * Dimension scale. This property controls the scale factor for dimensioning objects. If you need
+         * to adjust the scale of your dimensions, you can change this value to better fit your drawing's
+         * scale.
+         */
+        get: function () {
+            return this.getAttr('dimscale');
+        },
+        set: function (value) {
+            this.setAttr('dimscale', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimasz", {
+        /**
+         * Dimension arrow size. This property controls the size of the arrowheads used in dimensions. You
+         * can modify this value to adjust the size of arrowheads based on your drawing's requirements.
+         */
+        get: function () {
+            return this.getAttr('dimasz');
+        },
+        set: function (value) {
+            this.setAttr('dimasz', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimexo", {
+        /**
+         * Dimension extension line offset. This property controls the offset distance from the origin point
+         * to where the extension line starts. You can adjust it to control how far the extension line is set
+         * back from the object being dimensioned.
+         */
+        get: function () {
+            return this.getAttr('dimexo');
+        },
+        set: function (value) {
+            this.setAttr('dimexo', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimdli", {
+        /**
+         * Dimension line Increment. This property controls the spacing between the dimension lines when you
+         * create multiple parallel dimensions using the baseline dimensioning method.
+         */
+        get: function () {
+            return this.getAttr('dimdli');
+        },
+        set: function (value) {
+            this.setAttr('dimdli', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimexe", {
+        /**
+         * Dimension extension line extension. This property controls how far beyond the dimension line the
+         * extension lines extend. You can adjust this value to control the length of the extension line
+         * past the dimension line.
+         */
+        get: function () {
+            return this.getAttr('dimexe');
+        },
+        set: function (value) {
+            this.setAttr('dimexe', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimrnd", {
+        /**
+         * Dimension rounding. This property controls the rounding of dimension distances to a specified value.
+         * When set to 0.0, no rounding occurs, and the dimension is displayed with its exact value. You can
+         * set it to a non-zero value to round dimensions to a specific increment.
+         */
+        get: function () {
+            return this.getAttr('dimrnd');
+        },
+        set: function (value) {
+            this.setAttr('dimrnd', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimdle", {
+        /**
+         * Dimension line extension. This property controls how far the dimension line is extended beyond
+         * the extension lines. By default, the dimension line ends at the extension lines, but you can
+         * adjust this value to extend the dimension line beyond them.
+         */
+        get: function () {
+            return this.getAttr('dimdle');
+        },
+        set: function (value) {
+            this.setAttr('dimdle', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtp", {
+        /**
+         * Dimension text post. This property controls the tolerance value added after the dimension text,
+         * typically used for specifying tolerance values in dimensions. The default setting of 0.0 means
+         * that no additional tolerance is applied by default.
+         */
+        get: function () {
+            return this.getAttr('dimtp');
+        },
+        set: function (value) {
+            this.setAttr('dimtp', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtm", {
+        /**
+         * Dimension minus tolerance. This property controls the lower tolerance limit for dimensions. When
+         * set to 0.0, no minus tolerance is applied by default. You can set this to a different value if
+         * you need to specify a negative tolerance for your dimensions.
+         */
+        get: function () {
+            return this.getAttr('dimtm');
+        },
+        set: function (value) {
+            this.setAttr('dimtm', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtxt", {
+        /**
+         * Dimension text height. This property controls the height of the dimension text. You can adjust
+         * this value to change the size of the text in your dimensions to fit the scale and appearance of
+         * your drawing.
+         */
+        get: function () {
+            return this.getAttr('dimtxt');
+        },
+        set: function (value) {
+            this.setAttr('dimtxt', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimcen", {
+        /**
+         * Dimension center mark size. This property controls the size of the center marks or centerlines
+         * for circles and arcs in dimensions. A positive value specifies the size of the center mark,
+         * while a negative value specifies the size of the centerline. If set to 0, no center mark or
+         * centerline is drawn.
+         */
+        get: function () {
+            return this.getAttr('dimcen');
+        },
+        set: function (value) {
+            this.setAttr('dimcen', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtsz", {
+        /**
+         * Dimension tick size. When set to 0.0, no tick marks are displayed, and the default arrowheads are
+         * used for dimension lines. If you set it to a positive value, it will display tick marks instead
+         * of arrowheads, with the value controlling the size of the ticks.
+         */
+        get: function () {
+            return this.getAttr('dimtsz');
+        },
+        set: function (value) {
+            this.setAttr('dimtsz', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimaltf", {
+        /**
+         * Alternate dimensioning. The default value of DIMALT is set to 0 for DIMALTF (Dimension Alternate
+         * Text Format), which means that alternate dimensions are not displayed by default.
+         * When DIMALT is set to 1, it indicates that alternate dimensioning is enabled, and you can use
+         * DIMALTF to specify the format of the alternate dimension text. You can set it to various values
+         * depending on how you want the alternate dimensions to be displayed.
+         */
+        get: function () {
+            return this.getAttr('dimaltf');
+        },
+        set: function (value) {
+            this.setAttr('dimaltf', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimlfac", {
+        /**
+         * Dimension linear factor. This property controls the scaling factor for linear dimensions. If you
+         * want to adjust the size of linear dimensions without changing the actual dimension text height or
+         * other dimension settings, you can modify this value. A setting of 1.0 means that dimensions are
+         * displayed at their actual size.
+         */
+        get: function () {
+            return this.getAttr('dimlfac');
+        },
+        set: function (value) {
+            this.setAttr('dimlfac', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtvp", {
+        /**
+         * Dimension text vertical position. This property controls the vertical position of dimension text
+         * relative to the dimension line. A value of 0.0 means that the dimension text is placed directly
+         * on the dimension line. You can adjust this value to change the vertical offset of the dimension
+         * text above or below the dimension line.
+         */
+        get: function () {
+            return this.getAttr('dimtvp');
+        },
+        set: function (value) {
+            this.setAttr('dimtvp', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtfac", {
+        /**
+         * Dimension text factor. This property is used to scale the height of dimension text based on the
+         * current DIMTXT value. If you set DIMTFAC to a value greater than 1.0, the dimension text will be
+         * larger than the default height specified by DIMTXT. Conversely, setting it to a value less than
+         * 1.0 will make the text smaller.
+         */
+        get: function () {
+            return this.getAttr('dimtfac');
+        },
+        set: function (value) {
+            this.setAttr('dimtfac', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimgap", {
+        /**
+         * Dimension gap. This property controls the distance between the dimension line and the extension
+         * lines. You can adjust this value to create more space or less space between these elements in
+         * your dimensions.
+         */
+        get: function () {
+            return this.getAttr('dimgap');
+        },
+        set: function (value) {
+            this.setAttr('dimgap', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimaltrnd", {
+        /**
+         * Dimension alternate rounding. This property controls rounds off the alternate dimension units.
+         */
+        get: function () {
+            return this.getAttr('dimaltrnd');
+        },
+        set: function (value) {
+            this.setAttr('dimaltrnd', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtol", {
+        /**
+         * Dimension tolerance. This property determines whether to appends tolerances to dimension text.
+         * Setting DIMTOL to on (1) turns DIMLIM off (0).
+         */
+        get: function () {
+            return this.getAttr('dimtol');
+        },
+        set: function (value) {
+            this.setAttr('dimtol', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimlim", {
+        /**
+         * Dimension limit. This property determines whether to generate dimension limits as the default
+         * text. Setting DIMLIM to On turns DIMTOL off.
+         * - 0: Dimension limits are not generated as default text
+         * - 1: Dimension limits are generated as default text
+         */
+        get: function () {
+            return this.getAttr('dimlim');
+        },
+        set: function (value) {
+            this.setAttr('dimlim', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtih", {
+        /**
+         * Dimension text inside horizontal. This property controls the position of dimension text inside the
+         * extension lines for all dimension types except Ordinate.
+         * - 0: Aligns text with the dimension line
+         * - 1: Draws text horizontally
+         */
+        get: function () {
+            return this.getAttr('dimtih');
+        },
+        set: function (value) {
+            this.setAttr('dimtih', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtoh", {
+        /**
+         * Dimension text outside horizontal. This property controls the position of dimension text
+         * outside the extension lines.
+         * - 0: Aligns text with the dimension line
+         * - 1: Draws text horizontally
+         */
+        get: function () {
+            return this.getAttr('dimtoh');
+        },
+        set: function (value) {
+            this.setAttr('dimtoh', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimse1", {
+        /**
+         * Dimension suppress extension line 1. This property controls whether to suppresses display of the
+         * first extension line.
+         * - 0: Extension line is not suppressed
+         * - 1: Extension line is suppressed
+         */
+        get: function () {
+            return this.getAttr('dimse1');
+        },
+        set: function (value) {
+            this.setAttr('dimse1', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimse2", {
+        /**
+         * Dimension suppress extension line 2. This property controls whether to suppresses display of the
+         * second extension line.
+         * - 0: Extension line is not suppressed
+         * - 1: Extension line is suppressed
+         */
+        get: function () {
+            return this.getAttr('dimse2');
+        },
+        set: function (value) {
+            this.setAttr('dimse2', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtad", {
+        /**
+         * Dimension text above dimension line. This property the vertical position of text in relation to
+         * the dimension line.
+         * - 0: Centers the dimension text between the extension lines.
+         * - 1: Places the dimension text above the dimension line except when the dimension line is not
+         * horizontal and text inside the extension lines is forced horizontal ( DIMTIH = 1). The distance
+         * from the dimension line to the baseline of the lowest line of text is the current DIMGAP value.
+         * - 2: Places the dimension text on the side of the dimension line farthest away from the defining
+         * points.
+         * - 3: Places the dimension text to conform to Japanese Industrial Standards (JIS).
+         * - 4: Places the dimension text below the dimension line.
+         */
+        get: function () {
+            return this.getAttr('dimtad');
+        },
+        set: function (value) {
+            this.setAttr('dimtad', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimzin", {
+        /**
+         * Dimension zero-in. This property controls the suppression of zeros in the primary unit value.
+         * - 0: Suppresses zero feet and precisely zero inches
+         * - 1: Includes zero feet and precisely zero inches
+         * - 2: Includes zero feet and suppresses zero inches
+         * - 3: Includes zero inches and suppresses zero feet
+         * - 4: Suppresses leading zeros in decimal dimensions (for example, 0.5000 becomes .5000)
+         * - 8: Suppresses trailing zeros in decimal dimensions (for example, 12.5000 becomes 12.5)
+         * - 12: Suppresses both leading and trailing zeros (for example, 0.5000 becomes .5)
+         */
+        get: function () {
+            return this.getAttr('dimzin');
+        },
+        set: function (value) {
+            this.setAttr('dimzin', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimazin", {
+        /**
+         * Dimension zero-in for angular dimensions.
+         * - 0: Displays all leading and trailing zeros
+         * - 1: Suppresses leading zeros in decimal dimensions (for example, 0.5000 becomes .5000)
+         * - 2: Suppresses trailing zeros in decimal dimensions (for example, 12.5000 becomes 12.5)
+         * - 3: Suppresses leading and trailing zeros (for example, 0.5000 becomes .5)
+         */
+        get: function () {
+            return this.getAttr('dimazin');
+        },
+        set: function (value) {
+            this.setAttr('dimazin', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimalt", {
+        /**
+         * Dimension angular zero-in. This property controls the display of alternate units in dimensions.
+         * - 0: Disables alternate units
+         * - 1: Enables alternate units
+         */
+        get: function () {
+            return this.getAttr('dimalt');
+        },
+        set: function (value) {
+            this.setAttr('dimalt', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimaltd", {
+        /**
+         * Dimension alternate dimension. This property controls the number of decimal places in alternate
+         * units. If DIMALT is turned on, DIMALTD sets the number of digits displayed to the right of the
+         * decimal point in the alternate measurement.
+         */
+        get: function () {
+            return this.getAttr('dimaltd');
+        },
+        set: function (value) {
+            this.setAttr('dimaltd', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtofl", {
+        /**
+         * Dimension to first extension line. This property controls whether a dimension line is drawn
+         * between the extension lines even when the text is placed outside. For radius and diameter
+         * dimensions, a dimension line is drawn inside the circle or arc when the text, arrowheads,
+         * and leader are placed outside.
+         * - 0: Does not draw dimension lines between the measured points when arrowheads are placed
+         * outside the measured points
+         * - 1: Draws dimension lines between the measured points even when arrowheads are placed
+         * outside the measured points
+         */
+        get: function () {
+            return this.getAttr('dimtofl');
+        },
+        set: function (value) {
+            this.setAttr('dimtofl', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimsah", {
+        /**
+         * Dimension suppress arrowheads. This property controls the display of dimension line arrowhead blocks.
+         * - 0: Use arrowhead blocks set by DIMBLK
+         * - 1: Use arrowhead blocks set by DIMBLK1 and DIMBLK2
+         */
+        get: function () {
+            return this.getAttr('dimsah');
+        },
+        set: function (value) {
+            this.setAttr('dimsah', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtix", {
+        /**
+         * Dimension text inside extension lines. This property controls the position of dimension text
+         * relative to the extension lines.
+         * - 0: For linear and angular dimensions, dimension text is placed inside the extension lines if
+         * there is sufficient room.
+         * - 1: Draws dimension text between the extension lines even if it would ordinarily be placed
+         * outside those lines. For radius and diameter dimensions, DIMTIX on always forces the dimension
+         * text outside the circle or arc.
+         */
+        get: function () {
+            return this.getAttr('dimtix');
+        },
+        set: function (value) {
+            this.setAttr('dimtix', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimsoxd", {
+        /**
+         * Dimension suppress offset x-direction. This property controls whether to suppresses arrowheads
+         * if not enough space is available inside the extension lines.
+         * If not enough space is available inside the extension lines and DIMTIX is on, setting DIMSOXD to
+         * On suppresses the arrowheads. If DIMTIX is off, DIMSOXD has no effect.
+         * - 0: Arrowheads are not suppressed
+         * - 1: Arrowheads are suppressed
+         */
+        get: function () {
+            return this.getAttr('dimsoxd');
+        },
+        set: function (value) {
+            this.setAttr('dimsoxd', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimclrd", {
+        /**
+         * Dimension color. This property controls colors to dimension lines, arrowheads, and dimension leader
+         * lines. For BYBLOCK, enter 0. For BYLAYER, enter 256.
+         */
+        get: function () {
+            return this.getAttr('dimclrd');
+        },
+        set: function (value) {
+            this.setAttr('dimclrd', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimclre", {
+        /**
+         * Dimension extension line color. This property controls colors to extension lines, center marks,
+         * and centerlines. For BYBLOCK, enter 0. For BYLAYER, enter 256.
+         */
+        get: function () {
+            return this.getAttr('dimclre');
+        },
+        set: function (value) {
+            this.setAttr('dimclre', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimclrt", {
+        /**
+         * Dimension text color. This property controls colors to dimension text. For BYBLOCK, enter 0.
+         * For BYLAYER, enter 256.
+         */
+        get: function () {
+            return this.getAttr('dimclrt');
+        },
+        set: function (value) {
+            this.setAttr('dimclrt', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimadec", {
+        /**
+         * Dimension angular decimal places. This property controls the number of precision places displayed
+         * in angular dimensions.
+         * - 1: Angular dimensions display the number of decimal places specified by DIMDEC
+         * - 0-8: Specifies the number of decimal places displayed in angular dimensions (independent of DIMDEC)
+         */
+        get: function () {
+            return this.getAttr('dimadec');
+        },
+        set: function (value) {
+            this.setAttr('dimadec', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimunit", {
+        /**
+         * Dimension linear units. This property controls the format in which linear dimensions are displayed.
+         * The value of this property include:
+         * - 1: Scientific
+         * - 2: Decimal
+         * - 3: Engineering
+         * - 4: Architectural (always displayed stacked)
+         * - 5: Fractional (always displayed stacked)
+         * - 6: Microsoft Windows Desktop (decimal format using Control Panel settings for decimal separator
+         * and number grouping symbols)
+         */
+        get: function () {
+            return this.getAttr('dimunit');
+        },
+        set: function (value) {
+            this.setAttr('dimunit', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimdec", {
+        /**
+         * Dimension decimal places. This property controls the number of decimal places displayed for the
+         * primary units of a dimension. Its initial value is	4 for imperial unit or 2 for metric unit.
+         * The precision is based on the units or angle format you have selected. Specified value is applied
+         * to angular dimensions when DIMADEC is set to -1.
+         */
+        get: function () {
+            return this.getAttr('dimdec');
+        },
+        set: function (value) {
+            this.setAttr('dimdec', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtdec", {
+        /**
+         * Dimension tolerance decimal places. This property controls the number of decimal places to display
+         * in tolerance values for the primary units in a dimension. This property has no effect unless DIMTOL
+         * is set to On. The default for DIMTOL is Off.
+         */
+        get: function () {
+            return this.getAttr('dimtdec');
+        },
+        set: function (value) {
+            this.setAttr('dimtdec', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimaltu", {
+        /**
+         * Dimension alternate unit format. This property controls the units format for alternate units of
+         * all dimension substyles except Angular. The value of this property include:
+         * - 1: Scientific
+         * - 2: Decimal
+         * - 3: Engineering
+         * - 4: Architectural (stacked)
+         * - 5: Fractional (stacked)
+         * - 6: Architectural
+         * - 7: Fractional
+         * - 8: Microsoft Windows Desktop (decimal format using Control Panel settings for decimal separator
+         * and number grouping symbols)
+         */
+        get: function () {
+            return this.getAttr('dimaltu');
+        },
+        set: function (value) {
+            this.setAttr('dimaltu', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimalttd", {
+        /**
+         * Dimension alternate tolerance decimal places. This property controls the number of decimal places
+         * for the tolerance values in the alternate units of a dimension.
+         */
+        get: function () {
+            return this.getAttr('dimalttd');
+        },
+        set: function (value) {
+            this.setAttr('dimalttd', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimaunit", {
+        /**
+         * Dimension angular units. This property controls the units format for angular dimensions.
+         * - 0: Decimal degrees
+         * - 1: Degrees/minutes/seconds
+         * - 2: Gradians
+         * - 3: Radians
+         */
+        get: function () {
+            return this.getAttr('dimaunit');
+        },
+        set: function (value) {
+            this.setAttr('dimaunit', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimfrac", {
+        /**
+         * Dimension fraction format. This property controls the fraction format when DIMLUNIT is set to 4
+         * (Architectural) or 5 (Fractional).
+         * - 0: Horizontal stacking
+         * - 1: Diagonal stacking
+         * - 2: Not stacked (for example, 1/2)
+         */
+        get: function () {
+            return this.getAttr('dimfrac');
+        },
+        set: function (value) {
+            this.setAttr('dimfrac', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimlunit", {
+        /**
+         * Dimension linear units. This property controls units for all dimension types except angular.
+         * The value of this property include:
+         * - 1: Scientific
+         * - 2: Decimal
+         * - 3: Engineering
+         * - 4: Architectural (always displayed stacked)
+         * - 5: Fractional (always displayed stacked)
+         * - 6: Microsoft Windows Desktop (decimal format using Control Panel settings for decimal separator
+         * and number grouping symbols)
+         */
+        get: function () {
+            return this.getAttr('dimlunit');
+        },
+        set: function (value) {
+            this.setAttr('dimlunit', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimdsep", {
+        /**
+         * Dimension decimal separator. This property is used to specifies a single-character decimal separator
+         * to use when creating dimensions whose unit format is decimal.
+         */
+        get: function () {
+            return this.getAttr('dimdsep');
+        },
+        set: function (value) {
+            this.setAttr('dimdsep', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtmove", {
+        /**
+         * Dimension text movement. This property is used to set dimension text movement rules.
+         * - 0: Moves the dimension line with dimension text
+         * - 1: Adds a leader when dimension text is moved
+         * - 2: Allows text to be moved freely without a leader
+         */
+        get: function () {
+            return this.getAttr('dimtmove');
+        },
+        set: function (value) {
+            this.setAttr('dimtmove', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimjust", {
+        /**
+         * Dimension text justification. This property controls the horizontal positioning of dimension text.
+         * - 0: Positions the text above the dimension line and center-justifies it between the extension lines
+         * - 1: Positions the text next to the first extension line
+         * - 2: Positions the text next to the second extension line
+         * - 3: Positions the text above and aligned with the first extension line
+         * - 4: Positions the text above and aligned with the second extension line
+         */
+        get: function () {
+            return this.getAttr('dimjust');
+        },
+        set: function (value) {
+            this.setAttr('dimjust', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimsd1", {
+        /**
+         * Suppress first dimension line. This property controls suppression of the first dimension line
+         * and arrowhead. When turned on, suppresses the display of the dimension line and arrowhead
+         * between the first extension line and the text.
+         * - 0: First dimension line is not suppressed
+         * - 1: First dimension line is suppressed
+         */
+        get: function () {
+            return this.getAttr('dimsd1');
+        },
+        set: function (value) {
+            this.setAttr('dimsd1', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimsd2", {
+        /**
+         * Suppress second dimension line. This property controls suppression of the second dimension line
+         * and arrowhead. When turned on, suppresses the display of the dimension line and arrowhead
+         * between the second extension line and the text.
+         * - 0: Second dimension line is not suppressed
+         * - 1: Second dimension line is suppressed
+         */
+        get: function () {
+            return this.getAttr('dimsd2');
+        },
+        set: function (value) {
+            this.setAttr('dimsd2', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtolj", {
+        /**
+         * Dimension tolerance justification. This property sets the vertical justification for tolerance
+         * values relative to the nominal dimension text. This property has no effect unless DIMTOL is set
+         * to On. The default for DIMTOL is Off.
+         * - 0: Bottom
+         * - 1: Middle
+         * - 2: Top
+         */
+        get: function () {
+            return this.getAttr('dimtolj');
+        },
+        set: function (value) {
+            this.setAttr('dimtolj', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtzin", {
+        /**
+         * Dimension tolerance zero suppress. This property controls the suppression of zeros in tolerance values.
+         * Values 0-3 affect feet-and-inch dimensions only.
+         * - 0: Suppresses zero feet and precisely zero inches
+         * - 1: Includes zero feet and precisely zero inches
+         * - 2: Includes zero feet and suppresses zero inches
+         * - 3: Includes zero inches and suppresses zero feet
+         * - 4: Suppresses leading zeros in decimal dimensions (for example, 0.5000 becomes .5000)
+         * - 8: Suppresses trailing zeros in decimal dimensions (for example, 12.5000 becomes 12.5)
+         * - 12: Suppresses both leading and trailing zeros (for example, 0.5000 becomes .5)
+         */
+        get: function () {
+            return this.getAttr('dimtzin');
+        },
+        set: function (value) {
+            this.setAttr('dimtzin', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimaltz", {
+        /**
+         * Dimension alternate unit zero suppress. This property controls the suppression of zeros for
+         * alternate unit dimension values. DIMALTZ values 0-3 affect feet-and-inch dimensions only.
+         * - 0: Suppresses zero feet and precisely zero inches
+         * - 1: Includes zero feet and precisely zero inches
+         * - 2: Includes zero feet and suppresses zero inches
+         * - 3: Includes zero inches and suppresses zero feet
+         * - 4: Suppresses leading zeros in decimal dimensions (for example, 0.5000 becomes .5000)
+         * - 8: Suppresses trailing zeros in decimal dimensions (for example, 12.5000 becomes 12.5)
+         * - 12: Suppresses both leading and trailing zeros (for example, 0.5000 becomes .5)
+         */
+        get: function () {
+            return this.getAttr('dimaltz');
+        },
+        set: function (value) {
+            this.setAttr('dimaltz', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimalttz", {
+        /**
+         * Dimension alternate tolerance zero suppress. This property controls suppression of zeros in
+         * tolerance values.
+         * - 0: Suppresses zero feet and precisely zero inches
+         * - 1: Includes zero feet and precisely zero inches
+         * - 2: Includes zero feet and suppresses zero inches
+         * - 3: Includes zero inches and suppresses zero feet
+         *
+         * To suppress leading or trailing zeros, add the following values to one of the preceding values:
+         * - 4: Suppresses leading zeros
+         * - 8: Suppresses trailing zeros
+         */
+        get: function () {
+            return this.getAttr('dimalttz');
+        },
+        set: function (value) {
+            this.setAttr('dimalttz', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimfit", {
+        /**
+         * Dimension fit. This property controls how dimension text fits within the dimension line.
+         * The value of this property include:
+         * - 0: Fit (default) – The dimension text is placed outside the dimension lines if it does not fit inside.
+         * - 1: Above – The dimension text is placed above the dimension line.
+         * - 2: Center – The dimension text is centered between the extension lines.
+         * With the default setting of 0, the software automatically positions the dimension text based on
+         * available space.
+         */
+        get: function () {
+            return this.getAttr('dimfit');
+        },
+        set: function (value) {
+            this.setAttr('dimfit', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimupt", {
+        /**
+         * Dimension update. This property controls options for user-positioned text.
+         * - 0: Cursor controls only the dimension line location
+         * - 1: Cursor controls both the text position and the dimension line location
+         */
+        get: function () {
+            return this.getAttr('dimupt');
+        },
+        set: function (value) {
+            this.setAttr('dimupt', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimatfit", {
+        /**
+         * Dimension angular tolerance fit. This property determines how dimension text and arrows are
+         * arranged when space is not sufficient to place both within the extension lines.
+         * - 0: Places both text and arrows outside extension lines
+         * - 1: Moves arrows first, then text
+         * - 2: Moves text first, then arrows
+         * - 3: Moves either text or arrows, whichever fits best
+         * A leader is added to moved dimension text when DIMTMOVE is set to 1.
+         */
+        get: function () {
+            return this.getAttr('dimatfit');
+        },
+        set: function (value) {
+            this.setAttr('dimatfit', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimtxsty", {
+        /**
+         * Dimension text style. This property specifies the text style of the dimension.
+         */
+        get: function () {
+            return this.getAttr('dimtxsty');
+        },
+        set: function (value) {
+            this.setAttr('dimtxsty', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimldrblk", {
+        /**
+         * Dimension leader block. This property specifies the arrow type for leaders. To return to the
+         * default, closed-filled arrowhead display, enter a single period (.). For a list of arrowhead
+         * entries, see DIMBLK.
+         * Note: Annotative blocks cannot be used as custom arrowheads for dimensions or leaders.
+         */
+        get: function () {
+            return this.getAttr('dimldrblk');
+        },
+        set: function (value) {
+            this.setAttr('dimldrblk', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimblk", {
+        /**
+         * Dimension arrowhead block. This property controls the arrowhead block displayed at the ends of
+         * dimension lines.
+         */
+        get: function () {
+            return this.getAttr('dimblk');
+        },
+        set: function (value) {
+            this.setAttr('dimblk', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimblk1", {
+        /**
+         * Dimension arrowhead block for the first arrow. This property controls the arrowhead for the
+         * first end of the dimension line when DIMSAH is on.
+         */
+        get: function () {
+            return this.getAttr('dimblk1');
+        },
+        set: function (value) {
+            this.setAttr('dimblk1', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimblk2", {
+        /**
+         * Dimension arrowhead block for the second arrow. This property controls the arrowhead for the
+         * second end of the dimension line when DIMSAH is on.
+         */
+        get: function () {
+            return this.getAttr('dimblk2');
+        },
+        set: function (value) {
+            this.setAttr('dimblk2', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimlwd", {
+        /**
+         * Dimension line weight. This property controls lineweight to dimension lines.
+         * - -1: Sets the lineweight to "BYLAYER."
+         * - -2: Sets the lineweight to "BYBLOCK."
+         * - -3: Sets the lineweight to "DEFAULT." "DEFAULT" is controlled by the LWDEFAULT system variable.
+         * Other valid values entered in hundredths of millimeters include 0, 5, 9, 13, 15, 18, 20, 25, 30,
+         * 35, 40, 50, 53, 60, 70, 80, 90, 100, 106, 120, 140, 158, 200, and 211.
+         * All values must be entered in hundredths of millimeters. (Multiply a value by 2540 to convert
+         * values from inches to hundredths of millimeters.)
+         */
+        get: function () {
+            return this.getAttr('dimlwd');
+        },
+        set: function (value) {
+            this.setAttr('dimlwd', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcDbDimStyleTableRecord.prototype, "dimlwe", {
+        /**
+         * Dimension line weight for extension lines. This property controls lineweight to extension lines.
+         * - -1: Sets the lineweight to "BYLAYER."
+         * - -2: Sets the lineweight to "BYBLOCK."
+         * - -3: Sets the lineweight to "DEFAULT." "DEFAULT" is controlled by the LWDEFAULT system variable.
+         * Other valid values entered in hundredths of millimeters include 0, 5, 9, 13, 15, 18, 20, 25, 30,
+         * 35, 40, 50, 53, 60, 70, 80, 90, 100, 106, 120, 140, 158, 200, and 211.
+         * All values must be entered in hundredths of millimeters. (Multiply a value by 2540 to convert
+         * values from inches to hundredths of millimeters.)
+         */
+        get: function () {
+            return this.getAttr('dimlwe');
+        },
+        set: function (value) {
+            this.setAttr('dimlwe', value);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AcDbDimStyleTableRecord.DEFAULT_DIM_VALUES = {
+        name: '',
+        dimpost: '',
+        dimapost: '',
+        dimscale: 1.0,
+        dimasz: 2.5,
+        dimexo: 0.625,
+        dimdli: 0.38,
+        dimexe: 0.18,
+        dimrnd: 0.0,
+        dimdle: 0.0,
+        dimtp: 0.0,
+        dimtm: 0.0,
+        dimtxt: 2.5,
+        dimcen: 2.5,
+        dimtsz: 0.0,
+        dimaltf: 0,
+        dimlfac: 1.0,
+        dimtvp: 0.0,
+        dimtfac: 1.0,
+        dimgap: 1.0,
+        dimaltrnd: 0.0,
+        dimtol: 0,
+        dimlim: 0,
+        // TODO: Its initial value is 1 (imperial) or 0 (metric)
+        dimtih: 0,
+        // TODO: Its initial value is 1 (imperial) or 0 (metric)
+        dimtoh: 0,
+        dimse1: 0,
+        dimse2: 0,
+        // TODO: Its initial value is 0 (imperial) or 1 (metric)
+        dimtad: AcDbDimTextVertical.Center,
+        // TODO: Its initial value is 0 (imperial) or 8 (metric)
+        dimzin: AcDbDimZeroSuppression.Feet,
+        dimazin: AcDbDimZeroSuppressionAngular.None,
+        dimalt: 0,
+        // TODO: Its initial value is 2 (imperial) or 3 (metric)
+        dimaltd: 2,
+        // TODO: Its initial value is 0 (imperial) or 1 (metric)
+        dimtofl: 0,
+        dimsah: 0,
+        dimtix: 0,
+        dimsoxd: 0,
+        dimclrd: 0,
+        dimclre: 0,
+        dimclrt: 0,
+        dimadec: 0,
+        dimunit: 2,
+        // TODO: Its initial value is 4 (imperial) or 2 (metric).
+        dimdec: 4,
+        // TODO: Its initial value is 4 (imperial) or 2 (metric).
+        dimtdec: 4,
+        dimaltu: 2,
+        // TODO: Its initial value is 2 (imperial) or 3 (metric)
+        dimalttd: 2,
+        dimaunit: 0,
+        dimfrac: 0,
+        dimlunit: 2,
+        // TODO: Its initial value is '.' (imperial) or ',' (metric)
+        dimdsep: '.',
+        dimtmove: 0,
+        dimjust: AcDbDimTextHorizontal.Center,
+        dimsd1: 0,
+        dimsd2: 0,
+        // TODO: Its initial value is 1 (imperial) or 0 (metric)
+        dimtolj: AcDbDimVerticalJustification.Bottom,
+        // TODO: Its initial value is 0 (imperial) or 8 (metric)
+        dimtzin: AcDbDimZeroSuppression.Feet,
+        dimaltz: AcDbDimZeroSuppression.Feet,
+        dimalttz: AcDbDimZeroSuppression.Feet,
+        dimfit: 0,
+        dimupt: 0,
+        dimatfit: 3,
+        dimtxsty: 'Standard',
+        dimldrblk: '',
+        dimblk: '',
+        dimblk1: '',
+        dimblk2: '',
+        dimlwd: -2,
+        dimlwe: -2
+    };
+    return AcDbDimStyleTableRecord;
+}(AcDbSymbolTableRecord));
+export { AcDbDimStyleTableRecord };
+//# sourceMappingURL=AcDbDimStyleTableRecord.js.map