}

public typealias KtLifetimeOwner = KaLifetimeOwner

public fun KaLifetimeOwner.isValid(): Boolean = token.isValid()

@Suppress("NOTHING_TO_INLINE")
public inline fun KaLifetimeOwner.assertIsValidAndAccessible() {
    token.assertIsValidAndAccessible()
}

public inline fun <R> KaLifetimeOwner.withValidityAssertion(action: () -> R): R {
    assertIsValidAndAccessible()
    return action()
}

/**

public typealias KtTypeCreatorMixIn = KaTypeCreatorMixIn

public inline fun KaTypeCreatorMixIn.buildClassType(
    classId: ClassId,
    build: KaClassTypeBuilder.() -> Unit = {},
): KaType =
    analysisSession.typesCreator.buildClassType(KaClassTypeBuilder.ByClassId(classId, token).apply(build))

public inline fun KaTypeCreatorMixIn.buildClassType(
    symbol: KaClassLikeSymbol,

                property("kind", "Unknown")
            }
        }
    }

    private
    inline fun <T> jsonObjectList(list: Iterable<T>, body: (T) -> Unit) {
        jsonList(list) {
            jsonObject {
                body(it)
            }
        }
    }

    private
    inline fun jsonObject(body: () -> Unit) {
        beginObject()
        body()
        endObject()
    }

namespace detail {

inline LogicalResult verifyIsIdempotent(Operation* op) {
  // TODO(b/246518997): Add back check for no side effects on operation.
  // Currently adding it would cause the shared library build
  // to fail since there would be a dependency of IR on SideEffectInterfaces
  // which is cyclical.
  return success();
}

inline OpFoldResult foldIdempotent(Operation* op) {

/**
 * Get symbol [PsiElement] if its type is [PSI], otherwise throws ClassCastException
 *
 * @see KaSymbol.psi
 */
public inline fun <reified PSI : PsiElement> KaSymbol.psi(): PSI =
    psi as PSI

/**
 * Get symbol [PsiElement] if its type is [PSI], otherwise null
 *
 * @see KaSymbol.psi
 */
public inline fun <reified PSI : PsiElement> KaSymbol.psiSafe(): PSI? =
    psi as? PSI

/**

        }
    }

    /**
     * Returns the list of files that contain all reached inline functions.
     */
    fun allFiles(): List<KtFile> = analyzedElements.mapTo(mutableSetOf()) { it.containingKtFile }.toList()

    /**
     * Returns the set of [KtObjectDeclaration]s which are defined as an object literal in one of the reached inline functions.
     */
    fun inlineObjectDeclarations(): Set<KtObjectDeclaration> {

// +k8s:prerelease-lifecycle-gen:introduced=1.8

// Role is a namespaced, logical grouping of PolicyRules that can be referenced as a unit by a RoleBinding.
type Role struct {
	metav1.TypeMeta `json:",inline"`
	// Standard object's metadata.
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`

	// Rules holds all the PolicyRules for this Role
	// +optional

        listOfNotNull(kotlinFile.script?.takeIf { it.fqName == scriptFqName })

    private inline fun <reified T : KtCallableDeclaration> getTopLevelCallables(callableId: CallableId): Collection<T> {
        require(callableId.classId == null)
        return getTopLevelDeclarations(callableId.packageName, callableId.callableName)
    }

    public fun renderDeclarationModifiers(analysisSession: KaSession, symbol: KaDeclarationSymbol, printer: PrettyPrinter) {
        modifierListRenderer.renderModifiers(analysisSession, symbol, this, printer)
    }

    public inline fun with(action: Builder.() -> Unit): KaDeclarationModifiersRenderer {
        val renderer = this
        return KaDeclarationModifiersRenderer {
            this.modifierListRenderer = renderer.modifierListRenderer

 * @param description A human-readable description of the [action], which is used to generate error messages when
 *  [analyze][org.jetbrains.kotlin.analysis.api.analyze] is called.
 */
@OptIn(KaAnalysisApiInternals::class)
public inline fun <R> forbidAnalysis(description: String, action: () -> R): R {
    val permissionRegistry = KaAnalysisPermissionRegistry.getInstance()
    if (permissionRegistry.explicitAnalysisRestriction != null) return action()