docs: protected Node record( final TypeDeclaration type,
                             final Node parentNode ) throws Exception {
          final String name = type.getName().getFullyQualifiedName();
  
          final Node typeNode = parentNode.addNode(name, ClassFileSequencerLexicon.CLASS);
          typeNode.setProperty(ClassFileSequencerLexicon.NAME, name);
          typeNode.setProperty(ClassFileSequencerLexicon.SEQUENCED_DATE, this.context.getTimestamp());
  
          final boolean isInterface = type.isInterface();
          typeNode.setProperty(ClassFileSequencerLexicon.INTERFACE, isInterface);
  
          // extends and implements
          @SuppressWarnings( "unchecked" )
          final List<Type> interfaces = type.superInterfaceTypes();
  
          { // extends
              if (isInterface) {
                  if ((interfaces != null) && !interfaces.isEmpty()) {
                      final Node extendsNode = typeNode.addNode(ClassFileSequencerLexicon.EXTENDS, ClassFileSequencerLexicon.TYPES);
  
                      for (final Type interfaceType : interfaces) {
                          record(interfaceType, ClassFileSequencerLexicon.INTERFACE, extendsNode);
                      }
                  }
              } else {
                  final Type superType = type.getSuperclassType();
                  String superTypeName = null;
  
                  if (superType == null) {
                      superTypeName = Object.class.getCanonicalName();
                  } else {
                      superTypeName = getTypeName(superType);
                  }
  
                  assert !StringUtil.isBlank(superTypeName);
                  typeNode.setProperty(ClassFileSequencerLexicon.SUPER_CLASS_NAME, superTypeName);
  
                  if (superType != null) {
                      final Node extendsNode = typeNode.addNode(ClassFileSequencerLexicon.EXTENDS, ClassFileSequencerLexicon.TYPES);
                      record(superType, getTypeName(superType), extendsNode);
                  }
              }
          }
  
          { // implements
              if (!isInterface && (interfaces != null) && !interfaces.isEmpty()) {
                  final Node implementsNode = typeNode.addNode(ClassFileSequencerLexicon.IMPLEMENTS,
                                                               ClassFileSequencerLexicon.TYPES);
                  final String[] interfaceNames = new String[interfaces.size()];
  
                  for (int i = 0, size = interfaces.size(); i < size; ++i) {
                      final Type interfaceType = interfaces.get(i);
                      interfaceNames[i] = getTypeName(interfaceType);
                      record(interfaceType, interfaceNames[i], implementsNode);
                  }
  
                  typeNode.setProperty(ClassFileSequencerLexicon.INTERFACES, interfaceNames);
              }
          }
  
          { // javadocs
              final Javadoc javadoc = type.getJavadoc();
  
              if (javadoc != null) {
                  record(javadoc, typeNode);
              }
          }
  
          { // modifiers
              final int modifiers = type.getModifiers();
  
              typeNode.setProperty(ClassFileSequencerLexicon.ABSTRACT, (modifiers & Modifier.ABSTRACT) != 0);
              typeNode.setProperty(ClassFileSequencerLexicon.FINAL, (modifiers & Modifier.FINAL) != 0);
              typeNode.setProperty(ClassFileSequencerLexicon.STATIC, (modifiers & Modifier.STATIC) != 0);
              typeNode.setProperty(ClassFileSequencerLexicon.STRICT_FP, (modifiers & Modifier.STRICTFP) != 0);
              typeNode.setProperty(ClassFileSequencerLexicon.VISIBILITY, getVisibility(modifiers));
          }
  
          { // annotations
              @SuppressWarnings( "unchecked" )
              final List<IExtendedModifier> modifiers = type.modifiers();
              recordAnnotations(modifiers, typeNode);
          }
  
          { // type parameters
              @SuppressWarnings( "unchecked" )
              final List<TypeParameter> typeParams = type.typeParameters();
  
              if ((typeParams != null) && !typeParams.isEmpty()) {
                  final Node containerNode = typeNode.addNode(ClassFileSequencerLexicon.TYPE_PARAMETERS,
                                                              ClassFileSequencerLexicon.TYPE_PARAMETERS);
  
                  for (final TypeParameter param : typeParams) {
                      record(param, containerNode);
                  }
              }
          }
  
          recordBodyDeclarations(type, typeNode);
          recordSourceReference(type, typeNode);
          return typeNode;
      }