> For the complete documentation index, see [llms.txt](https://docs.konsist.lemonappdev.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.konsist.lemonappdev.com/features/declaration-references.md). # Declaration References Declaration reference represents a link between codebase declarations. Konsist allows precise verification of properties of the linked type. This type can be used in function or property declaration or child/parent class or interface. For example: 1\. Verify if all types of function parameters are interfaces: ```kotlin Konsist .scopeFromProject() .functions() .parameters .types .assertTrue { it.sourceDeclaration?.isInterface } ``` 2\. Access properties of parents (parent classes and parent interfaces). Below snippet checks if all parent interfaces have `internal` modifier: ```kotlin fun `all parent interfaces are internal`() { Konsist .scopeFromProject() .classes() .parentInterfaces() .assertTrue { it.sourceDeclaration?.asInterfaceDeclaration()?.hasInternalModifier } } ``` 3\. Access properties of children (child classes and child interfaces). Below snippet checks if all interfaces have children that reside in `..somepackage..` package: ```kotlin Konsist .scopeFromProject() .interfaces() .assertTrue { it.hasAllChildren(indirectChildren = true) { child -> child.resideInPackage("..somepackage..") } } ``` ## Type Representation Kotlin types can be defined in multiple ways. Consider `foo` property with `Foo` type: ```kotlin val foo: Foo ``` The `Foo` type can be defined by: * class * interface * object * type alias * import alias * kotlin types (Kotlin basic type or Kotlin collections type) * function type * external library (type defined outside project codebase) represents declaration which is not defined in the project The `Foo` type can be represented by one of `KoXDeclaration` classes:

Source	Declaration
#type-represented-by-class	`KoClassDeclaration`
#type-represented-by-interface	`KoInterfaceDeclaration`
#type-represented-by-object	`KoObjectDeclaration`
#type-represented-by-type-alias	`KoTypeAliasDeclaration`
#type-represented-by-import-alias	`KoImportAliasDeclaration`
#type-represented-by-kotlin-type	`KoKotlinTypeDeclaration`
#type-represented-function-type	`KoFunctionDeclaration`
#type-represented-by-external-type	`KoExternalDeclaration`

Each of these types possesses a largely distinct set of characteristics; for instance, classes and interfaces can include annotations, whereas import aliases cannot. To access properties of the specific declaration type, the declaration must be cast to a more specific type (from generic `KoTypeDeclaration`). Example below assumes that `Foo` is represented by the `Foo` class: ```kotlin Konsist .scopeFromProject() .properties() .types .assertTrue { koTypeDeclaration -> val koClass = koTypeDeclaration.sourceDeclaration as KoClassDeclaration koClass.hasAllAnnotations { it.representsTypeOf() } } ``` To facilitate testing Konsist API provides a set of dedicated casting extensions. The above code can be simplified: ```kotlin Konsist .scopeFromProject() .properties() .types .assertTrue { koTypeDeclaration -> koTypeDeclaration .sourceDeclaration ?.asClassDeclaration() ?.hasAllAnnotations { it.representsTypeOf() } } ``` Here is the list of all casting extensions (available on `sourceDeclaration`):

Source	Declaration	Cast Extension	Type Check Extension
#type-represented-by-class	`KoClassDeclaration`	`asClassDeclaration()`	`isClass`
#type-represented-by-interface	`KoInterfaceDeclaration`	`asInterfaceDeclaration()`	`isInterface`
#type-represented-by-object	`KoObjectDeclaration`	`asObjectDeclaration()`	`isObject`
#type-represented-by-type-alias	`KoTypeAliasDeclaration`	`asTypeAliasDeclaration()`	`isTypeAlias`
#type-represented-by-import-alias	`KoImportAliasDeclaration`	`asImportAliasDeclaration()`	`isImportAlias`
#type-represented-by-kotlin-type	`KoKotlinTypeDeclaration`	`asKotlinTypeDeclaration()`	`isKotlinType`
#type-represented-by-external-type	`KoExternalDeclaration`	`asExternalDeclaration()`	`isExternal`

### Type Represented By Class Source code: ```kotlin internal class Foo ``` Usage: ```kotlin val foo: Foo? = null ``` Konsist test: ```kotlin scope .properties() .types .assertTrue { it.sourceDeclaration?.asClassDeclaration()?.hasInternalModifier } ``` ### Type Represented By Interface Source code: ```kotlin internal interface Foo ``` Usage: ```kotlin val foo: Foo? = null ``` Konsist test: ```kotlin scope .properties() .types .assertTrue { it.sourceDeclaration?.asInterfaceDeclaration()?.hasInternalModifier } ``` ### Type Represented By Object This scenario is uncommon, but still possible. Source code: ```kotlin internal object Foo ``` Usage: ```kotlin val foo: Foo? = null ``` Konsist test: ```kotlin scope .properties() .types .assertTrue { it.sourceDeclaration?.asObjectDeclaration()?.hasInternalModifier } ``` ### Type Represented By Type Alias Source code: ```kotlin internal interface Foo ``` Usage: ```kotlin typealias MyFoo = Foo val foo: MyFoo? = null ``` Konsist test: ```kotlin scope .properties() .types .assertTrue { it .sourceDeclaration ?.asTypeAliasDeclaration() ?.type ?.sourceDeclaration ?.asInterfaceDeclaration() ?.hasInternalModifier } ``` ### Type Represented By Import Alias Source code: ```kotlin internal interface Foo ``` Usage: ```kotlin import com.app.Foo as MyFoo val foo: MyFoo? = null ``` Konsist test: ```kotlin scope .properties() .types .assertTrue { it .sourceDeclaration ?.asImportAliasDeclaration() ?.sourceDeclaration ?.asInterfaceDeclaration() ?.hasInternalModifier } ``` ### Type Represented By Kotlin Type Source code: ```kotlin // Kotlin internal source code for String ``` Usage: ```kotlin val foo: String? = null ``` Konsist test:

scope
    .properties()
    .types
    .assertTrue {
        it.sourceDeclaration?.asKotlinTypeDeclaration()?.name == "String"
    }

### Type Represented Function Type Source code: ```kotlin // Kotlin internal source code ``` Usage: ```kotlin val foo: (() -> Unit)? = null ``` Konsist test:

scope
    .properties()
    .types
    .assertTrue {
        it
            .parameters
            ?.isEmpty()
    }

### Type Represented By External Type External type represents the type defined outside of the project codebase, usually by external library. Konsist is not able to parse this type, so type information is limited (Konsist is not able to parse the compiled file). For example: ```kotlin class MyViewModel : ViewModel() ``` The Android `ViewModel` class is provided by `androidx.lifecycle:lifecycle-viewmodel-ktx` dependency, so Konsist has limited information. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://docs.konsist.lemonappdev.com/features/declaration-references.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.