public sealed interface KaType : KaLifetimeOwner, KaAnnotated {
    public val nullability: KaTypeNullability

    /**
     * The abbreviated type for this expanded [KaType], or `null` if this type has not been expanded from an abbreviated type or the
     * abbreviated type cannot be resolved.
     *
     * An abbreviated type is a type alias application that has been expanded to some other Kotlin type. For example, if we have a type

 * which can still be expanded.
 */
public enum class KaExpandedTypeRenderingMode {
    /**
     * Renders only the abbreviated type as-is, e.g. `foo.bar.StringAlias`.
     */
    RENDER_ABBREVIATED_TYPE,

    /**

public val KtType.classSymbol: KaClassLikeSymbol?
    get() = symbol

/**
 * Returns the [KaType]'s [abbreviated type][KaType.abbreviatedType], or the type itself if it doesn't have an abbreviated type.
 *
 * A common pattern is to prefer the abbreviated type if it exists, and otherwise take the original type, for example to find the best
 * target for navigation.
 */

	WorkloadAuthorizationType  = model.WorkloadAuthorizationType

	// nolint
	HttpProtocolOptionsType = "envoy.extensions.upstreams.http.v3.HttpProtocolOptions"
)

// GetShortType returns an abbreviated form of a type, useful for logging or human friendly messages
func GetShortType(typeURL string) string {
	return model.GetShortType(typeURL)
}

// GetMetricType returns the form of a type reported for metrics

	WorkloadType              = APITypePrefix + "istio.workload.Workload"
	WorkloadAuthorizationType = APITypePrefix + "istio.security.Authorization"
)

// GetShortType returns an abbreviated form of a type, useful for logging or human friendly messages
func GetShortType(typeURL string) string {
	switch typeURL {
	case ClusterType:
		return "CDS"
	case ListenerType:
		return "LDS"
	case RouteType:

 */
internal fun KaSymbolByFirBuilder.buildAbbreviatedType(coneType: ConeClassLikeType): KaUsualClassType? {
    return coneType.abbreviatedType?.let { abbreviatedConeType ->
        // If the resulting type is an error type, the abbreviated type couldn't be resolved. As per the contract of
        // `KaType.abbreviatedType`, we should return `null` in such cases. The user can then fall back to the expanded type.

 * the expansion-site module instead of the use-site module in these tests, as we want to check the `KaType` when it's built with an
 * expanded type from a library vs. from a source module. (Abbreviated types from libraries and from sources aren't necessarily constructed
 * in the same way.)
 *
 * This test is different from [AbstractTypeByDeclarationReturnTypeTest] because we want to generate tests for extension-site modules with

        if (actualName == null) {
            throw throwTaskSelectionException(context, targetProject, taskName, includeSubprojects, matcher);
        }
        LOGGER.info("Abbreviated task name '{}' matched '{}'", taskName, actualName);
        return new TaskSelection(targetProject.getProjectPath().getPath(), taskName, tasksByName.get(actualName));
    }

----
No exact project with name ':mAL' has been found. Checking for abbreviated names.
Found exactly one project that matches the abbreviated name ':mAL': ':my-awesome-library'.
No exact task with name ':cT' has been found. Checking for abbreviated names.
Found exactly one task name, that matches the abbreviated name ':cT': ':compileTest'.
----

== Common tasks

	Everything
)

// The number of single names should not exceed 64.
// This will break masking. Use bit 63 as extension.
var _ = uint64(1 << objectSingleTypesEnd)

// Expand - returns expanded values of abbreviated event type.
func (name Name) Expand() []Name {
	switch name {

	case ObjectAccessedAll:
		return []Name{
			ObjectAccessedGet, ObjectAccessedHead,