docs: function () {
              var axis = this,
                horiz = axis.horiz,
                reversed = axis.reversed,
                chart = axis.chart,
                renderer = chart.renderer,
                options = axis.options,
                isLog = axis.isLog,
                isLinked = axis.isLinked,
                tickPositions = axis.tickPositions,
                sortedPositions,
                axisTitle = axis.axisTitle,
                ticks = axis.ticks,
                minorTicks = axis.minorTicks,
                alternateBands = axis.alternateBands,
                stackLabelOptions = options.stackLabels,
                alternateGridColor = options.alternateGridColor,
                tickmarkOffset = axis.tickmarkOffset,
                lineWidth = options.lineWidth,
                linePath,
                hasRendered = chart.hasRendered,
                slideInTicks = hasRendered && defined(axis.oldMin) && !isNaN(axis.oldMin),
                hasData = axis.hasData,
                showAxis = axis.showAxis,
                from,
                overflow = options.labels.overflow,
                justifyLabels = axis.justifyLabels = horiz && overflow !== false,
                to;
  
              // Reset
              axis.labelEdge.length = 0;
              axis.justifyToPlot = overflow === 'justify';
  
              // Mark all elements inActive before we go over and mark the active ones
              each([ticks, minorTicks, alternateBands], function (coll) {
                  var pos;
                  for (pos in coll) {
                      coll[pos].isActive = false;
                  }
              });
  
              // If the series has data draw the ticks. Else only the line and title
              if (hasData || isLinked) {
  
                  // minor ticks
                  if (axis.minorTickInterval && !axis.categories) {
                      each(axis.getMinorTickPositions(), function (pos) {
                          if (!minorTicks[pos]) {
                              minorTicks[pos] = new Tick(axis, pos, 'minor');
                          }
  
                          // render new ticks in old position
                          if (slideInTicks && minorTicks[pos].isNew) {
                              minorTicks[pos].render(null, true);
                          }
  
                          minorTicks[pos].render(null, false, 1);
                      });
                  }
  
                  // Major ticks. Pull out the first item and render it last so that
                  // we can get the position of the neighbour label. #808.
                  if (tickPositions.length) { // #1300
                      sortedPositions = tickPositions.slice();
                      if ((horiz && reversed) || (!horiz && !reversed)) {
                          sortedPositions.reverse();
                      }
                      if (justifyLabels) {
                          sortedPositions = sortedPositions.slice(1).concat([sortedPositions[0]]);
                      }
                      each(sortedPositions, function (pos, i) {
  
                          // Reorganize the indices
                          if (justifyLabels) {
                              i = (i === sortedPositions.length - 1) ? 0 : i + 1;
                          }
  
                          // linked axes need an extra check to find out if
                          if (!isLinked || (pos >= axis.min && pos <= axis.max)) {
  
                              if (!ticks[pos]) {
                                  ticks[pos] = new Tick(axis, pos);
                              }
  
                              // render new ticks in old position
                              if (slideInTicks && ticks[pos].isNew) {
                                  ticks[pos].render(i, true, 0.1);
                              }
  
                              ticks[pos].render(i);
                          }
  
                      });
                      // In a categorized axis, the tick marks are displayed between labels. So
                      // we need to add a tick mark and grid line at the left edge of the X axis.
                      if (tickmarkOffset && axis.min === 0) {
                          if (!ticks[-1]) {
                              ticks[-1] = new Tick(axis, -1, null, true);
                          }
                          ticks[-1].render(-1);
                      }
  
                  }
  
                  // alternate grid color
                  if (alternateGridColor) {
                      each(tickPositions, function (pos, i) {
                          if (i % 2 === 0 && pos < axis.max) {
                              if (!alternateBands[pos]) {
                                  alternateBands[pos] = new Highcharts.PlotLineOrBand(axis);
                              }
                              from = pos + tickmarkOffset; // #949
                              to = tickPositions[i + 1] !== UNDEFINED ? tickPositions[i + 1] + tickmarkOffset : axis.max;
                              alternateBands[pos].options = {
                                  from: isLog ? lin2log(from) : from,
                                  to: isLog ? lin2log(to) : to,
                                  color: alternateGridColor
                              };
                              alternateBands[pos].render();
                              alternateBands[pos].isActive = true;
                          }
                      });
                  }
  
                  // custom plot lines and bands
                  if (!axis._addedPlotLB) { // only first time
                      each((options.plotLines || []).concat(options.plotBands || []), function (plotLineOptions) {
                          axis.addPlotBandOrLine(plotLineOptions);
                      });
                      axis._addedPlotLB = true;
                  }
  
              } // end if hasData
  
              // Remove inactive ticks
              each([ticks, minorTicks, alternateBands], function (coll) {
                  var pos,
                    i,
                    forDestruction = [],
                    delay = globalAnimation ? globalAnimation.duration || 500 : 0,
                    destroyInactiveItems = function () {
                        i = forDestruction.length;
                        while (i--) {
                            // When resizing rapidly, the same items may be destroyed in different timeouts,
                            // or the may be reactivated
                            if (coll[forDestruction[i]] && !coll[forDestruction[i]].isActive) {
                                coll[forDestruction[i]].destroy();
                                delete coll[forDestruction[i]];
                            }
                        }
  
                    };
  
                  for (pos in coll) {
  
                      if (!coll[pos].isActive) {
                          // Render to zero opacity
                          coll[pos].render(pos, false, 0);
                          coll[pos].isActive = false;
                          forDestruction.push(pos);
                      }
                  }
  
                  // When the objects are finished fading out, destroy them
                  if (coll === alternateBands || !chart.hasRendered || !delay) {
                      destroyInactiveItems();
                  } else if (delay) {
                      setTimeout(destroyInactiveItems, delay);
                  }
              });
  
              // Static items. As the axis group is cleared on subsequent calls
              // to render, these items are added outside the group.
              // axis line
              if (lineWidth) {
                  linePath = axis.getLinePath(lineWidth);
                  if (!axis.axisLine) {
                      axis.axisLine = renderer.path(linePath)
                        .attr({
                            stroke: options.lineColor,
                            'stroke-width': lineWidth,
                            zIndex: 7
                        })
                        .add(axis.axisGroup);
                  } else {
                      axis.axisLine.animate({ d: linePath });
                  }
  
                  // show or hide the line depending on options.showEmpty
                  axis.axisLine[showAxis ? 'show' : 'hide']();
              }
  
              if (axisTitle && showAxis) {
  
                  axisTitle[axisTitle.isNew ? 'attr' : 'animate'](
                    axis.getTitlePosition()
                  );
                  axisTitle.isNew = false;
              }
  
              // Stacked totals:
              if (stackLabelOptions && stackLabelOptions.enabled) {
                  axis.renderStackTotals();
              }
              // End stacked totals
  
              axis.isDirty = false;
          }