Koin Annotations

https://insert-koin.io/docs/reference/koin-annotations/
Admin
Koin Annotations is a library that lets you declare Koin dependency injection definitions using...
Tokens:19,461
Snippets:258
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Complete Koin Compiler Plugin Configuration Example

Source: https://insert-koin.io/docs/reference/koin-annotations/options

An example demonstrating how to configure all available options for the Koin compiler plugin in build.gradle.kts.

```kotlin
// build.gradle.kts
plugins {
    alias(libs.plugins.koin.compiler)
}

koinCompiler {
    userLogs = true           // Log component detection
    debugLogs = false         // Verbose logs (off by default)
    compileSafety = true      // Compile-time dependency validation
    strictSafety = true       // Force aggregator to re-run safety pass (auto-detected by default)
    skipDefaultValues = true  // Use Kotlin defaults instead of DI resolution
    unsafeDslChecks = true    // Validate DSL usage
}

```

--------------------------------

### Start Koin Application

Source: https://insert-koin.io/docs/reference/koin-annotations/modules

Initiate the Koin application using the typed API, with or without a configuration block.

```kotlin
fun main() {  
    startKoin<MyApp>()  
  
    // Or with configuration  
    startKoin<MyApp> {  
        printLogger()  
    }  
}  
```

--------------------------------

### Custom Configuration for Koin Application

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Demonstrates how to provide additional configuration options when starting a Koin application manually.

```kotlin
MyApp.startKoin {
    printLogger()
    // additional configuration
}
```

--------------------------------

### Load Specific Configurations at Startup

Source: https://insert-koin.io/docs/reference/koin-annotations/start

When starting Koin with @KoinApplication, you can specify which configurations to load using the 'configurations' parameter. This allows for environment-specific module loading.

```kotlin
@KoinApplication(
    modules = [CoreModule::class],
    configurations = ["prod"] // Only loads @Configuration("prod") modules
)
class ProdApp

fun main() {
    startKoin<ProdApp>()
}
```

--------------------------------

### Implement Actual ContextWrapper for Android

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Provide the 'actual' implementation of ContextWrapper for Android, including its constructor and the module providing it. Requires androidContext() setup.

```kotlin
// androidMain  
actual class ContextWrapper(val context: Context)  

@Module  
actual class ContextModule {  
      
    // needs androidContext() to be setup at start  
    @Single  
    actual fun providesContextWrapper(scope : Scope) : ContextWrapper = ContextWrapper(scope.get())  
}  

```

--------------------------------

### Start Koin Application with @KoinApplication

Source: https://insert-koin.io/docs/reference/koin-annotations/start

Use the @KoinApplication annotation on your application class to specify the modules to load. The typed startup API `startKoin<MyApp>()` is then used in your main function.

```kotlin
@KoinApplication(modules = [AppModule::class])
class MyApp

fun main() {
    startKoin<MyApp> {
        printLogger()
    }

    // Use your Koin API as usual
    KoinPlatform.getKoin().get<MyService>()
}
```

--------------------------------

### Setup Koin Compiler Plugin and Dependencies

Source: https://insert-koin.io/docs/reference/koin-annotations/start

Add the Koin Compiler Plugin to your build.gradle.kts file and include the necessary Koin core and annotations dependencies.

```gradle
plugins {
    alias(libs.plugins.koin.compiler)
}

dependencies {
    implementation(libs.koin.core)
    implementation(libs.koin.annotations)
}
```

--------------------------------

### Module Load Order and Overrides Example

Source: https://insert-koin.io/docs/reference/koin-annotations/modules

Demonstrates how Koin handles module load order and overrides, where app-level overrides win over dependency defaults. The last-defined module takes precedence.

```kotlin
// In a dependency library module  
@Module @Configuration  
class CoreModule {  
    @Singleton fun feature(): Feature = DefaultFeature()  
}  

// In your app module  
@Module  
class AppModule {  
    @Singleton fun feature(): Feature = AppFeature()  // custom override  
}  

@KoinApplication(modules = [AppModule::class])  
class MyApp  
// Load order: CoreModule (DefaultFeature) → AppModule (AppFeature wins)  
// Runtime get<Feature>() returns AppFeature.  
```

--------------------------------

### Implement Actual NativeModuleD for iOS

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Provide the actual implementation for the expect NativeModuleD in the iOSMain source set. This includes the actual factory function and the platform-specific component implementation, which does not require platform-specific context in this example.

```kotlin
// iOSMain
@Module
actual class NativeModuleD {
    @Factory
    actual fun providesPlatformComponentD(scope : org.koin.core.scope.Scope) : PlatformComponentD = PlatformComponentDiOS()
}

class PlatformComponentDiOS : PlatformComponentD{
    override fun sayHello() : String = "I'm iOS - D"
}
```

--------------------------------

### Use KoinTestRule for Testing Modules

Source: https://insert-koin.io/docs/reference/koin-annotations/start

The KoinTestRule allows you to load specific modules for testing purposes, such as loading a NetworkModule, without starting a full application.

```kotlin
@get:Rule
val koinTestRule = KoinTestRule.create {
    module<NetworkModule>()
}
```

--------------------------------

### Referencing Root Module with Included Modules

Source: https://insert-koin.io/docs/reference/koin-annotations/modules

When referencing a root module in your @KoinApplication, any modules included within it are automatically loaded, simplifying application setup.

```kotlin
@KoinApplication(modules = [ModuleB::class])  // Includes ModuleA automatically  
class MyApp  
  
fun main() {  
    startKoin<MyApp>()  
}  
```

--------------------------------

### Apply Koin Compiler Plugin in Gradle

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Apply the Koin compiler plugin in your shared module's build.gradle.kts file to enable Koin annotations. This is the primary setup step for KMP projects.

```kotlin
plugins {
    kotlin("multiplatform")
    alias(libs.plugins.koin.compiler)
}

kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation(libs.koin.core)
            implementation(libs.koin.annotations)
        }
    }
}
```

--------------------------------

### Define Component with Automatic Binding

Source: https://insert-koin.io/docs/reference/koin-annotations/definitions

Koin automatically detects associated supertypes (bindings) for a component. This example shows a component tied to MyInterface.

```kotlin
@Single
class MyComponent(val myDependency : MyDependency) : MyInterface
```

--------------------------------

### Generate Singleton DSL with @Single

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

The @Single annotation generates the Koin DSL for a singleton definition. This example shows the generated DSL for a simple class with a dependency.

```kotlin
single { MyClass(get()) }  

```

--------------------------------

### Generate Factory DSL with @Factory

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

The @Factory annotation generates the Koin DSL for a factory definition. This example shows the generated DSL for a simple class with a dependency.

```kotlin
factory { MyClass(get()) }  

```

--------------------------------

### Injecting Lazy Dependencies with `Lazy<T>`

Source: https://insert-koin.io/docs/reference/koin-annotations/definitions

Koin automatically resolves `Lazy<T>` types. The generated DSL uses `inject()` instead of `get()` for lazy resolution.

```kotlin
@Single
class LoggerInMemoryDataSource : LoggerDataSource

@Single
class LoggerAggregator(val lazyLogger : Lazy<LoggerDataSource>)
```

```kotlin
single { LoggerAggregator(inject()) }
```

--------------------------------

### Dependency resolution from within a scope

Source: https://insert-koin.io/docs/reference/koin-annotations/scope

Scoped definitions can resolve dependencies from inner scopes and parent scopes. This example shows resolution of a root 'single' definition and another scoped definition.

```kotlin
@Single
class MySingle

@Scope(name = "my_scope_name")
@Scoped
class MyScopedComponent(
  val mySingle : MySingle,
  val myOtherScopedComponent :MyOtherScopedComponent
)

@Scope(name = "my_scope_name")
@Scoped
class MyOtherScopedComponent(
  val mySingle : MySingle
)
```

--------------------------------

### Using Koin Configurations with @KoinApplication

Source: https://insert-koin.io/docs/reference/koin-annotations/modules

Specify which configurations to load when bootstrapping your Koin application using the 'configurations' parameter of the @KoinApplication annotation.

```kotlin
@KoinApplication(configurations = ["default", "production"])  
class ProductionApp  
  
@KoinApplication(configurations = ["default", "development"])    
class DevelopmentApp  
  
// Load only default configuration (same as @KoinApplication with no parameters)  
@KoinApplication  
class SimpleApp  
```

--------------------------------

### Define Application Entry Point with @KoinApplication

Source: https://insert-koin.io/docs/reference/koin-annotations/modules

Use the `@KoinApplication` annotation to define your application's entry point, specifying the modules to include.

```kotlin
@KoinApplication(modules = [MyModule::class])  
class MyApp  
```

```kotlin
@KoinApplication(  
    modules = [CoreModule::class],  
    configurations = ["production"]  
)  
class ProdApp  
```

--------------------------------

### Specific Configurations Bootstrap with @KoinApplication

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Specify configurations to scan during bootstrap by passing them to the 'configurations' parameter of @KoinApplication.

```kotlin
@KoinApplication(configurations = ["default", "prod"])
class MyApp
```

--------------------------------

### Bootstrap with Modules using @KoinApplication

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Include specific Koin modules during bootstrap by listing them in the 'modules' parameter of @KoinApplication.

```kotlin
@KoinApplication(
    configurations = ["default"],
    modules = [CoreModule::class, ApiModule::class]
)
class MyApp
```

--------------------------------

### Generate ViewModel Scope DSL with @ViewModelScope

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

The @ViewModelScope annotation generates the Koin DSL for a scoped definition within the viewModelScope. This example shows the generated DSL for a class.

```kotlin
viewModelScope {  
    scoped { MyClass(get()) }  
}  

```

--------------------------------

### Initialize Kotzilla Analytics in Koin Configuration

Source: https://insert-koin.io/docs/reference/koin-annotations/monitor

Enable Kotzilla monitoring by calling the analytics() function during Koin initialization. Ensure the Kotzilla SDK is configured.

```kotlin
import io.kotzilla.sdk.analytics.koin.analytics

fun initKoin() {
    startKoin {
        // Enable Kotzilla monitoring
        analytics()
        modules(appModule)
    }
}
```

--------------------------------

### Support Multiple Configurations for Modules

Source: https://insert-koin.io/docs/reference/koin-annotations/modules

Associate a module with multiple configurations by listing them in the `@Configuration` annotation. This allows a module to be available in different environments or scenarios.

```kotlin
// This module is available in both "prod" and "test" configurations  
@Module  
@Configuration("prod", "test")  
class DatabaseModule {  
    @Single  
    fun database() = PostgreSQLDatabase()  
}  

// This module is available in default, test, and development  
@Module  
@Configuration("default", "test", "development")   
class LoggingModule {  
    @Single  
    fun logger() = Logger()  
}  
```

--------------------------------

### Declare a Scope with @Scope Annotation (Class)

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Use @Scope with a KClass value to define a custom scope. This example shows how to declare a class within a scope named MyScope.

```kotlin
@Scope(MyScope::class)  
class MyClass(val d : MyDependency)  

```

--------------------------------

### Implement Actual PlatformComponentA for Android

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Provide the 'actual' implementation of PlatformComponentA for Android, utilizing the Android ContextWrapper to return a platform-specific string.

```kotlin
// androidMain  
  
// package com.jetbrains.kmpapp.native  
actual class PlatformComponentA actual constructor(val ctx : ContextWrapper) {  
    actual fun sayHello() : String = "I'm Android - A - with context: ${ctx.context}"  
}  

```

--------------------------------

### Declare a Scope with @Scope Annotation (String Name)

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Use @Scope with a String name to define a custom scope. This example shows how to declare a class within a scope named 'my_custom_scope'.

```kotlin
@Scope(name = "my_custom_scope")  
class MyClass(val d : MyDependency)  

```

--------------------------------

### Generate Scoped DSL with @Scope (Class)

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

The @Scope annotation with a KClass value generates the Koin DSL for a scoped definition. This example shows the generated DSL for a class within a MyScope.

```kotlin
scope<MyScope> {  
    scoped { MyClass(get()) }  
}  

```

--------------------------------

### Define Regular and Scoped Components

Source: https://insert-koin.io/docs/reference/koin-annotations/scope

Illustrates how to define regular singletons alongside scoped components using scope archetype annotations like @ActivityScope and @FragmentScope.

```kotlin
// Regular components  
@Single  
class GlobalService  
  
// Scoped components using archetypes  
@ActivityScope  
class ActivityService(val global: GlobalService)  
  
@FragmentScope    
class FragmentService(  
    val global: GlobalService,  
    val activity: ActivityService  
)  

```

--------------------------------

### Default and Specific Configurations with @Configuration

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Combine the default configuration with specific names using @Configuration.

```kotlin
@Module
@Configuration("default", "test")
class MyModule
```

--------------------------------

### Default Configuration Bootstrap with @KoinApplication

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Use @KoinApplication on a class to generate default Koin application bootstrap functions.

```kotlin
@KoinApplication
class MyApp
```

--------------------------------

### Implement Actual PlatformComponentA for iOS

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Provide the actual implementation for the expect PlatformComponentA in the iOSMain source set. This implementation fulfills the contract defined in commonMain.

```kotlin
// iOSMain

// package com.jetbrains.kmpapp.native
actual class PlatformComponentA {
    actual fun sayHello() : String = "I'm iOS - A"
}
```

--------------------------------

### Implement Actual PlatformComponentB for iOS

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Provide the actual implementation for the expect PlatformComponentB in the iOSMain source set. This implementation fulfills the contract defined in commonMain.

```kotlin
// iOSMain

// package com.jetbrains.kmpapp.native
actual class PlatformComponentB {
    actual fun sayHello() : String = "I'm iOS - B"
}
```

--------------------------------

### Organize Modules with @Configuration

Source: https://insert-koin.io/docs/reference/koin-annotations/modules

Use the `@Configuration` annotation to organize modules into different configurations, such as environments or feature sets. The default configuration is named 'default'.

```kotlin
// Put module in default Configuration  
@Module  
@Configuration  
class CoreModule  
```

```kotlin
// module A  
@Module  
@Configuration  
class ModuleA  
  
// module B  
@Module  
@Configuration  
class ModuleB  
  
// module App, scan all @Configuration modules  
@KoinApplication  
object MyApp  
```

--------------------------------

### Implement Actual PlatformComponentA for iOS

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Provide the 'actual' implementation of PlatformComponentA for iOS. This version does not use the ContextWrapper in its output.

```kotlin
// iOSMain  

// package com.jetbrains.kmpapp.native  
actual class PlatformComponentA actual constructor(val ctx : ContextWrapper) {  
    actual fun sayHello() : String = "I'm iOS - A"  
}  

```

--------------------------------

### Default Configuration with @Configuration

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Apply @Configuration without arguments to a @Module class to include it in the default configuration.

```kotlin
@Module
@Configuration
class MyModule
```

--------------------------------

### Environment-Specific Koin Configurations

Source: https://insert-koin.io/docs/reference/koin-annotations/modules

Define modules that are loaded based on the environment. Use @Configuration to tag modules for specific environments like 'development' or 'production', or 'default' for general use.

```kotlin
// Development-only configuration  
@Module  
@Configuration("development")  
class DevDatabaseModule {  
    @Single  
    fun database() = InMemoryDatabase()  
}  
  
// Production-only configuration    
@Module  
@Configuration("production")  
class ProdDatabaseModule {  
    @Single  
    fun database() = PostgreSQLDatabase()  
}  
  
// Available in multiple environments  
@Module  
@Configuration("default", "production", "development")  
class CoreModule {  
    @Single  
    fun logger() = Logger()  
}
```

--------------------------------

### Implement Actual PlatformComponentB for Android

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Provide the actual implementation for the expect PlatformComponentB in the androidMain source set. This implementation fulfills the contract defined in commonMain.

```kotlin
// androidMain

// package com.jetbrains.kmpapp.native
actual class PlatformComponentB {
    actual fun sayHello() : String = "I'm Android - B"
}
```

--------------------------------

### Implement Actual PlatformComponentA for Android

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Provide the actual implementation for the expect PlatformComponentA in the androidMain source set. This implementation fulfills the contract defined in commonMain.

```kotlin
// androidMain

// package com.jetbrains.kmpapp.native
actual class PlatformComponentA {
    actual fun sayHello() : String = "I'm Android - A"
}
```

--------------------------------

### Injecting List of Dependencies with `List<T>`

Source: https://insert-koin.io/docs/reference/koin-annotations/definitions

Koin automatically resolves all definitions of a given type into a `List<T>`. The generated DSL uses `getAll()`.

```kotlin
@Single
@Named("InMemoryLogger")
class LoggerInMemoryDataSource : LoggerDataSource

@Single
@Named("DatabaseLogger")
class LoggerLocalDataSource(private val logDao: LogDao) : LoggerDataSource

@Single
class LoggerAggregator(val datasource : List<LoggerDataSource>)
```

```kotlin
single { LoggerAggregator(getAll()) }
```

--------------------------------

### Configure allOpen Plugin for @Monitor

Source: https://insert-koin.io/docs/reference/koin-annotations/monitor

Configure the allOpen plugin to make classes annotated with @Monitor extensible. This is required for the proxy generation to work correctly.

```kotlin
plugins {
    id "org.jetbrains.kotlin.plugin.allopen"
}

allOpen {
    annotation("org.koin.core.annotation.Monitor")
}
```

--------------------------------

### Multiple Configurations with @Configuration

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Specify multiple configuration names in @Configuration to make a @Module class available in different environments.

```kotlin
@Module
@Configuration("prod", "test")
class MyModule
```

--------------------------------

### Implement Actual NativeModuleD for Android

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Provide the actual implementation for the expect NativeModuleD in the androidMain source set. This includes the actual factory function and the platform-specific component implementation, which can access Android-specific context.

```kotlin
// androidMain

@Module
actual class NativeModuleD {
    @Factory
    actual fun providesPlatformComponentD(scope : org.koin.core.scope.Scope) : PlatformComponentD = PlatformComponentDAndroid(scope)
}

class PlatformComponentDAndroid(scope : org.koin.core.scope.Scope) : PlatformComponentD{
    val context : Context = scope.get()
    override fun sayHello() : String = "I'm Android - D - with ${context}"
}
```

--------------------------------

### Annotate Components with Koin Definitions

Source: https://insert-koin.io/docs/reference/koin-annotations/start

Tag your classes with Koin definition annotations like @Singleton and @Factory to have them processed by the compiler plugin. Dependencies are automatically resolved.

```kotlin
@Singleton
class MyRepository

@Singleton
class MyService(val repository: MyRepository)

@Factory
class MyUseCase(val service: MyService)
```

--------------------------------

### Scan with Glob Patterns using @ComponentScan

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Utilize glob patterns with @ComponentScan for flexible package scanning, including multi-level and wildcard matching.

```kotlin
@ComponentScan("com.example.**", "org.app.*.services")
class MyApp
```

--------------------------------

### Provide Instances with Annotated Top-Level Functions

Source: https://insert-koin.io/docs/reference/koin-annotations/definitions

Use annotations like @Singleton on top-level functions to provide instances, useful for external libraries. Parameters are auto-resolved from the DI container. Qualifiers like @Named can be used.

```kotlin
import org.koin.core.annotation.Singleton  
import org.koin.core.annotation.Factory  
import org.koin.core.annotation.Named  
  
// Provide a Room database instance  
@Singleton  
fun provideDatabase(context: Context): AppDatabase =  
    Room.databaseBuilder(context, AppDatabase::class.java, "my-db").build()  
  
// Provide a JSON serializer  
@Singleton  
fun provideJson(): Json = Json { ignoreUnknownKeys = true }  
  
// Provide an HTTP client  
@Singleton  
@Named("api")  
fun provideHttpClient(json: Json): HttpClient = HttpClient { install(ContentNegotiation) { json(json) } }
```

--------------------------------

### Enable User Logs for Koin Compiler

Source: https://insert-koin.io/docs/reference/koin-annotations/options

Enable logs for component detection and DSL/annotation processing to debug component discovery issues.

```kotlin
koinCompiler {
    userLogs = true
}

```

--------------------------------

### Implement Actual ContextWrapper for iOS

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Provide the 'actual' implementation of ContextWrapper for iOS. This implementation is simpler as it doesn't require an Android Context.

```kotlin
// iOSMain  
actual class ContextWrapper  

@Module  
actual class ContextModule {  

    @Single  
    actual fun providesContextWrapper(scope : Scope) : ContextWrapper = ContextWrapper()  
}  

```

--------------------------------

### Configure Koin Compiler Plugin Options

Source: https://insert-koin.io/docs/reference/koin-annotations/options

Set various options for the Koin compiler plugin in your build.gradle.kts file to customize its behavior.

```kotlin
koinCompiler {
    userLogs = true
    debugLogs = false
    compileSafety = true
    strictSafety = true       // auto-detected by default
    skipDefaultValues = true
    unsafeDslChecks = true
}

```

--------------------------------

### Define Configuration Labels for Modules

Source: https://insert-koin.io/docs/reference/koin-annotations/start

Use the @Configuration annotation on @Module classes to define different configurations. You can specify a label, like 'prod' or 'test', for specific module sets.

```kotlin
@Module
@Configuration // Default configuration
class CoreModule

@Module
@Configuration("prod")
class ProdModule

@Module
@Configuration("test")
class TestModule
```

--------------------------------

### Implement Actual NativeModuleC for iOS

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Provide the 'actual' implementation of NativeModuleC for iOS. In this case, no specific implementation is needed for iOS.

```kotlin
// iOSMain  
// do nothing on iOS  
@Module  
actual class NativeModuleC  

```

--------------------------------

### Kotzilla Platform Configuration

Source: https://insert-koin.io/docs/reference/koin-annotations/monitor

Configure your Kotzilla Platform API key and application details in the kotzilla.json file. This file is used by the Kotzilla SDK to authenticate and send monitoring data.

```json
{
  "sdkVersion": "latest.version",
  "keys": [
    {
      "appId": "your-app-id",
      "applicationPackageName": "com.example.app",
      "keyId": "your-key-id",
      "apiKey": "your-api-key"
    }
  ]
}
```

--------------------------------

### Module Provider Functions with @Singleton

Source: https://insert-koin.io/docs/reference/koin-annotations/definitions

Within a @Module class, functions annotated with @Singleton act as provider functions, similar to @Provides in Dagger/Hilt. This pattern is useful for wrapping external libraries.

```kotlin
import org.koin.core.annotation.Module  
import org.koin.core.annotation.Singleton  
  
@Module  
internal object DatabaseModule {  
  
    @Singleton  
    fun providesDatabase(context: Context): AppDatabase =  
        Room.databaseBuilder(context, AppDatabase::class.java, "my-db").build()  
}  
  
@Module(includes = [DatabaseModule::class])  
class DaosModule {  
  
    @Singleton  
    fun providesTopicDao(database: AppDatabase): TopicDao = database.topicDao()  
  
    @Singleton  
    fun providesNewsDao(database: AppDatabase): NewsResourceDao = database.newsResourceDao()  
}
```

--------------------------------

### Define Expect PlatformComponentA in commonMain

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Define an 'expect' class for PlatformComponentA in commonMain, which depends on ContextWrapper. This sets up the cross-platform interface.

```kotlin
// commonMain  
  
@Module  
@ComponentScan("com.jetbrains.kmpapp.native")  
class NativeModuleA()  
  
// package com.jetbrains.kmpapp.native  
@Factory  
expect class PlatformComponentA(ctx : ContextWrapper) {  
    fun sayHello() : String  
}  

```

--------------------------------

### Load Individual Modules Directly

Source: https://insert-koin.io/docs/reference/koin-annotations/start

You can load @Module classes directly using functions like `module<NetworkModule>()` and `modules(DataModule::class, CacheModule::class)` without needing a @KoinApplication class. This is particularly useful for testing.

```kotlin
startKoin {
    module<NetworkModule>()
    modules(DataModule::class, CacheModule::class)
}
```

--------------------------------

### Scan Current Package with @ComponentScan

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Use @ComponentScan without arguments to scan the current package and its subpackages for Koin definitions.

```kotlin
@ComponentScan
class MyApp
```

--------------------------------

### Scan for Expect/Actual Definitions in Common Code

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Declare a Koin module in commonMain and use @ComponentScan to scan for expect/actual definitions. The expect class is defined in commonMain, and actual implementations are provided in platform-specific source sets.

```kotlin
// commonMain

@Module
@ComponentScan("com.jetbrains.kmpapp.native")
class NativeModuleA()

// package com.jetbrains.kmpapp.native
@Factory
expect class PlatformComponentA() {
    fun sayHello() : String
}
```

--------------------------------

### Referencing Modules in @KoinApplication

Source: https://insert-koin.io/docs/reference/koin-annotations/modules

Include your custom modules in the Koin application bootstrap by listing them in the 'modules' parameter of the @KoinApplication annotation.

```kotlin
@KoinApplication(modules = [MyModule::class])  
class MyApp  
  
fun main() {  
    startKoin<MyApp>()  
}  
```

--------------------------------

### Load Individual Modules Directly

Source: https://insert-koin.io/docs/reference/koin-annotations/modules

Load `@Module` classes directly using `module<T>()` or `modules(vararg KClass)` without needing `@KoinApplication`. This is useful for tests or mixing annotation modules with DSL configuration.

```kotlin
startKoin {  
    module<NetworkModule>()  
    modules(DataModule::class, CacheModule::class)  
}  
```

```kotlin
// In tests — load only the modules you need  
@get:Rule  
val koinTestRule = KoinTestRule.create {  
    module<NetworkModule>()  
}  
```

--------------------------------

### Implement Actual NativeModuleC for Android

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Provide the 'actual' implementation of NativeModuleC for Android, including component scanning for native-only components. Also defines a PlatformComponentC.

```kotlin
// androidMain  
@Module  
@ComponentScan("com.jetbrains.kmpapp.other.android")  
actual class NativeModuleC  

//com.jetbrains.kmpapp.other.android  
@Factory  
class PlatformComponentC(val context: Context) {  
    fun sayHello() : String = "I'm Android - C - $context"  
}  

```

--------------------------------

### Scan Specific Packages with @ComponentScan

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Provide specific package names to @ComponentScan to target Koin definition scanning.

```kotlin
@ComponentScan("com.example.services", "com.example.repositories")
class MyApp
```

--------------------------------

### Define Expect Module with Platform-Specific Implementations

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

In commonMain, declare an expect class for a module that provides a platform-specific component. This allows for different constructor arguments or dependencies on each platform.

```kotlin
// commonMain

expect class NativeModuleD() {
    @Factory
    fun providesPlatformComponentD(scope : org.koin.core.scope.Scope) : PlatformComponentD
}

interface PlatformComponentD {
    fun sayHello() : String
}
```

--------------------------------

### Resolve Constructor Parameter from ParametersHolder with @InjectedParam (Usage)

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Demonstrates how to retrieve an instance of MyClass, passing a parameter for the @InjectedParam annotated constructor argument.

```kotlin
val instance = koin.get<MyClass> { parametersOf(42) }
```

--------------------------------

### Declare Expect/Actual Function Definition in Common Code

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Define a Koin module in commonMain that provides an expect class. The expect class definition is in commonMain, and actual implementations are provided in platform-specific source sets.

```kotlin
// commonMain

@Module
class NativeModuleB() {

    @Factory
    fun providesPlatformComponentB() : PlatformComponentB = PlatformComponentB()
}

expect class PlatformComponentB() {
    fun sayHello() : String
}
```

--------------------------------

### Define Expect ContextWrapper in commonMain

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Define an 'expect' class for ContextWrapper in the commonMain source set. This serves as a contract for platform-specific implementations.

```kotlin
// commonMain  
  
expect class ContextWrapper  
  
@Module  
expect class ContextModule() {  
  
    @Single  
    fun providesContextWrapper(scope : Scope) : ContextWrapper  
}  

```

--------------------------------

### Monitor Class with @Monitor

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Apply @Monitor to a class to automatically generate a Koin proxy that monitors all public method calls for performance tracing.

```kotlin
@Monitor
class UserService(private val userRepository: UserRepository) {
    fun findUser(id: String): User? = userRepository.findById(id)
}
```

--------------------------------

### Use Scope Archetypes on Function Definitions

Source: https://insert-koin.io/docs/reference/koin-annotations/scope

Demonstrates how scope archetype annotations can be applied to functions within Koin modules to define scoped components.

```kotlin
@Module  
class MyModule {  
      
    @ActivityScope  
    fun activityComponent(dep: MyDependency) = MyActivityComponent(dep)  
      
    @FragmentScope    
    fun fragmentComponent(dep: MyDependency) = MyFragmentComponent(dep)  
}  

```

--------------------------------

### Automatic Component Scanning with @ComponentScan

Source: https://insert-koin.io/docs/reference/koin-annotations/modules

Use @ComponentScan within a @Module to automatically discover and register components annotated with Koin annotations within the current package and its subpackages.

```kotlin
@Module  
@ComponentScan  
class MyModule  
```

--------------------------------

### Handle Nullable Dependencies

Source: https://insert-koin.io/docs/reference/koin-annotations/definitions

Koin automatically handles nullable dependencies. Use the nullable type in your constructor, and Koin will use `getOrNull()` for resolution.

```kotlin
@Single
class MyComponent(val myDependency : MyDependency?)
```

--------------------------------

### Generated UserService Proxy Class

Source: https://insert-koin.io/docs/reference/koin-annotations/monitor

The compiler generates a proxy class for components annotated with @Monitor. This proxy class wraps the original methods to capture performance metrics using Kotzilla's tracing capabilities.

```kotlin
/**
 * Generated by @Monitor - Koin proxy for 'UserService'
 */
class UserServiceProxy(userRepository: UserRepository) : UserService(userRepository) {
    override fun findUser(id: String): User? {
        return KotzillaCore.getDefaultInstance().trace("UserService.findUser") {
            super.findUser(id)
        }
    }
      
    override suspend fun createUser(userData: UserData): User {
        return KotzillaCore.getDefaultInstance().suspendTrace("UserService.createUser") {
            super.createUser(userData)
        }
    }
}
```

--------------------------------

### Declare a Singleton Component with @Single

Source: https://insert-koin.io/docs/reference/koin-annotations/definitions

Tag a class with @Single to declare it as a singleton instance, equivalent to `single { }` in the Koin DSL. Dependencies are automatically resolved.

```kotlin
@Single  
class MyComponent(val myDependency : MyDependency)
```

--------------------------------

### Define Expect NativeModuleC in commonMain

Source: https://insert-koin.io/docs/reference/koin-annotations/kmp

Define an 'expect' class for NativeModuleC in the commonMain source set. This serves as a placeholder for platform-specific module implementations.

```kotlin
// commonMain  
  
@Module  
expect class NativeModuleC()  

```

--------------------------------

### Declare Koin Modules with Annotations

Source: https://insert-koin.io/docs/reference/koin-annotations/start

Create a module class annotated with @Module and optionally @ComponentScan to organize your Koin definitions. The component scan will find annotated classes within the specified package.

```kotlin
@Module
@ComponentScan("com.myapp")
class AppModule
```

--------------------------------

### Add Kotzilla SDK Dependency

Source: https://insert-koin.io/docs/reference/koin-annotations/monitor

Include the Kotzilla SDK dependency in your project's build file. Check the Kotzilla documentation for the latest version.

```kotlin
dependencies {
    implementation "io.kotzilla:kotzilla-core:latest.version"
}
```

--------------------------------

### @Single / @Singleton

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Declares a type or function as a 'single' (singleton) definition in Koin. A single instance is created and shared across the application. '@Singleton' is the preferred name; '@Single' is an alias.

```APIDOC
## @Single / @Singleton

### Description
Declares a type or function as a `single` (singleton) definition in Koin. A single instance is created and shared across the application. `@Singleton` is the preferred name (standard naming convention); `@Single` is an alias.

### Parameters
  * `binds: Array<KClass<*>> = [Unit::class]` - Explicit types to bind to this definition. Supertypes are automatically detected.
  * `createdAtStart: Boolean = false` - If `true`, the instance is created when Koin starts.

### Behavior
All dependencies are filled by constructor injection.

### Example
```kotlin
@Single  
class MyClass(val d : MyDependency)  
```

**Generated Koin DSL:**
```kotlin
single { MyClass(get()) }  
```

**With explicit binding:**
```kotlin
@Single(binds = [MyInterface::class])  
class MyClass(val d : MyDependency) : MyInterface  
```

**With creation at start:**
```kotlin
@Single(createdAtStart = true)  
class MyClass(val d : MyDependency)  
```
```

--------------------------------

### Annotate Koin Components with @Monitor

Source: https://insert-koin.io/docs/reference/koin-annotations/monitor

Apply the @Monitor annotation to your Koin components (e.g., Single, Factory) to enable automatic performance monitoring. This annotation should be used alongside Koin's scope annotations.

```kotlin
@Monitor
@Single
class UserService(private val userRepository: UserRepository) {
    fun findUser(id: String): User? = userRepository.findById(id)
      
    suspend fun createUser(userData: UserData): User {
        return userRepository.save(userData)
    }
}
```

--------------------------------

### @Named

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Defines a qualifier for a Koin definition, allowing distinction between multiple definitions of the same type using either a string or a class.

```APIDOC
## @Named

### Description
Defines a qualifier for a given definition. Generates `StringQualifier("...")` or type-based qualifier.

### Target
`CLASS`, `FUNCTION`, `VALUE_PARAMETER`

### Parameters
* **value** (`String = ""`) - String qualifier
* **type** (`KClass<*> = Unit::class`) - Class qualifier

### Behavior
Used to distinguish between multiple definitions of the same type.

### Example with string
```kotlin
@Single  
@Named("special")  
class MyClass(val d : MyDependency)  
```

### Usage in parameter
```kotlin
@Single  
class Consumer(@Named("special") val myClass: MyClass)
```

### Example with type
```kotlin
@Single  
@Named(type = MyType::class)  
class MyClass(val d : MyDependency)  
```
```

--------------------------------

### Use Custom Qualifiers in Module Providers and Injection Points

Source: https://insert-koin.io/docs/reference/koin-annotations/definitions

Apply custom qualifier annotations like @Dispatcher to provider functions and injection points. Mismatches between provider and injection point qualifiers result in compile-time errors.

```kotlin
import org.koin.core.annotation.Module  
import org.koin.core.annotation.Configuration  
import org.koin.core.annotation.Singleton  
  
@Module  
@Configuration  
class DispatchersModule {  
  
    @Singleton  
    @Dispatcher(NiaDispatchers.IO)  
    fun providesIODispatcher(): CoroutineDispatcher = Dispatchers.IO  
  
    @Singleton  
    @Dispatcher(NiaDispatchers.Default)  
    fun providesDefaultDispatcher(): CoroutineDispatcher = Dispatchers.Default  
  
    @Singleton  
    fun providesApplicationScope(  
        @Dispatcher(NiaDispatchers.Default) dispatcher: CoroutineDispatcher,  
    ): CoroutineScope = CoroutineScope(SupervisorJob() + dispatcher)  
}
```

--------------------------------

### Use @Singleton Annotation

Source: https://insert-koin.io/docs/reference/koin-annotations/definitions

The @Singleton annotation from jakarta.inject is equivalent to Koin's @Single, ensuring a singleton instance is created.

```kotlin
import jakarta.inject.Singleton

@Singleton
class DatabaseService
```

--------------------------------

### Define ViewModel with @KoinViewModel (Android/CMP)

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Use @KoinViewModel to declare a class as a ViewModel definition in Koin, suitable for Android and Compose Multiplatform. Dependencies are injected via the constructor.

```kotlin
import androidx.lifecycle.ViewModel
import org.koin.android.annotation.KoinViewModel

@KoinViewModel
class MyViewModel(val d : MyDependency) : ViewModel()
```

```kotlin
viewModel { MyViewModel(get()) }
```

--------------------------------

### Define Koin Module with @Module

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Use the @Module annotation on a class to gather definitions. Functions within the class annotated with Koin definition annotations will be collected.

```kotlin
@Module
class MyModule {
    @Single
    fun myClass(d : MyDependency) = MyClass(d)
}
```

--------------------------------

### Monitor ViewModels with @Monitor

Source: https://insert-koin.io/docs/reference/koin-annotations/monitor

Annotate your ViewModels with @Monitor to track UI performance. This allows you to capture method execution times and other performance metrics for your ViewModels.

```kotlin
@Monitor
@KoinViewModel
class DetailViewModel(private val repository: Repository) : ViewModel() {
    fun loadData(id: String): StateFlow<Data> = repository.getData(id)
}
```

--------------------------------

### Declaring a Koin Module with @Module

Source: https://insert-koin.io/docs/reference/koin-annotations/modules

Tag a class with the @Module annotation to declare it as a Koin module. This is the fundamental way to organize your Koin definitions.

```kotlin
@Module  
class MyModule  
```

--------------------------------

### Injected Parameters with @InjectedParam

Source: https://insert-koin.io/docs/reference/koin-annotations/definitions

Tag constructor parameters with `@InjectedParam` to pass them during dependency resolution. Use `parametersOf()` when calling `koin.get()`.

```kotlin
@Single
class MyComponent(@InjectedParam val myDependency : MyDependency)
```

```kotlin
val m = MyDependency()
// Resolve MyComponent while passing MyDependency
koin.get<MyComponent> { parametersOf(m) }
```

--------------------------------

### Composing Modules with 'includes'

Source: https://insert-koin.io/docs/reference/koin-annotations/modules

Combine multiple modules into a larger module by using the 'includes' attribute in the @Module annotation. This allows for hierarchical organization of definitions.

```kotlin
@Module  
class ModuleA  
  
@Module(includes = [ModuleA::class])  
class ModuleB  
```

--------------------------------

### Enable Debug Logs for Koin Compiler

Source: https://insert-koin.io/docs/reference/koin-annotations/options

Enable verbose debug logs for internal plugin processing, useful for troubleshooting plugin issues or reporting bugs.

```kotlin
koinCompiler {
    debugLogs = true
}

```

--------------------------------

### Define Koin Module with Includes

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Specify other module classes to include using the 'includes' parameter of the @Module annotation. This allows for modular organization of definitions.

```kotlin
@Module(includes = [OtherModule::class])
class MyModule {
    // definitions
}
```

--------------------------------

### @Module Annotation

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Class annotation to help gather definitions inside a Koin module. Each function can be annotated with a Koin definition annotation.

```APIDOC
## @Module

### Description
Class annotation to help gather definitions inside a Koin module. Each function can be annotated with a Koin definition annotation.

### Target
`CLASS`

### Parameters
* `includes: Array<KClass<*>> = []` - Module classes to include
* `createdAtStart: Boolean = false` - If `true`, module instances are created at start

### Behavior
Gathers all annotated functions and classes within the module.

### Example
```kotlin
@Module  
class MyModule {  
    @Single  
    fun myClass(d : MyDependency) = MyClass(d)  
}
```

### Generated Koin DSL
```kotlin
val MyModule.module = module {  
    val moduleInstance = MyModule()  
    single { moduleInstance.myClass(get()) }
}
```

### With includes
```kotlin
@Module(includes = [OtherModule::class])  
class MyModule {  
    // definitions  
}
```
```

--------------------------------

### @KoinViewModel

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Marks a class or function as a ViewModel definition within Koin. It supports Android, Kotlin Multiplatform, and Compose Multiplatform.

```APIDOC
## @KoinViewModel

### Description
ViewModel annotation for Koin definition. Declares a type or function as a `viewModel` definition in Koin.

### Target
`CLASS`, `FUNCTION`

### Platform Support
  * ✅ Android
  * ✅ Kotlin Multiplatform (KMP)
  * ✅ Compose Multiplatform (CMP)

### Parameters
* **binds** (`Array<KClass<*>> = []`) - Explicit types to bind to this definition. Supertypes are automatically detected.

### Behavior
All dependencies are filled by constructor injection. Creates a ViewModel instance managed by Koin. Works across all platforms including Android, iOS, Desktop, and Web when using Compose Multiplatform.

### Example (Android/CMP)
```kotlin
@KoinViewModel  
class MyViewModel(val d : MyDependency) : ViewModel()  
```

### Example (KMP/CMP shared)
```kotlin
@KoinViewModel  
class SharedViewModel(
    val repository: Repository,
    val analytics: Analytics
) : ViewModel()
```

### Generated Koin DSL
```kotlin
viewModel { MyViewModel(get()) }
```
```

--------------------------------

### Generate ViewModels for Kotlin Multiplatform with @KoinViewModel

Source: https://insert-koin.io/docs/reference/koin-annotations/definitions

Use the @KoinViewModel annotation to generate ViewModels compatible with both Android and Compose Multiplatform using the unified koin-core-viewmodel API.

```kotlin
@KoinViewModel  
class UserViewModel(val repository: UserRepository) : ViewModel()
```

--------------------------------

### Define Custom Qualifier Annotations with @Qualifier

Source: https://insert-koin.io/docs/reference/koin-annotations/definitions

Create custom qualifier annotations using @Qualifier and @Retention(AnnotationRetention.RUNTIME) for compile-time validation. These can include parameters.

```kotlin
import org.koin.core.annotation.Qualifier  
  
@Qualifier  
@Retention(AnnotationRetention.RUNTIME)  
annotation class Dispatcher(val niaDispatcher: NiaDispatchers)  
  
enum class NiaDispatchers { Default, IO }
```

--------------------------------

### Create Custom Qualifier Annotations

Source: https://insert-koin.io/docs/reference/koin-annotations/definitions

Use @Qualifier as a meta-annotation to define custom annotations for more specific dependency qualification.

```kotlin
import jakarta.inject.Qualifier

@Qualifier
annotation class Database

@Qualifier
annotation class Cache

@Singleton
@Database
class DatabaseConfig

@Singleton
@Cache
class CacheConfig
```

--------------------------------

### Explicit Package Scanning with @ComponentScan

Source: https://insert-koin.io/docs/reference/koin-annotations/modules

Specify a particular package to scan for components when using @ComponentScan to limit the scope of automatic discovery.

```kotlin
@Module  
@ComponentScan("com.myapp.features")  
class FeatureModule  
```

--------------------------------

### Defining Components in Class Modules

Source: https://insert-koin.io/docs/reference/koin-annotations/modules

Define Koin components directly within a class module by annotating functions with definition annotations like @Single. The function's return type determines the component type.

```kotlin
// given   
// class MyComponent(val myDependency : MyDependency)  
  
@Module  
class MyModule {  
  
  @Single  
  fun myComponent(myDependency : MyDependency) = MyComponent(myDependency)  
}  
```

--------------------------------

### Configure Skip Default Values for Koin

Source: https://insert-koin.io/docs/reference/koin-annotations/options

Control whether parameters with Kotlin default values use the default instead of being resolved from the DI container. Enabled by default.

```kotlin
koinCompiler {
    skipDefaultValues = true
}

```

--------------------------------

### Mix JSR-330 and Koin Annotations

Source: https://insert-koin.io/docs/reference/koin-annotations/definitions

Freely combine JSR-330 annotations with Koin's native annotations within the same project or even the same class.

```kotlin
// JSR-330 style
@Singleton
@Named("primary")
class PrimaryDatabase : Database

// Koin style  
@Single
@Named("secondary")
class SecondaryDatabase : Database

// Mixed in same class
@Factory
class DatabaseManager @Inject constructor(
    @Named("primary") private val primary: Database,
    @Named("secondary") private val secondary: Database
)
```

--------------------------------

### @Factory

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Declares a type or function as a 'factory' definition in Koin. A new instance is created each time it is requested.

```APIDOC
## @Factory

### Description
Declares a type or function as a `factory` definition in Koin. A new instance is created each time it is requested.

### Parameters
  * `binds: Array<KClass<*>> = [Unit::class]` - Explicit types to bind to this definition. Supertypes are automatically detected.

### Behavior
All dependencies are filled by constructor injection. Each request creates a new instance.

### Example
```kotlin
@Factory  
class MyClass(val d : MyDependency)  
```

**Generated Koin DSL:**
```kotlin
factory { MyClass(get()) }  
```
```

--------------------------------

### ProGuard/R8 Rules for Koin Annotations

Source: https://insert-koin.io/docs/reference/koin-annotations/start

These ProGuard/R8 rules are necessary for SDK development to ensure that Koin annotation definitions and annotated classes are kept during code shrinking and obfuscation.

```proguard
# Keep annotation definitions
-keep class org.koin.core.annotation.** { *; }

# Keep classes annotated with Koin annotations
-keep @org.koin.core.annotation.* class * { *; }
```

--------------------------------

### @Provided Annotation

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Marks a type or parameter as externally provided at runtime (e.g., Android framework types, third-party SDKs). Compile-time safety validation skips these types.

```APIDOC
## @Provided

### Description
Marks a type or parameter as externally provided at runtime (e.g., Android framework types, third-party SDKs). Compile-time safety validation skips these types.

### Target
`CLASS`, `VALUE_PARAMETER`

### Parameters
None

### Behavior
* On a **class** : all usages of that type skip compile safety validation
* On a **parameter** : only that specific parameter skips validation
* The type is still resolved via `scope.get<T>()` at runtime — `@Provided` only affects compile-time checks

### Example on class
```kotlin
@Provided  
class FirebaseAnalytics // all usages skip validation  
  
@Singleton  
class AnalyticsService(val analytics: FirebaseAnalytics)
```

### Example on parameter
```kotlin
@Factory  
class PaymentProcessor(@Provided val gateway: PaymentGateway)
```

### Note
Common Android framework types (`Context`, `Application`, `Activity`, `Fragment`, `SavedStateHandle`, `WorkerParameters`) are automatically whitelisted and don't need `@Provided`.

### See Also
Compile-Time Safety
```

--------------------------------

### Create Custom Scope Annotations

Source: https://insert-koin.io/docs/reference/koin-annotations/definitions

Utilize @Scope as a meta-annotation to define custom scopes, which can then be integrated with Koin's scope system.

```kotlin
import jakarta.inject.Scope

@Scope
annotation class RequestScoped

// Use with Koin's scope system
@Scope(name = "request") 
@RequestScoped
class RequestProcessor
```

--------------------------------

### Add koin-jsr330 Dependency

Source: https://insert-koin.io/docs/reference/koin-annotations/definitions

Include the koin-jsr330 module in your project's dependencies to enable JSR-330 annotation support.

```gradle
dependencies {
    implementation "io.insert-koin:koin-jsr330:$koin_version"
}
```

--------------------------------

### Bypass Compile-Time Checks with @Provided

Source: https://insert-koin.io/docs/reference/koin-annotations/start

Use the @Provided annotation to indicate that a dependency is provided externally. This is useful when a dependency is not managed by Koin or is provided through other means, bypassing compile-time checks.

```kotlin
class ExternalComponent // Declared elsewhere

@Factory
class MyPresenter(@Provided val external: ExternalComponent)
```

--------------------------------

### Define ViewModel with @KoinViewModel (KMP/CMP Shared)

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Use @KoinViewModel for shared ViewModel definitions in Kotlin Multiplatform and Compose Multiplatform projects. It supports constructor injection for dependencies.

```kotlin
import androidx.lifecycle.ViewModel
import org.koin.android.annotation.KoinViewModel

@KoinViewModel
class SharedViewModel(
    val repository: Repository,
    val analytics: Analytics
) : ViewModel()
```

--------------------------------

### @Property Annotation

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Annotates a constructor parameter or function parameter to resolve as a Koin property.

```APIDOC
## @Property

### Description
Annotates a constructor parameter or function parameter to resolve as a Koin property.

### Target
`VALUE_PARAMETER`

### Parameters
* `value: String` - Property name

### Behavior
Resolves the parameter value from Koin properties instead of dependency injection.

### Example
```kotlin
@Factory  
class MyClass(@Property("name") val name : String)  
```

### Generated Koin DSL
```kotlin
factory { MyClass(getProperty("name")) }
```

### With default value
```kotlin
@PropertyValue("name")  
val defaultName = "MyName"  
  
@Factory  
class MyClass(@Property("name") val name : String)  
```

### Generated Koin DSL
```kotlin
factory { MyClass(getProperty("name", defaultName)) }
```
```

--------------------------------

### Declare a basic scope with @Scope

Source: https://insert-koin.io/docs/reference/koin-annotations/scope

Use the @Scope annotation on a class to declare a scope. This is equivalent to a scope declaration in Koin modules.

```kotlin
@Scope
class MyScopeClass
```

--------------------------------

### Define Class Qualifier with @Qualifier

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Use @Qualifier to distinguish between multiple definitions of the same type. It can use a class or a string as a qualifier.

```kotlin
@Single
@Qualifier(name = "special")
class MyClass(val d : MyDependency)
```

--------------------------------

### Declare a Singleton with @Single Annotation

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Use @Single to declare a class or function as a singleton definition in Koin. An instance is created once and shared throughout the application. Dependencies are injected via the constructor.

```kotlin
@Single  
class MyClass(val d : MyDependency)  

```

```kotlin
@Single(binds = [MyInterface::class])  
class MyClass(val d : MyDependency) : MyInterface  

```

```kotlin
@Single(createdAtStart = true)  
class MyClass(val d : MyDependency)  

```

--------------------------------

### @ActivityRetainedScope

Source: https://insert-koin.io/docs/reference/koin-annotations/annotations-inventory

Declares a class within an Activity Koin scope that is retained across configuration changes. This is useful for maintaining state during Activity recreation.

```APIDOC
## @ActivityRetainedScope

### Description
Declares a class in an Activity Koin scope, but retained across configuration changes.

### Target
`CLASS`, `FUNCTION`

### Parameters
None

### Behavior
Creates a scoped definition within the `activityRetainedScope`.

### Example
```kotlin
@ActivityRetainedScope  
class MyClass(val d : MyDependency)  
```

### Generated Koin DSL
```kotlin
activityRetainedScope {
    scoped { MyClass(get()) }
}
```
```
Tokens:
Raw