.github/workflows/ci.yml

@@ -1,129 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-
-permissions:
-  contents: read
-
-jobs:
-  test:
-    name: Unit Tests & Lint
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262  # v4
-      - uses: actions/setup-java@cf277c60eb25467037889841efdb72551f06f6c3  # v4
-        with:
-          java-version: '17'
-          distribution: 'temurin'
-      - uses: android-actions/setup-android@9fc6c4e9069bf8d3d10b2204b1fb8f6ef7065407  # v3
-        with:
-          packages: 'platforms;android-35 build-tools;35.0.0'
-
-      - name: Grant execute permission for gradlew
-        run: chmod +x gradlew
-
-      - name: Run unit tests
-        run: ./gradlew testDebugUnitTest
-
-      - name: Upload test results
-        if: always()
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02  # v4
-        with:
-          name: unit-test-results
-          path: app/build/test-results/testDebugUnitTest/*.xml
-          retention-days: 14
-
-      - name: Run lint
-        run: ./gradlew lintDebug
-
-      - name: Upload lint results
-        if: always()
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02  # v4
-        with:
-          name: lint-results
-          path: app/build/reports/lint-results-debug.*
-          retention-days: 14
-
-  build-debug:
-    name: Debug APK
-    runs-on: ubuntu-latest
-    needs: test
-    steps:
-      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262  # v4
-      - uses: actions/setup-java@cf277c60eb25467037889841efdb72551f06f6c3  # v4
-        with:
-          java-version: '17'
-          distribution: 'temurin'
-      - uses: android-actions/setup-android@9fc6c4e9069bf8d3d10b2204b1fb8f6ef7065407  # v3
-        with:
-          packages: 'platforms;android-35 build-tools;35.0.0'
-
-      - name: Grant execute permission for gradlew
-        run: chmod +x gradlew
-
-      - name: Assemble Debug
-        run: ./gradlew assembleDebug
-
-      - name: Upload Debug APK
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02  # v4
-        with:
-          name: debug-apk
-          path: app/build/outputs/apk/debug/app-debug.apk
-          retention-days: 14
-
-  build-release:
-    name: Release APK (debug-signed)
-    runs-on: ubuntu-latest
-    needs: test
-    steps:
-      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262  # v4
-      - uses: actions/setup-java@cf277c60eb25467037889841efdb72551f06f6c3  # v4
-        with:
-          java-version: '17'
-          distribution: 'temurin'
-      - uses: android-actions/setup-android@9fc6c4e9069bf8d3d10b2204b1fb8f6ef7065407  # v3
-        with:
-          packages: 'platforms;android-35 build-tools;35.0.0'
-
-      - name: Grant execute permission for gradlew
-        run: chmod +x gradlew
-
-      # 确保存在 debug keystore（某些 runner 镜像可能没有）
-      - name: Ensure debug keystore
-        run: |
-          KS="$HOME/.android/debug.keystore"
-          mkdir -p "$HOME/.android"
-          if [ ! -f "$KS" ]; then
-            keytool -genkeypair -v -keystore "$KS" -storepass android -alias androiddebugkey -keypass android -keyalg RSA -keysize 2048 -validity 10000 -dname "CN=Android Debug,O=Android,C=US"
-            echo "Generated debug keystore"
-          else
-            echo "Debug keystore exists"
-          fi
-
-      # CI 无 release.jks；build.gradle.kts 自动 fallback 到 debug keystore
-      # 只验证编译 + 资源完整性，签名由 Release workflow 用 secrets 完成
-      - name: Assemble Release
-        run: ./gradlew assembleRelease
-
-      - name: Verify Release APK
-        run: |
-          APK=app/build/outputs/apk/release/app-release.apk
-          if [ ! -f "$APK" ]; then
-            echo "❌ Release APK not found"
-            exit 1
-          fi
-          echo "✅ Release APK size: $(du -h "$APK" | cut -f1)"
-          unzip -l "$APK" | grep -q "AndroidManifest.xml" || { echo "❌ AndroidManifest.xml missing"; exit 1; }
-          unzip -l "$APK" | grep -q "resources.arsc" || { echo "❌ resources.arsc missing"; exit 1; }
-          unzip -l "$APK" | grep -q "res/" || { echo "❌ res/ directory missing"; exit 1; }
-          echo "✅ APK integrity verified: manifest + arsc + res/ all present"
-
-      - name: Upload Release APK
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02  # v4
-        with:
-          name: release-apk
-          path: app/build/outputs/apk/release/app-release.apk
-          retention-days: 14

.github/workflows/release.yml

@@ -10,31 +10,24 @@ jobs:
     permissions:
       contents: write
     steps:
-      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262  # v4
+      - uses: actions/checkout@v4
-      - uses: actions/setup-java@cf277c60eb25467037889841efdb72551f06f6c3  # v4
+      - uses: actions/setup-java@v4
         with:
           java-version: '17'
           distribution: 'temurin'
-      - uses: android-actions/setup-android@9fc6c4e9069bf8d3d10b2204b1fb8f6ef7065407  # v3
+      - uses: android-actions/setup-android@v3
         with:
           packages: 'platforms;android-35 build-tools;35.0.0'
       - name: Decode Keystore
         run: echo "${{ secrets.KEYSTORE_BASE64 }}" | base64 -d > release.jks
       - name: Build Release APK
-        env:
-          KEYSTORE_PASSWORD: ${{ secrets.KEYSTORE_PASSWORD }}
-          KEYSTORE_ALIAS: ${{ secrets.KEYSTORE_ALIAS }}
-          KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}
         run: |
           chmod +x gradlew
           ./gradlew assembleRelease
-      - name: Cleanup keystore (always run for security)
-        run: rm -f release.jks
-        if: always()
       - name: Rename & Release
         run: |
           cp app/build/outputs/apk/release/app-release.apk "RainyToken-${GITHUB_REF#refs/tags/}.apk"
-      - uses: softprops/action-gh-release@3bb12739c298aeb8a4eeaf626c5b8d85266b0e65  # v2
+      - uses: softprops/action-gh-release@v2
         with:
           name: "🎉 RainyToken ${{ github.ref_name }}"
           files: RainyToken-${{ github.ref_name }}.apk

.gitignore

@@ -7,10 +7,8 @@
 /.idea/workspace.xml
 /.idea/navEditor.xml
 /.idea/assetWizardSettings.xml
-/.idea/
 .DS_Store
 /build
-app/build/
 /captures
 .externalNativeBuild
 .cxx
@@ -20,10 +18,3 @@ release.jks
 .operit/
 .kotlin/
 *.jks
-tmp_cc/
-goal.md
-/reference/
-
-# 调试临时文件（可能包含真实接口响应/账号数据，禁止提交）
-_tmp_*
-build_compile.log

AGENTS.md

@@ -1,5 +1,98 @@
-任务开始前必须先读取 taste.md（协作偏好），任务全程遵守其中约定，包括：修改后派发独立 subagent 审计（无阻断问题 + 无影响用户体验问题），修复后用同一个 subagent 复审。
+# 雨晴Token — AI 余额查询 APP
 
-未经用户允许禁止提交推送
+## 项目概述
 
-派发子代理任务（独立审计/探索/通用 subagent）时，prompt 中涉及工作区文件的所有路径必须使用完整绝对路径（以工作区根目录为前缀）。子代理没有工作区附着上下文，相对路径会导致其找不到文件或无法执行。
+Android（Jetpack Compose + Kotlin）APP，统一查询 DeepSeek、OpenCode Go 两项服务的余额/配额。
+DeepSeek 走 REST API，OpenCode Go 通过 OkHttp 抓取 dashboard HTML 解析 SSR hydration 数据。
+APP 名为「雨晴Token」（粉色调品牌），配套桌面小组件。
+
+## 技术栈
+
+- Kotlin 100% · Jetpack Compose + Material 3
+- MVVM + Repository + `RefreshBalanceUseCase`（单一 UseCase，按 ServiceType 分发）
+- Hilt + KSP（DI）
+- Retrofit 2 + OkHttp 4 + Kotlinx Serialization
+- DataStore（本地缓存）+ Android Keystore（凭据加密，AES-256 GCM）
+- `minSdk=31`（Android 12+）
+- WorkManager（计划中）
+
+## 当前实现状态
+
+**服务**：
+- ✅ DeepSeek — REST API `GET /user/balance`，API Key 认证
+- ✅ OpenCode Go — OkHttp 抓 dashboard HTML，解析 `rollingUsage`/`weeklyUsage`/`monthlyUsage`
+- ❌ OpenCode Zen / 小米 MiMo — 未实现
+
+**用量统计系统**：
+- ✅ `UsageCache`（DataStore，~3700 条记录）— 全量 JSON 序列化 + 内存缓存（`@Volatile cachedAll`），仅在写入后失效
+- ✅ `SyncUsageUseCase` — 首次全量同步（cursor 翻页）、增量同步（逐页比对本地 ID 集合）
+- ✅ `UsageViewModel` — `loadStatsInternal()` 单次 `getRecords()`→ 内存聚合 Overview/ModelStats/DailyStats，所有重操作包在 `withContext(Dispatchers.Default)` 避免主线程卡顿
+- ✅ `UsageChartViewModel` — 图表粒度（5h/24h/今天/昨天/7天/当月/自定义日/月/范围），模型多选，3 张 Canvas 图表
+- ✅ `UsageDataViewModel` — 原始记录分页浏览（20条/页），支持时间+模型筛选，页码输入跳转
+- ✅ 全局刷新绑定 — Dashboard 下拉刷新 → `DashboardViewModel.refresh()` → `UsageViewModel.sync()`（增量）
+
+**页面导航**：
+```
+Dashboard → UsageDetail（图表） → UsageOverview（总统计）
+                 ↘ UsageData（原始数据）
+```
+
+**桌面小组件（Widget）**：
+- 显示 OpenCode Go 三个用量窗口（5h/本周/本月）+ 进度条 + 重置时间 + DeepSeek 余额
+- 右上角刷新按钮（后台广播 → `WidgetRefreshReceiver` → EntryPoints 获取 `RefreshBalanceUseCase`）
+- 进度条颜色按百分比动态变化（<50% 草莓粉 / 50-80% 暖橙 / >80% 玫红）
+
+## RemoteViews 兼容性红线
+
+以下元素在 Widget 布局中**不可用**，会导致「载入出现问题」：
+
+| ❌ 不可用 | ✅ 替代方案 |
+|-----------|------------|
+| `<Space>` | 透明 ProgressBar（`0dp + weight=1`） |
+| `<View>` | ProgressBar 或 TextView |
+| `<ImageView>` + 矢量 drawable | PNG（`drawable-nodpi`） |
+| `<TextView>` `0dp+weight=1` 空串 spacer | ProgressBar spacer |
+| `<TextView>` 固定 dp 宽度 + `gravity` | 仅固定 dp，不加 gravity |
+
+## 关键命令
+
+```bash
+cd /data/user/0/com.ai.assistance.operit/files/workspace/Rainytoken
+export ANDROID_HOME=$HOME/Android
+export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-arm64
+./gradlew assembleDebug
+# APK: app/build/outputs/apk/debug/app-debug.apk
+```
+
+## 数据流
+
+```
+DashboardViewModel.refresh()
+  → RefreshBalanceUseCase(service)
+    → DeepSeekRepository.fetchBalance()    / OpenCodeGoRepository.fetchBalance()
+  → BalanceCache.put(service, result)
+  → OpenCodeGoWidgetProvider.notifyDataChanged(context)
+
+Dashboard 下拉刷新 → usageSyncTrigger++ → UsageViewModel.sync()
+  → SyncUsageUseCase.fullSync() / incrementalSync()
+    → OpenCodeUsageRepository.fetchPage(cursor) 逐页抓取
+    → UsageCache.insertAll() → persist() → invalidateCache()
+  → UsageViewModel.loadStats() → getRecords() → 内存聚合
+
+Widget 刷新按钮：
+  ↻ → PendingIntent.getBroadcast() → WidgetRefreshReceiver
+    → EntryPoints → RefreshBalanceUseCase(DEEPSEEK + OPENCODE_GO)
+    → notifyDataChanged()
+```
+
+## 品牌色
+
+| 用途 | 色值 |
+|------|------|
+| 主品牌草莓粉 | `#FF85A2` |
+| 樱粉背景/点缀 | `#FFD1DC` |
+| 浅粉背景 | `#FFF0F5` |
+| 深暖文字 | `#3D2C35` |
+| 暖灰辅助 | `#8A7A82` |
+| 玫红（>80% 警示） | `#E91E63` |
+| 暖橙（50-80%） | `#FFA726` |

LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Rainy
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

README.en.md

@@ -1,238 +0,0 @@
-# RainyToken (雨晴Token)
-
-> *"AI Balance & Usage at a Glance"*
-
-[![CI](https://github.com/CATMIAOZHI/Rainytoken/actions/workflows/ci.yml/badge.svg)](https://github.com/CATMIAOZHI/Rainytoken/actions/workflows/ci.yml)
-[![Release](https://github.com/CATMIAOZHI/Rainytoken/actions/workflows/release.yml/badge.svg)](https://github.com/CATMIAOZHI/Rainytoken/actions)
-[![Version](https://img.shields.io/github/v/release/CATMIAOZHI/Rainytoken?color=ff85a2)](https://github.com/CATMIAOZHI/Rainytoken/releases)
-Android app for checking AI balance & usage — unified view of DeepSeek, OpenCode Go, CommandCode, Codex / ChatGPT, and Ollama balances and usage quotas. Pink-toned brand UI, with companion home screen widgets.
-RainyToken (雨晴Token) — AI Balance & Usage Quota Query · the Rainy Family tools.
-
----
-
-## 📸 Screenshots
-
-<p align="center">
-  <img src="docs/screenshots/dashboard-light.jpg" width="200" alt="Dashboard (light)" />
-  <img src="docs/screenshots/dashboard-dark.jpg" width="200" alt="Dashboard (dark)" />
-  <img src="docs/screenshots/detail.jpg" width="200" alt="Usage charts" />
-  <img src="docs/screenshots/ollama-detail.jpg" width="200" alt="Ollama model call counts" />
-</p>
-
-<p align="center">
-  <em>Dashboard (light) · Dashboard (dark) · Usage charts · Ollama model call counts</em>
-</p>
-
-<p align="center">
-  <img src="docs/screenshots/widget.jpg" width="300" alt="Home screen widget" />
-  <img src="docs/screenshots/ollama-card.jpg" width="200" alt="Ollama card" />
-</p>
-
-<p align="center">
-  <em>Home screen widget · Ollama home card</em>
-</p>
-
-<p align="center">
-  <img src="docs/screenshots/heatmap.jpg" width="200" alt="Token Activity" />
-</p>
-
-<p align="center">
-  <em>Token Activity</em>
-</p>
-
----
-
-## ✨ Features
-
-| Feature | Description |
-|------|------|
-| 📊 **Dashboard** | DeepSeek balance (¥) + usage/balance cards for each service; OCGO/CCGO cards link directly to usage details; long-press & drag to reorder (persisted); pull-to-refresh globally · tablet-adaptive two-pane layout |
-| 📈 **Usage charts** | 3 Canvas-drawn charts — amount spent / API request count / token consumption (dual data sources: OCGO & CCGO); UTC+0/UTC+8 timezone switching and custom day/month/range; automatic fallback (no data in last 5h → 12h → 7 days → current month); side-by-side on tablets |
-| 🗓️ **Token Activity** | OCGO daily token heatmap (GitHub contribution-graph style): daily / weekly / cumulative views + year switching (last 365 days by default, or a calendar year); personal profile + activity insights (total requests / top 3 request hours) + yearly stats (total / peak / streaks); 6-level pink quantile scale, tap / slide to inspect |
-| 📱 **Tablet adaptation** | Global `BoxWithConstraints` adaptive container width; ≥600dp dual-column cards, ≥700dp side-by-side charts; two-pane 35/65 split (Expanded mode); supports Android 13+ predictive back gestures |
-| 📋 **Detailed data** | Paginated browsing of raw records with time + model filtering; tap to view full fields |
-| 🔍 **Multi-granularity filters** | 5 hours / 12 hours (10-minute buckets) / 24 hours / today / yesterday / last 7 days / last 30 days / current month / custom day · month · range |
-| 🏷️ **Model filtering** | Multi-select / single-select / select all, with dynamic legends that wrap automatically |
-| 📱 **Home screen widget** | Check usage without opening the app; switch between four services (OCGO/CCGO/Codex/Ollama) + DeepSeek balance; top-left corner → open app, tap elsewhere to switch, ↻ to refresh; can be added to the At a Glance screen; auto-refreshes when scrolled into view (MIUI exposure refresh) |
-| 🔄 **Auto sync** | Pull-to-refresh on home auto-syncs usage; auto full sync on startup when no cache; CCGO detail page supports manual clear & re-sync |
-| 🌙 **Dark mode** | Fully adaptive — in-app text/icons/background switch automatically; widget adapts independently with a dark layout |
-| ➕ **One-tap add to home screen** | Tap + inside the app to add the widget directly, no need to browse the system list; double confirmation + permission check |
-| 💡 **Usage tips** | Home page shows a random operation tip (refreshed on each launch); settings page lists all 13 hidden tips |
-| ⚡ **Room database** | Usage records stored in Room (indexed on workspaceId+timeCreated); DAO queries replace full JSON serialization; auto-migration from the legacy DataStore on first launch |
-| 🎀 **Rainy pink theme** | Material Design 3 · Refined Rose primary #C9436C · Blush white background #FDEFF4 |
-| 🔐 **Codex OAuth sign-in** | Headless OAuth PKCE: the app generates an authorization link → sign in in an external browser → paste the callback URL to complete authorization; no manual auth.json export needed |
-| ⚡ **Codex one-tap usage activation** | Codex detail page can send a short request to the ChatGPT API to trigger usage tracking; model list fetched dynamically from models.dev and persisted, with manual refresh; response dialog is copyable |
-| ⚡ **OCGO / Ollama one-tap usage activation** | OCGO detail page can send a request to `opencode.ai/zen/v1`, Ollama detail page to `ollama.com/v1` to trigger usage tracking; API keys are entered manually in settings; model lists fetched dynamically from models.dev |
-| 🐛 **Debug logs** | In-app "Debug Logs" page showing detailed logs of Repository network requests, token refreshes, parse errors, etc.; no computer needed |
-| 🌐 **Multilingual** | Simplified Chinese / 繁體中文 / English interface; one-tap switching in settings (follow system / Simplified / Traditional / English); two-way sync with the system "App languages" page on Android 13+; non-CN/EN system languages fall back to English; home screen app name and widget follow the language |
-
----
-
-## 📦 Download
-
-Download the latest APK from [Releases](https://github.com/CATMIAOZHI/Rainytoken/releases).
-
-> ⚠️ You need a DeepSeek API Key, OpenCode Go login credentials, CommandCode API Key, Codex (OAuth sign-in or pasted auth.json), or an Ollama Cookie to fetch data.
-
----
-
-## 🏗️ Architecture
-
-```
-┌──────────────────────────────────────────────────────────────────┐
-│                           Android App                            │
-│                                                                  │
-│  ┌────────────────────────────────────────────────────────────┐  │
-│  │ Compose UI (3-layer screens)                               │  │
-│  │ Dashboard · Usage Charts · Totals                          │  │
-│  │ Detail · Token Activity · Settings                         │  │
-│  └──────────────────────────────┬─────────────────────────────┘  │
-│                                 │                                │
-│  ┌──────────────────────────────▼─────────────────────────────┐  │
-│  │ ViewModel Layer (MVVM)                                     │  │
-│  │ DashboardVM · UsageVM · UsageChartVM                       │  │
-│  │ · UsageDataVM (Hilt injected)                              │  │
-│  └──────────────────────────────┬─────────────────────────────┘  │
-│                                 │                                │
-│  ┌──────────────────────────────▼─────────────────────────────┐  │
-│  │ UseCase Layer                                              │  │
-│  │ RefreshBalanceUseCase (balance)                            │  │
-│  │ SyncUsageUseCase / SyncCommandCodeUsageUseCase             │  │
-│  └──────────────────────────────┬─────────────────────────────┘  │
-│                                 │                                │
-│  ┌──────────────────────────────▼─────────────────────────────┐  │
-│  │ Repository + Network                                       │  │
-│  │ DeepSeekApi (Retrofit) · OpenCodeGo web scraping           │  │
-│  │ · OpenCodeUsageRepository · CommandCodeUsageRepository     │  │
-│  │ · CodexRepository · OllamaRepository (OkHttp)              │  │
-│  └──────────────────────────────┬─────────────────────────────┘  │
-│                                 │                                │
-│  ┌──────────────────────────────▼─────────────────────────────┐  │
-│  │ Local Storage                                              │  │
-│  │ BalanceCache (DataStore)                                   │  │
-│  │ UsageCache (Room, indexed on workspaceId+timeCreated)      │  │
-│  │ CredentialRepository (Keystore AES-256 GCM)                │  │
-│  └────────────────────────────────────────────────────────────┘  │
-└──────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## 📁 Project Structure
-
-```
-Rainytoken/
-├── app/src/main/java/com/rainy/token/
-│   ├── data/
-│   │   ├── cache/          # BalanceCache (DataStore)
-│   │   ├── local/          # UsageCache (Room), UsageRecordEntity, UsageDao, UsageDatabase, ChartBucket
-│   │   ├── remote/         # DeepSeekApi (Retrofit) + OpenCodeGo scraping + UsageRepository
-│   │   └── repository/     # DeepSeek / OpenCodeGo / CommandCode / Codex / Ollama / Credential repositories
-│   ├── domain/
-│   │   ├── model/          # ServiceBalance, Credential, etc.
-│   │   ├── service/        # ServiceType enum
-│   │   └── usecase/        # RefreshBalanceUseCase / SyncUsageUseCase / SyncCommandCodeUsageUseCase
-│   ├── ui/
-│   │   ├── dashboard/      # DashboardScreen / UsageDetailScreen / UsageOverviewScreen / UsageDataScreen
-│   │   ├── heatmap/        # Token Activity heatmap (HeatmapScreen / HeatmapCanvas / HeatmapViewModel)
-│   │   ├── servicedetail/  # Service detail (ServiceDetailScreen)
-│   │   ├── settings/       # Settings / credential editing (SettingsScreen / CredentialEditScreen)
-│   │   ├── webview/        # Web login / Codex OAuth (WebViewLoginScreen / CodexOAuthScreen)
-│   │   ├── widget/         # Home screen widget (OpenCodeGoWidgetProvider)
-│   │   ├── components/     # ServiceIcon / StatusChip, etc.
-│   │   ├── theme/          # Rainy pink theme (StrawberryPink / InkMuted)
-│   │   └── RainyTokenNavHost.kt  # Navigation routes
-│   └── di/                 # Hilt modules
-├── gradle/libs.versions.toml   # Version Catalog dependency management
-├── build.gradle.kts            # Project-level configuration
-└── settings.gradle.kts         # Project settings
-```
-
----
-
-## 🛠️ Build
-
-### Option 1: Android Studio (recommended)
-1. Clone the repository: `git clone https://github.com/CATMIAOZHI/Rainytoken.git`
-2. Open the project in Android Studio
-3. Sync Gradle, connect a device, and hit Run ▶️
-
-### Option 2: Command line
-```bash
-# Run unit tests
-./gradlew testDebugUnitTest
-
-# Build a Debug APK
-./gradlew assembleDebug
-# APK output: app/build/outputs/apk/debug/app-debug.apk
-
-# Build a Release APK
-./gradlew assembleRelease
-```
-
-<details>
-<summary>🔧 ARM64 environment notes (optional)</summary>
-
-The project bundles an ARM64 AAPT2 binary, which is enabled automatically in ARM64 environments such as Proot/Termux:
-```bash
-chmod +x ./setup_android_env.sh
-./setup_android_env.sh
-```
-The script configures `$ANDROID_HOME` and uses the project-bundled ARM64 build-tools.
-
-**Extra Release build configuration**: Under ARM64 Proot, AGP 9.0 passes `--resource-path-shortening-map=<path>` (equals-sign syntax) to `optimizeReleaseResources`, which the ARM64 AAPT2 does not accept. Configure the AAPT2 wrapper in `~/.gradle/gradle.properties` (global, not committed to the repository):
-```properties
-android.aapt2FromMavenOverride=/path/to/android-aapt2-wrapper/aapt2
-```
-The wrapper script splits the equals-sign syntax into two separate space-delimited argv entries. The project's `build.gradle.kts` includes a built-in `guardReleaseResources` task as a build safeguard (falls back to the linked `.ap_` automatically when the optimized `.ap_` is missing).
-> On x86_64 environments (GitHub Actions / regular Linux), the official AAPT2 is used automatically — no extra steps required.
-</details>
-
----
-
-## 📦 Dependency Management
-
-The project manages all dependencies with a Gradle Version Catalog (`gradle/libs.versions.toml`).
-
-| Dependency | Purpose |
-|------|------|
-| `androidx.compose:compose-bom` | Jetpack Compose BOM |
-| `androidx.navigation:navigation-compose` | Page navigation |
-| `com.squareup.retrofit2:retrofit` | DeepSeek REST API |
-| `com.squareup.okhttp3:okhttp` | OpenCode Go web scraping |
-| `org.jetbrains.kotlinx:kotlinx-serialization-json` | JSON serialization |
-| `androidx.room:room-runtime` | Local usage database (Room) |
-| `androidx.datastore:datastore-preferences` | Local caching |
-| `com.google.dagger:hilt-android` | Dependency injection |
-| `com.google.devtools.ksp:symbol-processing-api` | KSP annotation processing |
-
----
-
-## 🔒 Security
-
-- ✅ API keys / session credentials are stored in the **Android Keystore** (AES-256 GCM encrypted)
-- ✅ Network requests are only sent to the official DeepSeek / OpenCode APIs
-- ✅ `allowBackup=false`: encrypted credentials and usage data are excluded from system backups, preventing undecryptable ciphertext when restoring on a new device
-- ✅ Fixed signing key — every Release can be installed over the previous version
-- ✅ Signing keys and passwords are stored encrypted in GitHub Secrets and decrypted during CI
-
----
-
-## 🐱 About
-
-RainyToken (雨晴Token) is the 4th member of the "Rainy Family" tools, maintained by [雨晴喵 (Rainy)](https://github.com/CATMIAOZHI), released alongside the [Rainy Family](https://github.com/CATMIAOZHI?tab=repositories):
-
-- [RainyLLM](https://github.com/CATMIAOZHI/RainyLLM) — fully offline Android local LLM inference server (Gemma + OpenAI-compatible API)
-- [RainyScanner](https://github.com/CATMIAOZHI/RainyScanner) — Android QR scanner that neither intercepts nor redirects
-- [Rainy2FA](https://github.com/CATMIAOZHI/Rainy2FA) — fully local · zero network · biometric-protected TOTP authenticator
-- **RainyToken** — AI Balance & Usage Quota Query (this project)
-
----
-
-## 📄 License
-
-MIT License © 2026 Rainy
-
----
-
-<p align="center">RainyToken · the Rainy Family tools</p>

README.md

@@ -1,239 +1,52 @@
 # 🌧️ 雨晴Token (RainyToken)
 
-> *"AI 用量，尽在掌握 — AI Balance & Usage at a Glance"*
+> *"AI 用量，尽在掌握"* 🐱✨
 
-[![CI](https://github.com/CATMIAOZHI/Rainytoken/actions/workflows/ci.yml/badge.svg)](https://github.com/CATMIAOZHI/Rainytoken/actions/workflows/ci.yml)
 [![Release](https://github.com/CATMIAOZHI/Rainytoken/actions/workflows/release.yml/badge.svg)](https://github.com/CATMIAOZHI/Rainytoken/actions)
 [![Version](https://img.shields.io/github/v/release/CATMIAOZHI/Rainytoken?color=ff85a2)](https://github.com/CATMIAOZHI/Rainytoken/releases)
-Android AI 余额与用量查询 APP —— 统一查看 DeepSeek、OpenCode Go、CommandCode、Codex / ChatGPT、Ollama 的余额与用量配额。粉色调品牌 UI，配套桌面小组件。
-RainyToken（雨晴Token）— AI Balance & Usage Quota Query · the Rainy Family tools.
 
----
+Android AI 余额查询 APP —— 统一查看 DeepSeek 和 OpenCode Go 的余额/配额。
 
-## 📸 截图
+## 功能
 
-<p align="center">
+- 📊 仪表盘：DeepSeek 余额（¥）+ OpenCode Go 用量（5h/本周/本月）+ 下拉全局刷新
-  <img src="docs/screenshots/dashboard-light.jpg" width="200" alt="仪表盘（亮色）" />
+- 📈 用量图表：消耗金额 / API 请求次数 / Token 消耗（3 张 Canvas 图表，支持多粒度筛选）
-  <img src="docs/screenshots/dashboard-dark.jpg" width="200" alt="仪表盘（深色）" />
+- 📋 详细数据：原始记录分页浏览，时间+模型筛选，原始数据弹窗
-  <img src="docs/screenshots/detail.jpg" width="200" alt="用量图表" />
+- 🧩 桌面小组件：不打开 APP 也能看用量
-  <img src="docs/screenshots/ollama-detail.jpg" width="200" alt="Ollama 模型调用次数" />
+- 🔄 自动同步：首页下拉自动同步用量；无缓存时启动自动全量同步
-</p>
+- 🎀 雨晴粉色调 UI
 
-<p align="center">
+## 构建
-  <em>仪表盘（亮色） · 仪表盘（深色） · 用量图表 · Ollama 模型调用次数</em>
-</p>
 
-<p align="center">
-  <img src="docs/screenshots/widget.jpg" width="300" alt="桌面小组件" />
-  <img src="docs/screenshots/ollama-card.jpg" width="200" alt="Ollama 卡片" />
-</p>
-
-<p align="center">
-  <em>桌面小组件 · Ollama 首页卡片</em>
-</p>
-
-<p align="center">
-  <img src="docs/screenshots/heatmap.jpg" width="200" alt="Token 活动" />
-</p>
-
-<p align="center">
-  <em>Token 活动</em>
-</p>
-
----
-
-## ✨ 功能特性
-
-| 特性 | 说明 |
-|------|------|
-| 📊 **仪表盘** | DeepSeek 余额（¥）+ 各服务用量/余额卡片；OCGO/CCGO 卡片可直达用量详情；长按拖动自由排序（持久化）；下拉全局刷新 · 平板自适应双窗格布局 |
-| 📈 **用量图表** | 3 张 Canvas 手绘图表 — 消耗金额 / API 请求次数 / Token 消耗（OCGO & CCGO 双数据源）；支持 UTC+0/UTC+8 时区切换和自定义日/月/范围；自动降级（近5h无数据→12h→7天→当月）；平板并排展示 |
-| 🗓️ **Token活动** | OCGO每日 Token热力图（GitHub贡献图风格）：每日 /每周 /累计三视图 +年份切换（默认最近 365 天，可切换自然年）；个人资料 +活动洞察（总请求次数 /最多请求时段 Top 3）+年度统计（累计 /峰值 /连续天数）；6 级粉色分位色阶，点击 /滑动查看 |
-| 📱 **平板适配** | 全局 `BoxWithConstraints` 自适应容器宽度；≥600dp 卡片双列，≥700dp 图表并排；双窗格 35/65 左右分栏（Expanded 模式）；支持 Android 13+ 预见性返回手势 |
-| 📋 **详细数据** | 原始记录分页浏览，支持时间 + 模型筛选，点击查看完整字段 |
-| 🔍 **多粒度筛选** | 5小时 / 12小时(10分钟桶) / 24小时 / 今天 / 昨天 / 最近7天 / 最近30天 / 当月 / 自定义日·月·范围 |
-| 🏷️ **模型筛选** | 多选 / 单选 / 全选，动态图例自适应换行 |
-| 📱 **桌面小组件** | 不打开 APP 也能看用量；支持四服务切换（OCGO/CCGO/Codex/Ollama）+ DeepSeek 余额；左上角 > 进 APP、其他区域点切换、↻ 刷新；可拖入负一屏；划到即自动刷新（MIUI 曝光刷新） |
-| 🔄 **自动同步** | 首页下拉自动同步用量；无缓存时启动自动全量同步；CCGO 详情页支持手动清除并重新同步 |
-| 🌙 **深色模式** | 全局自适应 — App 内文字/图标/背景自动切换，小组件独立适配暗色布局 |
-| ➕ **一键添桌面** | APP 内点 + 直接添加小组件，不用去系统列表翻；二次确认 + 权限检测 |
-| 💡 **使用小技巧** | 首页随机展示一条操作提示（每次启动刷新）；设置页可查看全部 13 条隐藏操作技巧 |
-| ⚡ **Room 数据库** | 用量记录存 Room（indexed on workspaceId+timeCreated），DAO 查询替代全量 JSON 序列化；首次启动自动从旧 DataStore 迁移 |
-| 🎀 **雨晴粉主题** | Material Design 3 · 精致玫瑰粉 主色 #C9436C · 粉白背景 #FDEFF4 |
-| 🔐 **Codex OAuth 登录** | 无头模式 OAuth PKCE：APP 生成授权链接 → 外部浏览器登录 → 粘贴回调 URL 完成授权，无需手动导出 auth.json |
-| ⚡ **Codex 一键激活用量** | Codex 详情页可向 ChatGPT API 发送简短请求触发用量统计；模型列表从 models.dev 动态获取并持久化，支持手动刷新；响应弹窗可复制 |
-| ⚡ **OCGO / Ollama 一键激活用量** | OCGO 详情页可向 `opencode.ai/zen/v1` 发送请求，Ollama 详情页可向 `ollama.com/v1` 发送请求触发用量统计；API Key 在设置页手动填写，模型列表从 models.dev 动态获取 |
-| 🐛 **调试日志** | APP 内「调试日志」页面，查看 Repository 网络请求、Token 刷新、解析错误等详细日志，无需连接电脑 |
-| 🌐 **多语言** | 简体中文 / 繁體中文 / English 三语言界面；设置页一键切换（跟随系统 / 简体 / 繁体 / English）；Android 13+ 与系统「应用语言」页双向同步；非中英系统语言自动回退英文；桌面 APP 名称与小组件跟随语言 |
-
----
-
-## 📦 下载
-
-前往 [Releases](https://github.com/CATMIAOZHI/Rainytoken/releases) 下载最新 APK。
-
-> ⚠️ 需要配置 DeepSeek API Key、OpenCode Go 登录凭据、CommandCode API Key、Codex（OAuth 登录或粘贴 auth.json）或 Ollama Cookie 才能拉取数据。
-
----
-
-## 🏗️ 技术架构
-
-```
-┌──────────────────────────────────────────────────┐
-│                 Android App                       │
-│                                                   │
-│  ┌─────────────────────────────────────────────┐ │
-│  │        Compose UI（3 层页面）                │ │
-│  │  仪表盘 · 用量图表 · 总统计                  │ │
-│  │  详细数据 · Token活动 · 设置                 │ │
-│  └────────────────────┬────────────────────────┘ │
-│                       │                           │
-│  ┌────────────────────▼─────────────────────────┐ │
-│  │         ViewModel 层（MVVM）                  │ │
-│  │  DashboardVM · UsageVM · UsageChartVM        │ │
-│  │  · UsageDataVM（Hilt 注入）                   │ │
-│  └────────────────────┬────────────────────────┘ │
-│                       │                           │
-│  ┌────────────────────▼─────────────────────────┐ │
-│  │         UseCase 层                            │ │
-│  │  RefreshBalanceUseCase（余额）                │ │
-│  │  SyncUsageUseCase / SyncCommandCodeUsageUseCase│ │
-│  └────────────────────┬────────────────────────┘ │
-│                       │                           │
-│  ┌────────────────────▼─────────────────────────┐ │
-│  │         Repository + Network                  │ │
-│  │  DeepSeekApi（Retrofit）· OpenCodeGo 网页抓取
-│  │  · OpenCodeUsageRepository · CommandCodeUsageRepository · CodexRepository · OllamaRepository（OkHttp）│ │
-│  └────────────────────┬────────────────────────┘ │
-│                       │                           │
-│  ┌────────────────────▼─────────────────────────┐ │
-│  │         本地存储                              │ │
-│  │  BalanceCache（DataStore）                    │ │
-│  │  UsageCache（Room，indexed on workspaceId+timeCreated） │ │
-│  │  CredentialRepository（Keystore AES-256 GCM） │ │
-│  └──────────────────────────────────────────────┘ │
-└──────────────────────────────────────────────────┘
-```
-
----
-
-## 📁 项目结构
-
-```
-Rainytoken/
-├── app/src/main/java/com/rainy/token/
-│   ├── data/
-│   │   ├── cache/          # BalanceCache（DataStore）
-│   │   ├── local/          # UsageCache（Room）、UsageRecordEntity、UsageDao、UsageDatabase、ChartBucket
-│   │   ├── remote/         # DeepSeekApi（Retrofit）+ OpenCodeGo 抓取 + UsageRepository
-│   │   └── repository/     # DeepSeek / OpenCodeGo / CommandCode / Codex / Ollama / Credential Repository
-│   ├── domain/
-│   │   ├── model/          # ServiceBalance、Credential 等
-│   │   ├── service/        # ServiceType 枚举
-│   │   └── usecase/        # RefreshBalanceUseCase / SyncUsageUseCase / SyncCommandCodeUsageUseCase
-│   ├── ui/
-│   │   ├── dashboard/      # DashboardScreen / UsageDetailScreen / UsageOverviewScreen / UsageDataScreen
-│   │   ├── heatmap/        # Token活动热力图（HeatmapScreen / HeatmapCanvas / HeatmapViewModel）
-│   │   ├── servicedetail/  # 服务详情（ServiceDetailScreen）
-│   │   ├── settings/       # 设置 /凭据编辑（SettingsScreen / CredentialEditScreen）
-│   │   ├── webview/        # 网页登录 / Codex OAuth（WebViewLoginScreen / CodexOAuthScreen）
-│   │   ├── widget/         # 桌面小组件（OpenCodeGoWidgetProvider）
-│   │   ├── components/     # ServiceIcon / StatusChip 等
-│   │   ├── theme/          # 雨晴粉主题（StrawberryPink / InkMuted）
-│   │   └── RainyTokenNavHost.kt  # Navigation 路由
-│   └── di/                 # Hilt 模块
-├── gradle/libs.versions.toml   # Version Catalog 依赖管理
-├── build.gradle.kts            # 项目级配置
-└── settings.gradle.kts         # 项目设置
-```
-
----
-
-## 🛠️ 构建
-
-### 方式一：Android Studio（推荐）
-1. Clone 仓库：`git clone https://github.com/CATMIAOZHI/Rainytoken.git`
-2. 用 Android Studio 打开项目
-3. 同步 Gradle，连接设备，Run ▶️
-
-### 方式二：命令行
 ```bash
-# 运行单元测试
+cd Rainytoken
-./gradlew testDebugUnitTest
+export ANDROID_HOME=$HOME/Android
-
+export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-arm64
-# 构建 Debug APK
 ./gradlew assembleDebug
-# APK 输出：app/build/outputs/apk/debug/app-debug.apk
-
-# 构建 Release APK
-./gradlew assembleRelease
 ```
 
-<details>
+APK 输出：`app/build/outputs/apk/debug/app-debug.apk`
-<summary>🔧 ARM64 环境说明（非必需）</summary>
+
+## 技术栈
+
+Kotlin + Jetpack Compose + Material 3 · Hilt + KSP · Retrofit + OkHttp · DataStore · minSdk=31
+
+## 项目结构
 
-项目内置了 ARM64 AAPT2 二进制，在 Proot/Termux 等 ARM64 环境中自动启用：
-```bash
-chmod +x ./setup_android_env.sh
-./setup_android_env.sh
 ```
-该脚本会配置 `$ANDROID_HOME` 并使用项目内置的 ARM64 build-tools。
+com.rainy.token/
-
+├── data/
-**Release 构建额外配置**：ARM64 Proot 下 AGP 9.0 的 `optimizeReleaseResources` 传入 `--resource-path-shortening-map=<path>` 等号参数，ARM64 AAPT2 不接受此语法，需在 `~/.gradle/gradle.properties`（全局，不提交项目仓库）中配置 AAPT2 wrapper：
+│   ├── cache/          # BalanceCache（DataStore）
-```properties
+│   ├── local/          # UsageCache（DataStore + 内存缓存）、UsageRecord、ChartBucket
-android.aapt2FromMavenOverride=/path/to/android-aapt2-wrapper/aapt2
+│   ├── remote/         # DeepSeekApi（Retrofit）+ OpenCodeGo 抓取 + OpenCodeUsageRepository
-```
+│   └── repository/     # DeepSeekRepository / OpenCodeGoRepository / CredentialRepository
-wrapper 脚本将等号形式拆分为空格分隔的两个独立 argv。项目 `build.gradle.kts` 中已内置 `guardReleaseResources` 任务作为构建防护（optimized `.ap_` 缺失时自动 fallback 到 linked `.ap_`）。
+├── domain/
-> 在 x86_64 环境（GitHub Actions / 普通 Linux）中会自动走官方 AAPT2，无需额外操作。
+│   ├── model/          # ServiceBalance、Credential 等
-</details>
+│   ├── service/        # ServiceType 枚举
-
+│   └── usecase/        # RefreshBalanceUseCase / SyncUsageUseCase
----
+├── ui/
-
+│   ├── dashboard/      # DashboardScreen、UsageDetailScreen（图表）、UsageOverviewScreen（总统计）、UsageDataScreen（原始数据）
-## 📦 依赖管理
+│   ├── widget/         # 桌面小组件（OpenCodeGoWidgetProvider）
-
+│   └── theme/          # 雨晴粉主题
-项目使用 Gradle Version Catalog (`gradle/libs.versions.toml`) 统一管理依赖。
+└── di/                 # Hilt 模块
-
+```
-| 依赖 | 用途 |
-|------|------|
-| `androidx.compose:compose-bom` | Jetpack Compose BOM |
-| `androidx.navigation:navigation-compose` | 页面导航 |
-| `com.squareup.retrofit2:retrofit` | DeepSeek REST API |
-| `com.squareup.okhttp3:okhttp` | OpenCode Go 网页抓取 |
-| `org.jetbrains.kotlinx:kotlinx-serialization-json` | JSON 序列化 |
-| `androidx.room:room-runtime` | 用量数据本地数据库（Room） |
-| `androidx.datastore:datastore-preferences` | 本地缓存 |
-| `com.google.dagger:hilt-android` | 依赖注入 |
-| `com.google.devtools.ksp:symbol-processing-api` | KSP 注解处理 |
-
----
-
-## 🔒 安全说明
-
-- ✅ API Key / Session 凭据存入 **Android Keystore**（AES-256 GCM 加密）
-- ✅ 网络请求仅向 DeepSeek / OpenCode 官方 API 发出
-- ✅ `allowBackup=false`：凭据密文、用量数据均不参与系统备份，避免换机恢复后密文无法解密
-- ✅ 签名密钥固定，每次 Release 可覆盖安装
-- ✅ GitHub Secrets 加密存储签名密钥及密码，CI 中解码使用
-
----
-
-## 🐱 关于
-
-RainyToken（雨晴Token）是「雨晴系列」的第 4 个成员，由 [雨晴喵](https://github.com/CATMIAOZHI) 开发维护，随 [雨晴系列](https://github.com/CATMIAOZHI?tab=repositories) 发布：
-
-- [RainyLLM](https://github.com/CATMIAOZHI/RainyLLM) — 纯离线 Android 本地 LLM 推理服务器（Gemma + OpenAI 兼容 API）
-- [RainyScanner](https://github.com/CATMIAOZHI/RainyScanner) — 不拦截不跳转的 Android 扫码工具
-- [Rainy2FA](https://github.com/CATMIAOZHI/Rainy2FA) — 纯本地 · 零联网 · 生物识别保护的 TOTP 验证器
-- **RainyToken** — AI 余额与用量查询 APP | AI Balance & Usage Quota Query（本项目）
-
-> 守护每一分 AI 算力预算 💖
-
----
-
-## 📄 License
-
-MIT License © 2026 Rainy
-
----
-
-<p align="center">RainyToken · the Rainy Family tools</p>

app/build.gradle.kts

@@ -1,5 +1,3 @@
-import java.io.File
-
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.compose)
@@ -16,8 +14,8 @@ android {
         applicationId = "com.rainy.token"
         minSdk = 31
         targetSdk = 35
-        versionCode = 49
+        versionCode = 1
-        versionName = "1.7.29"
+        versionName = "1.0"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
         vectorDrawables {
@@ -27,40 +25,10 @@ android {
 
     signingConfigs {
         create("release") {
-            // CI 环境没有 release.jks，自动 fallback 到 debug keystore
+            storeFile = rootProject.file("release.jks")
-            // Release workflow 通过 Secret 注入 release.jks
+            storePassword = System.getenv("KEYSTORE_PASSWORD") ?: "RainyToken2026!"
-            val keystoreFile = rootProject.file("release.jks")
+            keyAlias = System.getenv("KEYSTORE_ALIAS") ?: "rainy"
-            if (keystoreFile.exists()) {
+            keyPassword = System.getenv("KEY_PASSWORD") ?: "RainyToken2026!"
-                storeFile = keystoreFile
-                // 凭据必须通过环境变量注入；缺失或为空时直接报错，不提供任何隐式 fallback
-                // 注意：GitHub Actions 中未设置的 secret 会被替换为空字符串（非 null），
-                // 因此用 takeIf { isNotBlank() } 同时防御 null 和空字符串
-                storePassword = System.getenv("KEYSTORE_PASSWORD")
-                    ?.takeIf { it.isNotBlank() }
-                    ?: throw GradleException("KEYSTORE_PASSWORD env var not set or empty — cannot sign release")
-                keyAlias = System.getenv("KEYSTORE_ALIAS")
-                    ?.takeIf { it.isNotBlank() }
-                    ?: throw GradleException("KEYSTORE_ALIAS env var not set or empty — cannot sign release")
-                keyPassword = System.getenv("KEY_PASSWORD")
-                    ?.takeIf { it.isNotBlank() }
-                    ?: throw GradleException("KEY_PASSWORD env var not set or empty — cannot sign release")
-            } else {
-                // 仅在 CI 环境中 fallback 到 debug keystore（用于编译/资源完整性验证）
-                // 本地构建缺少 release.jks 时直接报错，避免静默生成 debug 签名的 Release APK
-                if (System.getenv("CI") != null) {
-                    val debugKeystore = file("${System.getProperty("user.home")}/.android/debug.keystore")
-                    storeFile = debugKeystore
-                    storePassword = "android"
-                    keyAlias = "androiddebugkey"
-                    keyPassword = "android"
-                } else {
-                    throw GradleException(
-                        "release.jks 不存在，且当前不是 CI 环境。\n" +
-                        "正式 Release 构建需要 release.jks 密钥库文件。\n" +
-                        "如需本地验证编译，请设置环境变量 CI=true 或使用 assembleDebug。"
-                    )
-                }
-            }
         }
     }
 
@@ -77,18 +45,12 @@ android {
             )
         }
     }
-    // noCompress workaround removed — no longer needed
     compileOptions {
         sourceCompatibility = JavaVersion.VERSION_17
         targetCompatibility = JavaVersion.VERSION_17
     }
     buildFeatures {
         compose = true
-        buildConfig = true
-    }
-    androidResources {
-        // Android 13+ 应用级语言设置：根据 values-* 目录自动生成 locales_config
-        generateLocaleConfig = true
     }
     packaging {
         resources {
@@ -97,84 +59,6 @@ android {
     }
 }
 
-// ═══════════════════════════════════════════════════════
-// AGP 9.0 ARM64 Proot: Release resource guard + fallback
-//
-// 根因：AGP 9.0 的 optimizeReleaseResources 传入 --resource-path-shortening-map=<path>
-// 等号形式，ARM64 AAPT2 不接受此语法（只接受空格分隔），exit code=1 但 AGP 不检查，
-// 导致 optimized .ap_ 缺失，packageRelease 生成无资源残缺 APK。
-//
-// 修复链：
-// 1. ~/.gradle/gradle.properties → android.aapt2FromMavenOverride 指向 wrapper
-//    wrapper 将 --resource-path-shortening-map=<path> 拆分为两个独立 argv
-// 2. 本任务作为构建防护：optimizeReleaseResources 之后验证 optimized .ap_ 完整性，
-//    若缺失则复制 linked .ap_ 作为 fallback（功能正确，仅跳过 path shortening）
-// 3. packageRelease 依赖此任务，确保消费到完整资源
-// ═══════════════════════════════════════════════════════
-if (System.getProperty("os.arch") == "aarch64") {
-    tasks.register("guardReleaseResources") {
-        dependsOn("optimizeReleaseResources")
-        doLast {
-            val linkedAp = layout.buildDirectory
-                .file("intermediates/linked_resources_binary_format/release/processReleaseResources/linked-resources-binary-format-release.ap_")
-                .get().asFile
-            val optimizedDir = layout.buildDirectory
-                .dir("intermediates/optimized_processed_res/release/optimizeReleaseResources")
-                .get().asFile
-            val optimizedAp = File(optimizedDir, "resources-release-optimize.ap_")
-
-            if (optimizedAp.exists() && optimizedAp.length() > 0) {
-                // optimized .ap_ 存在，验证内容完整性
-                val zipList = providers.exec {
-                    commandLine("unzip", "-l", optimizedAp.absolutePath)
-                    isIgnoreExitValue = true
-                }.standardOutput.asText.get()
-
-                val hasManifest = zipList.contains("AndroidManifest.xml")
-                val hasArsc = zipList.contains("resources.arsc")
-                val hasRes = zipList.contains("res/")
-
-                if (hasManifest && hasArsc && hasRes) {
-                    logger.lifecycle("GuardReleaseResources: optimized .ap_ OK (${optimizedAp.length()} bytes)")
-                    return@doLast
-                }
-                logger.warn("GuardReleaseResources: optimized .ap_ incomplete (manifest=$hasManifest arsc=$hasArsc res=$hasRes)")
-            } else {
-                logger.warn("GuardReleaseResources: optimized .ap_ missing or empty")
-            }
-
-            // Fallback: copy linked .ap_ → optimized .ap_
-            if (!linkedAp.exists() || linkedAp.length() == 0L) {
-                throw GradleException("GuardReleaseResources: linked .ap_ also missing or empty — cannot recover")
-            }
-
-            optimizedDir.mkdirs()
-            linkedAp.copyTo(optimizedAp, overwrite = true)
-
-            // Verify the copy
-            val verifyList = providers.exec {
-                commandLine("unzip", "-l", optimizedAp.absolutePath)
-                isIgnoreExitValue = true
-            }.standardOutput.asText.get()
-
-            val vManifest = verifyList.contains("AndroidManifest.xml")
-            val vArsc = verifyList.contains("resources.arsc")
-            val vRes = verifyList.contains("res/")
-
-            if (!vManifest || !vArsc || !vRes) {
-                throw GradleException("GuardReleaseResources: fallback copy verification failed (manifest=$vManifest arsc=$vArsc res=$vRes)")
-            }
-
-            logger.lifecycle("GuardReleaseResources: fallback — copied linked .ap_ → optimized .ap_ (${optimizedAp.length()} bytes, path shortening skipped)")
-        }
-    }
-
-    // packageRelease 必须依赖此防护任务
-    project.tasks.matching { it.name == "packageRelease" }.configureEach {
-        dependsOn("guardReleaseResources")
-    }
-}
-
 // Force ARM64 AAPT2 in Proot environment (local only; GitHub Actions x86_64 uses default)
 if (System.getProperty("os.arch") == "aarch64") {
     configurations.all {
@@ -190,7 +74,6 @@ dependencies {
 
     // Core
     implementation(libs.androidx.core.ktx)
-    implementation(libs.androidsvg)
     implementation(libs.androidx.lifecycle.runtime.ktx)
     implementation(libs.androidx.lifecycle.runtime.compose)
     implementation(libs.androidx.lifecycle.viewmodel.compose)
@@ -202,7 +85,6 @@ dependencies {
     implementation(libs.androidx.ui.graphics)
     implementation(libs.androidx.ui.tooling.preview)
     implementation(libs.androidx.material3)
-    implementation(libs.androidx.material3.window.size)
 
     // Navigation
     implementation(libs.androidx.navigation.compose)
@@ -213,12 +95,7 @@ dependencies {
     implementation(libs.okhttp.logging.interceptor)
     implementation(libs.kotlinx.serialization.json)
     implementation(libs.retrofit.kotlinx.serialization.converter)
-
+    implementation(libs.jsoup)
-    // Ktor 本地反代 HTTP 服务
-    implementation(libs.ktor.server.core)
-    implementation(libs.ktor.server.cio)
-    implementation(libs.ktor.server.content.negotiation)
-    implementation(libs.ktor.serialization.kotlinx.json)
 
     // DataStore
     implementation(libs.androidx.datastore.preferences)
@@ -231,11 +108,6 @@ dependencies {
     ksp(libs.hilt.compiler)
     implementation(libs.androidx.hilt.navigation.compose)
 
-    // Room
-    implementation(libs.room.runtime)
-    implementation(libs.room.ktx)
-    ksp(libs.room.compiler)
-
     // Test
     testImplementation(libs.junit)
     androidTestImplementation(libs.androidx.junit)

app/build/generated/hilt/component_sources/debug/com/rainy/token/DaggerRainyTokenApplication_HiltComponents_SingletonC.java

@@ -0,0 +1,809 @@
+package com.rainy.token;
+
+import android.app.Activity;
+import android.app.Service;
+import android.view.View;
+import androidx.datastore.core.DataStore;
+import androidx.datastore.preferences.core.Preferences;
+import androidx.fragment.app.Fragment;
+import androidx.lifecycle.SavedStateHandle;
+import androidx.lifecycle.ViewModel;
+import com.rainy.token.data.cache.BalanceCache;
+import com.rainy.token.data.local.SecureStorage;
+import com.rainy.token.data.local.UsageCache;
+import com.rainy.token.data.remote.DeepSeekApi;
+import com.rainy.token.data.repository.CredentialRepository;
+import com.rainy.token.data.repository.DeepSeekRepository;
+import com.rainy.token.data.repository.OpenCodeGoRepository;
+import com.rainy.token.data.repository.OpenCodeUsageRepository;
+import com.rainy.token.data.repository.WebViewSessionSaver;
+import com.rainy.token.di.NetworkModule_ProvideBalanceCacheDataStoreFactory;
+import com.rainy.token.di.NetworkModule_ProvideBalanceCacheFactory;
+import com.rainy.token.di.NetworkModule_ProvideDeepSeekApiFactory;
+import com.rainy.token.di.NetworkModule_ProvideDeepSeekRepositoryFactory;
+import com.rainy.token.di.NetworkModule_ProvideJsonFactory;
+import com.rainy.token.di.NetworkModule_ProvideOkHttpClientFactory;
+import com.rainy.token.di.NetworkModule_ProvideOpenCodeGoRepositoryFactory;
+import com.rainy.token.di.NetworkModule_ProvideOpenCodeUsageRepositoryFactory;
+import com.rainy.token.di.NetworkModule_ProvideRetrofitFactory;
+import com.rainy.token.di.NetworkModule_ProvideSecureStorageFactory;
+import com.rainy.token.di.NetworkModule_ProvideUsageCacheFactory;
+import com.rainy.token.di.StorageModule_ProvideSecureStorageDataStoreFactory;
+import com.rainy.token.di.StorageModule_ProvideUsageCacheDataStoreFactory;
+import com.rainy.token.domain.usecase.RefreshBalanceUseCase;
+import com.rainy.token.domain.usecase.SyncUsageUseCase;
+import com.rainy.token.ui.dashboard.DashboardViewModel;
+import com.rainy.token.ui.dashboard.DashboardViewModel_HiltModules;
+import com.rainy.token.ui.dashboard.DashboardViewModel_HiltModules_BindsModule_Binds_LazyMapKey;
+import com.rainy.token.ui.dashboard.DashboardViewModel_HiltModules_KeyModule_Provide_LazyMapKey;
+import com.rainy.token.ui.dashboard.UsageChartViewModel;
+import com.rainy.token.ui.dashboard.UsageChartViewModel_HiltModules;
+import com.rainy.token.ui.dashboard.UsageChartViewModel_HiltModules_BindsModule_Binds_LazyMapKey;
+import com.rainy.token.ui.dashboard.UsageChartViewModel_HiltModules_KeyModule_Provide_LazyMapKey;
+import com.rainy.token.ui.dashboard.UsageDataViewModel;
+import com.rainy.token.ui.dashboard.UsageDataViewModel_HiltModules;
+import com.rainy.token.ui.dashboard.UsageDataViewModel_HiltModules_BindsModule_Binds_LazyMapKey;
+import com.rainy.token.ui.dashboard.UsageDataViewModel_HiltModules_KeyModule_Provide_LazyMapKey;
+import com.rainy.token.ui.dashboard.UsageViewModel;
+import com.rainy.token.ui.dashboard.UsageViewModel_HiltModules;
+import com.rainy.token.ui.dashboard.UsageViewModel_HiltModules_BindsModule_Binds_LazyMapKey;
+import com.rainy.token.ui.dashboard.UsageViewModel_HiltModules_KeyModule_Provide_LazyMapKey;
+import com.rainy.token.ui.servicedetail.ServiceDetailViewModel;
+import com.rainy.token.ui.servicedetail.ServiceDetailViewModel_HiltModules;
+import com.rainy.token.ui.servicedetail.ServiceDetailViewModel_HiltModules_BindsModule_Binds_LazyMapKey;
+import com.rainy.token.ui.servicedetail.ServiceDetailViewModel_HiltModules_KeyModule_Provide_LazyMapKey;
+import com.rainy.token.ui.settings.CredentialEditViewModel;
+import com.rainy.token.ui.settings.CredentialEditViewModel_HiltModules;
+import com.rainy.token.ui.settings.CredentialEditViewModel_HiltModules_BindsModule_Binds_LazyMapKey;
+import com.rainy.token.ui.settings.CredentialEditViewModel_HiltModules_KeyModule_Provide_LazyMapKey;
+import com.rainy.token.ui.settings.SettingsViewModel;
+import com.rainy.token.ui.settings.SettingsViewModel_HiltModules;
+import com.rainy.token.ui.settings.SettingsViewModel_HiltModules_BindsModule_Binds_LazyMapKey;
+import com.rainy.token.ui.settings.SettingsViewModel_HiltModules_KeyModule_Provide_LazyMapKey;
+import com.rainy.token.ui.webview.WebViewLoginViewModel;
+import com.rainy.token.ui.webview.WebViewLoginViewModel_HiltModules;
+import com.rainy.token.ui.webview.WebViewLoginViewModel_HiltModules_BindsModule_Binds_LazyMapKey;
+import com.rainy.token.ui.webview.WebViewLoginViewModel_HiltModules_KeyModule_Provide_LazyMapKey;
+import dagger.hilt.android.ActivityRetainedLifecycle;
+import dagger.hilt.android.ViewModelLifecycle;
+import dagger.hilt.android.internal.builders.ActivityComponentBuilder;
+import dagger.hilt.android.internal.builders.ActivityRetainedComponentBuilder;
+import dagger.hilt.android.internal.builders.FragmentComponentBuilder;
+import dagger.hilt.android.internal.builders.ServiceComponentBuilder;
+import dagger.hilt.android.internal.builders.ViewComponentBuilder;
+import dagger.hilt.android.internal.builders.ViewModelComponentBuilder;
+import dagger.hilt.android.internal.builders.ViewWithFragmentComponentBuilder;
+import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
+import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories_InternalFactoryFactory_Factory;
+import dagger.hilt.android.internal.managers.ActivityRetainedComponentManager_LifecycleModule_ProvideActivityRetainedLifecycleFactory;
+import dagger.hilt.android.internal.managers.SavedStateHandleHolder;
+import dagger.hilt.android.internal.modules.ApplicationContextModule;
+import dagger.hilt.android.internal.modules.ApplicationContextModule_ProvideContextFactory;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.DoubleCheck;
+import dagger.internal.LazyClassKeyMap;
+import dagger.internal.MapBuilder;
+import dagger.internal.Preconditions;
+import dagger.internal.Provider;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.processing.Generated;
+import kotlinx.serialization.json.Json;
+import okhttp3.OkHttpClient;
+import retrofit2.Retrofit;
+
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class DaggerRainyTokenApplication_HiltComponents_SingletonC {
+  private DaggerRainyTokenApplication_HiltComponents_SingletonC() {
+  }
+
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  public static final class Builder {
+    private ApplicationContextModule applicationContextModule;
+
+    private Builder() {
+    }
+
+    public Builder applicationContextModule(ApplicationContextModule applicationContextModule) {
+      this.applicationContextModule = Preconditions.checkNotNull(applicationContextModule);
+      return this;
+    }
+
+    public RainyTokenApplication_HiltComponents.SingletonC build() {
+      Preconditions.checkBuilderRequirement(applicationContextModule, ApplicationContextModule.class);
+      return new SingletonCImpl(applicationContextModule);
+    }
+  }
+
+  private static final class ActivityRetainedCBuilder implements RainyTokenApplication_HiltComponents.ActivityRetainedC.Builder {
+    private final SingletonCImpl singletonCImpl;
+
+    private SavedStateHandleHolder savedStateHandleHolder;
+
+    private ActivityRetainedCBuilder(SingletonCImpl singletonCImpl) {
+      this.singletonCImpl = singletonCImpl;
+    }
+
+    @Override
+    public ActivityRetainedCBuilder savedStateHandleHolder(
+        SavedStateHandleHolder savedStateHandleHolder) {
+      this.savedStateHandleHolder = Preconditions.checkNotNull(savedStateHandleHolder);
+      return this;
+    }
+
+    @Override
+    public RainyTokenApplication_HiltComponents.ActivityRetainedC build() {
+      Preconditions.checkBuilderRequirement(savedStateHandleHolder, SavedStateHandleHolder.class);
+      return new ActivityRetainedCImpl(singletonCImpl, savedStateHandleHolder);
+    }
+  }
+
+  private static final class ActivityCBuilder implements RainyTokenApplication_HiltComponents.ActivityC.Builder {
+    private final SingletonCImpl singletonCImpl;
+
+    private final ActivityRetainedCImpl activityRetainedCImpl;
+
+    private Activity activity;
+
+    private ActivityCBuilder(SingletonCImpl singletonCImpl,
+        ActivityRetainedCImpl activityRetainedCImpl) {
+      this.singletonCImpl = singletonCImpl;
+      this.activityRetainedCImpl = activityRetainedCImpl;
+    }
+
+    @Override
+    public ActivityCBuilder activity(Activity activity) {
+      this.activity = Preconditions.checkNotNull(activity);
+      return this;
+    }
+
+    @Override
+    public RainyTokenApplication_HiltComponents.ActivityC build() {
+      Preconditions.checkBuilderRequirement(activity, Activity.class);
+      return new ActivityCImpl(singletonCImpl, activityRetainedCImpl, activity);
+    }
+  }
+
+  private static final class FragmentCBuilder implements RainyTokenApplication_HiltComponents.FragmentC.Builder {
+    private final SingletonCImpl singletonCImpl;
+
+    private final ActivityRetainedCImpl activityRetainedCImpl;
+
+    private final ActivityCImpl activityCImpl;
+
+    private Fragment fragment;
+
+    private FragmentCBuilder(SingletonCImpl singletonCImpl,
+        ActivityRetainedCImpl activityRetainedCImpl, ActivityCImpl activityCImpl) {
+      this.singletonCImpl = singletonCImpl;
+      this.activityRetainedCImpl = activityRetainedCImpl;
+      this.activityCImpl = activityCImpl;
+    }
+
+    @Override
+    public FragmentCBuilder fragment(Fragment fragment) {
+      this.fragment = Preconditions.checkNotNull(fragment);
+      return this;
+    }
+
+    @Override
+    public RainyTokenApplication_HiltComponents.FragmentC build() {
+      Preconditions.checkBuilderRequirement(fragment, Fragment.class);
+      return new FragmentCImpl(singletonCImpl, activityRetainedCImpl, activityCImpl, fragment);
+    }
+  }
+
+  private static final class ViewWithFragmentCBuilder implements RainyTokenApplication_HiltComponents.ViewWithFragmentC.Builder {
+    private final SingletonCImpl singletonCImpl;
+
+    private final ActivityRetainedCImpl activityRetainedCImpl;
+
+    private final ActivityCImpl activityCImpl;
+
+    private final FragmentCImpl fragmentCImpl;
+
+    private View view;
+
+    private ViewWithFragmentCBuilder(SingletonCImpl singletonCImpl,
+        ActivityRetainedCImpl activityRetainedCImpl, ActivityCImpl activityCImpl,
+        FragmentCImpl fragmentCImpl) {
+      this.singletonCImpl = singletonCImpl;
+      this.activityRetainedCImpl = activityRetainedCImpl;
+      this.activityCImpl = activityCImpl;
+      this.fragmentCImpl = fragmentCImpl;
+    }
+
+    @Override
+    public ViewWithFragmentCBuilder view(View view) {
+      this.view = Preconditions.checkNotNull(view);
+      return this;
+    }
+
+    @Override
+    public RainyTokenApplication_HiltComponents.ViewWithFragmentC build() {
+      Preconditions.checkBuilderRequirement(view, View.class);
+      return new ViewWithFragmentCImpl(singletonCImpl, activityRetainedCImpl, activityCImpl, fragmentCImpl, view);
+    }
+  }
+
+  private static final class ViewCBuilder implements RainyTokenApplication_HiltComponents.ViewC.Builder {
+    private final SingletonCImpl singletonCImpl;
+
+    private final ActivityRetainedCImpl activityRetainedCImpl;
+
+    private final ActivityCImpl activityCImpl;
+
+    private View view;
+
+    private ViewCBuilder(SingletonCImpl singletonCImpl, ActivityRetainedCImpl activityRetainedCImpl,
+        ActivityCImpl activityCImpl) {
+      this.singletonCImpl = singletonCImpl;
+      this.activityRetainedCImpl = activityRetainedCImpl;
+      this.activityCImpl = activityCImpl;
+    }
+
+    @Override
+    public ViewCBuilder view(View view) {
+      this.view = Preconditions.checkNotNull(view);
+      return this;
+    }
+
+    @Override
+    public RainyTokenApplication_HiltComponents.ViewC build() {
+      Preconditions.checkBuilderRequirement(view, View.class);
+      return new ViewCImpl(singletonCImpl, activityRetainedCImpl, activityCImpl, view);
+    }
+  }
+
+  private static final class ViewModelCBuilder implements RainyTokenApplication_HiltComponents.ViewModelC.Builder {
+    private final SingletonCImpl singletonCImpl;
+
+    private final ActivityRetainedCImpl activityRetainedCImpl;
+
+    private SavedStateHandle savedStateHandle;
+
+    private ViewModelLifecycle viewModelLifecycle;
+
+    private ViewModelCBuilder(SingletonCImpl singletonCImpl,
+        ActivityRetainedCImpl activityRetainedCImpl) {
+      this.singletonCImpl = singletonCImpl;
+      this.activityRetainedCImpl = activityRetainedCImpl;
+    }
+
+    @Override
+    public ViewModelCBuilder savedStateHandle(SavedStateHandle handle) {
+      this.savedStateHandle = Preconditions.checkNotNull(handle);
+      return this;
+    }
+
+    @Override
+    public ViewModelCBuilder viewModelLifecycle(ViewModelLifecycle viewModelLifecycle) {
+      this.viewModelLifecycle = Preconditions.checkNotNull(viewModelLifecycle);
+      return this;
+    }
+
+    @Override
+    public RainyTokenApplication_HiltComponents.ViewModelC build() {
+      Preconditions.checkBuilderRequirement(savedStateHandle, SavedStateHandle.class);
+      Preconditions.checkBuilderRequirement(viewModelLifecycle, ViewModelLifecycle.class);
+      return new ViewModelCImpl(singletonCImpl, activityRetainedCImpl, savedStateHandle, viewModelLifecycle);
+    }
+  }
+
+  private static final class ServiceCBuilder implements RainyTokenApplication_HiltComponents.ServiceC.Builder {
+    private final SingletonCImpl singletonCImpl;
+
+    private Service service;
+
+    private ServiceCBuilder(SingletonCImpl singletonCImpl) {
+      this.singletonCImpl = singletonCImpl;
+    }
+
+    @Override
+    public ServiceCBuilder service(Service service) {
+      this.service = Preconditions.checkNotNull(service);
+      return this;
+    }
+
+    @Override
+    public RainyTokenApplication_HiltComponents.ServiceC build() {
+      Preconditions.checkBuilderRequirement(service, Service.class);
+      return new ServiceCImpl(singletonCImpl, service);
+    }
+  }
+
+  private static final class ViewWithFragmentCImpl extends RainyTokenApplication_HiltComponents.ViewWithFragmentC {
+    private final SingletonCImpl singletonCImpl;
+
+    private final ActivityRetainedCImpl activityRetainedCImpl;
+
+    private final ActivityCImpl activityCImpl;
+
+    private final FragmentCImpl fragmentCImpl;
+
+    private final ViewWithFragmentCImpl viewWithFragmentCImpl = this;
+
+    ViewWithFragmentCImpl(SingletonCImpl singletonCImpl,
+        ActivityRetainedCImpl activityRetainedCImpl, ActivityCImpl activityCImpl,
+        FragmentCImpl fragmentCImpl, View viewParam) {
+      this.singletonCImpl = singletonCImpl;
+      this.activityRetainedCImpl = activityRetainedCImpl;
+      this.activityCImpl = activityCImpl;
+      this.fragmentCImpl = fragmentCImpl;
+
+
+    }
+  }
+
+  private static final class FragmentCImpl extends RainyTokenApplication_HiltComponents.FragmentC {
+    private final SingletonCImpl singletonCImpl;
+
+    private final ActivityRetainedCImpl activityRetainedCImpl;
+
+    private final ActivityCImpl activityCImpl;
+
+    private final FragmentCImpl fragmentCImpl = this;
+
+    FragmentCImpl(SingletonCImpl singletonCImpl, ActivityRetainedCImpl activityRetainedCImpl,
+        ActivityCImpl activityCImpl, Fragment fragmentParam) {
+      this.singletonCImpl = singletonCImpl;
+      this.activityRetainedCImpl = activityRetainedCImpl;
+      this.activityCImpl = activityCImpl;
+
+
+    }
+
+    @Override
+    public DefaultViewModelFactories.InternalFactoryFactory getHiltInternalFactoryFactory() {
+      return activityCImpl.getHiltInternalFactoryFactory();
+    }
+
+    @Override
+    public ViewWithFragmentComponentBuilder viewWithFragmentComponentBuilder() {
+      return new ViewWithFragmentCBuilder(singletonCImpl, activityRetainedCImpl, activityCImpl, fragmentCImpl);
+    }
+  }
+
+  private static final class ViewCImpl extends RainyTokenApplication_HiltComponents.ViewC {
+    private final SingletonCImpl singletonCImpl;
+
+    private final ActivityRetainedCImpl activityRetainedCImpl;
+
+    private final ActivityCImpl activityCImpl;
+
+    private final ViewCImpl viewCImpl = this;
+
+    ViewCImpl(SingletonCImpl singletonCImpl, ActivityRetainedCImpl activityRetainedCImpl,
+        ActivityCImpl activityCImpl, View viewParam) {
+      this.singletonCImpl = singletonCImpl;
+      this.activityRetainedCImpl = activityRetainedCImpl;
+      this.activityCImpl = activityCImpl;
+
+
+    }
+  }
+
+  private static final class ActivityCImpl extends RainyTokenApplication_HiltComponents.ActivityC {
+    private final SingletonCImpl singletonCImpl;
+
+    private final ActivityRetainedCImpl activityRetainedCImpl;
+
+    private final ActivityCImpl activityCImpl = this;
+
+    ActivityCImpl(SingletonCImpl singletonCImpl, ActivityRetainedCImpl activityRetainedCImpl,
+        Activity activityParam) {
+      this.singletonCImpl = singletonCImpl;
+      this.activityRetainedCImpl = activityRetainedCImpl;
+
+
+    }
+
+    Map keySetMapOfClassOfAndBooleanBuilder() {
+      MapBuilder mapBuilder = MapBuilder.<String, Boolean>newMapBuilder(8);
+      mapBuilder.put(CredentialEditViewModel_HiltModules_KeyModule_Provide_LazyMapKey.lazyClassKeyName, CredentialEditViewModel_HiltModules.KeyModule.provide());
+      mapBuilder.put(DashboardViewModel_HiltModules_KeyModule_Provide_LazyMapKey.lazyClassKeyName, DashboardViewModel_HiltModules.KeyModule.provide());
+      mapBuilder.put(ServiceDetailViewModel_HiltModules_KeyModule_Provide_LazyMapKey.lazyClassKeyName, ServiceDetailViewModel_HiltModules.KeyModule.provide());
+      mapBuilder.put(SettingsViewModel_HiltModules_KeyModule_Provide_LazyMapKey.lazyClassKeyName, SettingsViewModel_HiltModules.KeyModule.provide());
+      mapBuilder.put(UsageChartViewModel_HiltModules_KeyModule_Provide_LazyMapKey.lazyClassKeyName, UsageChartViewModel_HiltModules.KeyModule.provide());
+      mapBuilder.put(UsageDataViewModel_HiltModules_KeyModule_Provide_LazyMapKey.lazyClassKeyName, UsageDataViewModel_HiltModules.KeyModule.provide());
+      mapBuilder.put(UsageViewModel_HiltModules_KeyModule_Provide_LazyMapKey.lazyClassKeyName, UsageViewModel_HiltModules.KeyModule.provide());
+      mapBuilder.put(WebViewLoginViewModel_HiltModules_KeyModule_Provide_LazyMapKey.lazyClassKeyName, WebViewLoginViewModel_HiltModules.KeyModule.provide());
+      return mapBuilder.build();
+    }
+
+    @Override
+    public void injectMainActivity(MainActivity arg0) {
+    }
+
+    @Override
+    public DefaultViewModelFactories.InternalFactoryFactory getHiltInternalFactoryFactory() {
+      return DefaultViewModelFactories_InternalFactoryFactory_Factory.newInstance(getViewModelKeys(), new ViewModelCBuilder(singletonCImpl, activityRetainedCImpl));
+    }
+
+    @Override
+    public Map<Class<?>, Boolean> getViewModelKeys() {
+      return LazyClassKeyMap.<Boolean>of(keySetMapOfClassOfAndBooleanBuilder());
+    }
+
+    @Override
+    public ViewModelComponentBuilder getViewModelComponentBuilder() {
+      return new ViewModelCBuilder(singletonCImpl, activityRetainedCImpl);
+    }
+
+    @Override
+    public FragmentComponentBuilder fragmentComponentBuilder() {
+      return new FragmentCBuilder(singletonCImpl, activityRetainedCImpl, activityCImpl);
+    }
+
+    @Override
+    public ViewComponentBuilder viewComponentBuilder() {
+      return new ViewCBuilder(singletonCImpl, activityRetainedCImpl, activityCImpl);
+    }
+  }
+
+  private static final class ViewModelCImpl extends RainyTokenApplication_HiltComponents.ViewModelC {
+    private final SingletonCImpl singletonCImpl;
+
+    private final ActivityRetainedCImpl activityRetainedCImpl;
+
+    private final ViewModelCImpl viewModelCImpl = this;
+
+    Provider<CredentialEditViewModel> credentialEditViewModelProvider;
+
+    Provider<DashboardViewModel> dashboardViewModelProvider;
+
+    Provider<ServiceDetailViewModel> serviceDetailViewModelProvider;
+
+    Provider<SettingsViewModel> settingsViewModelProvider;
+
+    Provider<UsageChartViewModel> usageChartViewModelProvider;
+
+    Provider<UsageDataViewModel> usageDataViewModelProvider;
+
+    Provider<SyncUsageUseCase> syncUsageUseCaseProvider;
+
+    Provider<UsageViewModel> usageViewModelProvider;
+
+    Provider<WebViewLoginViewModel> webViewLoginViewModelProvider;
+
+    ViewModelCImpl(SingletonCImpl singletonCImpl, ActivityRetainedCImpl activityRetainedCImpl,
+        SavedStateHandle savedStateHandleParam, ViewModelLifecycle viewModelLifecycleParam) {
+      this.singletonCImpl = singletonCImpl;
+      this.activityRetainedCImpl = activityRetainedCImpl;
+
+      initialize(savedStateHandleParam, viewModelLifecycleParam);
+
+    }
+
+    Map hiltViewModelMapMapOfClassOfAndProviderOfViewModelBuilder() {
+      MapBuilder mapBuilder = MapBuilder.<String, javax.inject.Provider<ViewModel>>newMapBuilder(8);
+      mapBuilder.put(CredentialEditViewModel_HiltModules_BindsModule_Binds_LazyMapKey.lazyClassKeyName, ((Provider) (credentialEditViewModelProvider)));
+      mapBuilder.put(DashboardViewModel_HiltModules_BindsModule_Binds_LazyMapKey.lazyClassKeyName, ((Provider) (dashboardViewModelProvider)));
+      mapBuilder.put(ServiceDetailViewModel_HiltModules_BindsModule_Binds_LazyMapKey.lazyClassKeyName, ((Provider) (serviceDetailViewModelProvider)));
+      mapBuilder.put(SettingsViewModel_HiltModules_BindsModule_Binds_LazyMapKey.lazyClassKeyName, ((Provider) (settingsViewModelProvider)));
+      mapBuilder.put(UsageChartViewModel_HiltModules_BindsModule_Binds_LazyMapKey.lazyClassKeyName, ((Provider) (usageChartViewModelProvider)));
+      mapBuilder.put(UsageDataViewModel_HiltModules_BindsModule_Binds_LazyMapKey.lazyClassKeyName, ((Provider) (usageDataViewModelProvider)));
+      mapBuilder.put(UsageViewModel_HiltModules_BindsModule_Binds_LazyMapKey.lazyClassKeyName, ((Provider) (usageViewModelProvider)));
+      mapBuilder.put(WebViewLoginViewModel_HiltModules_BindsModule_Binds_LazyMapKey.lazyClassKeyName, ((Provider) (webViewLoginViewModelProvider)));
+      return mapBuilder.build();
+    }
+
+    @SuppressWarnings("unchecked")
+    private void initialize(final SavedStateHandle savedStateHandleParam,
+        final ViewModelLifecycle viewModelLifecycleParam) {
+      this.credentialEditViewModelProvider = new SwitchingProvider<>(singletonCImpl, activityRetainedCImpl, viewModelCImpl, 0);
+      this.dashboardViewModelProvider = new SwitchingProvider<>(singletonCImpl, activityRetainedCImpl, viewModelCImpl, 1);
+      this.serviceDetailViewModelProvider = new SwitchingProvider<>(singletonCImpl, activityRetainedCImpl, viewModelCImpl, 2);
+      this.settingsViewModelProvider = new SwitchingProvider<>(singletonCImpl, activityRetainedCImpl, viewModelCImpl, 3);
+      this.usageChartViewModelProvider = new SwitchingProvider<>(singletonCImpl, activityRetainedCImpl, viewModelCImpl, 4);
+      this.usageDataViewModelProvider = new SwitchingProvider<>(singletonCImpl, activityRetainedCImpl, viewModelCImpl, 5);
+      this.syncUsageUseCaseProvider = new SwitchingProvider<>(singletonCImpl, activityRetainedCImpl, viewModelCImpl, 7);
+      this.usageViewModelProvider = new SwitchingProvider<>(singletonCImpl, activityRetainedCImpl, viewModelCImpl, 6);
+      this.webViewLoginViewModelProvider = new SwitchingProvider<>(singletonCImpl, activityRetainedCImpl, viewModelCImpl, 8);
+    }
+
+    @Override
+    public Map<Class<?>, javax.inject.Provider<ViewModel>> getHiltViewModelMap() {
+      return LazyClassKeyMap.<javax.inject.Provider<ViewModel>>of(hiltViewModelMapMapOfClassOfAndProviderOfViewModelBuilder());
+    }
+
+    @Override
+    public Map<Class<?>, Object> getHiltViewModelAssistedMap() {
+      return Collections.<Class<?>, Object>emptyMap();
+    }
+
+    private static final class SwitchingProvider<T> implements Provider<T> {
+      private final SingletonCImpl singletonCImpl;
+
+      private final ActivityRetainedCImpl activityRetainedCImpl;
+
+      private final ViewModelCImpl viewModelCImpl;
+
+      private final int id;
+
+      SwitchingProvider(SingletonCImpl singletonCImpl, ActivityRetainedCImpl activityRetainedCImpl,
+          ViewModelCImpl viewModelCImpl, int id) {
+        this.singletonCImpl = singletonCImpl;
+        this.activityRetainedCImpl = activityRetainedCImpl;
+        this.viewModelCImpl = viewModelCImpl;
+        this.id = id;
+      }
+
+      @Override
+      @SuppressWarnings("unchecked")
+      public T get() {
+        switch (id) {
+          case 0: // com.rainy.token.ui.settings.CredentialEditViewModel
+          return (T) new CredentialEditViewModel(singletonCImpl.credentialRepositoryProvider.get(), singletonCImpl.provideOpenCodeGoRepositoryProvider, singletonCImpl.refreshBalanceUseCaseProvider);
+
+          case 1: // com.rainy.token.ui.dashboard.DashboardViewModel
+          return (T) new DashboardViewModel(singletonCImpl.credentialRepositoryProvider.get(), singletonCImpl.provideBalanceCacheProvider.get(), singletonCImpl.refreshBalanceUseCaseProvider.get(), ApplicationContextModule_ProvideContextFactory.provideContext(singletonCImpl.applicationContextModule));
+
+          case 2: // com.rainy.token.ui.servicedetail.ServiceDetailViewModel
+          return (T) new ServiceDetailViewModel(singletonCImpl.credentialRepositoryProvider.get(), singletonCImpl.provideBalanceCacheProvider.get(), singletonCImpl.refreshBalanceUseCaseProvider.get());
+
+          case 3: // com.rainy.token.ui.settings.SettingsViewModel
+          return (T) new SettingsViewModel(singletonCImpl.credentialRepositoryProvider.get());
+
+          case 4: // com.rainy.token.ui.dashboard.UsageChartViewModel
+          return (T) new UsageChartViewModel(singletonCImpl.provideUsageCacheProvider, singletonCImpl.credentialRepositoryProvider.get());
+
+          case 5: // com.rainy.token.ui.dashboard.UsageDataViewModel
+          return (T) new UsageDataViewModel(singletonCImpl.provideUsageCacheProvider, singletonCImpl.credentialRepositoryProvider.get());
+
+          case 6: // com.rainy.token.ui.dashboard.UsageViewModel
+          return (T) new UsageViewModel(singletonCImpl.provideUsageCacheProvider, viewModelCImpl.syncUsageUseCaseProvider, singletonCImpl.credentialRepositoryProvider.get());
+
+          case 7: // com.rainy.token.domain.usecase.SyncUsageUseCase
+          return (T) new SyncUsageUseCase(singletonCImpl.provideOpenCodeUsageRepositoryProvider, singletonCImpl.provideUsageCacheProvider);
+
+          case 8: // com.rainy.token.ui.webview.WebViewLoginViewModel
+          return (T) new WebViewLoginViewModel(singletonCImpl.webViewSessionSaverProvider.get());
+
+          default: throw new AssertionError(id);
+        }
+      }
+    }
+  }
+
+  private static final class ActivityRetainedCImpl extends RainyTokenApplication_HiltComponents.ActivityRetainedC {
+    private final SingletonCImpl singletonCImpl;
+
+    private final ActivityRetainedCImpl activityRetainedCImpl = this;
+
+    Provider<ActivityRetainedLifecycle> provideActivityRetainedLifecycleProvider;
+
+    ActivityRetainedCImpl(SingletonCImpl singletonCImpl,
+        SavedStateHandleHolder savedStateHandleHolderParam) {
+      this.singletonCImpl = singletonCImpl;
+
+      initialize(savedStateHandleHolderParam);
+
+    }
+
+    @SuppressWarnings("unchecked")
+    private void initialize(final SavedStateHandleHolder savedStateHandleHolderParam) {
+      this.provideActivityRetainedLifecycleProvider = DoubleCheck.provider(new SwitchingProvider<ActivityRetainedLifecycle>(singletonCImpl, activityRetainedCImpl, 0));
+    }
+
+    @Override
+    public ActivityComponentBuilder activityComponentBuilder() {
+      return new ActivityCBuilder(singletonCImpl, activityRetainedCImpl);
+    }
+
+    @Override
+    public ActivityRetainedLifecycle getActivityRetainedLifecycle() {
+      return provideActivityRetainedLifecycleProvider.get();
+    }
+
+    private static final class SwitchingProvider<T> implements Provider<T> {
+      private final SingletonCImpl singletonCImpl;
+
+      private final ActivityRetainedCImpl activityRetainedCImpl;
+
+      private final int id;
+
+      SwitchingProvider(SingletonCImpl singletonCImpl, ActivityRetainedCImpl activityRetainedCImpl,
+          int id) {
+        this.singletonCImpl = singletonCImpl;
+        this.activityRetainedCImpl = activityRetainedCImpl;
+        this.id = id;
+      }
+
+      @Override
+      @SuppressWarnings("unchecked")
+      public T get() {
+        switch (id) {
+          case 0: // dagger.hilt.android.ActivityRetainedLifecycle
+          return (T) ActivityRetainedComponentManager_LifecycleModule_ProvideActivityRetainedLifecycleFactory.provideActivityRetainedLifecycle();
+
+          default: throw new AssertionError(id);
+        }
+      }
+    }
+  }
+
+  private static final class ServiceCImpl extends RainyTokenApplication_HiltComponents.ServiceC {
+    private final SingletonCImpl singletonCImpl;
+
+    private final ServiceCImpl serviceCImpl = this;
+
+    ServiceCImpl(SingletonCImpl singletonCImpl, Service serviceParam) {
+      this.singletonCImpl = singletonCImpl;
+
+
+    }
+  }
+
+  private static final class SingletonCImpl extends RainyTokenApplication_HiltComponents.SingletonC {
+    private final ApplicationContextModule applicationContextModule;
+
+    private final SingletonCImpl singletonCImpl = this;
+
+    Provider<OkHttpClient> provideOkHttpClientProvider;
+
+    Provider<Json> provideJsonProvider;
+
+    Provider<Retrofit> provideRetrofitProvider;
+
+    Provider<DeepSeekApi> provideDeepSeekApiProvider;
+
+    Provider<DataStore<Preferences>> provideSecureStorageDataStoreProvider;
+
+    Provider<SecureStorage> provideSecureStorageProvider;
+
+    Provider<CredentialRepository> credentialRepositoryProvider;
+
+    Provider<DataStore<Preferences>> provideBalanceCacheDataStoreProvider;
+
+    Provider<BalanceCache> provideBalanceCacheProvider;
+
+    Provider<DeepSeekRepository> provideDeepSeekRepositoryProvider;
+
+    Provider<OpenCodeGoRepository> provideOpenCodeGoRepositoryProvider;
+
+    Provider<RefreshBalanceUseCase> refreshBalanceUseCaseProvider;
+
+    Provider<DataStore<Preferences>> provideUsageCacheDataStoreProvider;
+
+    Provider<UsageCache> provideUsageCacheProvider;
+
+    Provider<OpenCodeUsageRepository> provideOpenCodeUsageRepositoryProvider;
+
+    Provider<WebViewSessionSaver> webViewSessionSaverProvider;
+
+    SingletonCImpl(ApplicationContextModule applicationContextModuleParam) {
+      this.applicationContextModule = applicationContextModuleParam;
+      initialize(applicationContextModuleParam);
+
+    }
+
+    @SuppressWarnings("unchecked")
+    private void initialize(final ApplicationContextModule applicationContextModuleParam) {
+      this.provideOkHttpClientProvider = DoubleCheck.provider(new SwitchingProvider<OkHttpClient>(singletonCImpl, 4));
+      this.provideJsonProvider = DoubleCheck.provider(new SwitchingProvider<Json>(singletonCImpl, 5));
+      this.provideRetrofitProvider = DoubleCheck.provider(new SwitchingProvider<Retrofit>(singletonCImpl, 3));
+      this.provideDeepSeekApiProvider = DoubleCheck.provider(new SwitchingProvider<DeepSeekApi>(singletonCImpl, 2));
+      this.provideSecureStorageDataStoreProvider = DoubleCheck.provider(new SwitchingProvider<DataStore<Preferences>>(singletonCImpl, 8));
+      this.provideSecureStorageProvider = DoubleCheck.provider(new SwitchingProvider<SecureStorage>(singletonCImpl, 7));
+      this.credentialRepositoryProvider = DoubleCheck.provider(new SwitchingProvider<CredentialRepository>(singletonCImpl, 6));
+      this.provideBalanceCacheDataStoreProvider = DoubleCheck.provider(new SwitchingProvider<DataStore<Preferences>>(singletonCImpl, 10));
+      this.provideBalanceCacheProvider = DoubleCheck.provider(new SwitchingProvider<BalanceCache>(singletonCImpl, 9));
+      this.provideDeepSeekRepositoryProvider = DoubleCheck.provider(new SwitchingProvider<DeepSeekRepository>(singletonCImpl, 1));
+      this.provideOpenCodeGoRepositoryProvider = DoubleCheck.provider(new SwitchingProvider<OpenCodeGoRepository>(singletonCImpl, 11));
+      this.refreshBalanceUseCaseProvider = new SwitchingProvider<>(singletonCImpl, 0);
+      this.provideUsageCacheDataStoreProvider = DoubleCheck.provider(new SwitchingProvider<DataStore<Preferences>>(singletonCImpl, 13));
+      this.provideUsageCacheProvider = DoubleCheck.provider(new SwitchingProvider<UsageCache>(singletonCImpl, 12));
+      this.provideOpenCodeUsageRepositoryProvider = DoubleCheck.provider(new SwitchingProvider<OpenCodeUsageRepository>(singletonCImpl, 14));
+      this.webViewSessionSaverProvider = DoubleCheck.provider(new SwitchingProvider<WebViewSessionSaver>(singletonCImpl, 15));
+    }
+
+    @Override
+    public void injectRainyTokenApplication(RainyTokenApplication rainyTokenApplication) {
+    }
+
+    @Override
+    public RefreshBalanceUseCase refreshBalanceUseCase() {
+      return refreshBalanceUseCaseProvider.get();
+    }
+
+    @Override
+    public Set<Boolean> getDisableFragmentGetContextFix() {
+      return Collections.<Boolean>emptySet();
+    }
+
+    @Override
+    public ActivityRetainedComponentBuilder retainedComponentBuilder() {
+      return new ActivityRetainedCBuilder(singletonCImpl);
+    }
+
+    @Override
+    public ServiceComponentBuilder serviceComponentBuilder() {
+      return new ServiceCBuilder(singletonCImpl);
+    }
+
+    private static final class SwitchingProvider<T> implements Provider<T> {
+      private final SingletonCImpl singletonCImpl;
+
+      private final int id;
+
+      SwitchingProvider(SingletonCImpl singletonCImpl, int id) {
+        this.singletonCImpl = singletonCImpl;
+        this.id = id;
+      }
+
+      @Override
+      @SuppressWarnings("unchecked")
+      public T get() {
+        switch (id) {
+          case 0: // com.rainy.token.domain.usecase.RefreshBalanceUseCase
+          return (T) new RefreshBalanceUseCase(singletonCImpl.provideDeepSeekRepositoryProvider, singletonCImpl.provideOpenCodeGoRepositoryProvider);
+
+          case 1: // com.rainy.token.data.repository.DeepSeekRepository
+          return (T) NetworkModule_ProvideDeepSeekRepositoryFactory.provideDeepSeekRepository(singletonCImpl.provideDeepSeekApiProvider.get(), singletonCImpl.credentialRepositoryProvider.get(), singletonCImpl.provideBalanceCacheProvider.get());
+
+          case 2: // com.rainy.token.data.remote.DeepSeekApi
+          return (T) NetworkModule_ProvideDeepSeekApiFactory.provideDeepSeekApi(singletonCImpl.provideRetrofitProvider.get());
+
+          case 3: // retrofit2.Retrofit
+          return (T) NetworkModule_ProvideRetrofitFactory.provideRetrofit(singletonCImpl.provideOkHttpClientProvider.get(), singletonCImpl.provideJsonProvider.get());
+
+          case 4: // okhttp3.OkHttpClient
+          return (T) NetworkModule_ProvideOkHttpClientFactory.provideOkHttpClient();
+
+          case 5: // kotlinx.serialization.json.Json
+          return (T) NetworkModule_ProvideJsonFactory.provideJson();
+
+          case 6: // com.rainy.token.data.repository.CredentialRepository
+          return (T) new CredentialRepository(singletonCImpl.provideSecureStorageProvider.get());
+
+          case 7: // com.rainy.token.data.local.SecureStorage
+          return (T) NetworkModule_ProvideSecureStorageFactory.provideSecureStorage(singletonCImpl.provideSecureStorageDataStoreProvider.get(), singletonCImpl.provideJsonProvider.get());
+
+          case 8: // @javax.inject.Named("dataStore.secureStorage") androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences>
+          return (T) StorageModule_ProvideSecureStorageDataStoreFactory.provideSecureStorageDataStore(ApplicationContextModule_ProvideContextFactory.provideContext(singletonCImpl.applicationContextModule));
+
+          case 9: // com.rainy.token.data.cache.BalanceCache
+          return (T) NetworkModule_ProvideBalanceCacheFactory.provideBalanceCache(singletonCImpl.provideBalanceCacheDataStoreProvider.get(), singletonCImpl.provideJsonProvider.get());
+
+          case 10: // @javax.inject.Named("dataStore.balanceCache") androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences>
+          return (T) NetworkModule_ProvideBalanceCacheDataStoreFactory.provideBalanceCacheDataStore(ApplicationContextModule_ProvideContextFactory.provideContext(singletonCImpl.applicationContextModule));
+
+          case 11: // com.rainy.token.data.repository.OpenCodeGoRepository
+          return (T) NetworkModule_ProvideOpenCodeGoRepositoryFactory.provideOpenCodeGoRepository(singletonCImpl.provideOkHttpClientProvider.get(), singletonCImpl.credentialRepositoryProvider.get(), singletonCImpl.provideBalanceCacheProvider.get());
+
+          case 12: // com.rainy.token.data.local.UsageCache
+          return (T) NetworkModule_ProvideUsageCacheFactory.provideUsageCache(singletonCImpl.provideUsageCacheDataStoreProvider.get(), singletonCImpl.provideJsonProvider.get());
+
+          case 13: // @javax.inject.Named("dataStore.usageCache") androidx.datastore.core.DataStore<androidx.datastore.preferences.core.Preferences>
+          return (T) StorageModule_ProvideUsageCacheDataStoreFactory.provideUsageCacheDataStore(ApplicationContextModule_ProvideContextFactory.provideContext(singletonCImpl.applicationContextModule));
+
+          case 14: // com.rainy.token.data.repository.OpenCodeUsageRepository
+          return (T) NetworkModule_ProvideOpenCodeUsageRepositoryFactory.provideOpenCodeUsageRepository(singletonCImpl.provideOkHttpClientProvider.get(), singletonCImpl.credentialRepositoryProvider.get());
+
+          case 15: // com.rainy.token.data.repository.WebViewSessionSaver
+          return (T) new WebViewSessionSaver(singletonCImpl.credentialRepositoryProvider.get());
+
+          default: throw new AssertionError(id);
+        }
+      }
+    }
+  }
+}

app/build/generated/hilt/component_sources/debug/com/rainy/token/Hilt_RainyTokenApplication.java

@@ -0,0 +1,55 @@
+package com.rainy.token;
+
+import android.app.Application;
+import androidx.annotation.CallSuper;
+import dagger.hilt.android.internal.managers.ApplicationComponentManager;
+import dagger.hilt.android.internal.managers.ComponentSupplier;
+import dagger.hilt.android.internal.modules.ApplicationContextModule;
+import dagger.hilt.internal.GeneratedComponentManagerHolder;
+import dagger.hilt.internal.UnsafeCasts;
+import java.lang.Object;
+import java.lang.Override;
+import javax.annotation.processing.Generated;
+
+/**
+ * A generated base class to be extended by the @dagger.hilt.android.HiltAndroidApp annotated class. If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
+ */
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.ApplicationGenerator")
+public abstract class Hilt_RainyTokenApplication extends Application implements GeneratedComponentManagerHolder {
+  private boolean injected = false;
+
+  private final ApplicationComponentManager componentManager = new ApplicationComponentManager(new ComponentSupplier() {
+    @Override
+    public Object get() {
+      return DaggerRainyTokenApplication_HiltComponents_SingletonC.builder()
+          .applicationContextModule(new ApplicationContextModule(Hilt_RainyTokenApplication.this))
+          .build();
+    }
+  });
+
+  @Override
+  public final ApplicationComponentManager componentManager() {
+    return componentManager;
+  }
+
+  @Override
+  public final Object generatedComponent() {
+    return this.componentManager().generatedComponent();
+  }
+
+  @CallSuper
+  @Override
+  public void onCreate() {
+    hiltInternalInject();
+    super.onCreate();
+  }
+
+  protected void hiltInternalInject() {
+    if (!injected) {
+      injected = true;
+      // This is a known unsafe cast, but is safe in the only correct use case:
+      // RainyTokenApplication extends Hilt_RainyTokenApplication
+      ((RainyTokenApplication_GeneratedInjector) generatedComponent()).injectRainyTokenApplication(UnsafeCasts.<RainyTokenApplication>unsafeCast(this));
+    }
+  }
+}

app/build/generated/hilt/component_sources/debug/com/rainy/token/RainyTokenApplication_GeneratedInjector.java

@@ -0,0 +1,17 @@
+package com.rainy.token;
+
+import dagger.hilt.InstallIn;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.hilt.components.SingletonComponent;
+import dagger.hilt.internal.GeneratedEntryPoint;
+import javax.annotation.processing.Generated;
+
+@OriginatingElement(
+    topLevelClass = RainyTokenApplication.class
+)
+@GeneratedEntryPoint
+@InstallIn(SingletonComponent.class)
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
+public interface RainyTokenApplication_GeneratedInjector {
+  void injectRainyTokenApplication(RainyTokenApplication rainyTokenApplication);
+}

app/build/generated/hilt/component_sources/debug/com/rainy/token/RainyTokenApplication_HiltComponents.java

@@ -0,0 +1,265 @@
+package com.rainy.token;
+
+import com.rainy.token.di.NetworkModule;
+import com.rainy.token.di.StorageModule;
+import com.rainy.token.ui.dashboard.DashboardViewModel_HiltModules;
+import com.rainy.token.ui.dashboard.UsageChartViewModel_HiltModules;
+import com.rainy.token.ui.dashboard.UsageDataViewModel_HiltModules;
+import com.rainy.token.ui.dashboard.UsageViewModel_HiltModules;
+import com.rainy.token.ui.servicedetail.ServiceDetailViewModel_HiltModules;
+import com.rainy.token.ui.settings.CredentialEditViewModel_HiltModules;
+import com.rainy.token.ui.settings.SettingsViewModel_HiltModules;
+import com.rainy.token.ui.webview.WebViewLoginViewModel_HiltModules;
+import com.rainy.token.ui.widget.WidgetRefreshEntryPoint;
+import dagger.Binds;
+import dagger.Component;
+import dagger.Module;
+import dagger.Subcomponent;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.components.FragmentComponent;
+import dagger.hilt.android.components.ServiceComponent;
+import dagger.hilt.android.components.ViewComponent;
+import dagger.hilt.android.components.ViewModelComponent;
+import dagger.hilt.android.components.ViewWithFragmentComponent;
+import dagger.hilt.android.flags.FragmentGetContextFix;
+import dagger.hilt.android.flags.HiltWrapper_FragmentGetContextFix_FragmentGetContextFixModule;
+import dagger.hilt.android.internal.builders.ActivityComponentBuilder;
+import dagger.hilt.android.internal.builders.ActivityRetainedComponentBuilder;
+import dagger.hilt.android.internal.builders.FragmentComponentBuilder;
+import dagger.hilt.android.internal.builders.ServiceComponentBuilder;
+import dagger.hilt.android.internal.builders.ViewComponentBuilder;
+import dagger.hilt.android.internal.builders.ViewModelComponentBuilder;
+import dagger.hilt.android.internal.builders.ViewWithFragmentComponentBuilder;
+import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelFactory;
+import dagger.hilt.android.internal.lifecycle.HiltWrapper_DefaultViewModelFactories_ActivityModule;
+import dagger.hilt.android.internal.lifecycle.HiltWrapper_HiltViewModelFactory_ActivityCreatorEntryPoint;
+import dagger.hilt.android.internal.lifecycle.HiltWrapper_HiltViewModelFactory_ViewModelModule;
+import dagger.hilt.android.internal.managers.ActivityComponentManager;
+import dagger.hilt.android.internal.managers.FragmentComponentManager;
+import dagger.hilt.android.internal.managers.HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedComponentBuilderEntryPoint;
+import dagger.hilt.android.internal.managers.HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedLifecycleEntryPoint;
+import dagger.hilt.android.internal.managers.HiltWrapper_ActivityRetainedComponentManager_LifecycleModule;
+import dagger.hilt.android.internal.managers.HiltWrapper_ActivitySavedStateHandleModule;
+import dagger.hilt.android.internal.managers.ServiceComponentManager;
+import dagger.hilt.android.internal.managers.ViewComponentManager;
+import dagger.hilt.android.internal.modules.ApplicationContextModule;
+import dagger.hilt.android.internal.modules.HiltWrapper_ActivityModule;
+import dagger.hilt.android.scopes.ActivityRetainedScoped;
+import dagger.hilt.android.scopes.ActivityScoped;
+import dagger.hilt.android.scopes.FragmentScoped;
+import dagger.hilt.android.scopes.ServiceScoped;
+import dagger.hilt.android.scopes.ViewModelScoped;
+import dagger.hilt.android.scopes.ViewScoped;
+import dagger.hilt.components.SingletonComponent;
+import dagger.hilt.internal.GeneratedComponent;
+import dagger.hilt.migration.DisableInstallInCheck;
+import javax.annotation.processing.Generated;
+import javax.inject.Singleton;
+
+@Generated("dagger.hilt.processor.internal.root.RootProcessor")
+public final class RainyTokenApplication_HiltComponents {
+  private RainyTokenApplication_HiltComponents() {
+  }
+
+  @Module(
+      subcomponents = ServiceC.class
+  )
+  @DisableInstallInCheck
+  @Generated("dagger.hilt.processor.internal.root.RootProcessor")
+  abstract interface ServiceCBuilderModule {
+    @Binds
+    ServiceComponentBuilder bind(ServiceC.Builder builder);
+  }
+
+  @Module(
+      subcomponents = ActivityRetainedC.class
+  )
+  @DisableInstallInCheck
+  @Generated("dagger.hilt.processor.internal.root.RootProcessor")
+  abstract interface ActivityRetainedCBuilderModule {
+    @Binds
+    ActivityRetainedComponentBuilder bind(ActivityRetainedC.Builder builder);
+  }
+
+  @Module(
+      subcomponents = ActivityC.class
+  )
+  @DisableInstallInCheck
+  @Generated("dagger.hilt.processor.internal.root.RootProcessor")
+  abstract interface ActivityCBuilderModule {
+    @Binds
+    ActivityComponentBuilder bind(ActivityC.Builder builder);
+  }
+
+  @Module(
+      subcomponents = ViewModelC.class
+  )
+  @DisableInstallInCheck
+  @Generated("dagger.hilt.processor.internal.root.RootProcessor")
+  abstract interface ViewModelCBuilderModule {
+    @Binds
+    ViewModelComponentBuilder bind(ViewModelC.Builder builder);
+  }
+
+  @Module(
+      subcomponents = ViewC.class
+  )
+  @DisableInstallInCheck
+  @Generated("dagger.hilt.processor.internal.root.RootProcessor")
+  abstract interface ViewCBuilderModule {
+    @Binds
+    ViewComponentBuilder bind(ViewC.Builder builder);
+  }
+
+  @Module(
+      subcomponents = FragmentC.class
+  )
+  @DisableInstallInCheck
+  @Generated("dagger.hilt.processor.internal.root.RootProcessor")
+  abstract interface FragmentCBuilderModule {
+    @Binds
+    FragmentComponentBuilder bind(FragmentC.Builder builder);
+  }
+
+  @Module(
+      subcomponents = ViewWithFragmentC.class
+  )
+  @DisableInstallInCheck
+  @Generated("dagger.hilt.processor.internal.root.RootProcessor")
+  abstract interface ViewWithFragmentCBuilderModule {
+    @Binds
+    ViewWithFragmentComponentBuilder bind(ViewWithFragmentC.Builder builder);
+  }
+
+  @Component(
+      modules = {
+          ApplicationContextModule.class,
+          HiltWrapper_FragmentGetContextFix_FragmentGetContextFixModule.class,
+          NetworkModule.class,
+          ActivityRetainedCBuilderModule.class,
+          ServiceCBuilderModule.class,
+          StorageModule.class
+      }
+  )
+  @Singleton
+  @jakarta.inject.Singleton
+  public abstract static class SingletonC implements RainyTokenApplication_GeneratedInjector,
+      WidgetRefreshEntryPoint,
+      FragmentGetContextFix.FragmentGetContextFixEntryPoint,
+      HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedComponentBuilderEntryPoint,
+      ServiceComponentManager.ServiceComponentBuilderEntryPoint,
+      SingletonComponent,
+      GeneratedComponent {
+  }
+
+  @Subcomponent
+  @ServiceScoped
+  public abstract static class ServiceC implements ServiceComponent,
+      GeneratedComponent {
+    @Subcomponent.Builder
+    abstract interface Builder extends ServiceComponentBuilder {
+    }
+  }
+
+  @Subcomponent(
+      modules = {
+          CredentialEditViewModel_HiltModules.KeyModule.class,
+          DashboardViewModel_HiltModules.KeyModule.class,
+          HiltWrapper_ActivityRetainedComponentManager_LifecycleModule.class,
+          HiltWrapper_ActivitySavedStateHandleModule.class,
+          ActivityCBuilderModule.class,
+          ViewModelCBuilderModule.class,
+          ServiceDetailViewModel_HiltModules.KeyModule.class,
+          SettingsViewModel_HiltModules.KeyModule.class,
+          UsageChartViewModel_HiltModules.KeyModule.class,
+          UsageDataViewModel_HiltModules.KeyModule.class,
+          UsageViewModel_HiltModules.KeyModule.class,
+          WebViewLoginViewModel_HiltModules.KeyModule.class
+      }
+  )
+  @ActivityRetainedScoped
+  public abstract static class ActivityRetainedC implements ActivityRetainedComponent,
+      ActivityComponentManager.ActivityComponentBuilderEntryPoint,
+      HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedLifecycleEntryPoint,
+      GeneratedComponent {
+    @Subcomponent.Builder
+    abstract interface Builder extends ActivityRetainedComponentBuilder {
+    }
+  }
+
+  @Subcomponent(
+      modules = {
+          HiltWrapper_ActivityModule.class,
+          HiltWrapper_DefaultViewModelFactories_ActivityModule.class,
+          FragmentCBuilderModule.class,
+          ViewCBuilderModule.class
+      }
+  )
+  @ActivityScoped
+  public abstract static class ActivityC implements MainActivity_GeneratedInjector,
+      ActivityComponent,
+      DefaultViewModelFactories.ActivityEntryPoint,
+      HiltWrapper_HiltViewModelFactory_ActivityCreatorEntryPoint,
+      FragmentComponentManager.FragmentComponentBuilderEntryPoint,
+      ViewComponentManager.ViewComponentBuilderEntryPoint,
+      GeneratedComponent {
+    @Subcomponent.Builder
+    abstract interface Builder extends ActivityComponentBuilder {
+    }
+  }
+
+  @Subcomponent(
+      modules = {
+          CredentialEditViewModel_HiltModules.BindsModule.class,
+          DashboardViewModel_HiltModules.BindsModule.class,
+          HiltWrapper_HiltViewModelFactory_ViewModelModule.class,
+          ServiceDetailViewModel_HiltModules.BindsModule.class,
+          SettingsViewModel_HiltModules.BindsModule.class,
+          UsageChartViewModel_HiltModules.BindsModule.class,
+          UsageDataViewModel_HiltModules.BindsModule.class,
+          UsageViewModel_HiltModules.BindsModule.class,
+          WebViewLoginViewModel_HiltModules.BindsModule.class
+      }
+  )
+  @ViewModelScoped
+  public abstract static class ViewModelC implements ViewModelComponent,
+      HiltViewModelFactory.ViewModelFactoriesEntryPoint,
+      GeneratedComponent {
+    @Subcomponent.Builder
+    abstract interface Builder extends ViewModelComponentBuilder {
+    }
+  }
+
+  @Subcomponent
+  @ViewScoped
+  public abstract static class ViewC implements ViewComponent,
+      GeneratedComponent {
+    @Subcomponent.Builder
+    abstract interface Builder extends ViewComponentBuilder {
+    }
+  }
+
+  @Subcomponent(
+      modules = ViewWithFragmentCBuilderModule.class
+  )
+  @FragmentScoped
+  public abstract static class FragmentC implements FragmentComponent,
+      DefaultViewModelFactories.FragmentEntryPoint,
+      ViewComponentManager.ViewWithFragmentComponentBuilderEntryPoint,
+      GeneratedComponent {
+    @Subcomponent.Builder
+    abstract interface Builder extends FragmentComponentBuilder {
+    }
+  }
+
+  @Subcomponent
+  @ViewScoped
+  public abstract static class ViewWithFragmentC implements ViewWithFragmentComponent,
+      GeneratedComponent {
+    @Subcomponent.Builder
+    abstract interface Builder extends ViewWithFragmentComponentBuilder {
+    }
+  }
+}

app/build/generated/hilt/component_sources/debug/dagger/hilt/internal/aggregatedroot/codegen/_com_rainy_token_RainyTokenApplication.java

@@ -0,0 +1,23 @@
+package dagger.hilt.internal.aggregatedroot.codegen;
+
+import dagger.hilt.android.HiltAndroidApp;
+import dagger.hilt.internal.aggregatedroot.AggregatedRoot;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedRoot(
+    root = "com.rainy.token.RainyTokenApplication",
+    rootPackage = "com.rainy.token",
+    originatingRoot = "com.rainy.token.RainyTokenApplication",
+    originatingRootPackage = "com.rainy.token",
+    rootAnnotation = HiltAndroidApp.class,
+    rootComponentPackage = "dagger.hilt.components",
+    rootSimpleNames = "RainyTokenApplication",
+    originatingRootSimpleNames = "RainyTokenApplication",
+    rootComponentSimpleNames = "SingletonComponent"
+)
+@Generated("dagger.hilt.processor.internal.root.AggregatedRootGenerator")
+public class _com_rainy_token_RainyTokenApplication {
+}

app/build/generated/hilt/component_sources/debug/hilt_aggregated_deps/_com_rainy_token_RainyTokenApplication_GeneratedInjector.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.components.SingletonComponent",
+    entryPoints = "com.rainy.token.RainyTokenApplication_GeneratedInjector"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_RainyTokenApplication_GeneratedInjector {
+}

app/build/generated/hilt/component_trees/debug/com/rainy/token/RainyTokenApplication_ComponentTreeDeps.java

@@ -0,0 +1,124 @@
+package com.rainy.token;
+
+import dagger.hilt.internal.aggregatedroot.codegen._com_rainy_token_RainyTokenApplication;
+import dagger.hilt.internal.componenttreedeps.ComponentTreeDeps;
+import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_components_ActivityComponent;
+import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_components_ActivityRetainedComponent;
+import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_components_FragmentComponent;
+import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_components_ServiceComponent;
+import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_components_ViewComponent;
+import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_components_ViewModelComponent;
+import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_components_ViewWithFragmentComponent;
+import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_internal_builders_ActivityComponentBuilder;
+import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_internal_builders_ActivityRetainedComponentBuilder;
+import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_internal_builders_FragmentComponentBuilder;
+import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_internal_builders_ServiceComponentBuilder;
+import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_internal_builders_ViewComponentBuilder;
+import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_internal_builders_ViewModelComponentBuilder;
+import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_android_internal_builders_ViewWithFragmentComponentBuilder;
+import dagger.hilt.processor.internal.definecomponent.codegen._dagger_hilt_components_SingletonComponent;
+import hilt_aggregated_deps._com_rainy_token_MainActivity_GeneratedInjector;
+import hilt_aggregated_deps._com_rainy_token_RainyTokenApplication_GeneratedInjector;
+import hilt_aggregated_deps._com_rainy_token_di_NetworkModule;
+import hilt_aggregated_deps._com_rainy_token_di_StorageModule;
+import hilt_aggregated_deps._com_rainy_token_ui_dashboard_DashboardViewModel_HiltModules_BindsModule;
+import hilt_aggregated_deps._com_rainy_token_ui_dashboard_DashboardViewModel_HiltModules_KeyModule;
+import hilt_aggregated_deps._com_rainy_token_ui_dashboard_UsageChartViewModel_HiltModules_BindsModule;
+import hilt_aggregated_deps._com_rainy_token_ui_dashboard_UsageChartViewModel_HiltModules_KeyModule;
+import hilt_aggregated_deps._com_rainy_token_ui_dashboard_UsageDataViewModel_HiltModules_BindsModule;
+import hilt_aggregated_deps._com_rainy_token_ui_dashboard_UsageDataViewModel_HiltModules_KeyModule;
+import hilt_aggregated_deps._com_rainy_token_ui_dashboard_UsageViewModel_HiltModules_BindsModule;
+import hilt_aggregated_deps._com_rainy_token_ui_dashboard_UsageViewModel_HiltModules_KeyModule;
+import hilt_aggregated_deps._com_rainy_token_ui_servicedetail_ServiceDetailViewModel_HiltModules_BindsModule;
+import hilt_aggregated_deps._com_rainy_token_ui_servicedetail_ServiceDetailViewModel_HiltModules_KeyModule;
+import hilt_aggregated_deps._com_rainy_token_ui_settings_CredentialEditViewModel_HiltModules_BindsModule;
+import hilt_aggregated_deps._com_rainy_token_ui_settings_CredentialEditViewModel_HiltModules_KeyModule;
+import hilt_aggregated_deps._com_rainy_token_ui_settings_SettingsViewModel_HiltModules_BindsModule;
+import hilt_aggregated_deps._com_rainy_token_ui_settings_SettingsViewModel_HiltModules_KeyModule;
+import hilt_aggregated_deps._com_rainy_token_ui_webview_WebViewLoginViewModel_HiltModules_BindsModule;
+import hilt_aggregated_deps._com_rainy_token_ui_webview_WebViewLoginViewModel_HiltModules_KeyModule;
+import hilt_aggregated_deps._com_rainy_token_ui_widget_WidgetRefreshEntryPoint;
+import hilt_aggregated_deps._dagger_hilt_android_flags_FragmentGetContextFix_FragmentGetContextFixEntryPoint;
+import hilt_aggregated_deps._dagger_hilt_android_flags_HiltWrapper_FragmentGetContextFix_FragmentGetContextFixModule;
+import hilt_aggregated_deps._dagger_hilt_android_internal_lifecycle_DefaultViewModelFactories_ActivityEntryPoint;
+import hilt_aggregated_deps._dagger_hilt_android_internal_lifecycle_DefaultViewModelFactories_FragmentEntryPoint;
+import hilt_aggregated_deps._dagger_hilt_android_internal_lifecycle_HiltViewModelFactory_ViewModelFactoriesEntryPoint;
+import hilt_aggregated_deps._dagger_hilt_android_internal_lifecycle_HiltWrapper_DefaultViewModelFactories_ActivityModule;
+import hilt_aggregated_deps._dagger_hilt_android_internal_lifecycle_HiltWrapper_HiltViewModelFactory_ActivityCreatorEntryPoint;
+import hilt_aggregated_deps._dagger_hilt_android_internal_lifecycle_HiltWrapper_HiltViewModelFactory_ViewModelModule;
+import hilt_aggregated_deps._dagger_hilt_android_internal_managers_ActivityComponentManager_ActivityComponentBuilderEntryPoint;
+import hilt_aggregated_deps._dagger_hilt_android_internal_managers_FragmentComponentManager_FragmentComponentBuilderEntryPoint;
+import hilt_aggregated_deps._dagger_hilt_android_internal_managers_HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedComponentBuilderEntryPoint;
+import hilt_aggregated_deps._dagger_hilt_android_internal_managers_HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedLifecycleEntryPoint;
+import hilt_aggregated_deps._dagger_hilt_android_internal_managers_HiltWrapper_ActivityRetainedComponentManager_LifecycleModule;
+import hilt_aggregated_deps._dagger_hilt_android_internal_managers_HiltWrapper_ActivitySavedStateHandleModule;
+import hilt_aggregated_deps._dagger_hilt_android_internal_managers_ServiceComponentManager_ServiceComponentBuilderEntryPoint;
+import hilt_aggregated_deps._dagger_hilt_android_internal_managers_ViewComponentManager_ViewComponentBuilderEntryPoint;
+import hilt_aggregated_deps._dagger_hilt_android_internal_managers_ViewComponentManager_ViewWithFragmentComponentBuilderEntryPoint;
+import hilt_aggregated_deps._dagger_hilt_android_internal_modules_ApplicationContextModule;
+import hilt_aggregated_deps._dagger_hilt_android_internal_modules_HiltWrapper_ActivityModule;
+
+@ComponentTreeDeps(
+    rootDeps = _com_rainy_token_RainyTokenApplication.class,
+    defineComponentDeps = {
+        _dagger_hilt_android_components_ActivityComponent.class,
+        _dagger_hilt_android_components_ActivityRetainedComponent.class,
+        _dagger_hilt_android_components_FragmentComponent.class,
+        _dagger_hilt_android_components_ServiceComponent.class,
+        _dagger_hilt_android_components_ViewComponent.class,
+        _dagger_hilt_android_components_ViewModelComponent.class,
+        _dagger_hilt_android_components_ViewWithFragmentComponent.class,
+        _dagger_hilt_android_internal_builders_ActivityComponentBuilder.class,
+        _dagger_hilt_android_internal_builders_ActivityRetainedComponentBuilder.class,
+        _dagger_hilt_android_internal_builders_FragmentComponentBuilder.class,
+        _dagger_hilt_android_internal_builders_ServiceComponentBuilder.class,
+        _dagger_hilt_android_internal_builders_ViewComponentBuilder.class,
+        _dagger_hilt_android_internal_builders_ViewModelComponentBuilder.class,
+        _dagger_hilt_android_internal_builders_ViewWithFragmentComponentBuilder.class,
+        _dagger_hilt_components_SingletonComponent.class
+    },
+    aggregatedDeps = {
+        _com_rainy_token_MainActivity_GeneratedInjector.class,
+        _com_rainy_token_RainyTokenApplication_GeneratedInjector.class,
+        _com_rainy_token_di_NetworkModule.class,
+        _com_rainy_token_di_StorageModule.class,
+        _com_rainy_token_ui_dashboard_DashboardViewModel_HiltModules_BindsModule.class,
+        _com_rainy_token_ui_dashboard_DashboardViewModel_HiltModules_KeyModule.class,
+        _com_rainy_token_ui_dashboard_UsageChartViewModel_HiltModules_BindsModule.class,
+        _com_rainy_token_ui_dashboard_UsageChartViewModel_HiltModules_KeyModule.class,
+        _com_rainy_token_ui_dashboard_UsageDataViewModel_HiltModules_BindsModule.class,
+        _com_rainy_token_ui_dashboard_UsageDataViewModel_HiltModules_KeyModule.class,
+        _com_rainy_token_ui_dashboard_UsageViewModel_HiltModules_BindsModule.class,
+        _com_rainy_token_ui_dashboard_UsageViewModel_HiltModules_KeyModule.class,
+        _com_rainy_token_ui_servicedetail_ServiceDetailViewModel_HiltModules_BindsModule.class,
+        _com_rainy_token_ui_servicedetail_ServiceDetailViewModel_HiltModules_KeyModule.class,
+        _com_rainy_token_ui_settings_CredentialEditViewModel_HiltModules_BindsModule.class,
+        _com_rainy_token_ui_settings_CredentialEditViewModel_HiltModules_KeyModule.class,
+        _com_rainy_token_ui_settings_SettingsViewModel_HiltModules_BindsModule.class,
+        _com_rainy_token_ui_settings_SettingsViewModel_HiltModules_KeyModule.class,
+        _com_rainy_token_ui_webview_WebViewLoginViewModel_HiltModules_BindsModule.class,
+        _com_rainy_token_ui_webview_WebViewLoginViewModel_HiltModules_KeyModule.class,
+        _com_rainy_token_ui_widget_WidgetRefreshEntryPoint.class,
+        _dagger_hilt_android_flags_FragmentGetContextFix_FragmentGetContextFixEntryPoint.class,
+        _dagger_hilt_android_flags_HiltWrapper_FragmentGetContextFix_FragmentGetContextFixModule.class,
+        _dagger_hilt_android_internal_lifecycle_DefaultViewModelFactories_ActivityEntryPoint.class,
+        _dagger_hilt_android_internal_lifecycle_DefaultViewModelFactories_FragmentEntryPoint.class,
+        _dagger_hilt_android_internal_lifecycle_HiltViewModelFactory_ViewModelFactoriesEntryPoint.class,
+        _dagger_hilt_android_internal_lifecycle_HiltWrapper_DefaultViewModelFactories_ActivityModule.class,
+        _dagger_hilt_android_internal_lifecycle_HiltWrapper_HiltViewModelFactory_ActivityCreatorEntryPoint.class,
+        _dagger_hilt_android_internal_lifecycle_HiltWrapper_HiltViewModelFactory_ViewModelModule.class,
+        _dagger_hilt_android_internal_managers_ActivityComponentManager_ActivityComponentBuilderEntryPoint.class,
+        _dagger_hilt_android_internal_managers_FragmentComponentManager_FragmentComponentBuilderEntryPoint.class,
+        _dagger_hilt_android_internal_managers_HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedComponentBuilderEntryPoint.class,
+        _dagger_hilt_android_internal_managers_HiltWrapper_ActivityRetainedComponentManager_ActivityRetainedLifecycleEntryPoint.class,
+        _dagger_hilt_android_internal_managers_HiltWrapper_ActivityRetainedComponentManager_LifecycleModule.class,
+        _dagger_hilt_android_internal_managers_HiltWrapper_ActivitySavedStateHandleModule.class,
+        _dagger_hilt_android_internal_managers_ServiceComponentManager_ServiceComponentBuilderEntryPoint.class,
+        _dagger_hilt_android_internal_managers_ViewComponentManager_ViewComponentBuilderEntryPoint.class,
+        _dagger_hilt_android_internal_managers_ViewComponentManager_ViewWithFragmentComponentBuilderEntryPoint.class,
+        _dagger_hilt_android_internal_modules_ApplicationContextModule.class,
+        _dagger_hilt_android_internal_modules_HiltWrapper_ActivityModule.class
+    }
+)
+public final class RainyTokenApplication_ComponentTreeDeps {
+}

app/build/generated/hilt/component_trees/debug/dagger/hilt/internal/processedrootsentinel/codegen/_com_rainy_token_RainyTokenApplication.java

@@ -0,0 +1,9 @@
+package dagger.hilt.internal.processedrootsentinel.codegen;
+
+import dagger.hilt.internal.processedrootsentinel.ProcessedRootSentinel;
+
+@ProcessedRootSentinel(
+    roots = "com.rainy.token.RainyTokenApplication"
+)
+public final class _com_rainy_token_RainyTokenApplication {
+}

app/build/generated/ksp/debug/java/com/rainy/token/Hilt_MainActivity.java

@@ -0,0 +1,96 @@
+package com.rainy.token;
+
+import android.content.Context;
+import android.os.Bundle;
+import androidx.activity.ComponentActivity;
+import androidx.activity.contextaware.OnContextAvailableListener;
+import androidx.annotation.CallSuper;
+import androidx.lifecycle.ViewModelProvider;
+import dagger.hilt.android.internal.lifecycle.DefaultViewModelFactories;
+import dagger.hilt.android.internal.managers.ActivityComponentManager;
+import dagger.hilt.internal.GeneratedComponentManagerHolder;
+import dagger.hilt.internal.UnsafeCasts;
+import java.lang.Object;
+import java.lang.Override;
+import javax.annotation.processing.Generated;
+
+/**
+ * A generated base class to be extended by the @dagger.hilt.android.AndroidEntryPoint annotated class. If using the Gradle plugin, this is swapped as the base class via bytecode transformation.
+ */
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.ActivityGenerator")
+public abstract class Hilt_MainActivity extends ComponentActivity implements GeneratedComponentManagerHolder {
+  private volatile ActivityComponentManager componentManager;
+
+  private final Object componentManagerLock = new Object();
+
+  private boolean injected = false;
+
+  Hilt_MainActivity() {
+    super();
+    _initHiltInternal();
+  }
+
+  Hilt_MainActivity(int contentLayoutId) {
+    super(contentLayoutId);
+    _initHiltInternal();
+  }
+
+  private void _initHiltInternal() {
+    addOnContextAvailableListener(new OnContextAvailableListener() {
+      @Override
+      public void onContextAvailable(Context context) {
+        inject();
+      }
+    });
+  }
+
+  private void initSavedStateHandleHolders() {
+    componentManager().initSavedStateHandleHolders();
+  }
+
+  @CallSuper
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    initSavedStateHandleHolders();
+  }
+
+  @Override
+  protected void onDestroy() {
+    super.onDestroy();
+    componentManager().clearSavedStateHandleHolders();
+  }
+
+  @Override
+  public final Object generatedComponent() {
+    return this.componentManager().generatedComponent();
+  }
+
+  protected ActivityComponentManager createComponentManager() {
+    return new ActivityComponentManager(this);
+  }
+
+  @Override
+  public final ActivityComponentManager componentManager() {
+    if (componentManager == null) {
+      synchronized (componentManagerLock) {
+        if (componentManager == null) {
+          componentManager = createComponentManager();
+        }
+      }
+    }
+    return componentManager;
+  }
+
+  protected void inject() {
+    if (!injected) {
+      injected = true;
+      ((MainActivity_GeneratedInjector) this.generatedComponent()).injectMainActivity(UnsafeCasts.<MainActivity>unsafeCast(this));
+    }
+  }
+
+  @Override
+  public ViewModelProvider.Factory getDefaultViewModelProviderFactory() {
+    return DefaultViewModelFactories.getActivityFactory(this, super.getDefaultViewModelProviderFactory());
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/MainActivity_GeneratedInjector.java

@@ -0,0 +1,17 @@
+package com.rainy.token;
+
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityComponent;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.hilt.internal.GeneratedEntryPoint;
+import javax.annotation.processing.Generated;
+
+@OriginatingElement(
+    topLevelClass = MainActivity.class
+)
+@GeneratedEntryPoint
+@InstallIn(ActivityComponent.class)
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
+public interface MainActivity_GeneratedInjector {
+  void injectMainActivity(MainActivity mainActivity);
+}

app/build/generated/ksp/debug/java/com/rainy/token/RainyTokenApplication_GeneratedInjector.java

@@ -0,0 +1,17 @@
+package com.rainy.token;
+
+import dagger.hilt.InstallIn;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.hilt.components.SingletonComponent;
+import dagger.hilt.internal.GeneratedEntryPoint;
+import javax.annotation.processing.Generated;
+
+@OriginatingElement(
+    topLevelClass = RainyTokenApplication.class
+)
+@GeneratedEntryPoint
+@InstallIn(SingletonComponent.class)
+@Generated("dagger.hilt.android.processor.internal.androidentrypoint.InjectorEntryPointGenerator")
+public interface RainyTokenApplication_GeneratedInjector {
+  void injectRainyTokenApplication(RainyTokenApplication rainyTokenApplication);
+}

app/build/generated/ksp/debug/java/com/rainy/token/data/repository/CredentialRepository_Factory.java

@@ -0,0 +1,46 @@
+package com.rainy.token.data.repository;
+
+import com.rainy.token.data.local.SecureStorage;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class CredentialRepository_Factory implements Factory<CredentialRepository> {
+  private final Provider<SecureStorage> secureStorageProvider;
+
+  private CredentialRepository_Factory(Provider<SecureStorage> secureStorageProvider) {
+    this.secureStorageProvider = secureStorageProvider;
+  }
+
+  @Override
+  public CredentialRepository get() {
+    return newInstance(secureStorageProvider.get());
+  }
+
+  public static CredentialRepository_Factory create(Provider<SecureStorage> secureStorageProvider) {
+    return new CredentialRepository_Factory(secureStorageProvider);
+  }
+
+  public static CredentialRepository newInstance(SecureStorage secureStorage) {
+    return new CredentialRepository(secureStorage);
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/data/repository/DeepSeekRepository_Factory.java

@@ -0,0 +1,58 @@
+package com.rainy.token.data.repository;
+
+import com.rainy.token.data.cache.BalanceCache;
+import com.rainy.token.data.remote.DeepSeekApi;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class DeepSeekRepository_Factory implements Factory<DeepSeekRepository> {
+  private final Provider<DeepSeekApi> deepSeekApiProvider;
+
+  private final Provider<CredentialRepository> credentialRepositoryProvider;
+
+  private final Provider<BalanceCache> balanceCacheProvider;
+
+  private DeepSeekRepository_Factory(Provider<DeepSeekApi> deepSeekApiProvider,
+      Provider<CredentialRepository> credentialRepositoryProvider,
+      Provider<BalanceCache> balanceCacheProvider) {
+    this.deepSeekApiProvider = deepSeekApiProvider;
+    this.credentialRepositoryProvider = credentialRepositoryProvider;
+    this.balanceCacheProvider = balanceCacheProvider;
+  }
+
+  @Override
+  public DeepSeekRepository get() {
+    return newInstance(deepSeekApiProvider.get(), credentialRepositoryProvider.get(), balanceCacheProvider.get());
+  }
+
+  public static DeepSeekRepository_Factory create(Provider<DeepSeekApi> deepSeekApiProvider,
+      Provider<CredentialRepository> credentialRepositoryProvider,
+      Provider<BalanceCache> balanceCacheProvider) {
+    return new DeepSeekRepository_Factory(deepSeekApiProvider, credentialRepositoryProvider, balanceCacheProvider);
+  }
+
+  public static DeepSeekRepository newInstance(DeepSeekApi deepSeekApi,
+      CredentialRepository credentialRepository, BalanceCache balanceCache) {
+    return new DeepSeekRepository(deepSeekApi, credentialRepository, balanceCache);
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/data/repository/WebViewSessionSaver_Factory.java

@@ -0,0 +1,46 @@
+package com.rainy.token.data.repository;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class WebViewSessionSaver_Factory implements Factory<WebViewSessionSaver> {
+  private final Provider<CredentialRepository> credentialRepositoryProvider;
+
+  private WebViewSessionSaver_Factory(Provider<CredentialRepository> credentialRepositoryProvider) {
+    this.credentialRepositoryProvider = credentialRepositoryProvider;
+  }
+
+  @Override
+  public WebViewSessionSaver get() {
+    return newInstance(credentialRepositoryProvider.get());
+  }
+
+  public static WebViewSessionSaver_Factory create(
+      Provider<CredentialRepository> credentialRepositoryProvider) {
+    return new WebViewSessionSaver_Factory(credentialRepositoryProvider);
+  }
+
+  public static WebViewSessionSaver newInstance(CredentialRepository credentialRepository) {
+    return new WebViewSessionSaver(credentialRepository);
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/di/NetworkModule_ProvideBalanceCacheDataStoreFactory.java

@@ -0,0 +1,53 @@
+package com.rainy.token.di;
+
+import android.content.Context;
+import androidx.datastore.core.DataStore;
+import androidx.datastore.preferences.core.Preferences;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata({
+    "javax.inject.Named",
+    "dagger.hilt.android.qualifiers.ApplicationContext"
+})
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class NetworkModule_ProvideBalanceCacheDataStoreFactory implements Factory<DataStore<Preferences>> {
+  private final Provider<Context> contextProvider;
+
+  private NetworkModule_ProvideBalanceCacheDataStoreFactory(Provider<Context> contextProvider) {
+    this.contextProvider = contextProvider;
+  }
+
+  @Override
+  public DataStore<Preferences> get() {
+    return provideBalanceCacheDataStore(contextProvider.get());
+  }
+
+  public static NetworkModule_ProvideBalanceCacheDataStoreFactory create(
+      Provider<Context> contextProvider) {
+    return new NetworkModule_ProvideBalanceCacheDataStoreFactory(contextProvider);
+  }
+
+  public static DataStore<Preferences> provideBalanceCacheDataStore(Context context) {
+    return Preconditions.checkNotNullFromProvides(NetworkModule.INSTANCE.provideBalanceCacheDataStore(context));
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/di/NetworkModule_ProvideBalanceCacheFactory.java

@@ -0,0 +1,55 @@
+package com.rainy.token.di;
+
+import androidx.datastore.core.DataStore;
+import androidx.datastore.preferences.core.Preferences;
+import com.rainy.token.data.cache.BalanceCache;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import kotlinx.serialization.json.Json;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata("javax.inject.Named")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class NetworkModule_ProvideBalanceCacheFactory implements Factory<BalanceCache> {
+  private final Provider<DataStore<Preferences>> dataStoreProvider;
+
+  private final Provider<Json> jsonProvider;
+
+  private NetworkModule_ProvideBalanceCacheFactory(
+      Provider<DataStore<Preferences>> dataStoreProvider, Provider<Json> jsonProvider) {
+    this.dataStoreProvider = dataStoreProvider;
+    this.jsonProvider = jsonProvider;
+  }
+
+  @Override
+  public BalanceCache get() {
+    return provideBalanceCache(dataStoreProvider.get(), jsonProvider.get());
+  }
+
+  public static NetworkModule_ProvideBalanceCacheFactory create(
+      Provider<DataStore<Preferences>> dataStoreProvider, Provider<Json> jsonProvider) {
+    return new NetworkModule_ProvideBalanceCacheFactory(dataStoreProvider, jsonProvider);
+  }
+
+  public static BalanceCache provideBalanceCache(DataStore<Preferences> dataStore, Json json) {
+    return Preconditions.checkNotNullFromProvides(NetworkModule.INSTANCE.provideBalanceCache(dataStore, json));
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/di/NetworkModule_ProvideDeepSeekApiFactory.java

@@ -0,0 +1,49 @@
+package com.rainy.token.di;
+
+import com.rainy.token.data.remote.DeepSeekApi;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import retrofit2.Retrofit;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class NetworkModule_ProvideDeepSeekApiFactory implements Factory<DeepSeekApi> {
+  private final Provider<Retrofit> retrofitProvider;
+
+  private NetworkModule_ProvideDeepSeekApiFactory(Provider<Retrofit> retrofitProvider) {
+    this.retrofitProvider = retrofitProvider;
+  }
+
+  @Override
+  public DeepSeekApi get() {
+    return provideDeepSeekApi(retrofitProvider.get());
+  }
+
+  public static NetworkModule_ProvideDeepSeekApiFactory create(
+      Provider<Retrofit> retrofitProvider) {
+    return new NetworkModule_ProvideDeepSeekApiFactory(retrofitProvider);
+  }
+
+  public static DeepSeekApi provideDeepSeekApi(Retrofit retrofit) {
+    return Preconditions.checkNotNullFromProvides(NetworkModule.INSTANCE.provideDeepSeekApi(retrofit));
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/di/NetworkModule_ProvideDeepSeekRepositoryFactory.java

@@ -0,0 +1,62 @@
+package com.rainy.token.di;
+
+import com.rainy.token.data.cache.BalanceCache;
+import com.rainy.token.data.remote.DeepSeekApi;
+import com.rainy.token.data.repository.CredentialRepository;
+import com.rainy.token.data.repository.DeepSeekRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class NetworkModule_ProvideDeepSeekRepositoryFactory implements Factory<DeepSeekRepository> {
+  private final Provider<DeepSeekApi> deepSeekApiProvider;
+
+  private final Provider<CredentialRepository> credentialRepositoryProvider;
+
+  private final Provider<BalanceCache> balanceCacheProvider;
+
+  private NetworkModule_ProvideDeepSeekRepositoryFactory(Provider<DeepSeekApi> deepSeekApiProvider,
+      Provider<CredentialRepository> credentialRepositoryProvider,
+      Provider<BalanceCache> balanceCacheProvider) {
+    this.deepSeekApiProvider = deepSeekApiProvider;
+    this.credentialRepositoryProvider = credentialRepositoryProvider;
+    this.balanceCacheProvider = balanceCacheProvider;
+  }
+
+  @Override
+  public DeepSeekRepository get() {
+    return provideDeepSeekRepository(deepSeekApiProvider.get(), credentialRepositoryProvider.get(), balanceCacheProvider.get());
+  }
+
+  public static NetworkModule_ProvideDeepSeekRepositoryFactory create(
+      Provider<DeepSeekApi> deepSeekApiProvider,
+      Provider<CredentialRepository> credentialRepositoryProvider,
+      Provider<BalanceCache> balanceCacheProvider) {
+    return new NetworkModule_ProvideDeepSeekRepositoryFactory(deepSeekApiProvider, credentialRepositoryProvider, balanceCacheProvider);
+  }
+
+  public static DeepSeekRepository provideDeepSeekRepository(DeepSeekApi deepSeekApi,
+      CredentialRepository credentialRepository, BalanceCache balanceCache) {
+    return Preconditions.checkNotNullFromProvides(NetworkModule.INSTANCE.provideDeepSeekRepository(deepSeekApi, credentialRepository, balanceCache));
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/di/NetworkModule_ProvideJsonFactory.java

@@ -0,0 +1,44 @@
+package com.rainy.token.di;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import kotlinx.serialization.json.Json;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class NetworkModule_ProvideJsonFactory implements Factory<Json> {
+  @Override
+  public Json get() {
+    return provideJson();
+  }
+
+  public static NetworkModule_ProvideJsonFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static Json provideJson() {
+    return Preconditions.checkNotNullFromProvides(NetworkModule.INSTANCE.provideJson());
+  }
+
+  private static final class InstanceHolder {
+    static final NetworkModule_ProvideJsonFactory INSTANCE = new NetworkModule_ProvideJsonFactory();
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/di/NetworkModule_ProvideOkHttpClientFactory.java

@@ -0,0 +1,44 @@
+package com.rainy.token.di;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import okhttp3.OkHttpClient;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class NetworkModule_ProvideOkHttpClientFactory implements Factory<OkHttpClient> {
+  @Override
+  public OkHttpClient get() {
+    return provideOkHttpClient();
+  }
+
+  public static NetworkModule_ProvideOkHttpClientFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static OkHttpClient provideOkHttpClient() {
+    return Preconditions.checkNotNullFromProvides(NetworkModule.INSTANCE.provideOkHttpClient());
+  }
+
+  private static final class InstanceHolder {
+    static final NetworkModule_ProvideOkHttpClientFactory INSTANCE = new NetworkModule_ProvideOkHttpClientFactory();
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/di/NetworkModule_ProvideOpenCodeGoRepositoryFactory.java

@@ -0,0 +1,63 @@
+package com.rainy.token.di;
+
+import com.rainy.token.data.cache.BalanceCache;
+import com.rainy.token.data.repository.CredentialRepository;
+import com.rainy.token.data.repository.OpenCodeGoRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import okhttp3.OkHttpClient;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class NetworkModule_ProvideOpenCodeGoRepositoryFactory implements Factory<OpenCodeGoRepository> {
+  private final Provider<OkHttpClient> okHttpClientProvider;
+
+  private final Provider<CredentialRepository> credentialRepositoryProvider;
+
+  private final Provider<BalanceCache> balanceCacheProvider;
+
+  private NetworkModule_ProvideOpenCodeGoRepositoryFactory(
+      Provider<OkHttpClient> okHttpClientProvider,
+      Provider<CredentialRepository> credentialRepositoryProvider,
+      Provider<BalanceCache> balanceCacheProvider) {
+    this.okHttpClientProvider = okHttpClientProvider;
+    this.credentialRepositoryProvider = credentialRepositoryProvider;
+    this.balanceCacheProvider = balanceCacheProvider;
+  }
+
+  @Override
+  public OpenCodeGoRepository get() {
+    return provideOpenCodeGoRepository(okHttpClientProvider.get(), credentialRepositoryProvider.get(), balanceCacheProvider.get());
+  }
+
+  public static NetworkModule_ProvideOpenCodeGoRepositoryFactory create(
+      Provider<OkHttpClient> okHttpClientProvider,
+      Provider<CredentialRepository> credentialRepositoryProvider,
+      Provider<BalanceCache> balanceCacheProvider) {
+    return new NetworkModule_ProvideOpenCodeGoRepositoryFactory(okHttpClientProvider, credentialRepositoryProvider, balanceCacheProvider);
+  }
+
+  public static OpenCodeGoRepository provideOpenCodeGoRepository(OkHttpClient okHttpClient,
+      CredentialRepository credentialRepository, BalanceCache balanceCache) {
+    return Preconditions.checkNotNullFromProvides(NetworkModule.INSTANCE.provideOpenCodeGoRepository(okHttpClient, credentialRepository, balanceCache));
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/di/NetworkModule_ProvideOpenCodeUsageRepositoryFactory.java

@@ -0,0 +1,57 @@
+package com.rainy.token.di;
+
+import com.rainy.token.data.repository.CredentialRepository;
+import com.rainy.token.data.repository.OpenCodeUsageRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import okhttp3.OkHttpClient;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class NetworkModule_ProvideOpenCodeUsageRepositoryFactory implements Factory<OpenCodeUsageRepository> {
+  private final Provider<OkHttpClient> okHttpClientProvider;
+
+  private final Provider<CredentialRepository> credentialRepositoryProvider;
+
+  private NetworkModule_ProvideOpenCodeUsageRepositoryFactory(
+      Provider<OkHttpClient> okHttpClientProvider,
+      Provider<CredentialRepository> credentialRepositoryProvider) {
+    this.okHttpClientProvider = okHttpClientProvider;
+    this.credentialRepositoryProvider = credentialRepositoryProvider;
+  }
+
+  @Override
+  public OpenCodeUsageRepository get() {
+    return provideOpenCodeUsageRepository(okHttpClientProvider.get(), credentialRepositoryProvider.get());
+  }
+
+  public static NetworkModule_ProvideOpenCodeUsageRepositoryFactory create(
+      Provider<OkHttpClient> okHttpClientProvider,
+      Provider<CredentialRepository> credentialRepositoryProvider) {
+    return new NetworkModule_ProvideOpenCodeUsageRepositoryFactory(okHttpClientProvider, credentialRepositoryProvider);
+  }
+
+  public static OpenCodeUsageRepository provideOpenCodeUsageRepository(OkHttpClient okHttpClient,
+      CredentialRepository credentialRepository) {
+    return Preconditions.checkNotNullFromProvides(NetworkModule.INSTANCE.provideOpenCodeUsageRepository(okHttpClient, credentialRepository));
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/di/NetworkModule_ProvideRetrofitFactory.java

@@ -0,0 +1,54 @@
+package com.rainy.token.di;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import kotlinx.serialization.json.Json;
+import okhttp3.OkHttpClient;
+import retrofit2.Retrofit;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class NetworkModule_ProvideRetrofitFactory implements Factory<Retrofit> {
+  private final Provider<OkHttpClient> clientProvider;
+
+  private final Provider<Json> jsonProvider;
+
+  private NetworkModule_ProvideRetrofitFactory(Provider<OkHttpClient> clientProvider,
+      Provider<Json> jsonProvider) {
+    this.clientProvider = clientProvider;
+    this.jsonProvider = jsonProvider;
+  }
+
+  @Override
+  public Retrofit get() {
+    return provideRetrofit(clientProvider.get(), jsonProvider.get());
+  }
+
+  public static NetworkModule_ProvideRetrofitFactory create(Provider<OkHttpClient> clientProvider,
+      Provider<Json> jsonProvider) {
+    return new NetworkModule_ProvideRetrofitFactory(clientProvider, jsonProvider);
+  }
+
+  public static Retrofit provideRetrofit(OkHttpClient client, Json json) {
+    return Preconditions.checkNotNullFromProvides(NetworkModule.INSTANCE.provideRetrofit(client, json));
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/di/NetworkModule_ProvideSecureStorageFactory.java

@@ -0,0 +1,55 @@
+package com.rainy.token.di;
+
+import androidx.datastore.core.DataStore;
+import androidx.datastore.preferences.core.Preferences;
+import com.rainy.token.data.local.SecureStorage;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import kotlinx.serialization.json.Json;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata("javax.inject.Named")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class NetworkModule_ProvideSecureStorageFactory implements Factory<SecureStorage> {
+  private final Provider<DataStore<Preferences>> dataStoreProvider;
+
+  private final Provider<Json> jsonProvider;
+
+  private NetworkModule_ProvideSecureStorageFactory(
+      Provider<DataStore<Preferences>> dataStoreProvider, Provider<Json> jsonProvider) {
+    this.dataStoreProvider = dataStoreProvider;
+    this.jsonProvider = jsonProvider;
+  }
+
+  @Override
+  public SecureStorage get() {
+    return provideSecureStorage(dataStoreProvider.get(), jsonProvider.get());
+  }
+
+  public static NetworkModule_ProvideSecureStorageFactory create(
+      Provider<DataStore<Preferences>> dataStoreProvider, Provider<Json> jsonProvider) {
+    return new NetworkModule_ProvideSecureStorageFactory(dataStoreProvider, jsonProvider);
+  }
+
+  public static SecureStorage provideSecureStorage(DataStore<Preferences> dataStore, Json json) {
+    return Preconditions.checkNotNullFromProvides(NetworkModule.INSTANCE.provideSecureStorage(dataStore, json));
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/di/NetworkModule_ProvideUsageCacheFactory.java

@@ -0,0 +1,55 @@
+package com.rainy.token.di;
+
+import androidx.datastore.core.DataStore;
+import androidx.datastore.preferences.core.Preferences;
+import com.rainy.token.data.local.UsageCache;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+import kotlinx.serialization.json.Json;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata("javax.inject.Named")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class NetworkModule_ProvideUsageCacheFactory implements Factory<UsageCache> {
+  private final Provider<DataStore<Preferences>> dataStoreProvider;
+
+  private final Provider<Json> jsonProvider;
+
+  private NetworkModule_ProvideUsageCacheFactory(Provider<DataStore<Preferences>> dataStoreProvider,
+      Provider<Json> jsonProvider) {
+    this.dataStoreProvider = dataStoreProvider;
+    this.jsonProvider = jsonProvider;
+  }
+
+  @Override
+  public UsageCache get() {
+    return provideUsageCache(dataStoreProvider.get(), jsonProvider.get());
+  }
+
+  public static NetworkModule_ProvideUsageCacheFactory create(
+      Provider<DataStore<Preferences>> dataStoreProvider, Provider<Json> jsonProvider) {
+    return new NetworkModule_ProvideUsageCacheFactory(dataStoreProvider, jsonProvider);
+  }
+
+  public static UsageCache provideUsageCache(DataStore<Preferences> dataStore, Json json) {
+    return Preconditions.checkNotNullFromProvides(NetworkModule.INSTANCE.provideUsageCache(dataStore, json));
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/di/StorageModule_ProvideSecureStorageDataStoreFactory.java

@@ -0,0 +1,53 @@
+package com.rainy.token.di;
+
+import android.content.Context;
+import androidx.datastore.core.DataStore;
+import androidx.datastore.preferences.core.Preferences;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata({
+    "javax.inject.Named",
+    "dagger.hilt.android.qualifiers.ApplicationContext"
+})
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class StorageModule_ProvideSecureStorageDataStoreFactory implements Factory<DataStore<Preferences>> {
+  private final Provider<Context> contextProvider;
+
+  private StorageModule_ProvideSecureStorageDataStoreFactory(Provider<Context> contextProvider) {
+    this.contextProvider = contextProvider;
+  }
+
+  @Override
+  public DataStore<Preferences> get() {
+    return provideSecureStorageDataStore(contextProvider.get());
+  }
+
+  public static StorageModule_ProvideSecureStorageDataStoreFactory create(
+      Provider<Context> contextProvider) {
+    return new StorageModule_ProvideSecureStorageDataStoreFactory(contextProvider);
+  }
+
+  public static DataStore<Preferences> provideSecureStorageDataStore(Context context) {
+    return Preconditions.checkNotNullFromProvides(StorageModule.INSTANCE.provideSecureStorageDataStore(context));
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/di/StorageModule_ProvideUsageCacheDataStoreFactory.java

@@ -0,0 +1,53 @@
+package com.rainy.token.di;
+
+import android.content.Context;
+import androidx.datastore.core.DataStore;
+import androidx.datastore.preferences.core.Preferences;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Preconditions;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata("javax.inject.Singleton")
+@QualifierMetadata({
+    "javax.inject.Named",
+    "dagger.hilt.android.qualifiers.ApplicationContext"
+})
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class StorageModule_ProvideUsageCacheDataStoreFactory implements Factory<DataStore<Preferences>> {
+  private final Provider<Context> contextProvider;
+
+  private StorageModule_ProvideUsageCacheDataStoreFactory(Provider<Context> contextProvider) {
+    this.contextProvider = contextProvider;
+  }
+
+  @Override
+  public DataStore<Preferences> get() {
+    return provideUsageCacheDataStore(contextProvider.get());
+  }
+
+  public static StorageModule_ProvideUsageCacheDataStoreFactory create(
+      Provider<Context> contextProvider) {
+    return new StorageModule_ProvideUsageCacheDataStoreFactory(contextProvider);
+  }
+
+  public static DataStore<Preferences> provideUsageCacheDataStore(Context context) {
+    return Preconditions.checkNotNullFromProvides(StorageModule.INSTANCE.provideUsageCacheDataStore(context));
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/domain/usecase/RefreshBalanceUseCase_Factory.java

@@ -0,0 +1,55 @@
+package com.rainy.token.domain.usecase;
+
+import com.rainy.token.data.repository.DeepSeekRepository;
+import com.rainy.token.data.repository.OpenCodeGoRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class RefreshBalanceUseCase_Factory implements Factory<RefreshBalanceUseCase> {
+  private final Provider<DeepSeekRepository> deepSeekRepositoryProvider;
+
+  private final Provider<OpenCodeGoRepository> openCodeGoRepositoryProvider;
+
+  private RefreshBalanceUseCase_Factory(Provider<DeepSeekRepository> deepSeekRepositoryProvider,
+      Provider<OpenCodeGoRepository> openCodeGoRepositoryProvider) {
+    this.deepSeekRepositoryProvider = deepSeekRepositoryProvider;
+    this.openCodeGoRepositoryProvider = openCodeGoRepositoryProvider;
+  }
+
+  @Override
+  public RefreshBalanceUseCase get() {
+    return newInstance(deepSeekRepositoryProvider, openCodeGoRepositoryProvider);
+  }
+
+  public static RefreshBalanceUseCase_Factory create(
+      Provider<DeepSeekRepository> deepSeekRepositoryProvider,
+      Provider<OpenCodeGoRepository> openCodeGoRepositoryProvider) {
+    return new RefreshBalanceUseCase_Factory(deepSeekRepositoryProvider, openCodeGoRepositoryProvider);
+  }
+
+  public static RefreshBalanceUseCase newInstance(
+      javax.inject.Provider<DeepSeekRepository> deepSeekRepositoryProvider,
+      javax.inject.Provider<OpenCodeGoRepository> openCodeGoRepositoryProvider) {
+    return new RefreshBalanceUseCase(deepSeekRepositoryProvider, openCodeGoRepositoryProvider);
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/domain/usecase/SyncUsageUseCase_Factory.java

@@ -0,0 +1,54 @@
+package com.rainy.token.domain.usecase;
+
+import com.rainy.token.data.local.UsageCache;
+import com.rainy.token.data.repository.OpenCodeUsageRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class SyncUsageUseCase_Factory implements Factory<SyncUsageUseCase> {
+  private final Provider<OpenCodeUsageRepository> usageRepoProvider;
+
+  private final Provider<UsageCache> cacheProvider;
+
+  private SyncUsageUseCase_Factory(Provider<OpenCodeUsageRepository> usageRepoProvider,
+      Provider<UsageCache> cacheProvider) {
+    this.usageRepoProvider = usageRepoProvider;
+    this.cacheProvider = cacheProvider;
+  }
+
+  @Override
+  public SyncUsageUseCase get() {
+    return newInstance(usageRepoProvider, cacheProvider);
+  }
+
+  public static SyncUsageUseCase_Factory create(Provider<OpenCodeUsageRepository> usageRepoProvider,
+      Provider<UsageCache> cacheProvider) {
+    return new SyncUsageUseCase_Factory(usageRepoProvider, cacheProvider);
+  }
+
+  public static SyncUsageUseCase newInstance(
+      javax.inject.Provider<OpenCodeUsageRepository> usageRepoProvider,
+      javax.inject.Provider<UsageCache> cacheProvider) {
+    return new SyncUsageUseCase(usageRepoProvider, cacheProvider);
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/DashboardViewModel_Factory.java

@@ -0,0 +1,66 @@
+package com.rainy.token.ui.dashboard;
+
+import android.content.Context;
+import com.rainy.token.data.cache.BalanceCache;
+import com.rainy.token.data.repository.CredentialRepository;
+import com.rainy.token.domain.usecase.RefreshBalanceUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata("dagger.hilt.android.qualifiers.ApplicationContext")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class DashboardViewModel_Factory implements Factory<DashboardViewModel> {
+  private final Provider<CredentialRepository> credentialRepositoryProvider;
+
+  private final Provider<BalanceCache> balanceCacheProvider;
+
+  private final Provider<RefreshBalanceUseCase> refreshBalanceUseCaseProvider;
+
+  private final Provider<Context> appContextProvider;
+
+  private DashboardViewModel_Factory(Provider<CredentialRepository> credentialRepositoryProvider,
+      Provider<BalanceCache> balanceCacheProvider,
+      Provider<RefreshBalanceUseCase> refreshBalanceUseCaseProvider,
+      Provider<Context> appContextProvider) {
+    this.credentialRepositoryProvider = credentialRepositoryProvider;
+    this.balanceCacheProvider = balanceCacheProvider;
+    this.refreshBalanceUseCaseProvider = refreshBalanceUseCaseProvider;
+    this.appContextProvider = appContextProvider;
+  }
+
+  @Override
+  public DashboardViewModel get() {
+    return newInstance(credentialRepositoryProvider.get(), balanceCacheProvider.get(), refreshBalanceUseCaseProvider.get(), appContextProvider.get());
+  }
+
+  public static DashboardViewModel_Factory create(
+      Provider<CredentialRepository> credentialRepositoryProvider,
+      Provider<BalanceCache> balanceCacheProvider,
+      Provider<RefreshBalanceUseCase> refreshBalanceUseCaseProvider,
+      Provider<Context> appContextProvider) {
+    return new DashboardViewModel_Factory(credentialRepositoryProvider, balanceCacheProvider, refreshBalanceUseCaseProvider, appContextProvider);
+  }
+
+  public static DashboardViewModel newInstance(CredentialRepository credentialRepository,
+      BalanceCache balanceCache, RefreshBalanceUseCase refreshBalanceUseCase, Context appContext) {
+    return new DashboardViewModel(credentialRepository, balanceCache, refreshBalanceUseCase, appContext);
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/DashboardViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.rainy.token.ui.dashboard;
+
+import androidx.lifecycle.ViewModel;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.components.ViewModelComponent;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.LazyClassKey;
+import javax.annotation.processing.Generated;
+
+@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
+@OriginatingElement(
+    topLevelClass = DashboardViewModel.class
+)
+public final class DashboardViewModel_HiltModules {
+  private DashboardViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(DashboardViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(DashboardViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(DashboardViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/DashboardViewModel_HiltModules_BindsModule_Binds_LazyMapKey.java

@@ -0,0 +1,28 @@
+package com.rainy.token.ui.dashboard;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.IdentifierNameString;
+import dagger.internal.KeepFieldType;
+import javax.annotation.processing.Generated;
+
+@IdentifierNameString
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class DashboardViewModel_HiltModules_BindsModule_Binds_LazyMapKey {
+  @KeepFieldType
+  static DashboardViewModel keepFieldType;
+
+  public static String lazyClassKeyName = "com.rainy.token.ui.dashboard.DashboardViewModel";
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/DashboardViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,42 @@
+package com.rainy.token.ui.dashboard;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class DashboardViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static DashboardViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return DashboardViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    static final DashboardViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new DashboardViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/DashboardViewModel_HiltModules_KeyModule_Provide_LazyMapKey.java

@@ -0,0 +1,28 @@
+package com.rainy.token.ui.dashboard;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.IdentifierNameString;
+import dagger.internal.KeepFieldType;
+import javax.annotation.processing.Generated;
+
+@IdentifierNameString
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class DashboardViewModel_HiltModules_KeyModule_Provide_LazyMapKey {
+  @KeepFieldType
+  static DashboardViewModel keepFieldType;
+
+  public static String lazyClassKeyName = "com.rainy.token.ui.dashboard.DashboardViewModel";
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/UsageChartViewModel_Factory.java

@@ -0,0 +1,53 @@
+package com.rainy.token.ui.dashboard;
+
+import com.rainy.token.data.local.UsageCache;
+import com.rainy.token.data.repository.CredentialRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class UsageChartViewModel_Factory implements Factory<UsageChartViewModel> {
+  private final Provider<UsageCache> cacheProvider;
+
+  private final Provider<CredentialRepository> credentialRepositoryProvider;
+
+  private UsageChartViewModel_Factory(Provider<UsageCache> cacheProvider,
+      Provider<CredentialRepository> credentialRepositoryProvider) {
+    this.cacheProvider = cacheProvider;
+    this.credentialRepositoryProvider = credentialRepositoryProvider;
+  }
+
+  @Override
+  public UsageChartViewModel get() {
+    return newInstance(cacheProvider, credentialRepositoryProvider.get());
+  }
+
+  public static UsageChartViewModel_Factory create(Provider<UsageCache> cacheProvider,
+      Provider<CredentialRepository> credentialRepositoryProvider) {
+    return new UsageChartViewModel_Factory(cacheProvider, credentialRepositoryProvider);
+  }
+
+  public static UsageChartViewModel newInstance(javax.inject.Provider<UsageCache> cacheProvider,
+      CredentialRepository credentialRepository) {
+    return new UsageChartViewModel(cacheProvider, credentialRepository);
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/UsageChartViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.rainy.token.ui.dashboard;
+
+import androidx.lifecycle.ViewModel;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.components.ViewModelComponent;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.LazyClassKey;
+import javax.annotation.processing.Generated;
+
+@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
+@OriginatingElement(
+    topLevelClass = UsageChartViewModel.class
+)
+public final class UsageChartViewModel_HiltModules {
+  private UsageChartViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(UsageChartViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(UsageChartViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(UsageChartViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/UsageChartViewModel_HiltModules_BindsModule_Binds_LazyMapKey.java

@@ -0,0 +1,28 @@
+package com.rainy.token.ui.dashboard;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.IdentifierNameString;
+import dagger.internal.KeepFieldType;
+import javax.annotation.processing.Generated;
+
+@IdentifierNameString
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class UsageChartViewModel_HiltModules_BindsModule_Binds_LazyMapKey {
+  @KeepFieldType
+  static UsageChartViewModel keepFieldType;
+
+  public static String lazyClassKeyName = "com.rainy.token.ui.dashboard.UsageChartViewModel";
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/UsageChartViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,42 @@
+package com.rainy.token.ui.dashboard;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class UsageChartViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static UsageChartViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return UsageChartViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    static final UsageChartViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new UsageChartViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/UsageChartViewModel_HiltModules_KeyModule_Provide_LazyMapKey.java

@@ -0,0 +1,28 @@
+package com.rainy.token.ui.dashboard;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.IdentifierNameString;
+import dagger.internal.KeepFieldType;
+import javax.annotation.processing.Generated;
+
+@IdentifierNameString
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class UsageChartViewModel_HiltModules_KeyModule_Provide_LazyMapKey {
+  @KeepFieldType
+  static UsageChartViewModel keepFieldType;
+
+  public static String lazyClassKeyName = "com.rainy.token.ui.dashboard.UsageChartViewModel";
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/UsageDataViewModel_Factory.java

@@ -0,0 +1,53 @@
+package com.rainy.token.ui.dashboard;
+
+import com.rainy.token.data.local.UsageCache;
+import com.rainy.token.data.repository.CredentialRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class UsageDataViewModel_Factory implements Factory<UsageDataViewModel> {
+  private final Provider<UsageCache> cacheProvider;
+
+  private final Provider<CredentialRepository> credentialRepositoryProvider;
+
+  private UsageDataViewModel_Factory(Provider<UsageCache> cacheProvider,
+      Provider<CredentialRepository> credentialRepositoryProvider) {
+    this.cacheProvider = cacheProvider;
+    this.credentialRepositoryProvider = credentialRepositoryProvider;
+  }
+
+  @Override
+  public UsageDataViewModel get() {
+    return newInstance(cacheProvider, credentialRepositoryProvider.get());
+  }
+
+  public static UsageDataViewModel_Factory create(Provider<UsageCache> cacheProvider,
+      Provider<CredentialRepository> credentialRepositoryProvider) {
+    return new UsageDataViewModel_Factory(cacheProvider, credentialRepositoryProvider);
+  }
+
+  public static UsageDataViewModel newInstance(javax.inject.Provider<UsageCache> cacheProvider,
+      CredentialRepository credentialRepository) {
+    return new UsageDataViewModel(cacheProvider, credentialRepository);
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/UsageDataViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.rainy.token.ui.dashboard;
+
+import androidx.lifecycle.ViewModel;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.components.ViewModelComponent;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.LazyClassKey;
+import javax.annotation.processing.Generated;
+
+@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
+@OriginatingElement(
+    topLevelClass = UsageDataViewModel.class
+)
+public final class UsageDataViewModel_HiltModules {
+  private UsageDataViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(UsageDataViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(UsageDataViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(UsageDataViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/UsageDataViewModel_HiltModules_BindsModule_Binds_LazyMapKey.java

@@ -0,0 +1,28 @@
+package com.rainy.token.ui.dashboard;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.IdentifierNameString;
+import dagger.internal.KeepFieldType;
+import javax.annotation.processing.Generated;
+
+@IdentifierNameString
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class UsageDataViewModel_HiltModules_BindsModule_Binds_LazyMapKey {
+  @KeepFieldType
+  static UsageDataViewModel keepFieldType;
+
+  public static String lazyClassKeyName = "com.rainy.token.ui.dashboard.UsageDataViewModel";
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/UsageDataViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,42 @@
+package com.rainy.token.ui.dashboard;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class UsageDataViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static UsageDataViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return UsageDataViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    static final UsageDataViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new UsageDataViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/UsageDataViewModel_HiltModules_KeyModule_Provide_LazyMapKey.java

@@ -0,0 +1,28 @@
+package com.rainy.token.ui.dashboard;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.IdentifierNameString;
+import dagger.internal.KeepFieldType;
+import javax.annotation.processing.Generated;
+
+@IdentifierNameString
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class UsageDataViewModel_HiltModules_KeyModule_Provide_LazyMapKey {
+  @KeepFieldType
+  static UsageDataViewModel keepFieldType;
+
+  public static String lazyClassKeyName = "com.rainy.token.ui.dashboard.UsageDataViewModel";
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/UsageViewModel_Factory.java

@@ -0,0 +1,60 @@
+package com.rainy.token.ui.dashboard;
+
+import com.rainy.token.data.local.UsageCache;
+import com.rainy.token.data.repository.CredentialRepository;
+import com.rainy.token.domain.usecase.SyncUsageUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class UsageViewModel_Factory implements Factory<UsageViewModel> {
+  private final Provider<UsageCache> cacheProvider;
+
+  private final Provider<SyncUsageUseCase> syncUseCaseProvider;
+
+  private final Provider<CredentialRepository> credentialRepositoryProvider;
+
+  private UsageViewModel_Factory(Provider<UsageCache> cacheProvider,
+      Provider<SyncUsageUseCase> syncUseCaseProvider,
+      Provider<CredentialRepository> credentialRepositoryProvider) {
+    this.cacheProvider = cacheProvider;
+    this.syncUseCaseProvider = syncUseCaseProvider;
+    this.credentialRepositoryProvider = credentialRepositoryProvider;
+  }
+
+  @Override
+  public UsageViewModel get() {
+    return newInstance(cacheProvider, syncUseCaseProvider, credentialRepositoryProvider.get());
+  }
+
+  public static UsageViewModel_Factory create(Provider<UsageCache> cacheProvider,
+      Provider<SyncUsageUseCase> syncUseCaseProvider,
+      Provider<CredentialRepository> credentialRepositoryProvider) {
+    return new UsageViewModel_Factory(cacheProvider, syncUseCaseProvider, credentialRepositoryProvider);
+  }
+
+  public static UsageViewModel newInstance(javax.inject.Provider<UsageCache> cacheProvider,
+      javax.inject.Provider<SyncUsageUseCase> syncUseCaseProvider,
+      CredentialRepository credentialRepository) {
+    return new UsageViewModel(cacheProvider, syncUseCaseProvider, credentialRepository);
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/UsageViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.rainy.token.ui.dashboard;
+
+import androidx.lifecycle.ViewModel;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.components.ViewModelComponent;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.LazyClassKey;
+import javax.annotation.processing.Generated;
+
+@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
+@OriginatingElement(
+    topLevelClass = UsageViewModel.class
+)
+public final class UsageViewModel_HiltModules {
+  private UsageViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(UsageViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(UsageViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(UsageViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/UsageViewModel_HiltModules_BindsModule_Binds_LazyMapKey.java

@@ -0,0 +1,28 @@
+package com.rainy.token.ui.dashboard;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.IdentifierNameString;
+import dagger.internal.KeepFieldType;
+import javax.annotation.processing.Generated;
+
+@IdentifierNameString
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class UsageViewModel_HiltModules_BindsModule_Binds_LazyMapKey {
+  @KeepFieldType
+  static UsageViewModel keepFieldType;
+
+  public static String lazyClassKeyName = "com.rainy.token.ui.dashboard.UsageViewModel";
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/UsageViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,42 @@
+package com.rainy.token.ui.dashboard;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class UsageViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static UsageViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return UsageViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    static final UsageViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new UsageViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/dashboard/UsageViewModel_HiltModules_KeyModule_Provide_LazyMapKey.java

@@ -0,0 +1,28 @@
+package com.rainy.token.ui.dashboard;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.IdentifierNameString;
+import dagger.internal.KeepFieldType;
+import javax.annotation.processing.Generated;
+
+@IdentifierNameString
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class UsageViewModel_HiltModules_KeyModule_Provide_LazyMapKey {
+  @KeepFieldType
+  static UsageViewModel keepFieldType;
+
+  public static String lazyClassKeyName = "com.rainy.token.ui.dashboard.UsageViewModel";
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/servicedetail/ServiceDetailViewModel_Factory.java

@@ -0,0 +1,61 @@
+package com.rainy.token.ui.servicedetail;
+
+import com.rainy.token.data.cache.BalanceCache;
+import com.rainy.token.data.repository.CredentialRepository;
+import com.rainy.token.domain.usecase.RefreshBalanceUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class ServiceDetailViewModel_Factory implements Factory<ServiceDetailViewModel> {
+  private final Provider<CredentialRepository> credentialRepositoryProvider;
+
+  private final Provider<BalanceCache> balanceCacheProvider;
+
+  private final Provider<RefreshBalanceUseCase> refreshBalanceUseCaseProvider;
+
+  private ServiceDetailViewModel_Factory(
+      Provider<CredentialRepository> credentialRepositoryProvider,
+      Provider<BalanceCache> balanceCacheProvider,
+      Provider<RefreshBalanceUseCase> refreshBalanceUseCaseProvider) {
+    this.credentialRepositoryProvider = credentialRepositoryProvider;
+    this.balanceCacheProvider = balanceCacheProvider;
+    this.refreshBalanceUseCaseProvider = refreshBalanceUseCaseProvider;
+  }
+
+  @Override
+  public ServiceDetailViewModel get() {
+    return newInstance(credentialRepositoryProvider.get(), balanceCacheProvider.get(), refreshBalanceUseCaseProvider.get());
+  }
+
+  public static ServiceDetailViewModel_Factory create(
+      Provider<CredentialRepository> credentialRepositoryProvider,
+      Provider<BalanceCache> balanceCacheProvider,
+      Provider<RefreshBalanceUseCase> refreshBalanceUseCaseProvider) {
+    return new ServiceDetailViewModel_Factory(credentialRepositoryProvider, balanceCacheProvider, refreshBalanceUseCaseProvider);
+  }
+
+  public static ServiceDetailViewModel newInstance(CredentialRepository credentialRepository,
+      BalanceCache balanceCache, RefreshBalanceUseCase refreshBalanceUseCase) {
+    return new ServiceDetailViewModel(credentialRepository, balanceCache, refreshBalanceUseCase);
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/servicedetail/ServiceDetailViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.rainy.token.ui.servicedetail;
+
+import androidx.lifecycle.ViewModel;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.components.ViewModelComponent;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.LazyClassKey;
+import javax.annotation.processing.Generated;
+
+@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
+@OriginatingElement(
+    topLevelClass = ServiceDetailViewModel.class
+)
+public final class ServiceDetailViewModel_HiltModules {
+  private ServiceDetailViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(ServiceDetailViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(ServiceDetailViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(ServiceDetailViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/servicedetail/ServiceDetailViewModel_HiltModules_BindsModule_Binds_LazyMapKey.java

@@ -0,0 +1,28 @@
+package com.rainy.token.ui.servicedetail;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.IdentifierNameString;
+import dagger.internal.KeepFieldType;
+import javax.annotation.processing.Generated;
+
+@IdentifierNameString
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class ServiceDetailViewModel_HiltModules_BindsModule_Binds_LazyMapKey {
+  @KeepFieldType
+  static ServiceDetailViewModel keepFieldType;
+
+  public static String lazyClassKeyName = "com.rainy.token.ui.servicedetail.ServiceDetailViewModel";
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/servicedetail/ServiceDetailViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,42 @@
+package com.rainy.token.ui.servicedetail;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class ServiceDetailViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static ServiceDetailViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return ServiceDetailViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    static final ServiceDetailViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new ServiceDetailViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/servicedetail/ServiceDetailViewModel_HiltModules_KeyModule_Provide_LazyMapKey.java

@@ -0,0 +1,28 @@
+package com.rainy.token.ui.servicedetail;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.IdentifierNameString;
+import dagger.internal.KeepFieldType;
+import javax.annotation.processing.Generated;
+
+@IdentifierNameString
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class ServiceDetailViewModel_HiltModules_KeyModule_Provide_LazyMapKey {
+  @KeepFieldType
+  static ServiceDetailViewModel keepFieldType;
+
+  public static String lazyClassKeyName = "com.rainy.token.ui.servicedetail.ServiceDetailViewModel";
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/settings/CredentialEditViewModel_Factory.java

@@ -0,0 +1,62 @@
+package com.rainy.token.ui.settings;
+
+import com.rainy.token.data.repository.CredentialRepository;
+import com.rainy.token.data.repository.OpenCodeGoRepository;
+import com.rainy.token.domain.usecase.RefreshBalanceUseCase;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class CredentialEditViewModel_Factory implements Factory<CredentialEditViewModel> {
+  private final Provider<CredentialRepository> credentialRepositoryProvider;
+
+  private final Provider<OpenCodeGoRepository> openCodeGoRepositoryProvider;
+
+  private final Provider<RefreshBalanceUseCase> refreshBalanceUseCaseProvider;
+
+  private CredentialEditViewModel_Factory(
+      Provider<CredentialRepository> credentialRepositoryProvider,
+      Provider<OpenCodeGoRepository> openCodeGoRepositoryProvider,
+      Provider<RefreshBalanceUseCase> refreshBalanceUseCaseProvider) {
+    this.credentialRepositoryProvider = credentialRepositoryProvider;
+    this.openCodeGoRepositoryProvider = openCodeGoRepositoryProvider;
+    this.refreshBalanceUseCaseProvider = refreshBalanceUseCaseProvider;
+  }
+
+  @Override
+  public CredentialEditViewModel get() {
+    return newInstance(credentialRepositoryProvider.get(), openCodeGoRepositoryProvider, refreshBalanceUseCaseProvider);
+  }
+
+  public static CredentialEditViewModel_Factory create(
+      Provider<CredentialRepository> credentialRepositoryProvider,
+      Provider<OpenCodeGoRepository> openCodeGoRepositoryProvider,
+      Provider<RefreshBalanceUseCase> refreshBalanceUseCaseProvider) {
+    return new CredentialEditViewModel_Factory(credentialRepositoryProvider, openCodeGoRepositoryProvider, refreshBalanceUseCaseProvider);
+  }
+
+  public static CredentialEditViewModel newInstance(CredentialRepository credentialRepository,
+      javax.inject.Provider<OpenCodeGoRepository> openCodeGoRepositoryProvider,
+      javax.inject.Provider<RefreshBalanceUseCase> refreshBalanceUseCaseProvider) {
+    return new CredentialEditViewModel(credentialRepository, openCodeGoRepositoryProvider, refreshBalanceUseCaseProvider);
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/settings/CredentialEditViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.rainy.token.ui.settings;
+
+import androidx.lifecycle.ViewModel;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.components.ViewModelComponent;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.LazyClassKey;
+import javax.annotation.processing.Generated;
+
+@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
+@OriginatingElement(
+    topLevelClass = CredentialEditViewModel.class
+)
+public final class CredentialEditViewModel_HiltModules {
+  private CredentialEditViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(CredentialEditViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(CredentialEditViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(CredentialEditViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/settings/CredentialEditViewModel_HiltModules_BindsModule_Binds_LazyMapKey.java

@@ -0,0 +1,28 @@
+package com.rainy.token.ui.settings;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.IdentifierNameString;
+import dagger.internal.KeepFieldType;
+import javax.annotation.processing.Generated;
+
+@IdentifierNameString
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class CredentialEditViewModel_HiltModules_BindsModule_Binds_LazyMapKey {
+  @KeepFieldType
+  static CredentialEditViewModel keepFieldType;
+
+  public static String lazyClassKeyName = "com.rainy.token.ui.settings.CredentialEditViewModel";
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/settings/CredentialEditViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,42 @@
+package com.rainy.token.ui.settings;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class CredentialEditViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static CredentialEditViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return CredentialEditViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    static final CredentialEditViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new CredentialEditViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/settings/CredentialEditViewModel_HiltModules_KeyModule_Provide_LazyMapKey.java

@@ -0,0 +1,28 @@
+package com.rainy.token.ui.settings;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.IdentifierNameString;
+import dagger.internal.KeepFieldType;
+import javax.annotation.processing.Generated;
+
+@IdentifierNameString
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class CredentialEditViewModel_HiltModules_KeyModule_Provide_LazyMapKey {
+  @KeepFieldType
+  static CredentialEditViewModel keepFieldType;
+
+  public static String lazyClassKeyName = "com.rainy.token.ui.settings.CredentialEditViewModel";
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/settings/SettingsViewModel_Factory.java

@@ -0,0 +1,47 @@
+package com.rainy.token.ui.settings;
+
+import com.rainy.token.data.repository.CredentialRepository;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class SettingsViewModel_Factory implements Factory<SettingsViewModel> {
+  private final Provider<CredentialRepository> credentialRepositoryProvider;
+
+  private SettingsViewModel_Factory(Provider<CredentialRepository> credentialRepositoryProvider) {
+    this.credentialRepositoryProvider = credentialRepositoryProvider;
+  }
+
+  @Override
+  public SettingsViewModel get() {
+    return newInstance(credentialRepositoryProvider.get());
+  }
+
+  public static SettingsViewModel_Factory create(
+      Provider<CredentialRepository> credentialRepositoryProvider) {
+    return new SettingsViewModel_Factory(credentialRepositoryProvider);
+  }
+
+  public static SettingsViewModel newInstance(CredentialRepository credentialRepository) {
+    return new SettingsViewModel(credentialRepository);
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/settings/SettingsViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.rainy.token.ui.settings;
+
+import androidx.lifecycle.ViewModel;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.components.ViewModelComponent;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.LazyClassKey;
+import javax.annotation.processing.Generated;
+
+@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
+@OriginatingElement(
+    topLevelClass = SettingsViewModel.class
+)
+public final class SettingsViewModel_HiltModules {
+  private SettingsViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(SettingsViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(SettingsViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(SettingsViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/settings/SettingsViewModel_HiltModules_BindsModule_Binds_LazyMapKey.java

@@ -0,0 +1,28 @@
+package com.rainy.token.ui.settings;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.IdentifierNameString;
+import dagger.internal.KeepFieldType;
+import javax.annotation.processing.Generated;
+
+@IdentifierNameString
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class SettingsViewModel_HiltModules_BindsModule_Binds_LazyMapKey {
+  @KeepFieldType
+  static SettingsViewModel keepFieldType;
+
+  public static String lazyClassKeyName = "com.rainy.token.ui.settings.SettingsViewModel";
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/settings/SettingsViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,42 @@
+package com.rainy.token.ui.settings;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class SettingsViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static SettingsViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return SettingsViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    static final SettingsViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new SettingsViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/settings/SettingsViewModel_HiltModules_KeyModule_Provide_LazyMapKey.java

@@ -0,0 +1,28 @@
+package com.rainy.token.ui.settings;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.IdentifierNameString;
+import dagger.internal.KeepFieldType;
+import javax.annotation.processing.Generated;
+
+@IdentifierNameString
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class SettingsViewModel_HiltModules_KeyModule_Provide_LazyMapKey {
+  @KeepFieldType
+  static SettingsViewModel keepFieldType;
+
+  public static String lazyClassKeyName = "com.rainy.token.ui.settings.SettingsViewModel";
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/webview/WebViewLoginViewModel_Factory.java

@@ -0,0 +1,47 @@
+package com.rainy.token.ui.webview;
+
+import com.rainy.token.data.repository.WebViewSessionSaver;
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.Provider;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class WebViewLoginViewModel_Factory implements Factory<WebViewLoginViewModel> {
+  private final Provider<WebViewSessionSaver> sessionSaverProvider;
+
+  private WebViewLoginViewModel_Factory(Provider<WebViewSessionSaver> sessionSaverProvider) {
+    this.sessionSaverProvider = sessionSaverProvider;
+  }
+
+  @Override
+  public WebViewLoginViewModel get() {
+    return newInstance(sessionSaverProvider.get());
+  }
+
+  public static WebViewLoginViewModel_Factory create(
+      Provider<WebViewSessionSaver> sessionSaverProvider) {
+    return new WebViewLoginViewModel_Factory(sessionSaverProvider);
+  }
+
+  public static WebViewLoginViewModel newInstance(WebViewSessionSaver sessionSaver) {
+    return new WebViewLoginViewModel(sessionSaver);
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/webview/WebViewLoginViewModel_HiltModules.java

@@ -0,0 +1,51 @@
+package com.rainy.token.ui.webview;
+
+import androidx.lifecycle.ViewModel;
+import dagger.Binds;
+import dagger.Module;
+import dagger.Provides;
+import dagger.hilt.InstallIn;
+import dagger.hilt.android.components.ActivityRetainedComponent;
+import dagger.hilt.android.components.ViewModelComponent;
+import dagger.hilt.android.internal.lifecycle.HiltViewModelMap;
+import dagger.hilt.codegen.OriginatingElement;
+import dagger.multibindings.IntoMap;
+import dagger.multibindings.LazyClassKey;
+import javax.annotation.processing.Generated;
+
+@Generated("dagger.hilt.android.processor.internal.viewmodel.ViewModelProcessor")
+@OriginatingElement(
+    topLevelClass = WebViewLoginViewModel.class
+)
+public final class WebViewLoginViewModel_HiltModules {
+  private WebViewLoginViewModel_HiltModules() {
+  }
+
+  @Module
+  @InstallIn(ViewModelComponent.class)
+  public abstract static class BindsModule {
+    private BindsModule() {
+    }
+
+    @Binds
+    @IntoMap
+    @LazyClassKey(WebViewLoginViewModel.class)
+    @HiltViewModelMap
+    public abstract ViewModel binds(WebViewLoginViewModel vm);
+  }
+
+  @Module
+  @InstallIn(ActivityRetainedComponent.class)
+  public static final class KeyModule {
+    private KeyModule() {
+    }
+
+    @Provides
+    @IntoMap
+    @LazyClassKey(WebViewLoginViewModel.class)
+    @HiltViewModelMap.KeySet
+    public static boolean provide() {
+      return true;
+    }
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/webview/WebViewLoginViewModel_HiltModules_BindsModule_Binds_LazyMapKey.java

@@ -0,0 +1,28 @@
+package com.rainy.token.ui.webview;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.IdentifierNameString;
+import dagger.internal.KeepFieldType;
+import javax.annotation.processing.Generated;
+
+@IdentifierNameString
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class WebViewLoginViewModel_HiltModules_BindsModule_Binds_LazyMapKey {
+  @KeepFieldType
+  static WebViewLoginViewModel keepFieldType;
+
+  public static String lazyClassKeyName = "com.rainy.token.ui.webview.WebViewLoginViewModel";
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/webview/WebViewLoginViewModel_HiltModules_KeyModule_ProvideFactory.java

@@ -0,0 +1,42 @@
+package com.rainy.token.ui.webview;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.Factory;
+import dagger.internal.QualifierMetadata;
+import dagger.internal.ScopeMetadata;
+import javax.annotation.processing.Generated;
+
+@ScopeMetadata
+@QualifierMetadata("dagger.hilt.android.internal.lifecycle.HiltViewModelMap.KeySet")
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class WebViewLoginViewModel_HiltModules_KeyModule_ProvideFactory implements Factory<Boolean> {
+  @Override
+  public Boolean get() {
+    return provide();
+  }
+
+  public static WebViewLoginViewModel_HiltModules_KeyModule_ProvideFactory create() {
+    return InstanceHolder.INSTANCE;
+  }
+
+  public static boolean provide() {
+    return WebViewLoginViewModel_HiltModules.KeyModule.provide();
+  }
+
+  private static final class InstanceHolder {
+    static final WebViewLoginViewModel_HiltModules_KeyModule_ProvideFactory INSTANCE = new WebViewLoginViewModel_HiltModules_KeyModule_ProvideFactory();
+  }
+}

app/build/generated/ksp/debug/java/com/rainy/token/ui/webview/WebViewLoginViewModel_HiltModules_KeyModule_Provide_LazyMapKey.java

@@ -0,0 +1,28 @@
+package com.rainy.token.ui.webview;
+
+import dagger.internal.DaggerGenerated;
+import dagger.internal.IdentifierNameString;
+import dagger.internal.KeepFieldType;
+import javax.annotation.processing.Generated;
+
+@IdentifierNameString
+@DaggerGenerated
+@Generated(
+    value = "dagger.internal.codegen.ComponentProcessor",
+    comments = "https://dagger.dev"
+)
+@SuppressWarnings({
+    "unchecked",
+    "rawtypes",
+    "KotlinInternal",
+    "KotlinInternalInJava",
+    "cast",
+    "deprecation",
+    "nullness:initialization.field.uninitialized"
+})
+public final class WebViewLoginViewModel_HiltModules_KeyModule_Provide_LazyMapKey {
+  @KeepFieldType
+  static WebViewLoginViewModel keepFieldType;
+
+  public static String lazyClassKeyName = "com.rainy.token.ui.webview.WebViewLoginViewModel";
+}

app/build/generated/ksp/debug/java/dagger/hilt/internal/aggregatedroot/codegen/_com_rainy_token_RainyTokenApplication.java

@@ -0,0 +1,23 @@
+package dagger.hilt.internal.aggregatedroot.codegen;
+
+import dagger.hilt.android.HiltAndroidApp;
+import dagger.hilt.internal.aggregatedroot.AggregatedRoot;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedRoot(
+    root = "com.rainy.token.RainyTokenApplication",
+    rootPackage = "com.rainy.token",
+    originatingRoot = "com.rainy.token.RainyTokenApplication",
+    originatingRootPackage = "com.rainy.token",
+    rootAnnotation = HiltAndroidApp.class,
+    rootComponentPackage = "dagger.hilt.components",
+    rootSimpleNames = "RainyTokenApplication",
+    originatingRootSimpleNames = "RainyTokenApplication",
+    rootComponentSimpleNames = "SingletonComponent"
+)
+@Generated("dagger.hilt.processor.internal.root.AggregatedRootGenerator")
+public class _com_rainy_token_RainyTokenApplication {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_MainActivity_GeneratedInjector.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ActivityComponent",
+    entryPoints = "com.rainy.token.MainActivity_GeneratedInjector"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_MainActivity_GeneratedInjector {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_RainyTokenApplication_GeneratedInjector.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.components.SingletonComponent",
+    entryPoints = "com.rainy.token.RainyTokenApplication_GeneratedInjector"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_RainyTokenApplication_GeneratedInjector {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_di_NetworkModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.components.SingletonComponent",
+    modules = "com.rainy.token.di.NetworkModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_di_NetworkModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_di_StorageModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.components.SingletonComponent",
+    modules = "com.rainy.token.di.StorageModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_di_StorageModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_dashboard_DashboardViewModel_HiltModules_BindsModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ViewModelComponent",
+    modules = "com.rainy.token.ui.dashboard.DashboardViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_dashboard_DashboardViewModel_HiltModules_BindsModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_dashboard_DashboardViewModel_HiltModules_KeyModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ActivityRetainedComponent",
+    modules = "com.rainy.token.ui.dashboard.DashboardViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_dashboard_DashboardViewModel_HiltModules_KeyModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_dashboard_UsageChartViewModel_HiltModules_BindsModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ViewModelComponent",
+    modules = "com.rainy.token.ui.dashboard.UsageChartViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_dashboard_UsageChartViewModel_HiltModules_BindsModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_dashboard_UsageChartViewModel_HiltModules_KeyModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ActivityRetainedComponent",
+    modules = "com.rainy.token.ui.dashboard.UsageChartViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_dashboard_UsageChartViewModel_HiltModules_KeyModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_dashboard_UsageDataViewModel_HiltModules_BindsModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ViewModelComponent",
+    modules = "com.rainy.token.ui.dashboard.UsageDataViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_dashboard_UsageDataViewModel_HiltModules_BindsModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_dashboard_UsageDataViewModel_HiltModules_KeyModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ActivityRetainedComponent",
+    modules = "com.rainy.token.ui.dashboard.UsageDataViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_dashboard_UsageDataViewModel_HiltModules_KeyModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_dashboard_UsageViewModel_HiltModules_BindsModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ViewModelComponent",
+    modules = "com.rainy.token.ui.dashboard.UsageViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_dashboard_UsageViewModel_HiltModules_BindsModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_dashboard_UsageViewModel_HiltModules_KeyModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ActivityRetainedComponent",
+    modules = "com.rainy.token.ui.dashboard.UsageViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_dashboard_UsageViewModel_HiltModules_KeyModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_servicedetail_ServiceDetailViewModel_HiltModules_BindsModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ViewModelComponent",
+    modules = "com.rainy.token.ui.servicedetail.ServiceDetailViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_servicedetail_ServiceDetailViewModel_HiltModules_BindsModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_servicedetail_ServiceDetailViewModel_HiltModules_KeyModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ActivityRetainedComponent",
+    modules = "com.rainy.token.ui.servicedetail.ServiceDetailViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_servicedetail_ServiceDetailViewModel_HiltModules_KeyModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_settings_CredentialEditViewModel_HiltModules_BindsModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ViewModelComponent",
+    modules = "com.rainy.token.ui.settings.CredentialEditViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_settings_CredentialEditViewModel_HiltModules_BindsModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_settings_CredentialEditViewModel_HiltModules_KeyModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ActivityRetainedComponent",
+    modules = "com.rainy.token.ui.settings.CredentialEditViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_settings_CredentialEditViewModel_HiltModules_KeyModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_settings_SettingsViewModel_HiltModules_BindsModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ViewModelComponent",
+    modules = "com.rainy.token.ui.settings.SettingsViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_settings_SettingsViewModel_HiltModules_BindsModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_settings_SettingsViewModel_HiltModules_KeyModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ActivityRetainedComponent",
+    modules = "com.rainy.token.ui.settings.SettingsViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_settings_SettingsViewModel_HiltModules_KeyModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_webview_WebViewLoginViewModel_HiltModules_BindsModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ViewModelComponent",
+    modules = "com.rainy.token.ui.webview.WebViewLoginViewModel_HiltModules.BindsModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_webview_WebViewLoginViewModel_HiltModules_BindsModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_webview_WebViewLoginViewModel_HiltModules_KeyModule.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.android.components.ActivityRetainedComponent",
+    modules = "com.rainy.token.ui.webview.WebViewLoginViewModel_HiltModules.KeyModule"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_webview_WebViewLoginViewModel_HiltModules_KeyModule {
+}

app/build/generated/ksp/debug/java/hilt_aggregated_deps/_com_rainy_token_ui_widget_WidgetRefreshEntryPoint.java

@@ -0,0 +1,15 @@
+package hilt_aggregated_deps;
+
+import dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps;
+import javax.annotation.processing.Generated;
+
+/**
+ * This class should only be referenced by generated code! This class aggregates information across multiple compilations.
+ */
+@AggregatedDeps(
+    components = "dagger.hilt.components.SingletonComponent",
+    entryPoints = "com.rainy.token.ui.widget.WidgetRefreshEntryPoint"
+)
+@Generated("dagger.hilt.processor.internal.aggregateddeps.AggregatedDepsGenerator")
+public class _com_rainy_token_ui_widget_WidgetRefreshEntryPoint {
+}

app/build/generated/ksp/debug/resources/META-INF/proguard/com_rainy_token_ui_dashboard_DashboardViewModel_HiltModules_BindsModule_LazyClassKeys.pro

@@ -0,0 +1 @@
+-keep,allowobfuscation,allowshrinking class com.rainy.token.ui.dashboard.DashboardViewModel