KtClassTypeQualifier.KtResolvedClassTypeQualifier(
                        innerType.classDescriptor.toKtClassSymbol(analysisContext),
                        innerType.arguments.map { it.toKtTypeProjection(analysisContext) },
                        token
                    )
                }

            }
        }

    override val classId: ClassId

                    overriddenElement,
                    callableSymbol.analysisSession.useSiteSession
                )
            }
        }

        return overriddenElement.map { analysisSession.firSymbolBuilder.callableBuilder.buildCallableSymbol(it) }
    }

    override fun <T : KtSymbol> getDirectlyOverriddenSymbols(callableSymbol: T): List<KtCallableSymbol> {

  // versions are the versions supported in this group. They are sorted in descending order of preference,
  // with the preferred version being the first entry.
  // +listType=map
  // +listMapKey=version
  repeated APIVersionDiscovery versions = 2;
}

// APIGroupDiscoveryList is a resource containing a list of APIGroupDiscovery.

        is ConeKotlinType -> convertArgument(argument, firSymbolBuilder)
        is FirTypeRef -> convertArgument(argument, firSymbolBuilder)
        is KtSourceElement -> convertArgument(argument, firSymbolBuilder)
        is Map<*, *> -> convertArgument(argument, firSymbolBuilder)
        is Collection<*> -> convertArgument(argument, firSymbolBuilder)
        is Pair<*, *> -> convertArgument(argument, firSymbolBuilder)
        else -> argument
    }
}

  }

  override fun toString(): String {
    val peerCertificatesString = peerCertificates.map { it.name }.toString()
    return "Handshake{" +
      "tlsVersion=$tlsVersion " +
      "cipherSuite=$cipherSuite " +
      "peerCertificates=$peerCertificatesString " +
      "localCertificates=${localCertificates.map { it.name }}}"
  }

  private val Certificate.name: String
    get() =
      when (this) {

        check(this is KtFirAnalysisSession)
        val fir = element.getOrBuildFir(firResolveSession) ?: return emptyList()
        return when (fir) {
            is FirFunctionCall -> fir.getCandidateSymbols().map { it.fir.buildSymbol(firSymbolBuilder) }
            is FirResolvedNamedReference -> listOf(fir.resolvedSymbol.buildSymbol(firSymbolBuilder))
            else -> emptyList()
        }
    }

|        3|...        |...       |

(Sheet)
MEMBER / MEMBER_LOGIN / MEMBER_SECURITY
- - - - - - - - - -/

The defaultValueMap.dataprop is for common columns like this:
/- - - - - - - - - - - - - - - - - - - -
map:{
    ; REGISTER_DATETIME = sysdate
    ; REGISTER_USER     = foo
    ; REGISTER_PROCESS  = bar
    ; UPDATE_DATETIME   = sysdate
    ; UPDATE_USER       = foo
    ; UPDATE_PROCESS    = bar
    ; VERSION_NO        = 0

                        withPsiEntry("reference", ref.element)
                    }
                }
                resolveToPsiElements.map { KotlinResolveResult(it) }.toTypedArray()
            }
        }
    }

        bindingContext[BindingContext.CLASS, psi]
    }

    override val superTypes: List<KtType>
        get() = withValidityAssertion {
            descriptor?.typeConstructor?.supertypes?.map { it.toKtType(analysisContext) } ?: emptyList()
        }

    override fun createPointer(): KtSymbolPointer<KtAnonymousObjectSymbol> = withValidityAssertion {

  override fun execute(command: Runnable) {
    if (shutdown) throw RejectedExecutionException()
    calls.add(command as RealCall.AsyncCall)
  }

  fun assertJobs(vararg expectedUrls: String) {
    val actualUrls = calls.map { it.request.url.toString() }
    assertThat(actualUrls).containsExactly(*expectedUrls)
  }

  fun finishJob(url: String) {
    val i = calls.iterator()
    while (i.hasNext()) {
      val call = i.next()