diff --git a/src/plot_api/plot_api.js b/src/plot_api/plot_api.js
index a104e88bb11..573117820af 100644
--- a/src/plot_api/plot_api.js
+++ b/src/plot_api/plot_api.js
@@ -2945,7 +2945,11 @@ function getDiffFlags(oldContainer, newContainer, outerparts, opts) {
         // so newContainer won't have them.
         if((key === 'tick0' || key === 'dtick') && outerparts[0] !== 'geo') {
             var tickMode = newContainer.tickmode;
-            if(tickMode === 'auto' || tickMode === 'array' || !tickMode) continue;
+            if(tickMode === 'auto' ||
+              tickMode === 'array' ||
+              tickMode === 'domain array' ||
+              tickMode === 'full domain' ||
+              !tickMode) continue;
         }
         // FIXME: Similarly for axis ranges for 3D
         // contourcarpet doesn't HAVE zmin/zmax, they're just auto-added. It needs them.
diff --git a/src/plots/cartesian/axes.js b/src/plots/cartesian/axes.js
index ba8faae29c4..2ebb3963e61 100644
--- a/src/plots/cartesian/axes.js
+++ b/src/plots/cartesian/axes.js
@@ -682,10 +682,13 @@ axes.prepTicks = function(ax, opts) {
             if(ax._name === 'radialaxis') nt *= 2;
         }
 
-        if(!(ax.minor && ax.minor.tickmode !== 'array')) {
+        if(!(ax.minor &&
+          (ax.minor.tickmode !== 'array' &&
+            ax.minor.tickmode !== 'domain array' &&
+            ax.minor.tickmode !== 'full domain'))) {
             // add a couple of extra digits for filling in ticks when we
             // have explicit tickvals without tick text
-            if(ax.tickmode === 'array') nt *= 100;
+            if(ax.tickmode === 'array' || ax.tickmode === 'domain array' || ax.tickmode === 'full domain') nt *= 100;
         }
 
         ax._roughDTick = Math.abs(rng[1] - rng[0]) / nt;
@@ -915,7 +918,6 @@ axes.calcTicks = function calcTicks(ax, opts) {
     var maxRange = Math.max(rng[0], rng[1]);
 
     var maxTicks = Math.max(1000, ax._length || 0);
-
     var ticksOut = [];
     var minorTicks = [];
 
@@ -944,15 +946,54 @@ axes.calcTicks = function calcTicks(ax, opts) {
             axes.prepTicks(mockAx, opts);
         }
 
-        // now that we've figured out the auto values for formatting
-        // in case we're missing some ticktext, we can break out for array ticks
-        if(mockAx.tickmode === 'array') {
+
+        if(mockAx.tickmode === 'array' || mockAx.tickmode === 'domain array' || mockAx.tickmode === 'full domain') {
+            var fractionalTickvals = [];
+            if(mockAx.tickmode === 'full domain') { // TODO: Change for minor, note: if minor we already have major
+                var nt = mockAx.nticks;
+                if(nt === undefined) nt = 0;
+                if(nt === 0) {
+                    // pass
+                } else if(nt === 1) {
+                    fractionalTickvals = [0.5];
+                } else if(nt === 2) {
+                    fractionalTickvals = [0, 1];
+                } else {
+                    var increment = 1 / (nt - 1); // (nt-2) + 1
+                    fractionalTickvals = [0];
+                    for(var tickIndex = 0; tickIndex < nt - 2; tickIndex++) {
+                        fractionalTickvals.push((tickIndex + 1) * increment);
+                    }
+                    fractionalTickvals.push(1);
+                }
+            }
+            if(mockAx.tickmode === 'domain array') {
+                fractionalTickvals = (major ? ax : ax.minor).tickvals;
+            }
+
+            if(mockAx.tickmode !== 'array') {
+                var width = (maxRange - minRange); // TODO: inspect this value for log, it shouldn't work!
+                if(axrev) width *= -1;
+                var offset = !axrev ? minRange : maxRange; // TODO: inspect this value for log
+                var mappedVals = Lib.simpleMap(fractionalTickvals,
+                    function(fraction, offset, width, type) {
+                        var mapped = offset + (width * fraction);
+                        return (type === 'log') ? Math.pow(10, mapped) : mapped;
+                    }, offset, width, type);
+                // reminder: ranges w/ type log use the exponent whereas ticks use the absolute value
+                // TODO: do some inspection here: it freaks me out doin arithmetic on possible exponents
+                (major ? ax : ax.minor)._mappedTickvals = mappedVals;
+            }
+            // now that we've figured out the auto values for formatting
+            // in case we're missing some ticktext, we can break out for array ticks
+
+            // Original 'array' only code
             if(major) {
                 tickVals = [];
-                ticksOut = arrayTicks(ax, !isMinor);
+                ticksOut = arrayTicks(ax, !isMinor); // ie arrayTicks(ax, majorOnly = !False)
             } else {
                 minorTickVals = [];
-                minorTicks = arrayTicks(ax, !isMinor);
+                minorTicks = arrayTicks(ax, !isMinor); // ie arrayTicks(ax, majorOnly = !True)
             }
             continue;
         }
@@ -1204,6 +1245,7 @@ axes.calcTicks = function calcTicks(ax, opts) {
             ticksOut.push(t);
         }
     }
+
     ticksOut = ticksOut.concat(minorTicks);
 
     ax._inCalcTicks = false;
@@ -1281,7 +1323,10 @@ function arrayTicks(ax, majorOnly) {
     for(var isMinor = 0; isMinor <= 1; isMinor++) {
         if((majorOnly !== undefined) && ((majorOnly && isMinor) || (majorOnly === false && !isMinor))) continue;
         if(isMinor && !ax.minor) continue;
-        var vals = !isMinor ? ax.tickvals : ax.minor.tickvals;
+
+        var targetAxis = (!isMinor ? ax : ax.minor);
+        var vals = (targetAxis.tickmode === 'array') ? targetAxis.tickvals : targetAxis._mappedTickvals;
+
         var text = !isMinor ? ax.ticktext : [];
         if(!vals) continue;
 
@@ -1618,18 +1663,23 @@ axes.tickFirst = function(ax, opts) {
 axes.tickText = function(ax, x, hover, noSuffixPrefix) {
     var out = tickTextObj(ax, x);
     var arrayMode = ax.tickmode === 'array';
+    var fractionalMode = (ax.tickmode === 'domain array' || ax.tickmode === 'full domain');
     var extraPrecision = hover || arrayMode;
     var axType = ax.type;
     // TODO multicategory, if we allow ticktext / tickvals
     var tickVal2l = axType === 'category' ? ax.d2l_noadd : ax.d2l;
     var i;
 
-    if(arrayMode && Lib.isArrayOrTypedArray(ax.ticktext)) {
+    if((arrayMode || fractionalMode) && Lib.isArrayOrTypedArray(ax.ticktext)) {
         var rng = Lib.simpleMap(ax.range, ax.r2l);
         var minDiff = (Math.abs(rng[1] - rng[0]) - (ax._lBreaks || 0)) / 10000;
 
         for(i = 0; i < ax.ticktext.length; i++) {
-            if(Math.abs(x - tickVal2l(ax.tickvals[i])) < minDiff) break;
+            if(arrayMode) {
+                if(Math.abs(x - tickVal2l(ax.tickvals[i])) < minDiff) break;
+            } else {
+                if(Math.abs(x - tickVal2l(ax._mappedTickvals[i])) < minDiff) break;
+            }
         }
         if(i < ax.ticktext.length) {
             out.text = String(ax.ticktext[i]);
@@ -3333,7 +3383,7 @@ axes.drawGrid = function(gd, ax, opts) {
 
     var counterAx = opts.counterAxis;
     if(counterAx && axes.shouldShowZeroLine(gd, ax, counterAx)) {
-        var isArrayMode = ax.tickmode === 'array';
+        var isArrayMode = (ax.tickmode === 'array' || ax.tickmode === 'domain array' || ax.tickmode === 'full domain');
         for(var i = 0; i < majorVals.length; i++) {
             var xi = majorVals[i].x;
             if(isArrayMode ? !xi : (Math.abs(xi) < ax.dtick / 100)) {
diff --git a/src/plots/cartesian/layout_attributes.js b/src/plots/cartesian/layout_attributes.js
index 2532e0c75cd..5e874db17ad 100644
--- a/src/plots/cartesian/layout_attributes.js
+++ b/src/plots/cartesian/layout_attributes.js
@@ -14,7 +14,7 @@ var DAY_OF_WEEK = constants.WEEKDAY_PATTERN;
 
 var minorTickmode = {
     valType: 'enumerated',
-    values: ['auto', 'linear', 'array'],
+    values: ['auto', 'linear', 'array', 'domain array', 'full domain'],
     editType: 'ticks',
     impliedEdits: {tick0: undefined, dtick: undefined},
     description: [
@@ -23,9 +23,16 @@ var minorTickmode = {
         'If *linear*, the placement of the ticks is determined by',
         'a starting position `tick0` and a tick step `dtick`',
         '(*linear* is the default value if `tick0` and `dtick` are provided).',
-        'If *array*, the placement of the ticks is set via `tickvals`',
-        'and the tick text is `ticktext`.',
-        '(*array* is the default value if `tickvals` is provided).'
+        'If *array*, the placement of the ticks is set via `tickvals`,',
+        'which are actual values, and the tick text is `ticktext`.',
+        '(*array* is the default value if `tickvals` is provided).',
+        'If *full domain*, the number of ticks is set bia `nticks` but ticks',
+        'are placed first at both axis ends and then at equal proportions',
+        'between the axis. So `nticks=5` would put ticks at both ends and',
+        'every quarter.',
+        'If *domain array*, the placement is similiar to *array* except that',
+        '`tickvals` are fractions between 0 and 1 representing distance on',
+        'the corresponding axis.'
     ].join(' ')
 };
 
diff --git a/src/plots/cartesian/tick_value_defaults.js b/src/plots/cartesian/tick_value_defaults.js
index 68b9207ee62..25b394587a1 100644
--- a/src/plots/cartesian/tick_value_defaults.js
+++ b/src/plots/cartesian/tick_value_defaults.js
@@ -29,8 +29,7 @@ module.exports = function handleTickValueDefaults(containerIn, containerOut, coe
         _dtick ? 'linear' :
         'auto';
     var tickmode = coerce(prefix + 'tickmode', tickmodeDefault);
-
-    if(tickmode === 'auto' || tickmode === 'sync') {
+    if(tickmode === 'auto' || tickmode === 'sync' || tickmode === 'full domain') {
         coerce(prefix + 'nticks');
     } else if(tickmode === 'linear') {
         // dtick is usually a positive number, but there are some
diff --git a/test/jasmine/tests/pikul_test.js b/test/jasmine/tests/pikul_test.js
new file mode 100644
index 00000000000..903b31c4579
--- /dev/null
+++ b/test/jasmine/tests/pikul_test.js
@@ -0,0 +1,405 @@
+
+var Plotly = require('../../../lib/index');
+
+var createGraphDiv = require('../assets/create_graph_div');
+var destroyGraphDiv = require('../assets/destroy_graph_div');
+
+
+// ******* UTILTIES ******* //
+
+// makeSet() returns array copy w/o duplicates.
+function makeSet(data) {
+    if(data === undefined || data.length === undefined || data.length === 0) return [];
+    return data.filter(function(value, index, array) { return array.indexOf(value) === index; });
+}
+
+// `reX` is regex to get position of an 'xtick', `reY` is for a 'ytick'
+// Note: `.source` converts regex to string, laid out this way to make for easier reading
+var funcName = 'translate' + /\(/.source; // "translate("
+var integerPart = /\d+/.source; // numbers left of decimal
+var fractionalPart = /(?:\.\d+)?/.source; // decimal + numbers to right
+var floatNum = integerPart + fractionalPart; // all together
+var any = /.+/.source; // any text
+var close = /\)/.source; // ")"
+var reX = new RegExp(funcName + '(' + floatNum + '),' + any + close); // parens '(', '),' are regex capture symbols not characters
+var reY = new RegExp(funcName + any + ',(' + floatNum + ')' + close);
+
+
+/* ****** PARAMETERIZATION ******* */
+
+/* TICK CONFIG GENERATORS */
+var MAJOR = 10; // `ticklen:10`
+var MINOR = 5; // `ticklen:5`
+
+// ticksOff() generates a config for no ticks
+function ticksOff() { return {ticklen: 0, showticklabels: false, nticks: 0}; }
+
+// generateTickConfig() can generate randomized but valid configs for `tickmode` "domain array" and "full domain"
+function generateTickConfig(tickLen, tickmode, nticks) {
+    if(tickmode === undefined) tickmode = 'domain array'; // default
+
+    var standardConfig = {tickmode: tickmode, ticklen: tickLen, showticklabels: false}; // no labels!
+    // We analyze DOM to find number and position of ticks, labels make it harder.
+
+
+    // Tick values will be random:
+    if(tickmode === 'domain array') { // 'domain array' will have random tick proportions
+        var n = Math.floor(Math.random() * 100);
+        var tickVals = [];
+
+        for(var i = 0; i <= n; i++) {
+            // NOTE: MEANT TO BE DIFFERENT EVERYTIME
+            var intermediate = (Math.trunc(Math.random() * 150) - 25) / 100; // Number between -.25 and 1.25 w/ 2 decimals max
+            tickVals.push(Math.min(Math.max(intermediate, 0), 1)); // 2 decimal number between 0 and 1 w/ higher odds of 0 or 1
+        }
+        standardConfig.tickvals = tickVals;
+    } else if(tickmode === 'full domain') { // TODO: full domain _could_ have a random number of ticks
+        standardConfig.nticks = nticks;
+    }
+    return standardConfig;
+}
+
+// areTicks() returns true if `config`, an axis config, contains ticks: false otherwise.
+function areTicks(config) { // Check if ticks exists in a generated config
+    return (config !== undefined && config.ticklen !== undefined && config.ticklen !== 0);
+}
+
+/* LOOP THROUGH ALL POSSIBLE COMBINATIONS:
+ * xAxis major has ticks, xAxis minor has ticks, yAxis major does not, yAxis minor does, etc */
+
+// numbers 0 through 15 are all possible combination of 4 boolean values (0001, 0010, 0011, 0100, 0101, etc)
+var XMAJOR = 1;// 0b0001;
+var XMINOR = 2;// 0b0010;
+var YMAJOR = 4;// 0b0100;
+var YMINOR = 8;// 0b1000;
+
+// binaryToTickType converts binary to info string
+function binaryToTickType(bin) {
+    var str = [];
+    if(bin & XMAJOR) str.push('xMajor');
+    if(bin & XMINOR) str.push('xMinor');
+    if(bin & YMAJOR) str.push('yMajor');
+    if(bin & YMINOR) str.push('yMinor');
+    if(str.length) {
+        return str.join(', ');
+    }
+    return 'None';
+}
+
+/* PARAMETERIZE POSSIBLE TYPES OF GRAPH */
+var graphTypes = [
+    { type: 'linear' },
+    { type: 'log'},
+    { type: 'date'},
+];
+
+/* getParameters() will loop through all possible parameters, initializing it the first time, and return false the last */
+/* it's for for-loops */
+function getParameters(op) {
+    // Initializize
+    if(op === undefined) return {tickConfig: 0, graphTypeIndex: 0};
+
+    // Loop through 15 possible tickConfigs
+    if(++op.tickConfig > 15) op.tickConfig = 0;
+    else return op;
+
+    // Loop through 4 graph types after each full loop above
+    if(++op.graphTypeIndex >= graphTypes.length) return false;
+    return op;
+}
+// Loops MUST be outside tests do to scopes (and better for output, honestly)
+for(var parameters = getParameters(); parameters; parameters = getParameters(parameters)) {
+    // Give parameters there own variable
+    var xGraphType = graphTypes[parameters.graphTypeIndex];
+    var tickConfig = parameters.tickConfig;
+
+    // Linters don't like variable redeclaration in subscope so make all testing same scope
+    var paramInfo = 'on axes ' + binaryToTickType(tickConfig) + ' for graph type: ' + xGraphType.type;
+
+    var xConfig = (tickConfig & XMAJOR) ? generateTickConfig(MAJOR) : ticksOff(); // generate configs
+    xConfig.minor = (tickConfig & XMINOR) ? generateTickConfig(MINOR) : ticksOff();
+
+    var yConfig = (tickConfig & YMAJOR) ? generateTickConfig(MAJOR) : ticksOff();
+    yConfig.minor = (tickConfig & YMINOR) ? generateTickConfig(MINOR) : ticksOff();
+
+    // Configs are random, so we should inspect if test fails:
+    var configInfo = '';
+    configInfo += areTicks(xConfig) ? '\n ' + 'xMajor: ' + makeSet(xConfig.tickvals).length + ' unique vals' : '';
+    configInfo += areTicks(xConfig.minor) ? '\n ' + 'xMinor: ' + makeSet(xConfig.minor.tickvals).length + ' unique vals' : '';
+    configInfo += areTicks(yConfig) ? '\n ' + 'yMajor: ' + makeSet(yConfig.tickvals).length + ' unique vals' : '';
+    configInfo += areTicks(yConfig.minor) ? '\n ' + 'yMinor: ' + makeSet(yConfig.minor.tickvals).length + ' unique vals' : '';
+
+    // variablesToInject + closure function(scopeLock) is a necessary result of using a version w promises but w/o `let`
+    var variablesToInject = {
+        xConfig: xConfig, // Generated xConfig
+        yConfig: yConfig, // Generated yConfig
+        xGraphType: xGraphType, // graphType parameter
+        tickConfig: tickConfig, // tickConfig parameter
+        paramInfo: paramInfo, // info string
+        configInfo: configInfo // info string
+    };
+    (function(scopeLock) {
+        describe('`tickmode`:"domain array"', function() {
+            var gd;
+
+            beforeEach(function() {
+                gd = createGraphDiv();
+            });
+
+            afterEach(destroyGraphDiv);
+
+            it('should create ticks correctly ' + scopeLock.paramInfo, function(done) {
+                Plotly.newPlot(gd, {
+                    data: [{
+                        x: [0, 1],
+                        y: [0, 1]
+                    }],
+                    layout: {
+                        width: 400,
+                        height: 400,
+                        margin: { t: 40, b: 40, l: 40, r: 40, },
+                        type: scopeLock.xGraphType,
+                        xaxis: scopeLock.xConfig,
+                        yaxis: scopeLock.yConfig,
+                    }
+                }
+                ).then(function() {
+                    var tickConfig = scopeLock.tickConfig;
+                    var xConfig = scopeLock.xConfig;
+                    var yConfig = scopeLock.yConfig;
+                    var configInfo = scopeLock.configInfo;
+                    for(var runNumber = 1; runNumber <= 15; runNumber <<= 1) {
+                        if(!(runNumber & tickConfig)) continue;
+                        var debugInfo = 'Configured Axes: ' + binaryToTickType(tickConfig);
+                        debugInfo += '\n Checking: ' + binaryToTickType(runNumber);
+
+                        var elementName = '';
+                        var targetConfig;
+                        var re;
+
+                        // Determine which runNumber we're in
+                        if(runNumber & XMAJOR) { // ie. (this run wants xMajor) & (xMajor was set in config above)
+                            elementName = 'xtick';
+                            targetConfig = xConfig;
+                            re = reX;
+                        } else if(runNumber & XMINOR) {
+                            elementName = 'xtick';
+                            targetConfig = xConfig.minor;
+                            re = reX;
+                        } else if(runNumber & YMAJOR) {
+                            elementName = 'ytick';
+                            targetConfig = yConfig;
+                            re = reY;
+                        } else if(runNumber & YMINOR) {
+                            elementName = 'ytick';
+                            targetConfig = yConfig.minor;
+                            re = reY;
+                        } else continue;
+                        var tickElements = gd.getElementsByClassName(elementName);
+                        var tickValsUnique = makeSet(targetConfig.tickvals);
+                        var expectedTickLen = String(targetConfig.ticklen);
+
+                        // This is the info I want to see on any failed test
+                        debugInfo += '\n Found ' + String(tickElements.length) + ' tick DOM elements.';
+                        debugInfo += '\n Expecting ' + String(tickValsUnique.length) + ' legitimate elements:';
+                        debugInfo += String(tickValsUnique);
+                        debugInfo += '\n Original Length: ' + String(targetConfig.tickvals.length);
+
+                        // Filter out major/minor and grab geometry
+                        var transformVals = []; // "transform" ie the positional property
+                        for(var i = 0; i < tickElements.length; i++) { // TODO it is helpful to dump html here if there is a problem
+                            if(!tickElements[i].getAttribute('d').endsWith(expectedTickLen)) continue;
+                            var translate = tickElements[i].getAttribute('transform');
+                            transformVals.push(Number(translate.match(re)[1]));
+                        }
+                        debugInfo += '\n Filtered Elements Length: ' + String(transformVals.length) + ':';
+                        debugInfo += transformVals;
+
+                        expect(transformVals.length).toBe(tickValsUnique.length,
+                            'filtered tick elements vs tickvals failed\n' + debugInfo + configInfo);
+                        if(transformVals.length < 2) return; // Can't test proportions with < 2 ticks (since no fixed reference)
+
+                        // To test geometries without using fixed point or data values...
+                        // we can check consistency of y = mx+b! (y is DOM position, x is proportion)
+                        // If x = 0 then y = b, but we may not have a 0 valued x
+                        // m = (y1 - y2) / (x1 - x2)
+                        // b = y1 - mx1
+                        var y = transformVals;
+                        var x = tickValsUnique;
+                        var m, b;
+                        var bIndex = x.indexOf(0);
+
+                        m = (y[0] - y[1]) / (x[0] - x[1]);
+                        b = (bIndex !== -1) ? b = y[bIndex] : y[0] - m * x[0];
+
+                        var calculatedY = [];
+                        for(var k = 0; k < x.length; k++) { // linter didn't like I being here
+                            calculatedY.push(m * x[k] + b);
+                        }
+
+                        /* THIS WOULD BE TO MANUALLY INSPECT OUTPUT */
+                        // yout = [];
+                        // ycalcout = [];
+                        // for (i = 0; i < Math.min(x.length, 10); i++) {
+                        //     yout.push(Number.parseFloat(y[i]).toFixed(2));
+                        //     ycalcout.push(Number.parseFloat(calculatedY[i]).toFixed(2));
+                        // }
+                        // console.log(yout);
+                        // console.log(ycalcout);
+                        expect(y).toBeCloseToArray(calculatedY, 'y=mx+b test failed comparing\n' + y + '\n' + calculatedY);
+                    }
+                }).then(done, done.fail);
+            });
+        });
+    })(variablesToInject);
+}
+
+// One loop should be separated from the other loop by scope, but we still have not `let`!
+(function() {
+    for(var parameters = getParameters(); parameters; parameters = getParameters(parameters)) {
+        // Give parameters there own variable
+        var xGraphType = graphTypes[parameters.graphTypeIndex];
+        var tickConfig = parameters.tickConfig;
+        // This next test has another parameter, since we can test it with multiple numbers of ticks
+        for(var nTicksParameter = 0; nTicksParameter < 5; nTicksParameter++) {
+            var xConfig = (tickConfig & XMAJOR) ? generateTickConfig(MAJOR, 'full domain', nTicksParameter) : ticksOff();
+            xConfig.minor = (tickConfig & XMINOR) ? generateTickConfig(MINOR, 'full domain', nTicksParameter) : ticksOff();
+            var yConfig = (tickConfig & MAJOR) ? generateTickConfig(MAJOR, 'full domain', nTicksParameter) : ticksOff();
+            yConfig.minor = (tickConfig & YMINOR) ? generateTickConfig(MINOR, 'full domain', nTicksParameter) : ticksOff();
+
+            var paramInfo = 'on axes ' + binaryToTickType(tickConfig) + ' with ' + String(nTicksParameter) + ' ticks each, for graph type: ' + xGraphType.type;
+
+            // variablesToInject + closurer function(scopeLock) is a necessary result of using a version w promises but w/o `let`
+            var variablesToInject = {xConfig: xConfig, yConfig: yConfig, xGraphType: xGraphType, tickConfig: tickConfig, nTicksParameter: nTicksParameter, paramInfo: paramInfo};
+            (function(scopeLock) {
+                describe('`tickmode`:"full domain"', function() {
+                    var gd;
+
+                    beforeEach(function() {
+                        gd = createGraphDiv();
+                    });
+
+                    afterEach(destroyGraphDiv);
+
+                    it('should create ticks correctly ' + scopeLock.paramInfo, function(done) {
+                        Plotly.newPlot(gd, {
+                            data: [{
+                                x: [0, 1],
+                                y: [0, 1]
+                            }],
+                            layout: {
+                                width: 400,
+                                height: 400,
+                                margin: { t: 40, b: 40, l: 40, r: 40, },
+                                type: scopeLock.xGraphType,
+                                xaxis: scopeLock.xConfig,
+                                yaxis: scopeLock.yConfig,
+                            }
+                        }).then(function() {
+                            var tickConfig = scopeLock.tickConfig;
+                            var xConfig = scopeLock.xConfig;
+                            var yConfig = scopeLock.yConfig;
+
+                            // This for loop only executes four times! It's bitshift, not increment! It's to checks all 4 axes.
+                            for(var runNumber = 1; runNumber <= 15; runNumber <<= 1) {
+                                if(!(runNumber & tickConfig)) continue;
+                                var runInfo = '\n Checking: ' + binaryToTickType(runNumber);
+
+                                var elementName = '';
+                                var targetConfig;
+                                var re;
+
+                                // Determine which runNumber we're in
+                                if(runNumber & XMAJOR) { // ie. (this run wants xMajor) & (xMajor was set in config above)
+                                    elementName = 'xtick';
+                                    targetConfig = xConfig;
+                                    re = reX;
+                                } else if(runNumber & XMINOR) {
+                                    elementName = 'xtick';
+                                    targetConfig = xConfig.minor;
+                                    re = reX;
+                                } else if(runNumber & YMAJOR) {
+                                    elementName = 'ytick';
+                                    targetConfig = yConfig;
+                                    re = reY;
+                                } else if(runNumber & YMINOR) {
+                                    elementName = 'ytick';
+                                    targetConfig = yConfig.minor;
+                                    re = reY;
+                                } else continue;
+
+                                // Determine where ticks _should be_
+                                var nt = targetConfig.nticks;
+                                var expectedTickLen = String(targetConfig.ticklen);
+                                var tickValsUnique = new Array();
+                                if(nt === 0) {
+                                    // pass
+                                } else if(nt === 1) {
+                                    tickValsUnique = [0];
+                                } else if(nt === 2) {
+                                    tickValsUnique = [0, 1];
+                                } else {
+                                    var increment = 1 / (nt - 1); // (nt-2) + 1
+                                    tickValsUnique.push(0);
+                                    for(var i = 0; i < nt - 2; i++) {
+                                        tickValsUnique.push((i + 1) * increment);
+                                    }
+                                    tickValsUnique.push(1);
+                                }
+
+                                // Get actual geometries
+                                var tickElements = gd.getElementsByClassName(elementName);
+                                var transformVals = []; // "transform" ie the positional property
+
+                                // Figure out which ticks are relevant to us for this config
+                                for(var j = 0; j < tickElements.length; j++) {
+                                    if(!tickElements[j].getAttribute('d').endsWith(expectedTickLen)) continue;
+                                    var translate = tickElements[j].getAttribute('transform');
+                                    var match = translate.match(re);
+                                    if(match === null) continue;
+                                    transformVals.push(Number(match[1]));
+                                }
+
+                                var debugInfo = '\n ' + 'tickElements: (' + tickElements.length + ') ' + tickElements + '\n ' +
+                                    'nticks: ' + tickValsUnique.length; // Could contain whole html, more helpful
+
+                                expect(transformVals.length).toBe(tickValsUnique.length,
+                                    'filtered tick elements vs tickvals failed' + runInfo + + debugInfo);
+
+                                if(transformVals.length < 2) return; // Can't test proportions with < 2 ticks (since no fixed reference)
+
+
+                                // To test geometries without using fixed point or data values...
+                                // we can check consistency of y = mx+b! (y is DOM position, x is proportion)
+                                // If x = 0 then y = b, but we may not have a 0 valued x
+                                // m = (y1 - y2) / (x1 - x2)
+                                // b = y1 - mx1
+                                var y = transformVals;
+                                var x = tickValsUnique;
+                                var m, b;
+                                var bIndex = x.indexOf(0);
+
+                                m = (y[0] - y[1]) / (x[0] - x[1]);
+                                b = (bIndex !== -1) ? b = y[bIndex] : y[0] - m * x[0];
+
+                                var calculatedY = [];
+                                for(var k = 0; k < x.length; k++) calculatedY.push(m * x[k] + b);
+
+                                /* **** Close this comment line to manually inspect output --> */
+                                // yout = [];
+                                // ycalcout = [];
+                                // for (i = 0; i < Math.min(x.length, 10); i++) {
+                                //     yout.push(Number.parseFloat(y[i]).toFixed(2));
+                                //     ycalcout.push(Number.parseFloat(calculatedY[i]).toFixed(2));
+                                // }
+                                // console.log(yout);
+                                // console.log(ycalcout);
+                                expect(y).toBeCloseToArray(calculatedY, 1, 'y=mx+b test failed comparing\n' + y + '\n' + calculatedY);
+                            }
+                        }).then(done, done.fail);
+                    });
+                });
+            }(variablesToInject));
+        }
+    }
+})();
diff --git a/test/plot-schema.json b/test/plot-schema.json
index b58690cba3c..232482477d9 100644
--- a/test/plot-schema.json
+++ b/test/plot-schema.json
@@ -1462,14 +1462,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "colorbars",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -4203,14 +4205,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "plot",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -4882,14 +4886,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "plot",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -6067,14 +6073,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "plot",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -6695,14 +6703,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "plot",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -7323,14 +7333,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "plot",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -9123,14 +9135,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "plot",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -9527,14 +9541,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "plot",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -9937,14 +9953,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "plot",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -11066,14 +11084,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "ticks",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "ticks": {
@@ -11794,7 +11814,7 @@
      "valType": "number"
     },
     "tickmode": {
-     "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *sync*, the number of ticks will sync with the overlayed axis set by `overlaying` property.",
+     "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis. If *sync*, the number of ticks will sync with the overlayed axis set by `overlaying` property.",
      "editType": "ticks",
      "impliedEdits": {},
      "valType": "enumerated",
@@ -11802,6 +11822,8 @@
       "auto",
       "linear",
       "array",
+      "domain array",
+      "full domain",
       "sync"
      ]
     },
@@ -12420,14 +12442,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "ticks",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "ticks": {
@@ -12899,7 +12923,7 @@
      "valType": "number"
     },
     "tickmode": {
-     "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *sync*, the number of ticks will sync with the overlayed axis set by `overlaying` property.",
+     "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis. If *sync*, the number of ticks will sync with the overlayed axis set by `overlaying` property.",
      "editType": "ticks",
      "impliedEdits": {},
      "valType": "enumerated",
@@ -12907,6 +12931,8 @@
       "auto",
       "linear",
       "array",
+      "domain array",
+      "full domain",
       "sync"
      ]
     },
@@ -13976,14 +14002,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "colorbars",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -15535,14 +15563,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "colorbars",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -19833,14 +19863,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "colorbars",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -20860,14 +20892,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "colorbars",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -21916,14 +21950,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "colorbars",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -22990,14 +23026,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "colorbars",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -24405,14 +24443,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "colorbars",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -25391,14 +25431,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "colorbars",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -26732,14 +26774,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "colorbars",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -28569,14 +28613,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "colorbars",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -29767,14 +29813,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "calc",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -31342,14 +31390,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "colorbars",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -32558,14 +32608,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "colorbars",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -33728,14 +33780,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "colorbars",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -35417,14 +35471,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "colorbars",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -36940,14 +36996,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "plot",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -37863,14 +37921,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "calc",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -39113,14 +39173,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "colorbars",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -41135,14 +41197,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "colorbars",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -42126,14 +42190,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "colorbars",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -45855,14 +45921,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "colorbars",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -48136,14 +48204,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "calc",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -48747,14 +48817,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "calc",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -50258,14 +50330,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "colorbars",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -52175,14 +52249,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "calc",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -54227,14 +54303,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "calc",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -56241,14 +56319,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "calc",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -57479,14 +57559,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "colorbars",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -59375,14 +59457,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "calc",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -61271,14 +61355,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "colorbars",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -63206,14 +63292,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "colorbars",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -65072,14 +65160,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "colorbars",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -66505,14 +66595,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "colorbars",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -68004,14 +68096,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "colorbars",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -68992,14 +69086,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "calc",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {
@@ -71392,14 +71488,16 @@
        "valType": "number"
       },
       "tickmode": {
-       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+       "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
        "editType": "colorbars",
        "impliedEdits": {},
        "valType": "enumerated",
        "values": [
         "auto",
         "linear",
-        "array"
+        "array",
+        "domain array",
+        "full domain"
        ]
       },
       "tickprefix": {
@@ -73852,14 +73950,16 @@
       "valType": "number"
      },
      "tickmode": {
-      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+      "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals`, which are actual values, and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *full domain*, the number of ticks is set bia `nticks` but ticks are placed first at both axis ends and then at equal proportions between the axis. So `nticks=5` would put ticks at both ends and every quarter. If *domain array*, the placement is similiar to *array* except that `tickvals` are fractions between 0 and 1 representing distance on the corresponding axis.",
       "editType": "calc",
       "impliedEdits": {},
       "valType": "enumerated",
       "values": [
        "auto",
        "linear",
-       "array"
+       "array",
+       "domain array",
+       "full domain"
       ]
      },
      "tickprefix": {