### Configure Minute Intervals

Source: https://context7.com/seojw0124/compose-wheel-time-picker/llms.txt

Shows how to use predefined constants or custom integer values to set the granularity of the minute selection wheel.

```kotlin
import com.jade.wheeltimepicker.wheel.WheelTimePickerDefaults
import com.jade.wheeltimepicker.wheel.rememberWheelTimePickerState

// Available minute interval constants
val interval1 = WheelTimePickerDefaults.MINUTE_INTERVAL_1   // Every minute: 00, 01, 02...59
val interval5 = WheelTimePickerDefaults.MINUTE_INTERVAL_5   // Every 5 min: 00, 05, 10...55 (default)
val interval10 = WheelTimePickerDefaults.MINUTE_INTERVAL_10 // Every 10 min: 00, 10, 20...50

// Usage examples
val preciseState = rememberWheelTimePickerState(
    initialHour = 9,
    initialMinute = 0,
    minuteInterval = WheelTimePickerDefaults.MINUTE_INTERVAL_1  // For precise scheduling
)

val quickSelectState = rememberWheelTimePickerState(
    initialHour = 14,
    initialMinute = 30,
    minuteInterval = WheelTimePickerDefaults.MINUTE_INTERVAL_10  // For quick, approximate times
)

// Custom interval (must be a divisor of 60: 1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30)
val customIntervalState = rememberWheelTimePickerState(
    initialHour = 8,
    initialMinute = 0,
    minuteInterval = 15  // Quarter-hour intervals: 00, 15, 30, 45
)
```

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

### Configure Gradle Dependencies

Source: https://context7.com/seojw0124/compose-wheel-time-picker/llms.txt

Add the library to your project using version catalogs or standard Gradle syntax.

```toml
# libs.versions.toml
[versions]
wheeltimepicker = "1.0.0"

[libraries]
wheeltimepicker = { group = "io.github.seojw0124", name = "wheeltimepicker", version.ref = "wheeltimepicker" }
```

```kotlin
// build.gradle.kts
dependencies {
    implementation(libs.wheeltimepicker)
    // Or traditional Gradle syntax:
    // implementation("io.github.seojw0124:wheeltimepicker:1.0.0")
}
```

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

### Publish to Local Maven Repository

Source: https://github.com/seojw0124/compose-wheel-time-picker/blob/main/wheeltimepicker/README.md

Execute this command to publish the library to your local Maven repository for testing.

```bash
./gradlew :wheeltimepicker:publishToMavenLocal
```

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

### Publish to Maven Central (Manual Release)

Source: https://github.com/seojw0124/compose-wheel-time-picker/blob/main/wheeltimepicker/README.md

Use this command to upload the library to Maven Central for a manual release process.

```bash
./gradlew :wheeltimepicker:publishToMavenCentral
```

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

### Implement Basic WheelTimePicker

Source: https://github.com/seojw0124/compose-wheel-time-picker/blob/main/README.md

Initialize the state and display the default time picker component.

```kotlin
val state = rememberWheelTimePickerState()

WheelTimePicker(
    state = state
)
```

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

### Implement WheelTimePicker in Compose

Source: https://context7.com/seojw0124/compose-wheel-time-picker/llms.txt

A full activity implementation demonstrating multiple configurations of the time picker, including default, 3D effect, and custom color styles.

```kotlin
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material3.*
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import com.jade.wheeltimepicker.wheel.WheelTimePicker
import com.jade.wheeltimepicker.wheel.WheelTimePickerAmPmLabels
import com.jade.wheeltimepicker.wheel.WheelTimePickerDefaults
import com.jade.wheeltimepicker.wheel.rememberWheelTimePickerState

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MaterialTheme {
                Surface(modifier = Modifier.fillMaxSize()) {
                    TimePickerShowcase()
                }
            }
        }
    }
}

@Composable
fun TimePickerShowcase() {
    val defaultState = rememberWheelTimePickerState(initialHour = 10, initialMinute = 30)
    val darkState = rememberWheelTimePickerState(initialHour = 21, initialMinute = 15)
    val colorfulState = rememberWheelTimePickerState(initialHour = 7, initialMinute = 45)

    Column(
        modifier = Modifier
            .fillMaxSize()
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.spacedBy(32.dp)
    ) {
        // Default minimal style
        Section(title = "Default Style") {
            WheelTimePicker(
                state = defaultState,
                modifier = Modifier.fillMaxWidth()
            )
            TimeDisplay(defaultState.hour12, defaultState.minute, defaultState.isPm)
        }

        HorizontalDivider()

        // 3D wheel effect with dark theme
        Section(title = "3D Wheel Effect") {
            WheelTimePicker(
                state = darkState,
                modifier = Modifier.fillMaxWidth(),
                isWheelEffectEnabled = true,
                visibleItemCount = 5,
                unselectedItemMinAlpha = 0.5f,
                colors = WheelTimePickerDefaults.colors(
                    backgroundColor = Color(0xFF1F2121),
                    selectedTextColor = Color.White,
                    unSelectedTextColor = Color(0xFFB0B0B0)
                ),
                amPmLabels = WheelTimePickerAmPmLabels("AM", "PM")
            )
            TimeDisplay(darkState.hour12, darkState.minute, darkState.isPm)
        }

        HorizontalDivider()

        // Fade edges with custom colors
        Section(title = "Custom Colors & Fade") {
            WheelTimePicker(
                state = colorfulState,
                modifier = Modifier.fillMaxWidth(),
                isFadeEdgeEnabled = true,
                visibleItemCount = 7,
                colors = WheelTimePickerDefaults.colors(
                    selectedTextColor = Color(0xFF6200EE),
                    unSelectedTextColor = Color.Gray,
                    fadeColor = Color.White
                )
            )
            TimeDisplay(colorfulState.hour12, colorfulState.minute, colorfulState.isPm)
        }
    }
}

@Composable
private fun Section(title: String, content: @Composable ColumnScope.() -> Unit) {
    Column(horizontalAlignment = Alignment.CenterHorizontally) {
        Text(title, style = MaterialTheme.typography.titleMedium)
        Spacer(modifier = Modifier.height(16.dp))
        content()
    }
}

@Composable
private fun TimeDisplay(hour12: Int, minute: Int, isPm: Boolean) {
    Text(
        text = "Selected: $hour12:${minute.toString().padStart(2, '0')} ${if (isPm) "PM" else "AM"}",
        modifier = Modifier.padding(top = 8.dp)
    )
}
```

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

### Add Dependency via Version Catalog

Source: https://github.com/seojw0124/compose-wheel-time-picker/blob/main/README.md

Configure the library dependency in your project's version catalog and module-level build file.

```toml
[versions]
wheeltimepicker = "1.0.0"

[libraries]
wheeltimepicker = { group = "io.github.seojw0124", name = "wheeltimepicker", version.ref = "wheeltimepicker" }
```

```kotlin
dependencies {
    implementation(libs.wheeltimepicker)
}
```

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

### Publish to Maven Central (Automatic Release)

Source: https://github.com/seojw0124/compose-wheel-time-picker/blob/main/wheeltimepicker/README.md

This command uploads the library to Maven Central and initiates an automatic release.

```bash
./gradlew :wheeltimepicker:publishAndReleaseToMavenCentral
```

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

### Implement WheelTimePicker UI

Source: https://context7.com/seojw0124/compose-wheel-time-picker/llms.txt

Render the time picker component with basic or advanced visual configurations.

```kotlin
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import com.jade.wheeltimepicker.wheel.WheelTimePicker
import com.jade.wheeltimepicker.wheel.WheelTimePickerDefaults
import com.jade.wheeltimepicker.wheel.rememberWheelTimePickerState

@Composable
fun BasicTimePicker() {
    val state = rememberWheelTimePickerState(
        initialHour = 10,
        initialMinute = 30
    )

    // Minimal implementation
    WheelTimePicker(state = state)
}

@Composable
fun AdvancedTimePicker() {
    val state = rememberWheelTimePickerState(
        initialHour = 14,
        initialMinute = 30,
        minuteInterval = WheelTimePickerDefaults.MINUTE_INTERVAL_5
    )

    WheelTimePicker(
        state = state,
        modifier = Modifier.fillMaxWidth(),
        isWheelEffectEnabled = true,       // Enable 3D cylinder rotation effect
        isFadeEdgeEnabled = true,          // Enable gradient fade on edges
        visibleItemCount = 5,              // Number of visible items (must be odd, >= 3)
        unselectedItemMinAlpha = 0.3f,     // Transparency for non-selected items
        wheelEffectRotationXDegree = 18f,  // 3D rotation intensity
        fadeEdgeStrength = 0.9f,           // Fade gradient intensity (0-1)
        colors = WheelTimePickerDefaults.colors(
            selectedTextColor = Color.Black,
            unSelectedTextColor = Color.Gray,
            backgroundColor = Color.White,
            fadeColor = Color.White
        )
    )
}
```

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

### Configure Advanced WheelTimePicker

Source: https://github.com/seojw0124/compose-wheel-time-picker/blob/main/README.md

Customize the picker with 3D effects, fade edges, minute intervals, and specific color schemes.

```kotlin
val state = rememberWheelTimePickerState(
    initialHour = 14,
    initialMinute = 30,
    minuteInterval = WheelTimePickerDefaults.MINUTE_INTERVAL_5
)

WheelTimePicker(
    state = state,
    isWheelEffectEnabled = true,   // Enable 3D cylinder effect
    isFadeEdgeEnabled = true,      // Enable edge gradients
    visibleItemCount = 5,          // Number of visible items (must be odd)
    colors = WheelTimePickerDefaults.colors(
        selectedTextColor = Color.Black,
        unSelectedTextColor = Color.Gray,
        fadeColor = Color.White
    )
)
```

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

### Implement TimePicker with State Controls

Source: https://context7.com/seojw0124/compose-wheel-time-picker/llms.txt

Demonstrates using rememberWheelTimePickerState to manage time selection and programmatically update values via the state object.

```kotlin
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.height
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import com.jade.wheeltimepicker.wheel.WheelTimePicker
import com.jade.wheeltimepicker.wheel.rememberWheelTimePickerState

@Composable
fun TimePickerWithControls() {
    val state = rememberWheelTimePickerState(initialHour = 10, initialMinute = 30)

    Column {
        WheelTimePicker(state = state)

        Spacer(modifier = Modifier.height(16.dp))

        // Display current selection
        Text(
            text = buildString {
                append("24h format: ${state.hour}:${state.minute.toString().padStart(2, '0')}")
                append("\n")
                append("12h format: ${state.hour12}:${state.minute.toString().padStart(2, '0')} ")
                append(if (state.isPm) "PM" else "AM")
            }
        )

        Spacer(modifier = Modifier.height(8.dp))

        // Programmatic time manipulation
        Button(onClick = { state.hour = 12 }) {
            Text("Set to 12:00 PM")
        }

        Button(onClick = { state.hour = 0 }) {
            Text("Set to 12:00 AM")
        }

        Button(onClick = { state.isPm = !state.isPm }) {
            Text("Toggle AM/PM")
        }

        Button(onClick = {
            state.minute = (state.minute + 5) % 60
        }) {
            Text("Add 5 minutes")
        }
    }
}
```

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

### Minute Interval Constants

Source: https://context7.com/seojw0124/compose-wheel-time-picker/llms.txt

Predefined constants and configuration options for controlling the granularity of minute selection in the time picker.

```APIDOC
## Minute Interval Constants

### Description
Predefined constants for common minute interval configurations. Custom intervals must be a divisor of 60 (e.g., 1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30).

### Constants
- **MINUTE_INTERVAL_1** - Every minute (00, 01, 02...59)
- **MINUTE_INTERVAL_5** - Every 5 minutes (00, 05, 10...55) - Default
- **MINUTE_INTERVAL_10** - Every 10 minutes (00, 10, 20...50)

### Usage Example
```kotlin
val state = rememberWheelTimePickerState(
    initialHour = 9,
    initialMinute = 0,
    minuteInterval = WheelTimePickerDefaults.MINUTE_INTERVAL_1
)
```
```

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

### WheelTimePickerDefaults.textStyles

Source: https://context7.com/seojw0124/compose-wheel-time-picker/llms.txt

Factory function to customize the typography of the time picker display.

```APIDOC
## WheelTimePickerDefaults.textStyles

### Description
Creates a WheelTimePickerTextStyles instance to define the font size, weight, and style of the picker text.

### Parameters
#### Request Body
- **textStyle** (TextStyle) - Required - The typography style to apply to the picker items.
```

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

### WheelTimePickerAmPmLabels

Source: https://context7.com/seojw0124/compose-wheel-time-picker/llms.txt

Data class for customizing AM/PM label text, supporting localization and custom terminology.

```APIDOC
## WheelTimePickerAmPmLabels

### Description
Defines the labels used for AM and PM indicators. Can be initialized with custom strings or via locale-based defaults.

### Parameters
#### Request Body
- **am** (String) - Required - The label for AM.
- **pm** (String) - Required - The label for PM.
```

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

### Customize AM/PM Labels

Source: https://context7.com/seojw0124/compose-wheel-time-picker/llms.txt

Customize AM/PM labels using `WheelTimePickerDefaults.amPmLabels` or by providing a `WheelTimePickerAmPmLabels` instance. This supports localization by automatically detecting system locale or by explicitly setting a `Locale`.

```kotlin
import com.jade.wheeltimepicker.wheel.WheelTimePicker
import com.jade.wheeltimepicker.wheel.WheelTimePickerAmPmLabels
import com.jade.wheeltimepicker.wheel.WheelTimePickerDefaults
import com.jade.wheeltimepicker.wheel.rememberWheelTimePickerState
import java.util.Locale

@Composable
fun LocalizedTimePicker() {
    val state = rememberWheelTimePickerState()

    // Use system locale (auto-detects English, Korean, Japanese)
    WheelTimePicker(
        state = state,
        amPmLabels = WheelTimePickerDefaults.amPmLabels()  // Auto: AM/PM, 오전/오후, 午前/午後
    )
}
```

```kotlin
import com.jade.wheeltimepicker.wheel.WheelTimePicker
import com.jade.wheeltimepicker.wheel.WheelTimePickerAmPmLabels
import com.jade.wheeltimepicker.wheel.WheelTimePickerDefaults
import com.jade.wheeltimepicker.wheel.rememberWheelTimePickerState
import java.util.Locale

@Composable
fun CustomLabelTimePicker() {
    val state = rememberWheelTimePickerState()

    // Custom AM/PM labels
    WheelTimePicker(
        state = state,
        amPmLabels = WheelTimePickerAmPmLabels(
            am = "Morning",
            pm = "Evening"
        )
    )
}
```

```kotlin
import com.jade.wheeltimepicker.wheel.WheelTimePicker
import com.jade.wheeltimepicker.wheel.WheelTimePickerAmPmLabels
import com.jade.wheeltimepicker.wheel.WheelTimePickerDefaults
import com.jade.wheeltimepicker.wheel.rememberWheelTimePickerState
import java.util.Locale

@Composable
fun KoreanTimePicker() {
    val state = rememberWheelTimePickerState()

    // Force Korean locale labels
    WheelTimePicker(
        state = state,
        amPmLabels = WheelTimePickerDefaults.amPmLabels(locale = Locale.KOREAN)
        // Results in: 오전/오후
    )
}
```

```kotlin
import com.jade.wheeltimepicker.wheel.WheelTimePicker
import com.jade.wheeltimepicker.wheel.WheelTimePickerAmPmLabels
import com.jade.wheeltimepicker.wheel.WheelTimePickerDefaults
import com.jade.wheeltimepicker.wheel.rememberWheelTimePickerState
import java.util.Locale

@Composable
fun JapaneseTimePicker() {
    val state = rememberWheelTimePickerState()

    // Force Japanese locale labels
    WheelTimePicker(
        state = state,
        amPmLabels = WheelTimePickerDefaults.amPmLabels(locale = Locale.JAPANESE)
        // Results in: 午前/午後
    )
}
```

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

### Add Dependency via Traditional Gradle

Source: https://github.com/seojw0124/compose-wheel-time-picker/blob/main/README.md

Directly add the library dependency to your module-level build file.

```kotlin
dependencies {
    implementation("io.github.seojw0124:wheeltimepicker:1.0.0")
}
```

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

### Customize Time Picker Text Styles

Source: https://context7.com/seojw0124/compose-wheel-time-picker/llms.txt

Utilize `WheelTimePickerDefaults.textStyles` to apply custom typography, such as font size and weight, or integrate with Material Theme typography. This allows for consistent styling across your application.

```kotlin
import androidx.compose.material3.MaterialTheme
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
import com.jade.wheeltimepicker.wheel.WheelTimePicker
import com.jade.wheeltimepicker.wheel.WheelTimePickerDefaults
import com.jade.wheeltimepicker.wheel.rememberWheelTimePickerState

@Composable
fun CustomTextStyleTimePicker() {
    val state = rememberWheelTimePickerState()

    WheelTimePicker(
        state = state,
        styles = WheelTimePickerDefaults.textStyles(
            textStyle = TextStyle(
                fontSize = 24.sp,
                fontWeight = FontWeight.Bold
            )
        )
    )
}
```

```kotlin
import androidx.compose.material3.MaterialTheme
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
import com.jade.wheeltimepicker.wheel.WheelTimePicker
import com.jade.wheeltimepicker.wheel.WheelTimePickerDefaults
import com.jade.wheeltimepicker.wheel.rememberWheelTimePickerState

@Composable
fun MaterialThemedTimePicker() {
    val state = rememberWheelTimePickerState()

    WheelTimePicker(
        state = state,
        styles = WheelTimePickerDefaults.textStyles(
            textStyle = MaterialTheme.typography.headlineMedium  // Default
        )
    )
}
```

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

### Manage WheelTimePicker State

Source: https://context7.com/seojw0124/compose-wheel-time-picker/llms.txt

Initialize and manipulate the time picker state, which handles 24-hour logic and 12-hour display conversion.

```kotlin
import com.jade.wheeltimepicker.wheel.rememberWheelTimePickerState
import com.jade.wheeltimepicker.wheel.WheelTimePickerDefaults

// Basic state with defaults (12:00 AM, 5-minute intervals)
val basicState = rememberWheelTimePickerState()

// State with custom initial time (2:30 PM)
val customState = rememberWheelTimePickerState(
    initialHour = 14,      // 24-hour format (0-23)
    initialMinute = 30,    // Minutes (0-59)
    minuteInterval = WheelTimePickerDefaults.MINUTE_INTERVAL_5  // 5-minute steps
)

// State with 1-minute intervals for precise time selection
val preciseState = rememberWheelTimePickerState(
    initialHour = 9,
    initialMinute = 15,
    minuteInterval = WheelTimePickerDefaults.MINUTE_INTERVAL_1
)

// Accessing state values
val hour24 = customState.hour        // 14 (24-hour format)
val hour12 = customState.hour12      // 2 (12-hour format)
val minute = customState.minute      // 30
val isPm = customState.isPm          // true

// Programmatically updating time
customState.hour = 10                // Set to 10:00 AM
customState.minute = 45              // Set minutes to 45
customState.isPm = true              // Toggle to PM (becomes 10:45 PM = 22:45)
customState.updateHour12(3)          // Set 12-hour display to 3 (maintains AM/PM)
```

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

### rememberWheelTimePickerState

Source: https://context7.com/seojw0124/compose-wheel-time-picker/llms.txt

Creates and manages the internal state for the time picker, including hour, minute, and AM/PM status.

```APIDOC
## rememberWheelTimePickerState

### Description
Creates and remembers a WheelTimePickerState that manages the time picker's internal state. It supports configuration changes via rememberSaveable.

### Parameters
- **initialHour** (Int) - Optional - Initial hour in 24-hour format (0-23).
- **initialMinute** (Int) - Optional - Initial minute (0-59).
- **minuteInterval** (Int) - Optional - Step interval for minutes (1, 5, or 10).

### Response
- **state** (WheelTimePickerState) - The state object containing hour, hour12, minute, and isPm properties.
```

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

### Customize Time Picker Colors

Source: https://context7.com/seojw0124/compose-wheel-time-picker/llms.txt

Use `WheelTimePickerDefaults.colors` to define custom colors for selected text, unselected text, background, and fade effects. Ensure fade color matches background for a seamless transition.

```kotlin
import androidx.compose.ui.graphics.Color
import com.jade.wheeltimepicker.wheel.WheelTimePicker
import com.jade.wheeltimepicker.wheel.WheelTimePickerDefaults
import com.jade.wheeltimepicker.wheel.rememberWheelTimePickerState

@Composable
fun DarkThemeTimePicker() {
    val state = rememberWheelTimePickerState(initialHour = 21, initialMinute = 15)

    WheelTimePicker(
        state = state,
        isWheelEffectEnabled = true,
        visibleItemCount = 5,
        colors = WheelTimePickerDefaults.colors(
            selectedTextColor = Color.White,
            unSelectedTextColor = Color(0xFFB0B0B0),
            backgroundColor = Color(0xFF1F2121),
            fadeColor = Color(0xFF1F2121)  // Should match background for seamless fade
        )
    )
}
```

```kotlin
import androidx.compose.ui.graphics.Color
import com.jade.wheeltimepicker.wheel.WheelTimePicker
import com.jade.wheeltimepicker.wheel.WheelTimePickerDefaults
import com.jade.wheeltimepicker.wheel.rememberWheelTimePickerState

@Composable
fun BrandedTimePicker() {
    val state = rememberWheelTimePickerState(initialHour = 7, initialMinute = 45)

    WheelTimePicker(
        state = state,
        isFadeEdgeEnabled = true,
        visibleItemCount = 7,
        colors = WheelTimePickerDefaults.colors(
            selectedTextColor = Color(0xFF6200EE),  // Purple accent
            unSelectedTextColor = Color.Gray,
            backgroundColor = Color.White,
            fadeColor = Color.White
        )
    )
}
```

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

### WheelTimePicker Composable

Source: https://context7.com/seojw0124/compose-wheel-time-picker/llms.txt

The main UI component for rendering the wheel-style time picker.

```APIDOC
## WheelTimePicker

### Description
Displays a scrollable wheel-style time picker with customizable visual effects and colors.

### Parameters
- **state** (WheelTimePickerState) - Required - The state object managing the picker values.
- **modifier** (Modifier) - Optional - Compose modifier for layout.
- **isWheelEffectEnabled** (Boolean) - Optional - Enables 3D cylinder rotation effect.
- **isFadeEdgeEnabled** (Boolean) - Optional - Enables gradient fade on edges.
- **visibleItemCount** (Int) - Optional - Number of visible items (must be odd, >= 3).
- **unselectedItemMinAlpha** (Float) - Optional - Transparency for non-selected items.
- **wheelEffectRotationXDegree** (Float) - Optional - 3D rotation intensity.
- **fadeEdgeStrength** (Float) - Optional - Fade gradient intensity (0-1).
- **colors** (WheelTimePickerColors) - Optional - Custom colors for text and background.
```

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

### WheelTimePickerDefaults.colors

Source: https://context7.com/seojw0124/compose-wheel-time-picker/llms.txt

Factory function to customize the color scheme of the time picker, including text, background, and fade gradient colors.

```APIDOC
## WheelTimePickerDefaults.colors

### Description
Creates a WheelTimePickerColors instance to define the visual color properties of the picker.

### Parameters
#### Request Body
- **selectedTextColor** (Color) - Optional - Color of the currently selected time item.
- **unSelectedTextColor** (Color) - Optional - Color of the unselected time items.
- **backgroundColor** (Color) - Optional - Background color of the picker.
- **fadeColor** (Color) - Optional - Color used for the fade gradient effect at the edges.
```

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

### WheelTimePickerState Interface

Source: https://context7.com/seojw0124/compose-wheel-time-picker/llms.txt

The state interface allows for reading and manipulating the current time selection in the WheelTimePicker component, supporting both 24-hour and 12-hour formats.

```APIDOC
## WheelTimePickerState Interface

### Description
The state interface exposes properties and methods for reading and manipulating the current time selection programmatically. It manages 24-hour logic internally while providing convenience properties for 12-hour display.

### Properties
- **hour** (Int) - Current hour in 24-hour format (0-23).
- **minute** (Int) - Current minute (0-59).
- **hour12** (Int) - Current hour in 12-hour format (1-12).
- **isPm** (Boolean) - Indicates if the current time is PM.

### Usage Example
```kotlin
val state = rememberWheelTimePickerState(initialHour = 10, initialMinute = 30)
state.hour = 12 // Sets time to 12:30
state.isPm = true // Toggles to PM
```
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.