fix(proxy): 测试按区域选凭据不再误用默认账号；签到成功/已签即时落本地记录

- 详情页主余额与首页卡片新增「美元用量额度」行（basic_usage_limit/used）
- 账户信息卡同步展示已用/总额美元额度
- 设备已实测：Free plan / $0.00 / $1.00 + 月请求配额

.github/workflows/ci.yml

@@ -0,0 +1,129 @@
+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,24 +10,31 @@ jobs:
     permissions:
       contents: write
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-java@v4
+      - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262  # v4
+      - uses: actions/setup-java@cf277c60eb25467037889841efdb72551f06f6c3  # v4
         with:
           java-version: '17'
           distribution: 'temurin'
-      - uses: android-actions/setup-android@v3
+      - uses: android-actions/setup-android@9fc6c4e9069bf8d3d10b2204b1fb8f6ef7065407  # 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@v2
+      - uses: softprops/action-gh-release@3bb12739c298aeb8a4eeaf626c5b8d85266b0e65  # v2
         with:
           name: "🎉 RainyToken ${{ github.ref_name }}"
           files: RainyToken-${{ github.ref_name }}.apk

.gitignore

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

AGENTS.md

@@ -1,98 +1,5 @@
-# 雨晴Token — AI 余额查询 APP
+任务开始前必须先读取 taste.md（协作偏好），任务全程遵守其中约定，包括：修改后派发独立 subagent 审计（无阻断问题 + 无影响用户体验问题），修复后用同一个 subagent 复审。
 
-## 项目概述
+未经用户允许禁止提交推送
 
-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` |
+派发子代理任务（独立审计/探索/通用 subagent）时，prompt 中涉及工作区文件的所有路径必须使用完整绝对路径（以工作区根目录为前缀）。子代理没有工作区附着上下文，相对路径会导致其找不到文件或无法执行。

LICENSE

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,238 @@
+# 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,52 +1,239 @@
 # 🌧️ 雨晴Token (RainyToken)
 
-> *"AI 用量，尽在掌握"* 🐱✨
+> *"AI 用量，尽在掌握 — 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 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 的余额/配额。
+---
 
-## 功能
+## 📸 截图
 
-- 📊 仪表盘：DeepSeek 余额（¥）+ OpenCode Go 用量（5h/本周/本月）+ 下拉全局刷新
-- 📈 用量图表：消耗金额 / API 请求次数 / Token 消耗（3 张 Canvas 图表，支持多粒度筛选）
-- 📋 详细数据：原始记录分页浏览，时间+模型筛选，原始数据弹窗
-- 🧩 桌面小组件：不打开 APP 也能看用量
-- 🔄 自动同步：首页下拉自动同步用量；无缓存时启动自动全量同步
-- 🎀 雨晴粉色调 UI
+<p align="center">
+  <img src="docs/screenshots/dashboard-light.jpg" width="200" alt="仪表盘（亮色）" />
+  <img src="docs/screenshots/dashboard-dark.jpg" width="200" alt="仪表盘（深色）" />
+  <img src="docs/screenshots/detail.jpg" width="200" alt="用量图表" />
+  <img src="docs/screenshots/ollama-detail.jpg" width="200" alt="Ollama 模型调用次数" />
+</p>
 
-## 构建
+<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
-export ANDROID_HOME=$HOME/Android
-export JAVA_HOME=/usr/lib/jvm/java-17-openjdk-arm64
+# 运行单元测试
+./gradlew testDebugUnitTest
+
+# 构建 Debug APK
 ./gradlew assembleDebug
+# APK 输出：app/build/outputs/apk/debug/app-debug.apk
+
+# 构建 Release APK
+./gradlew assembleRelease
 ```
 
-APK 输出：`app/build/outputs/apk/debug/app-debug.apk`
-
-## 技术栈
-
-Kotlin + Jetpack Compose + Material 3 · Hilt + KSP · Retrofit + OkHttp · DataStore · minSdk=31
-
-## 项目结构
+<details>
+<summary>🔧 ARM64 环境说明（非必需）</summary>
 
+项目内置了 ARM64 AAPT2 二进制，在 Proot/Termux 等 ARM64 环境中自动启用：
+```bash
+chmod +x ./setup_android_env.sh
+./setup_android_env.sh
 ```
-com.rainy.token/
-├── data/
-│   ├── cache/          # BalanceCache（DataStore）
-│   ├── local/          # UsageCache（DataStore + 内存缓存）、UsageRecord、ChartBucket
-│   ├── remote/         # DeepSeekApi（Retrofit）+ OpenCodeGo 抓取 + OpenCodeUsageRepository
-│   └── repository/     # DeepSeekRepository / OpenCodeGoRepository / CredentialRepository
-├── domain/
-│   ├── model/          # ServiceBalance、Credential 等
-│   ├── service/        # ServiceType 枚举
-│   └── usecase/        # RefreshBalanceUseCase / SyncUsageUseCase
-├── ui/
-│   ├── dashboard/      # DashboardScreen、UsageDetailScreen（图表）、UsageOverviewScreen（总统计）、UsageDataScreen（原始数据）
-│   ├── widget/         # 桌面小组件（OpenCodeGoWidgetProvider）
-│   └── theme/          # 雨晴粉主题
-└── di/                 # Hilt 模块
-```
+该脚本会配置 `$ANDROID_HOME` 并使用项目内置的 ARM64 build-tools。
+
+**Release 构建额外配置**：ARM64 Proot 下 AGP 9.0 的 `optimizeReleaseResources` 传入 `--resource-path-shortening-map=<path>` 等号参数，ARM64 AAPT2 不接受此语法，需在 `~/.gradle/gradle.properties`（全局，不提交项目仓库）中配置 AAPT2 wrapper：
+```properties
+android.aapt2FromMavenOverride=/path/to/android-aapt2-wrapper/aapt2
+```
+wrapper 脚本将等号形式拆分为空格分隔的两个独立 argv。项目 `build.gradle.kts` 中已内置 `guardReleaseResources` 任务作为构建防护（optimized `.ap_` 缺失时自动 fallback 到 linked `.ap_`）。
+> 在 x86_64 环境（GitHub Actions / 普通 Linux）中会自动走官方 AAPT2，无需额外操作。
+</details>
+
+---
+
+## 📦 依赖管理
+
+项目使用 Gradle Version Catalog (`gradle/libs.versions.toml`) 统一管理依赖。
+
+| 依赖 | 用途 |
+|------|------|
+| `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,3 +1,5 @@
+import java.io.File
+
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.compose)
@@ -14,8 +16,8 @@ android {
         applicationId = "com.rainy.token"
         minSdk = 31
         targetSdk = 35
-        versionCode = 1
-        versionName = "1.0"
+        versionCode = 44
+        versionName = "1.7.24"
 
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
         vectorDrawables {
@@ -25,10 +27,40 @@ android {
 
     signingConfigs {
         create("release") {
-            storeFile = rootProject.file("release.jks")
-            storePassword = System.getenv("KEYSTORE_PASSWORD") ?: "RainyToken2026!"
-            keyAlias = System.getenv("KEYSTORE_ALIAS") ?: "rainy"
-            keyPassword = System.getenv("KEY_PASSWORD") ?: "RainyToken2026!"
+            // CI 环境没有 release.jks，自动 fallback 到 debug keystore
+            // Release workflow 通过 Secret 注入 release.jks
+            val keystoreFile = rootProject.file("release.jks")
+            if (keystoreFile.exists()) {
+                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。"
+                    )
+                }
+            }
         }
     }
 
@@ -45,12 +77,18 @@ 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 {
@@ -59,6 +97,84 @@ 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 {
@@ -74,6 +190,7 @@ 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)
@@ -85,6 +202,7 @@ 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)
@@ -95,7 +213,12 @@ 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)
@@ -108,6 +231,11 @@ 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

@@ -1,809 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,265 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

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