docs: function isSymbolAccessible(symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible) {
              if (symbol && enclosingDeclaration && !(symbol.flags & 262144 /* TypeParameter */)) {
                  var initialSymbol = symbol;
                  var meaningToLook = meaning;
                  while (symbol) {
                      // Symbol is accessible if it by itself is accessible
                      var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaningToLook, /*useOnlyExternalAliasing*/ false);
                      if (accessibleSymbolChain) {
                          var hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0], shouldComputeAliasesToMakeVisible);
                          if (!hasAccessibleDeclarations) {
                              return {
                                  accessibility: 1 /* NotAccessible */,
                                  errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning),
                                  errorModuleName: symbol !== initialSymbol ? symbolToString(symbol, enclosingDeclaration, 1920 /* Namespace */) : undefined
                              };
                          }
                          return hasAccessibleDeclarations;
                      }
                      // If we haven't got the accessible symbol, it doesn't mean the symbol is actually inaccessible.
                      // It could be a qualified symbol and hence verify the path
                      // e.g.:
                      // module m {
                      //     export class c {
                      //     }
                      // }
                      // const x: typeof m.c
                      // In the above example when we start with checking if typeof m.c symbol is accessible,
                      // we are going to see if c can be accessed in scope directly.
                      // But it can't, hence the accessible is going to be undefined, but that doesn't mean m.c is inaccessible
                      // It is accessible if the parent m is accessible because then m.c can be accessed through qualification
                      meaningToLook = getQualifiedLeftMeaning(meaning);
                      symbol = getParentOfSymbol(symbol);
                  }
                  // This could be a symbol that is not exported in the external module
                  // or it could be a symbol from different external module that is not aliased and hence cannot be named
                  var symbolExternalModule = ts.forEach(initialSymbol.declarations, getExternalModuleContainer);
                  if (symbolExternalModule) {
                      var enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration);
                      if (symbolExternalModule !== enclosingExternalModule) {
                          // name from different external module that is not visible
                          return {
                              accessibility: 2 /* CannotBeNamed */,
                              errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning),
                              errorModuleName: symbolToString(symbolExternalModule)
                          };
                      }
                  }
                  // Just a local name that is not accessible
                  return {
                      accessibility: 1 /* NotAccessible */,
                      errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning)
                  };
              }
              return { accessibility: 0 /* Accessible */ };
              function getExternalModuleContainer(declaration) {
                  for (; declaration; declaration = declaration.parent) {
                      if (hasExternalModuleSymbol(declaration)) {
                          return getSymbolOfNode(declaration);
                      }
                  }
              }
          }