> 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/writing-tests/declaration-query-and-filter.md). # Declaration Filtering Query and filter declarations using Konsist API ## Query Declarations Declaration querying allows retrieval of declarations of a given type. It is the middle step of the Konsist config preceded by scope retrieval ([Create The Scope](/writing-tests/koscope.md)) and followed by the verification ([Declaration Assertion](/writing-tests/declaration-assert.md)) step. ```mermaid %%{init: {'theme':'forest'}}%% flowchart TB Step1["1\. Create The Scope"]-->Step2 Step2["2\. Filter Declarations"]-->Step3 Step3["3\. Define Assertion"] style Step2 fill:#52B523,stroke:#666,stroke-width:2px,color:#fff ``` Typically, verification is performed on a collection of declarations such as methods marked with particular annotations or classes located within a single package. Every [Create The Scope](/writing-tests/koscope.md) contains a set of declarations ([Declaration](/features/declaration.md)) such as classes (`KoClassDeclaration`), properties (`KoPropertyDeclaration`), functions (`KoFunctionDeclaration`), etc. The `KoScope` class provides a set of properties and methods to access Kotlin declarations. Each of them returns a list representing a declaration subset: | Method | Description | | ---------------- | --------------------------------------------- | | `files` | returns all files present in the scope | | `packages` | returns all packages present in the scope | | `imports` | returns all imports present in the scope | | `classes()` | returns all classes present in the scope | | `interfaces()` | returns all interfaces present in the scope | | `objects()` | returns all objects present in the scope | | `functions()` | returns all functions present in the scope | | `properties()` | returns all properties present in the scope | | `typeAliases` | returns all type aliases present in the scope | | `declarations()` | returns all declarations present in the scope | To get all classes from the given scope use `KoScope.classes()` method: ```kotlin koScope .classes() ``` Here is an example of querying all properties defined inside classes: ```kotlin koScope .classes() .properties() .assertTrue { //... } ``` ## Filter Declarations More granular filtering can be applied to additionally filter classes annotated with certain attributes like classes annotated with `UseCase` annotation. Konsist is compatible with [Kotlin Collection processing](https://kotlinlang.org/docs/collections-overview.html#list) API, so the `filter` method can be used to filter the content of the `List`. Here, `filter` returns classes annotated with `UseCase` annotation: ```kotlin koScope .classes() .filter { it.hasAnnotationOf() } .assertTrue { //... } ``` Konsist provides a set of `with...` extensions to simplify the filtering syntax. The above snippet can be improved: ```kotlin koScope .classes() .withAllAnnotationsOf(UseCase::class) .assertTrue { //... } ``` {% hint style="info" %} The `.`**`withAllAnnotationsOf`**`(Annotation1::class, Annotation2::class)` filters classes having all annotations present (`Annotation1` **and** `Annotation2`). The `.`**`withAnnotationOf`**`(Annotation1::class, Annotation2::class)` filters classes having at least one annotation (`Annotation1` **or** `Annotation2`)`.` {% endhint %} Multiple conditions can be chained to perform more specific filtering. The below snippet filters classes annotated with the `UseCase` annotation that reside in the `usecase` package: ```kotlin koScope .classes() .withAllAnnotationsOf(UseCase::class) .withPackage("..usecase") .assertTrue { //... } ``` It is also possible to filter declarations by using certain aspects e.g. visibility modifiers. Usage of `providers` allows verifying the visibility of different declaration types such as classes, functions, properties, etc: ```kotlin koScope .declarationsOf() .assertTrue { it.hasInternalModifier } ``` ## Query And Filter Declaration Querying and filtering stages can be mixed to perform more specific checks. The below snippet filters classes residing in the `controller` package, retrieves all properties, and filters properties with the `Inject` annotation: ```kotlin koScope .classes() // query all classes .withPackage("..controller") // filter classes in 'controller' package .properties() // query all properties .withAnnotationOf(Inject::class) // filter properties annotated with 'Inject' .assertTrue { //... } ``` ## Print Declarations To print all declarations within the list, use the `print()` method: ```kotlin koScope .classes() .properties() .print() ``` --- # 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/writing-tests/declaration-query-and-filter.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.