docs: function validateIndent() {
              /**
               * Check whether the line start is in template tag.
               * @param {number} line The line.
               * @returns {boolean} `true` if the line start is in template tag.
               */
              function inTemplateTag(line) {
                  if (line <= 1) {
                      return false
                  }
                  const lineStartIndex = sourceCode.getIndexFromLoc({
                      line,
                      column: 0,
                  })
                  return microTemplateService.inTemplateTag(lineStartIndex - 1)
              }
  
              /**
               * Define the function which fixes the problem.
               * @param {number} line The number of line.
               * @param {string} actualText The actual indentation text.
               * @param {ExpectedIndent} expectedIndent The expected indentation info.
               * @returns {function} The defined function.
               */
              function defineFix(line, actualText, expectedIndent) {
                  return fixer => {
                      const start = sourceCode.getIndexFromLoc({
                          line,
                          column: 0,
                      })
                      const indent = expectedIndent.indentText
                      return fixer.replaceTextRange(
                          [start, start + actualText.length],
                          indent
                      )
                  }
              }
  
              /**
               * Validate base point indentation.
               * @param {number} line The number of line.
               * @param {string} actualText The actual indentation text.
               * @param {ExpectedIndent} expectedIndent The expected indent.
               * @returns {void}
               */
              function validateBaseIndent(line, actualText, expectedIndent) {
                  const expectedBaseIndentText = expectedIndent.baseIndentText
                  if (
                      expectedBaseIndentText &&
                      (actualText.length < expectedBaseIndentText.length ||
                          !actualText.startsWith(expectedBaseIndentText))
                  ) {
                      context.report({
                          loc: {
                              start: { line, column: 0 },
                              end: {
                                  line,
                                  column: actualText.length,
                              },
                          },
                          messageId: actualText
                              ? "unexpectedBaseIndentation"
                              : "missingBaseIndentation",
                          data: {
                              expected: JSON.stringify(expectedBaseIndentText),
                              actual: actualText
                                  ? JSON.stringify(
                                        actualText.slice(
                                            0,
                                            expectedBaseIndentText.length
                                        )
                                    )
                                  : "",
                          },
                          fix: defineFix(line, actualText, expectedIndent),
                      })
                      return false
                  }
                  return true
              }
  
              offsets.forEach((value, line) => {
                  if (!inTemplateTag(line)) {
                      return
                  }
                  if (!getLineText(line).trim()) {
                      // empty line
                      return
                  }
                  const actualText = value.actualText
                  const expectedIndent = getExpectedIndent(line)
                  if (!expectedIndent) {
                      return
                  }
                  if (!validateBaseIndent(line, actualText, expectedIndent)) {
                      return
                  }
                  const expectedBaseIndent = expectedIndent.baseIndentText.length
  
                  const actualRelativeText = actualText.slice(expectedBaseIndent)
  
                  for (let i = 0; i < actualRelativeText.length; ++i) {
                      if (actualRelativeText[i] !== options.indentChar) {
                          context.report({
                              loc: {
                                  start: { line, column: expectedBaseIndent + i },
                                  end: {
                                      line,
                                      column: expectedBaseIndent + i + 1,
                                  },
                              },
                              messageId: "unexpectedIndentationCharacter",
                              data: {
                                  expected: JSON.stringify(options.indentChar),
                                  actual: JSON.stringify(actualRelativeText[i]),
                              },
                              fix: defineFix(line, actualText, expectedIndent),
                          })
                          return
                      }
                  }
  
                  const actualRelativeIndent = actualRelativeText.length
  
                  if (actualRelativeIndent !== expectedIndent.indent) {
                      context.report({
                          loc: {
                              start: { line, column: expectedBaseIndent },
                              end: { line, column: actualText.length },
                          },
                          messageId: expectedBaseIndent
                              ? "unexpectedRelativeIndentation"
                              : "unexpectedIndentation",
                          data: {
                              expectedIndent: expectedIndent.indent,
                              actualIndent: actualRelativeIndent,
                              unit,
                              expectedIndentPlural:
                                  expectedIndent.indent === 1 ? "" : "s",
                              actualIndentPlural:
                                  actualRelativeIndent === 1 ? "" : "s",
                          },
                          fix: defineFix(line, actualText, expectedIndent),
                      })
                  }
              })
          }