diff --git a/.claude/settings.local.json b/.claude/settings.local.json new file mode 100644 index 0000000..ab12185 --- /dev/null +++ b/.claude/settings.local.json @@ -0,0 +1,17 @@ +{ + "permissions": { + "allow": [ + "Bash(cargo check:*)", + "Bash(curl:*)", + "Bash(cargo build:*)", + "Bash(pkill:*)", + "Bash(jq:*)", + "Bash(timeout 10 curl:*)", + "Bash(cat:*)", + "Bash(timeout 35 curl:*)", + "Bash(npm run build:*)", + "WebFetch(domain:localhost)", + "Bash(cargo test:*)" + ] + } +} diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..6f3ca82 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,183 @@ +name: Release + +on: + push: + tags: + - 'v*' + workflow_dispatch: + inputs: + version: + description: 'Version to release (e.g., 0.1.0)' + required: true + type: string + +env: + CARGO_TERM_COLOR: always + +jobs: + build-frontend: + name: Build Frontend + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Setup pnpm + uses: pnpm/action-setup@v4 + with: + version: 9 + + - name: Setup Node.js + uses: actions/setup-node@v4 + with: + node-version: '22' + cache: 'pnpm' + cache-dependency-path: frontend/pnpm-lock.yaml + + - name: Install dependencies + working-directory: frontend + run: pnpm install --frozen-lockfile + + - name: Build frontend + working-directory: frontend + run: pnpm build + + - name: Create frontend zip + working-directory: frontend + run: | + cd out + zip -r ../frontend.zip . + + - name: Upload frontend artifact + uses: actions/upload-artifact@v4 + with: + name: frontend + path: frontend/frontend.zip + + build-cli: + name: Build CLI (${{ matrix.target }}) + runs-on: ${{ matrix.os }} + strategy: + matrix: + include: + - target: x86_64-apple-darwin + os: macos-latest + name: opencode-studio-darwin-x86_64 + - target: aarch64-apple-darwin + os: macos-latest + name: opencode-studio-darwin-arm64 + - target: x86_64-unknown-linux-gnu + os: ubuntu-latest + name: opencode-studio-linux-x86_64 + steps: + - uses: actions/checkout@v4 + + - name: Install Rust toolchain + uses: dtolnay/rust-action@stable + with: + targets: ${{ matrix.target }} + + - name: Cache cargo registry + uses: actions/cache@v4 + with: + path: | + ~/.cargo/registry + ~/.cargo/git + target + key: ${{ runner.os }}-${{ matrix.target }}-cargo-${{ hashFiles('**/Cargo.lock') }} + restore-keys: | + ${{ runner.os }}-${{ matrix.target }}-cargo- + + - name: Build CLI + run: cargo build --release --package opencode-studio --target ${{ matrix.target }} + + - name: Package binary (Unix) + run: | + mkdir -p dist + cp target/${{ matrix.target }}/release/opencode-studio dist/${{ matrix.name }} + chmod +x dist/${{ matrix.name }} + cd dist && tar -czvf ${{ matrix.name }}.tar.gz ${{ matrix.name }} + + - name: Upload CLI artifact + uses: actions/upload-artifact@v4 + with: + name: ${{ matrix.name }} + path: dist/${{ matrix.name }}.tar.gz + + release: + name: Create Release + needs: [build-frontend, build-cli] + runs-on: ubuntu-latest + permissions: + contents: write + steps: + - uses: actions/checkout@v4 + + - name: Download all artifacts + uses: actions/download-artifact@v4 + with: + path: artifacts + + - name: Prepare release assets + run: | + mkdir -p release + cp artifacts/frontend/frontend.zip release/ + cp artifacts/opencode-studio-darwin-x86_64/opencode-studio-darwin-x86_64.tar.gz release/ + cp artifacts/opencode-studio-darwin-arm64/opencode-studio-darwin-arm64.tar.gz release/ + cp artifacts/opencode-studio-linux-x86_64/opencode-studio-linux-x86_64.tar.gz release/ + ls -la release/ + + - name: Get version + id: version + run: | + if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then + echo "version=${{ inputs.version }}" >> $GITHUB_OUTPUT + else + echo "version=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT + fi + + - name: Create Release + uses: softprops/action-gh-release@v2 + with: + tag_name: v${{ steps.version.outputs.version }} + name: OpenCode Studio v${{ steps.version.outputs.version }} + draft: false + prerelease: false + files: | + release/frontend.zip + release/opencode-studio-darwin-x86_64.tar.gz + release/opencode-studio-darwin-arm64.tar.gz + release/opencode-studio-linux-x86_64.tar.gz + body: | + ## OpenCode Studio v${{ steps.version.outputs.version }} + + ### Installation + + **macOS (Apple Silicon)** + ```bash + curl -L https://github.com/${{ github.repository }}/releases/download/v${{ steps.version.outputs.version }}/opencode-studio-darwin-arm64.tar.gz | tar xz + sudo mv opencode-studio-darwin-arm64 /usr/local/bin/opencode-studio + ``` + + **macOS (Intel)** + ```bash + curl -L https://github.com/${{ github.repository }}/releases/download/v${{ steps.version.outputs.version }}/opencode-studio-darwin-x86_64.tar.gz | tar xz + sudo mv opencode-studio-darwin-x86_64 /usr/local/bin/opencode-studio + ``` + + **Linux (x86_64)** + ```bash + curl -L https://github.com/${{ github.repository }}/releases/download/v${{ steps.version.outputs.version }}/opencode-studio-linux-x86_64.tar.gz | tar xz + sudo mv opencode-studio-linux-x86_64 /usr/local/bin/opencode-studio + ``` + + ### Usage + + ```bash + # Navigate to any git/jj project and run: + opencode-studio + ``` + + The CLI will automatically: + 1. Initialize `.opencode-studio/` directory + 2. Download the frontend app (first run only) + 3. Start the server and open your browser diff --git a/.opencode-studio/config.toml b/.opencode-studio/config.toml new file mode 100644 index 0000000..d3137d0 --- /dev/null +++ b/.opencode-studio/config.toml @@ -0,0 +1,6 @@ +[project] +name = "opencode-os" + +[server] +port = 3001 +opencode_url = "http://localhost:4096" diff --git a/.opencode-studio/kanban/plans/02c83e72-f9d4-413a-a341-6995ff757a82.md b/.opencode-studio/kanban/plans/02c83e72-f9d4-413a-a341-6995ff757a82.md new file mode 100644 index 0000000..92a45fd --- /dev/null +++ b/.opencode-studio/kanban/plans/02c83e72-f9d4-413a-a341-6995ff757a82.md @@ -0,0 +1,218 @@ +# Implementation Plan: Watch Idle + +**Task ID:** 02c83e72-f9d4-413a-a341-6995ff757a82 +**Title:** Watch idle +**Description:** x +**Generated:** 2025-01-01T01:36:13+01:00 + +## 1. Technical Analysis + +### Problem Statement +The task "Watch idle" with minimal description requires interpretation. Based on OpenCode Studio's architecture, this likely involves implementing idle detection and management for: +- Long-running OpenCode sessions that have become unresponsive +- Tasks stuck in intermediate states (Planning, InProgress, etc.) +- System resources monitoring for idle cleanup +- Session timeout management + +### Current System Context +- **Task Lifecycle:** TODO → PLANNING → PLANNING_REVIEW → IN_PROGRESS → AI_REVIEW → REVIEW → DONE +- **Session Management:** Each phase runs as separate OpenCode session +- **Event System:** `tokio::broadcast` event bus for real-time updates +- **Persistence:** SQLite database with task/session tracking +- **Known Issue:** Tasks timing out after 30s in `POST /api/tasks/{id}/execute` + +### Proposed Solution +Implement an **Idle Watch Service** that: +1. **Session Monitoring:** Detect OpenCode sessions running longer than threshold +2. **Task State Monitoring:** Identify tasks stuck in intermediate states +3. **Health Checks:** Periodic validation of OpenCode connectivity +4. **Cleanup Actions:** Automatic timeout handling and resource cleanup +5. **Notifications:** Event emission for idle state changes + +## 2. Files to Modify/Create + +### New Files +``` +crates/orchestrator/src/idle_watch.rs # Core idle monitoring logic +crates/orchestrator/src/idle_config.rs # Configuration structures +crates/server/src/routes/idle.rs # Idle management API endpoints +migrations/003_idle_tracking.sql # Database schema updates +``` + +### Files to Modify +``` +crates/orchestrator/src/lib.rs # Export new modules +crates/orchestrator/src/executor.rs # Integrate idle monitoring +crates/orchestrator/Cargo.toml # Add tokio-cron-scheduler dependency +crates/server/src/lib.rs # Register idle routes +crates/server/src/routes/mod.rs # Add idle module +crates/core/src/domain/session.rs # Add idle-related fields +crates/core/src/domain/task.rs # Add last_activity timestamp +crates/db/src/models/session.rs # Database model updates +crates/db/src/repositories/session_repository.rs # Idle queries +crates/events/src/types.rs # New idle events +``` + +## 3. Step-by-Step Implementation + +### Phase 1: Data Model Updates (30 min) +1. **Database Migration** + - Add `last_activity` timestamp to tasks table + - Add `idle_since` timestamp to sessions table + - Add `idle_threshold_minutes` configuration table + +2. **Domain Model Updates** + - Extend `Task` struct with idle tracking fields + - Extend `Session` struct with idle metadata + - Add `IdleStatus` enum: `Active`, `Idle`, `TimedOut` + +### Phase 2: Core Idle Detection (1 hour) +3. **Idle Watch Service (`idle_watch.rs`)** + ```rust + pub struct IdleWatchService { + db: Arc, + event_bus: EventBus, + config: IdleConfig, + } + + impl IdleWatchService { + pub async fn start_monitoring(&self) -> Result<(), Error> + pub async fn check_idle_sessions(&self) -> Result, Error> + pub async fn check_idle_tasks(&self) -> Result, Error> + pub async fn handle_idle_session(&self, session: &Session) -> Result<(), Error> + } + ``` + +4. **Configuration Management (`idle_config.rs`)** + ```rust + #[derive(Debug, Clone)] + pub struct IdleConfig { + pub session_idle_threshold: Duration, + pub task_idle_threshold: Duration, + pub check_interval: Duration, + pub auto_timeout_enabled: bool, + } + ``` + +### Phase 3: Scheduler Integration (45 min) +5. **Background Task Scheduler** + - Use `tokio-cron-scheduler` for periodic checks + - Default: check every 30 seconds + - Configurable via environment variables + +6. **Event Integration** + - Add `SessionIdle`, `SessionTimedOut`, `TaskIdle` events + - Emit through existing EventBus + - Update SSE streams to include idle events + +### Phase 4: API Endpoints (30 min) +7. **REST API (`routes/idle.rs`)** + ``` + GET /api/idle/sessions # List idle sessions + GET /api/idle/tasks # List idle tasks + POST /api/idle/timeout/{id} # Force timeout specific session + GET /api/idle/config # Get idle configuration + PUT /api/idle/config # Update idle configuration + ``` + +### Phase 5: Integration & Testing (45 min) +8. **Executor Integration** + - Update `run_full_cycle()` to track activity timestamps + - Add heartbeat mechanism for long-running operations + - Handle idle detection during OpenCode execution + +9. **Database Queries** + - Add `find_idle_sessions(threshold: Duration)` + - Add `find_idle_tasks(threshold: Duration)` + - Add `update_activity_timestamp(id: Uuid)` + +10. **Unit Tests** + - Idle detection logic tests + - Configuration parsing tests + - Database query tests + - Event emission tests + +## 4. Potential Risks + +### High Risk +- **Unclear Requirements:** Minimal task description requires assumptions +- **False Positives:** Legitimate long-running tasks marked as idle +- **Resource Cleanup:** Risk of prematurely terminating valid sessions +- **Database Locks:** Concurrent access during idle checks vs. normal operations + +### Medium Risk +- **Performance Impact:** Additional periodic database queries +- **Configuration Complexity:** Threshold tuning for different task types +- **Event Flooding:** Too frequent idle checks generating excessive events + +### Low Risk +- **Dependency Addition:** `tokio-cron-scheduler` increases binary size +- **API Surface Expansion:** New endpoints require documentation + +### Mitigation Strategies +1. **Gradual Rollout:** Start with monitoring-only mode, no automatic actions +2. **Configurable Thresholds:** Per-task-type idle timeouts +3. **Manual Override:** Always allow human intervention to prevent timeouts +4. **Comprehensive Logging:** Detailed audit trail for idle detection decisions +5. **Circuit Breaker:** Disable idle monitoring if system is under heavy load + +## 5. Estimated Complexity + +**Size:** **M (Medium)** + +### Justification +- **Lines of Code:** ~400-500 lines across multiple files +- **New Concepts:** Idle detection patterns, background scheduling +- **Integration Points:** 4 crates (orchestrator, server, core, db) +- **Database Changes:** Minor schema additions +- **Testing Effort:** ~10-15 unit tests required +- **Time Estimate:** 3-4 hours development + 1 hour testing + +### Complexity Factors +- **Low Complexity:** Well-defined async patterns in existing codebase +- **Medium Complexity:** Background scheduling, event integration +- **No High Complexity:** No major architectural changes required + +## Dependencies + +### New Dependencies +```toml +# crates/orchestrator/Cargo.toml +[dependencies] +tokio-cron-scheduler = "0.10" +``` + +### Environment Variables +```bash +IDLE_SESSION_TIMEOUT_MINUTES=60 +IDLE_TASK_TIMEOUT_MINUTES=120 +IDLE_CHECK_INTERVAL_SECONDS=30 +IDLE_AUTO_TIMEOUT_ENABLED=false +``` + +## Success Criteria + +1. **Functional** + - ✅ Detect sessions idle > threshold + - ✅ Detect tasks idle > threshold + - ✅ Emit appropriate events + - ✅ API endpoints respond correctly + - ✅ Background scheduler runs reliably + +2. **Performance** + - ✅ Idle checks complete in <100ms + - ✅ No more than 5% CPU overhead + - ✅ Database queries use appropriate indexes + +3. **Integration** + - ✅ All existing tests pass + - ✅ No clippy warnings + - ✅ SSE events include idle notifications + - ✅ OpenCode sessions properly tracked + +## Notes + +- **Assumption:** "Watch idle" means monitoring for unresponsive sessions/tasks +- **Alternative Interpretations:** Could also mean "watch when system is idle" for maintenance tasks +- **Follow-up Required:** Clarification needed on specific idle detection requirements +- **Implementation Order:** Start with monitoring/logging before implementing automatic timeouts \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/116942a0-0ca8-4215-a242-3573d7493df8.md b/.opencode-studio/kanban/plans/116942a0-0ca8-4215-a242-3573d7493df8.md new file mode 100644 index 0000000..1b261cd --- /dev/null +++ b/.opencode-studio/kanban/plans/116942a0-0ca8-4215-a242-3573d7493df8.md @@ -0,0 +1,236 @@ +# Implementation Plan: Transition Test + +**Task ID**: 116942a0-0ca8-4215-a242-3573d7493df8 +**Title**: Transition Test +**Description**: Testing status transitions +**Created**: 2025-12-31T19:55:51Z + +## Technical Analysis + +### Current State Assessment + +OpenCode Studio implements a comprehensive task lifecycle state machine with 7 distinct states: + +``` +TODO → PLANNING → PLANNING_REVIEW → IN_PROGRESS → AI_REVIEW → REVIEW → DONE +``` + +**Existing Infrastructure:** +- **State Machine**: `crates/orchestrator/src/state_machine.rs` - Full transition validation logic +- **API Endpoints**: `crates/server/src/routes/tasks.rs` - `/api/tasks/{id}/transition` endpoint +- **Domain Models**: `crates/core/src/domain/task.rs` - TaskStatus enum with serialization +- **Event System**: SSE events for `task.status_changed` notifications +- **Current Tests**: 4 basic state machine unit tests (transition validation) + +**Gaps Identified:** +1. **Missing Integration Tests**: No end-to-end API testing for transitions +2. **Insufficient Edge Case Coverage**: Limited testing of error scenarios +3. **No Concurrency Testing**: Parallel transition attempts untested +4. **Missing Event Validation**: SSE event emission not verified +5. **No Database State Testing**: Task persistence during transitions not validated + +### Technical Dependencies + +- **Core Crates**: `opencode_core`, `orchestrator`, `server`, `db`, `events` +- **Testing Infrastructure**: Standard Rust `#[cfg(test)]` inline modules +- **API Framework**: Axum with OpenAPI/utoipa integration +- **Database**: SQLite with sqlx (async ORM) +- **Event Bus**: tokio::broadcast for SSE events + +## Files to Modify/Create + +### New Test Files +1. **`crates/orchestrator/src/state_machine_integration_tests.rs`** + - Comprehensive integration tests for state machine + - Multi-step transition sequences + - Error condition testing + +2. **`crates/server/src/routes/tasks_integration_tests.rs`** + - HTTP API endpoint testing + - Request/response validation + - Authentication/authorization edge cases + +3. **`crates/db/src/repositories/task_repository_transition_tests.rs`** + - Database persistence during transitions + - Concurrent update scenarios + - Transaction isolation testing + +### Modified Existing Files +1. **`crates/orchestrator/src/state_machine.rs`** + - Expand existing unit tests + - Add property-based testing + - Include stress testing scenarios + +2. **`crates/server/src/routes/tasks.rs`** + - Enhance error handling validation + - Add transition logging verification + - Improve event emission testing + +3. **`crates/core/src/domain/task.rs`** + - Add helper methods for test data generation + - Include transition history tracking (if needed) + +## Step-by-Step Implementation + +### Phase 1: Enhanced Unit Testing (1-2 hours) +1. **Expand State Machine Tests** + - Add comprehensive transition matrix validation + - Test all valid forward/backward transitions + - Validate all invalid transition rejections + - Add edge cases (same-state transitions, null checks) + +2. **Property-Based Testing** + - Generate random transition sequences + - Verify state machine invariants + - Test transition idempotency where applicable + +### Phase 2: Integration Testing (2-3 hours) +3. **API Integration Tests** + - Create test harness for HTTP endpoints + - Test complete transition workflows (TODO→DONE) + - Validate JSON serialization/deserialization + - Test error response formats and HTTP status codes + +4. **Database Integration Tests** + - Test task persistence during transitions + - Verify `updated_at` timestamp changes + - Test transaction rollback on failures + - Validate concurrent transition attempts + +### Phase 3: Event System Testing (1-2 hours) +5. **SSE Event Validation** + - Verify `TaskStatusChanged` events are emitted + - Test event payload format and content + - Validate event delivery timing + - Test event subscription/unsubscription + +6. **Event Bus Integration** + - Test event propagation across modules + - Verify event ordering guarantees + - Test event delivery failure scenarios + +### Phase 4: End-to-End Workflow Testing (2-3 hours) +7. **Complete Lifecycle Tests** + - Test full TODO→DONE automation flow + - Include OpenCode session integration + - Test human approval workflows + - Validate file generation (plans, reviews) + +8. **Error Recovery Testing** + - Test transition failures and rollbacks + - Validate system state consistency + - Test retry mechanisms + - Error logging and monitoring verification + +### Phase 5: Performance & Stress Testing (1-2 hours) +9. **Concurrency Testing** + - Multiple simultaneous transitions on different tasks + - Race condition detection + - Database lock testing + - Event bus throughput validation + +10. **Load Testing** + - High-frequency transition requests + - Memory usage monitoring + - Database connection pool testing + - SSE connection scaling + +## Potential Risks + +### High Risk +- **Database Corruption**: Concurrent transitions could corrupt task state +- **Event Loss**: SSE events might be lost during high load +- **State Inconsistency**: Orchestrator and database could diverge + +### Medium Risk +- **Test Flakiness**: Async nature might cause intermittent test failures +- **Performance Degradation**: New tests might slow CI pipeline +- **Mock Complexity**: OpenCode client mocking might be complex + +### Low Risk +- **Test Maintenance**: Additional tests require ongoing maintenance +- **Code Coverage**: Might reveal gaps in existing code coverage + +## Mitigation Strategies + +1. **Database Safety** + - Use database transactions for multi-step operations + - Implement proper locking mechanisms + - Add comprehensive rollback testing + +2. **Event Reliability** + - Implement event persistence for critical events + - Add retry mechanisms for event delivery + - Test event ordering guarantees + +3. **Test Stability** + - Use deterministic test data + - Implement proper async test patterns + - Add timeout handling for long-running tests + +4. **Performance Monitoring** + - Add benchmarks for critical paths + - Monitor test execution time + - Implement parallel test execution where safe + +## Success Criteria + +### Functional Requirements +- ✅ All valid transitions work correctly +- ✅ All invalid transitions are properly rejected +- ✅ Events are emitted for all status changes +- ✅ Database state remains consistent +- ✅ API responses are correctly formatted + +### Quality Requirements +- ✅ Test coverage >95% for transition-related code +- ✅ All tests complete within 30 seconds +- ✅ Zero flaky test failures +- ✅ Clean `cargo clippy` and `cargo fmt` output + +### Performance Requirements +- ✅ Single transition completes within 100ms +- ✅ 100 concurrent transitions complete within 5 seconds +- ✅ Memory usage remains stable during stress tests + +## Estimated Complexity: **MEDIUM (M)** + +### Justification +- **Scope**: Focused on existing functionality, not new features +- **Technical Depth**: Requires understanding of multiple system components +- **Integration Complexity**: Must test across database, API, and event systems +- **Time Estimate**: 8-12 hours total development time +- **Risk Level**: Medium due to concurrency and state management concerns + +### Complexity Breakdown +- **State Machine Logic**: Simple (well-defined state transitions) +- **API Testing**: Medium (HTTP integration complexity) +- **Database Testing**: Medium (transaction and concurrency concerns) +- **Event Testing**: Medium (async event propagation) +- **Integration Testing**: Complex (multiple system components) + +## Implementation Notes + +### Testing Strategy +- Prefer integration tests over mocking where possible +- Use real SQLite database for persistence testing +- Mock only external dependencies (OpenCode API) +- Implement proper test isolation and cleanup + +### Code Quality +- Follow existing project conventions (inline `#[cfg(test)]` modules) +- Maintain clippy compliance (`-D warnings`) +- Use proper error handling (`Result` patterns) +- Include comprehensive documentation for complex test scenarios + +### Future Considerations +- Consider adding transition audit logging +- Evaluate need for transition rate limiting +- Plan for eventual transition webhooks/notifications +- Consider adding transition analytics/metrics + +--- + +**Plan Status**: Ready for Implementation +**Next Step**: Begin Phase 1 - Enhanced Unit Testing +**Estimated Total Time**: 8-12 hours \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/15e199e2-08ad-4e67-af50-131803ca5edb.md b/.opencode-studio/kanban/plans/15e199e2-08ad-4e67-af50-131803ca5edb.md new file mode 100644 index 0000000..3faa91d --- /dev/null +++ b/.opencode-studio/kanban/plans/15e199e2-08ad-4e67-af50-131803ca5edb.md @@ -0,0 +1,343 @@ +# Implementation Plan: Capture Test + +**Task ID**: 15e199e2-08ad-4e67-af50-131803ca5edb +**Title**: Capture test +**Description**: Capture raw events +**Created**: 2026-01-01T00:36:13Z + +## Technical Analysis + +### Current State Assessment + +OpenCode Studio implements a sophisticated event-driven architecture with the following components: + +**Existing Event Infrastructure:** +- **Event Bus**: `crates/events/src/bus.rs` - tokio::broadcast-based pub/sub system +- **Event Types**: `crates/events/src/types.rs` - 13 event types covering tasks, sessions, workspaces, projects +- **SSE Events**: Server-Sent Events for real-time frontend updates via `/api/events` +- **OpenCode Events**: `crates/orchestrator/src/opencode_events.rs` - Real-time OpenCode session monitoring +- **Event Count**: 8 existing tests in events crate, 108+ tests across workspace + +**Event Flow Architecture:** +``` +EventBus (tokio::broadcast) → SSE Stream → Frontend + ↑ ↑ +Orchestrator Server Routes + ↑ ↑ +Task Lifecycle HTTP API Endpoints +``` + +**Current Event Types:** +- Task events: created, updated, status_changed +- Session events: started, ended, agent.message, tool.execution +- Workspace events: created, merged, deleted +- Project events: opened, closed +- System events: errors + +**Gaps Identified:** +1. **No Event Capture Mechanism**: Events flow through broadcast channels but aren't persisted +2. **Testing Limitations**: No way to capture events during test runs for verification +3. **No Debugging Support**: Can't replay or analyze event sequences +4. **Missing Event History**: Events are ephemeral - no historical data +5. **No Event Filtering**: Cannot selectively capture specific event types + +### Technical Requirements + +The "Capture test" task appears to require implementing raw event capture functionality for: +- **Test Verification**: Capturing events during test runs to validate behavior +- **Debugging Support**: Recording event sequences for post-mortem analysis +- **Development Tools**: Event replay and inspection capabilities +- **Quality Assurance**: Ensuring all expected events are emitted + +### Architecture Decision + +Implement an **EventCapture** system that can: +1. Subscribe to the EventBus and record all events +2. Filter events by type, task_id, or time range +3. Persist captured events for later analysis +4. Provide replay capabilities for testing +5. Integrate with existing test infrastructure + +## Files to Modify/Create + +### New Core Files + +1. **`crates/events/src/capture.rs`** (NEW) + - `EventCapture` struct with configurable filtering + - `CaptureConfig` for filtering options + - `CapturedEvent` struct with metadata + - In-memory and persistent storage options + +2. **`crates/events/src/storage.rs`** (NEW) + - `EventStorage` trait for pluggable backends + - `MemoryEventStorage` for tests + - `FileEventStorage` for development/debugging + - `DatabaseEventStorage` for production (optional) + +### Database Extensions + +3. **`crates/db/migrations/002_event_capture.sql`** (NEW) + - `captured_events` table schema + - Indexes for efficient querying by type, timestamp, task_id + +4. **`crates/db/src/models/captured_event.rs`** (NEW) + - `CapturedEvent` model for database persistence + - Serialization/deserialization logic + +5. **`crates/db/src/repositories/event_repository.rs`** (NEW) + - Database CRUD operations for captured events + - Query methods with filtering support + +### Test Infrastructure + +6. **`crates/events/src/test_utils.rs`** (NEW) + - `EventCaptureTester` utility for test scenarios + - Helper macros for event assertions + - Test fixtures and mock data + +7. **`crates/orchestrator/src/executor_test_capture.rs`** (NEW) + - Integration tests using event capture + - Validate task lifecycle events are emitted correctly + - Test OpenCode session event capture + +### API Extensions + +8. **`crates/server/src/routes/events_capture.rs`** (NEW) + - `/api/events/capture/start` - Start capturing + - `/api/events/capture/stop` - Stop and return captured events + - `/api/events/capture/history` - Query historical events + - `/api/events/capture/replay` - Replay event sequence (dev only) + +### Modified Files + +9. **`crates/events/src/lib.rs`** + - Export new capture and storage modules + - Add feature flags for capture functionality + +10. **`crates/events/src/bus.rs`** + - Add optional capture integration + - Capture subscription management + +11. **`crates/server/src/lib.rs`** + - Include new events capture routes in OpenAPI schema + +12. **`crates/db/src/lib.rs`** + - Export new captured_event model and repository + +13. **`crates/orchestrator/src/executor.rs`** + - Optional event capture integration for development + - Capture configuration via environment variables + +## Step-by-Step Implementation Steps + +### Phase 1: Core Capture Infrastructure (Day 1-2) + +1. **Create Core Capture Module** + ```rust + // crates/events/src/capture.rs + pub struct EventCapture { + config: CaptureConfig, + storage: Box, + subscription: Option>, + } + ``` + +2. **Implement Storage Abstraction** + ```rust + // crates/events/src/storage.rs + #[async_trait] + pub trait EventStorage: Send + Sync { + async fn store(&mut self, event: CapturedEvent) -> Result<(), EventCaptureError>; + async fn query(&self, filter: EventFilter) -> Result, EventCaptureError>; + async fn clear(&mut self) -> Result<(), EventCaptureError>; + } + ``` + +3. **Add Memory Storage Implementation** + - `MemoryEventStorage` using `Vec` + - Thread-safe access with `Arc>>` + - Filtering and querying logic + +4. **Create CapturedEvent Model** + ```rust + pub struct CapturedEvent { + pub id: Uuid, + pub captured_at: DateTime, + pub event_envelope: EventEnvelope, + pub context: Option, // Additional debug info + } + ``` + +### Phase 2: Database Integration (Day 2-3) + +5. **Database Schema Migration** + ```sql + CREATE TABLE captured_events ( + id TEXT PRIMARY KEY, + captured_at DATETIME NOT NULL, + event_id TEXT NOT NULL, + event_type TEXT NOT NULL, + event_timestamp DATETIME NOT NULL, + event_data TEXT NOT NULL, -- JSON serialized EventEnvelope + task_id TEXT, + session_id TEXT, + context TEXT + ); + ``` + +6. **Database Models and Repository** + - Implement `CapturedEvent` sqlx model + - Create `EventRepository` with async methods + - Add filtering and pagination support + +7. **File Storage Implementation** + - `FileEventStorage` using JSONL format + - Rotation and cleanup policies + - Compression support for large captures + +### Phase 3: Test Infrastructure (Day 3-4) + +8. **Create Test Utilities** + ```rust + // crates/events/src/test_utils.rs + pub struct EventCaptureTester { + capture: EventCapture, + bus: EventBus, + } + + impl EventCaptureTester { + pub async fn assert_event_emitted(&self, predicate: F) + where F: Fn(&Event) -> bool; + + pub async fn assert_event_sequence(&self, expected: Vec); + } + ``` + +9. **Integration Test Suite** + - Test task lifecycle events are captured correctly + - Test OpenCode session events are captured + - Test event filtering and querying + - Test concurrent capture scenarios + +10. **Test Helper Macros** + ```rust + assert_event_captured!(capture, Event::TaskCreated { task_id, .. }); + assert_events_in_sequence!(capture, [ + Event::TaskCreated { .. }, + Event::TaskStatusChanged { .. } + ]); + ``` + +### Phase 4: API Integration (Day 4-5) + +11. **REST API Endpoints** + ```rust + POST /api/events/capture/start + { + "filter": { + "event_types": ["task.created", "task.status_changed"], + "task_id": "optional-uuid", + "duration_seconds": 300 + } + } + ``` + +12. **Server Integration** + - Add capture routes to server + - Integrate with existing SSE infrastructure + - Add authorization/permissions for capture endpoints + +13. **OpenAPI Documentation** + - Document all capture endpoints + - Add response schemas for captured events + - Include filtering parameter documentation + +### Phase 5: Advanced Features (Day 5-6) + +14. **Event Replay System** + - `EventReplayer` for recreating event sequences + - Timeline reconstruction capabilities + - Development/debugging tools + +15. **Configuration Management** + ```rust + pub struct CaptureConfig { + pub enabled: bool, + pub storage_type: StorageType, + pub max_events: Option, + pub retention_days: Option, + pub filter: EventFilter, + } + ``` + +16. **Performance Optimizations** + - Async batch writing for high-volume scenarios + - Background cleanup tasks + - Memory usage monitoring and limits + +### Phase 6: Testing and Documentation (Day 6-7) + +17. **Comprehensive Test Suite** + - Unit tests for all capture components + - Integration tests with real EventBus + - Performance tests for high event volumes + - Error condition and edge case tests + +18. **Documentation and Examples** + - Usage examples in code comments + - Integration guide for test developers + - Performance tuning recommendations + +## Potential Risks + +### Technical Risks +- **Performance Impact**: Event capture could slow down the EventBus + - **Mitigation**: Make capture optional, use async processing, implement batching + +- **Memory Usage**: Large event captures could consume excessive memory + - **Mitigation**: Implement size limits, streaming to disk, background cleanup + +- **Storage Scaling**: Database/file storage could grow large over time + - **Mitigation**: Retention policies, compression, archival strategies + +### Integration Risks +- **Test Flakiness**: Async event capture might introduce timing issues in tests + - **Mitigation**: Proper synchronization, deterministic test helpers + +- **Breaking Changes**: Adding capture might affect existing event flow + - **Mitigation**: Feature flags, backward compatibility, thorough testing + +### Development Risks +- **Complexity Creep**: Feature could become overcomplicated + - **Mitigation**: Start with minimal viable implementation, iterate + +- **Maintenance Burden**: Additional code to maintain and debug + - **Mitigation**: Good test coverage, clear documentation, simple design + +## Estimated Complexity: **L (Large)** + +### Justification +- **Multiple Crates Modified**: events, db, server, orchestrator (4 crates) +- **Database Schema Changes**: New table, migration, repository layer +- **New API Surface**: REST endpoints with filtering and querying +- **Complex Testing**: Integration tests across multiple components +- **Storage Abstractions**: Multiple storage backends to implement +- **Performance Considerations**: Async processing, memory management + +### Complexity Breakdown +- **Core Capture Logic**: M (Medium) - Event subscription and filtering +- **Storage Layer**: M (Medium) - Multiple storage implementations +- **Database Integration**: M (Medium) - Schema, models, repositories +- **API Layer**: S (Small) - Standard REST endpoints +- **Test Infrastructure**: L (Large) - Complex integration testing +- **Documentation**: S (Small) - Standard documentation tasks + +**Total Estimated Time**: 6-7 days for experienced Rust developer + +### Dependencies +- Requires understanding of existing EventBus architecture +- Database migration expertise (SQLite/sqlx) +- Async Rust patterns for performance +- Test infrastructure knowledge for integration tests + +This implementation will provide comprehensive event capture capabilities for testing, debugging, and development scenarios while maintaining performance and backward compatibility. \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/1e29f7ae-7ddb-45db-b3f7-474e24f8744f.md b/.opencode-studio/kanban/plans/1e29f7ae-7ddb-45db-b3f7-474e24f8744f.md new file mode 100644 index 0000000..38faf84 --- /dev/null +++ b/.opencode-studio/kanban/plans/1e29f7ae-7ddb-45db-b3f7-474e24f8744f.md @@ -0,0 +1,370 @@ +# Implementation Plan: Execute Test - Enhanced Testing & Issue Resolution + +**Task ID:** 1e29f7ae-7ddb-45db-b3f7-474e24f8744f +**Title:** Execute Test +**Description:** Test task execution with OpenCode +**Created:** 2025-12-31 19:55 +**Updated:** 2025-12-31 19:55 (Enhanced with recent findings) +**Estimated Complexity:** L (Large - due to critical issue resolution) + +## 1. Technical Analysis + +### Critical Issues Identified (Recent Testing) +Based on comprehensive E2E testing conducted previously: + +1. **🚨 Execution Timeout Issue** + - `POST /api/tasks/{id}/execute` times out after 30 seconds + - Endpoint blocks during execution instead of returning immediately + - **Root Cause**: Synchronous execution pattern in API handler + +2. **🚨 Status Synchronization Failure** + - Task status remains 'todo' in Studio DB despite OpenCode completion + - OpenCode successfully creates sessions and modifies files (confirmed: 300 additions, 59 deletions) + - **Root Cause**: Status update mechanism not working after OpenCode completion + +3. **🚨 Empty Session Activity** + - `/api/sessions/{id}/activity` endpoint returns empty data + - SSE events may not be properly captured + - **Root Cause**: Activity store not properly populated + +4. **✅ Confirmed Working** + - OpenCode integration creates sessions successfully + - File modifications occur as expected + - SSE events for `task.status_changed` and `session.started` work + - AGENTS.md generation works correctly + +### Architecture Assessment +Current execution flow: +``` +API Request → executor.execute_phase() → [BLOCKS] → OpenCode Session → File Changes → Status Update Fails +``` + +Required flow: +``` +API Request → Start Background Task → Immediate Response +Background: executor.execute_phase() → OpenCode Session → File Changes → Status Update → SSE Events +``` + +## 2. Files to Modify/Create + +### Critical Fixes Required +| File | Issue | Required Change | +|------|-------|-----------------| +| `crates/server/src/routes/tasks.rs` | 30s timeout | Convert to async background execution | +| `crates/orchestrator/src/executor.rs` | Status sync failure | Add proper status update callbacks | +| `crates/db/src/repositories/session_repository.rs` | Empty activity | Implement activity tracking | +| `crates/orchestrator/src/activity_store.rs` | SSE data missing | Fix activity capture and storage | + +### New Test Files +| File | Purpose | +|------|---------| +| `tests/e2e/critical_execution_flow.rs` | E2E test reproducing timeout/status issues | +| `crates/orchestrator/tests/executor_async_test.rs` | Async execution pattern testing | +| `crates/server/tests/execution_timeout_test.rs` | API timeout behavior testing | + +### Supporting Infrastructure +| File | Purpose | +|------|---------| +| `crates/server/src/background_tasks.rs` | Background task management (NEW) | +| `crates/events/src/task_events.rs` | Enhanced task event definitions | + +## 3. Step-by-Step Implementation + +### Phase 1: Fix Critical Timeout Issue (High Priority - 2-3 hours) + +1. **Create Background Task Infrastructure** + ```rust + // crates/server/src/background_tasks.rs + pub struct BackgroundTaskManager { + pub task_handles: Arc>>>>, + } + + impl BackgroundTaskManager { + pub async fn execute_task_async(&self, task_id: TaskId) -> Result<(), Error> + pub async fn get_execution_status(&self, task_id: TaskId) -> ExecutionStatus + } + ``` + +2. **Refactor Task Execution Endpoint** + ```rust + // crates/server/src/routes/tasks.rs - CRITICAL CHANGE + pub async fn execute_task( + Path(task_id): Path, + State(app_state): State, + ) -> Result, AppError> { + // OLD: let result = executor.execute_phase(&task).await; // BLOCKS! + + // NEW: Start background execution + let task_manager = &app_state.background_tasks; + task_manager.execute_task_async(task_id).await?; + + // Return immediately with execution started status + Ok(Json(ExecuteResponse { + task_id, + status: "execution_started".to_string(), + message: "Task execution started in background".to_string(), + })) + } + ``` + +3. **Test Timeout Fix** + ```rust + #[tokio::test] + async fn test_execute_returns_immediately() { + let response = client.post(format!("/api/tasks/{}/execute", task_id)).send().await; + + // Should return within 100ms, not 30+ seconds + assert!(response.status().is_success()); + assert_eq!(response.json::().await.status, "execution_started"); + } + ``` + +### Phase 2: Fix Status Synchronization (High Priority - 2-3 hours) + +4. **Add Status Update Callbacks to Executor** + ```rust + // crates/orchestrator/src/executor.rs - CRITICAL FIX + impl TaskExecutor { + pub async fn execute_phase_with_callbacks( + &self, + task: &Task, + status_callback: Box, + ) -> Result { + // Existing execution logic... + + // CRITICAL: Add status updates at each phase transition + match task.status { + TaskStatus::Todo => { + status_callback(TaskStatus::Planning); + // Execute planning... + status_callback(TaskStatus::PlanningReview); + } + TaskStatus::InProgress => { + // Execute implementation... + status_callback(TaskStatus::AiReview); + } + // etc. + } + } + } + ``` + +5. **Integrate Status Updates in Background Task** + ```rust + // Background task implementation + let status_callback = { + let task_repo = app_state.task_repository.clone(); + let event_bus = app_state.event_bus.clone(); + + Box::new(move |new_status: TaskStatus| { + // Update database + task_repo.update_task_status(task_id, new_status).await?; + + // Emit SSE event + event_bus.emit(TaskEvent::StatusChanged { task_id, new_status }).await?; + }) + }; + + executor.execute_phase_with_callbacks(&task, status_callback).await?; + ``` + +6. **Test Status Updates Work** + ```rust + #[tokio::test] + async fn test_status_updates_during_execution() { + // Start task execution + // Poll task status endpoint + // Verify status progression: Todo → Planning → PlanningReview → etc. + // Verify final status is not stuck at 'todo' + } + ``` + +### Phase 3: Fix Session Activity Tracking (Medium Priority - 2 hours) + +7. **Debug Activity Store Population** + ```rust + // crates/orchestrator/src/activity_store.rs - DEBUG + impl SessionActivityRegistry { + pub fn record_activity(&mut self, session_id: &str, activity: ActivityMessage) { + tracing::info!("Recording activity for session {}: {:?}", session_id, activity); + // Existing logic + debug logging + } + } + ``` + +8. **Fix Session Activity Endpoint** + ```rust + // Investigate why /api/sessions/{id}/activity returns empty + // Add proper activity capture during OpenCode session execution + // Ensure activity store is properly connected to executor + ``` + +### Phase 4: Comprehensive E2E Testing (Medium Priority - 2-3 hours) + +9. **Create Full Execution Test** + ```rust + #[tokio::test] + async fn test_full_task_execution_e2e() { + // 1. Create task via API + // 2. Start execution (should return immediately) + // 3. Poll status until completion + // 4. Verify OpenCode session was created + // 5. Verify file changes occurred + // 6. Verify final status is 'done' or appropriate end state + // 7. Verify session activity was captured + } + ``` + +10. **Test Concurrent Executions** + ```rust + #[tokio::test] + async fn test_multiple_concurrent_executions() { + // Start 5 tasks simultaneously + // Verify all execute without interfering + // Verify proper resource isolation + } + ``` + +### Phase 5: Performance & Monitoring (Low Priority - 1-2 hours) + +11. **Add Execution Monitoring** + - Metrics for execution duration + - Status update success/failure tracking + - OpenCode integration health monitoring + +12. **Load Testing** + - Test 10+ concurrent task executions + - Monitor memory usage and performance + - Verify database connection pooling works + +## 4. Potential Risks + +### Critical Risks (High Impact) +| Risk | Impact | Mitigation | +|------|--------|------------| +| **Background task crashes** | Task stuck in limbo | Add task timeout and recovery mechanisms | +| **Database transaction deadlock** | Status updates fail | Use proper transaction isolation and retry logic | +| **Memory leaks from long tasks** | Server instability | Implement task cleanup and resource limits | +| **OpenCode session orphaning** | Resources not cleaned up | Add session cleanup on task completion/failure | + +### Medium Risks +| Risk | Impact | Mitigation | +|------|--------|------------| +| **SSE connection failures** | UI not updated | Add connection retry and fallback polling | +| **VCS operation conflicts** | File corruption | Use proper locking and atomic operations | +| **Activity store corruption** | Lost execution logs | Add data validation and backup mechanisms | + +## 5. Estimated Complexity: L (Large) + +### Reasoning +- **Multiple critical issues** requiring architectural changes +- **Background execution** is a significant paradigm shift +- **Status synchronization** touches multiple systems (DB, events, OpenCode) +- **Testing complexity** requires E2E scenarios and race condition testing +- **Risk assessment** shows multiple high-impact failure modes + +### Time Breakdown +| Phase | Effort | Priority | +|-------|--------|----------| +| Fix timeout (async execution) | 2-3 hours | 🚨 Critical | +| Fix status synchronization | 2-3 hours | 🚨 Critical | +| Fix session activity | 2 hours | ⚠️ High | +| E2E testing | 2-3 hours | ⚠️ High | +| Performance & monitoring | 1-2 hours | ℹ️ Medium | +| **Total** | **9-13 hours** | | + +## 6. Success Criteria + +### Critical (Must Fix) +- [ ] `POST /api/tasks/{id}/execute` returns within 500ms +- [ ] Task status correctly progresses through lifecycle +- [ ] Task status updates are persisted to database +- [ ] Final task status reflects actual OpenCode completion +- [ ] No 30-second timeouts during normal operation + +### High Priority +- [ ] `/api/sessions/{id}/activity` returns populated data +- [ ] SSE events are emitted for all status changes +- [ ] Multiple concurrent executions work without interference +- [ ] OpenCode sessions are properly created and tracked + +### Medium Priority +- [ ] Comprehensive test coverage for new execution flow +- [ ] Performance metrics and monitoring in place +- [ ] Documentation updated with new architecture +- [ ] Error handling for all edge cases + +## 7. Testing Strategy + +### Critical Path Testing +```rust +// Test the exact scenario that failed before +#[tokio::test] +async fn test_reproduce_timeout_issue() { + // This test MUST pass to confirm fix + let start = Instant::now(); + let response = execute_task_api(task_id).await; + let duration = start.elapsed(); + + assert!(duration < Duration::from_millis(500)); // No more 30s timeouts! + assert_eq!(response.status, "execution_started"); +} + +#[tokio::test] +async fn test_reproduce_status_sync_issue() { + // This test MUST pass to confirm fix + execute_task_api(task_id).await; + + // Poll until completion (with reasonable timeout) + let final_status = poll_task_status_until_complete(task_id).await; + assert_ne!(final_status, TaskStatus::Todo); // Must not remain 'todo'! +} +``` + +### Regression Testing +- All existing tests must continue to pass +- Performance must not degrade for other operations +- UI must continue to work with new async execution model + +## 8. Rollback Plan + +### Immediate Rollback (if critical failures) +1. **Feature flag**: Disable new async execution, revert to synchronous +2. **Database rollback**: Restore task status update mechanism +3. **Monitor**: Watch for any database corruption or task stuck states + +### Partial Rollback (if some features fail) +- Keep async execution but disable concurrent execution limits +- Fall back to polling for status updates if SSE fails +- Disable session activity tracking if it causes performance issues + +## 9. Implementation Notes + +### Known Technical Debt to Address +- `crates/cli` still uses path dependencies instead of workspace dependencies +- Some clippy warnings may need resolution after changes +- OpenCode SDK integration may need error handling improvements + +### Integration Points to Verify +- **Frontend**: Ensure UI handles new async execution responses properly +- **SSE**: Verify frontend receives status update events +- **Database**: Confirm transaction isolation works with background tasks +- **VCS**: Ensure workspace operations don't conflict with concurrent executions + +--- + +**Next Steps:** +1. **IMMEDIATE**: Start with Phase 1 (timeout fix) - highest priority +2. **URGENT**: Implement Phase 2 (status sync) - critical for user experience +3. **HIGH**: Complete Phase 3 (activity tracking) - important for debugging +4. **VALIDATE**: Run comprehensive E2E tests to confirm all fixes work + +**Dependencies:** +- OpenCode server must be available for testing +- SQLite database for integration testing +- VCS operations (jj/git) for workspace testing + +**Success Metrics:** +- Zero execution timeouts during normal operation +- 100% status update success rate +- Sub-second API response times for execution requests \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/3173e278-12a5-4a29-b667-1b25d9883f7a.md b/.opencode-studio/kanban/plans/3173e278-12a5-4a29-b667-1b25d9883f7a.md new file mode 100644 index 0000000..0d1b83f --- /dev/null +++ b/.opencode-studio/kanban/plans/3173e278-12a5-4a29-b667-1b25d9883f7a.md @@ -0,0 +1,256 @@ +# Implementation Plan: Capture Idle + +**Task ID:** 3173e278-12a5-4a29-b667-1b25d9883f7a +**Title:** Capture idle +**Description:** x +**Created:** 2025-01-01T01:36:13Z + +## Technical Analysis + +### Problem Interpretation +Given the minimal description "x", this task is interpreted as implementing idle state detection and management within OpenCode Studio. This involves: + +1. **Session Idle Detection**: Identifying OpenCode sessions that have been inactive +2. **Task Idle Detection**: Detecting tasks stuck in intermediate states +3. **Resource Cleanup**: Automatically handling idle resources to prevent resource leaks +4. **Monitoring & Metrics**: Tracking idle states for system health + +### System Context +OpenCode Studio orchestrates AI-powered development tasks through: +- Task lifecycle: `TODO → PLANNING → PLANNING_REVIEW → IN_PROGRESS → AI_REVIEW → REVIEW → DONE` +- OpenCode session management for each phase +- SSE events for real-time updates +- VCS workspace management + +### Idle State Scenarios +1. **Hanging Sessions**: OpenCode sessions that start but never complete +2. **Orphaned Tasks**: Tasks in intermediate states without active sessions +3. **Stale Workspaces**: VCS workspaces from abandoned tasks +4. **Resource Leaks**: Accumulated idle processes/connections + +## Files to Modify/Create + +### Core Domain +- `crates/core/src/domain/mod.rs` - Add idle detection traits +- `crates/core/src/domain/idle.rs` - New idle state domain models + +### Database Layer +- `crates/db/migrations/002_idle_tracking.sql` - New migration for idle tracking +- `crates/db/src/models/mod.rs` - Export idle models +- `crates/db/src/models/idle_tracker.rs` - New idle state persistence +- `crates/db/src/repositories/mod.rs` - Export idle repository +- `crates/db/src/repositories/idle_repository.rs` - New idle state queries + +### Orchestrator +- `crates/orchestrator/src/idle_monitor.rs` - New idle detection service +- `crates/orchestrator/src/cleanup.rs` - New cleanup service +- `crates/orchestrator/src/lib.rs` - Export new modules + +### Server API +- `crates/server/src/routes/mod.rs` - Add idle routes +- `crates/server/src/routes/idle.rs` - New idle management endpoints +- `crates/server/src/state.rs` - Add idle monitor to app state + +### Events +- `crates/events/src/types.rs` - Add idle-related events + +### Frontend (Optional) +- `frontend/src/components/monitoring/IdleMonitor.tsx` - New monitoring component +- `frontend/src/api/generated/idle/` - Generated API hooks + +## Step-by-Step Implementation + +### Phase 1: Core Domain & Database (2-3 hours) + +1. **Define Idle Domain Models** + ```rust + // crates/core/src/domain/idle.rs + pub struct IdleSession { + pub session_id: String, + pub task_id: String, + pub last_activity: DateTime, + pub idle_duration: Duration, + pub idle_type: IdleType, + } + + pub enum IdleType { + NoActivity, + UnresponsiveSession, + StuckInPhase, + OrphanedWorkspace, + } + ``` + +2. **Create Database Migration** + ```sql + -- migrations/002_idle_tracking.sql + CREATE TABLE idle_sessions ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + session_id TEXT NOT NULL, + task_id TEXT NOT NULL, + detected_at DATETIME NOT NULL, + last_activity DATETIME NOT NULL, + idle_type TEXT NOT NULL, + resolved BOOLEAN DEFAULT FALSE, + FOREIGN KEY (task_id) REFERENCES tasks(id) + ); + ``` + +3. **Implement Repository Layer** + - Database models and CRUD operations + - Queries for detecting idle patterns + +### Phase 2: Idle Detection Service (3-4 hours) + +4. **Create Idle Monitor Service** + ```rust + // crates/orchestrator/src/idle_monitor.rs + pub struct IdleMonitor { + db: Arc, + event_bus: Arc, + config: IdleConfig, + } + + impl IdleMonitor { + pub async fn scan_for_idle_sessions(&self) -> Result>; + pub async fn detect_hung_tasks(&self) -> Result>; + pub async fn cleanup_idle_resources(&self) -> Result; + } + ``` + +5. **Implement Detection Logic** + - Check for sessions inactive > threshold (e.g., 30 minutes) + - Detect tasks stuck in intermediate states > threshold (e.g., 2 hours) + - Identify orphaned VCS workspaces + +6. **Add Background Monitoring** + - Periodic scanning (every 5 minutes) + - Event-driven detection on session state changes + +### Phase 3: Cleanup & Recovery (2-3 hours) + +7. **Implement Cleanup Service** + ```rust + // crates/orchestrator/src/cleanup.rs + pub struct CleanupService { + workspace_manager: Arc, + opencode_client: Arc, + } + + impl CleanupService { + pub async fn cleanup_idle_session(&self, session_id: &str) -> Result<()>; + pub async fn recover_stuck_task(&self, task_id: &str) -> Result<()>; + pub async fn cleanup_orphaned_workspace(&self, workspace_id: &str) -> Result<()>; + } + ``` + +8. **Add Recovery Strategies** + - Graceful session termination + - Task state reset with notification + - Workspace cleanup with backup + +### Phase 4: API & Events (1-2 hours) + +9. **Create REST Endpoints** + ```rust + // GET /api/idle/sessions - List idle sessions + // POST /api/idle/cleanup - Trigger manual cleanup + // GET /api/idle/stats - Idle statistics + ``` + +10. **Add SSE Events** + ```rust + pub enum IdleEvent { + IdleSessionDetected { session_id: String, idle_type: IdleType }, + CleanupCompleted { cleanup_report: CleanupReport }, + RecoveryAttempted { task_id: String, success: bool }, + } + ``` + +### Phase 5: Integration & Testing (2-3 hours) + +11. **Integrate with Orchestrator** + - Start idle monitor as background service + - Wire into existing executor lifecycle + +12. **Add Configuration** + ```rust + pub struct IdleConfig { + pub session_timeout: Duration, + pub task_timeout: Duration, + pub scan_interval: Duration, + pub auto_cleanup: bool, + } + ``` + +13. **Write Comprehensive Tests** + - Unit tests for detection logic + - Integration tests for cleanup scenarios + - Mock OpenCode client responses + +### Phase 6: Frontend Integration (Optional - 1-2 hours) + +14. **Create Monitoring UI** + - Real-time idle session display + - Manual cleanup triggers + - System health dashboard + +## Potential Risks + +### High Risk +- **Resource Cleanup**: Aggressive cleanup could terminate valid long-running tasks +- **Race Conditions**: Cleanup while session is becoming active +- **Data Loss**: Improper workspace cleanup could lose uncommitted changes + +### Medium Risk +- **False Positives**: Detecting idle when OpenCode is processing +- **Performance**: Frequent scanning could impact database performance +- **Notification Fatigue**: Too many idle alerts + +### Low Risk +- **Configuration Complexity**: Tuning thresholds for different workload patterns +- **Monitoring Overhead**: Additional database storage for tracking + +### Mitigation Strategies +1. **Grace Periods**: Multiple confirmation checks before cleanup +2. **Backup Before Cleanup**: Preserve state before resource cleanup +3. **Manual Override**: Allow users to prevent cleanup of specific sessions +4. **Incremental Rollout**: Start with detection-only, add cleanup gradually +5. **Comprehensive Logging**: Full audit trail of all idle detection and cleanup actions + +## Estimated Complexity: **L (Large)** + +### Breakdown +- **Medium complexity** for core detection logic +- **High complexity** for safe cleanup mechanisms +- **Medium complexity** for integration with existing systems +- **Low complexity** for API and frontend components + +### Reasoning +- Requires careful state management across multiple systems +- Safety-critical cleanup logic needs extensive testing +- Integration with VCS, OpenCode, and database systems +- Moderate amount of new code (~800-1200 lines) +- Significant testing requirements for edge cases + +### Time Estimate +- **Development**: 10-15 hours +- **Testing**: 5-8 hours +- **Integration & Documentation**: 2-3 hours +- **Total**: 17-26 hours + +## Success Criteria + +1. **Detection Accuracy**: >95% correct identification of truly idle sessions +2. **Recovery Rate**: >90% successful recovery of stuck tasks +3. **Resource Efficiency**: <1% CPU overhead for monitoring +4. **Zero Data Loss**: No committed work lost during cleanup +5. **Event Reliability**: All idle events properly propagated via SSE + +## Future Enhancements + +1. **Machine Learning**: Adaptive thresholds based on historical patterns +2. **Predictive Cleanup**: Detect likely-to-become-idle sessions +3. **Resource Optimization**: Hibernate instead of terminate +4. **Advanced Recovery**: Smart retry with modified parameters +5. **Metrics Dashboard**: Comprehensive idle state analytics \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/42944d6d-7561-4030-afed-f425f9e4f279.md b/.opencode-studio/kanban/plans/42944d6d-7561-4030-afed-f425f9e4f279.md new file mode 100644 index 0000000..4793ae2 --- /dev/null +++ b/.opencode-studio/kanban/plans/42944d6d-7561-4030-afed-f425f9e4f279.md @@ -0,0 +1,219 @@ +# Implementation Plan: Test SSE v2 + +## Task Analysis +**Title:** Test SSE v2 +**Description:** Quick test +**Plan ID:** 42944d6d-7561-4030-afed-f425f9e4f279 +**Created:** 2026-01-01T01:36:13+01:00 + +## 1. Technical Analysis + +### Context +Based on project knowledge, OpenCode Studio has recently migrated from WebSocket to Server-Sent Events (SSE) for real-time communication. The SSE infrastructure is largely complete, but comprehensive testing is needed to ensure reliability and proper functionality. + +### Current SSE Implementation Status +- ✅ Backend SSE Infrastructure (Feature 1) - Complete +- ✅ Frontend SSE Hooks (Feature 2) - Complete +- ✅ Backend Activity Message Serialization (Feature 3) - Complete +- 🟡 WebSocket Code Cleanup (Feature 4) - In Progress +- ❌ Documentation & Testing (Feature 5) - Pending + +### Key SSE Components to Test +1. **Global Event Stream**: `/api/events` endpoint +2. **Session Activity Stream**: `/api/sessions/{id}/activity` endpoint +3. **Frontend Hooks**: `useEventStream` and `useSessionActivitySSE` +4. **Event Types**: `task.status_changed`, `session.started`, `session.ended` +5. **Reconnection Logic**: Auto-reconnect and history replay +6. **EventBuffer**: Server-side buffering for reconnection scenarios + +### Known Issues to Address +- `/api/sessions/{id}/activity` endpoint previously returned empty responses +- Task status synchronization issues between OpenCode and Studio DB +- 30-second timeout issues during task execution + +## 2. Files to Modify/Create + +### Test Files to Create +``` +crates/server/src/routes/events_test.rs # SSE endpoint integration tests +crates/server/src/routes/sessions_test.rs # Session activity SSE tests +frontend/src/hooks/__tests__/useEventStream.test.ts # Frontend hook unit tests +frontend/src/hooks/__tests__/useSessionActivitySSE.test.ts +tests/integration/sse_integration_test.rs # End-to-end SSE tests +tests/manual/sse_manual_test.md # Manual testing checklist +``` + +### Files to Review/Modify +``` +crates/server/src/routes/events.rs # Verify SSE implementation +crates/server/src/routes/sessions.rs # Check session activity endpoint +crates/orchestrator/src/executor.rs # Event emission verification +frontend/src/hooks/useEventStream.ts # Hook reliability +frontend/src/hooks/useSessionActivitySSE.ts # Session-specific SSE +crates/events/src/bus.rs # Event bus functionality +``` + +## 3. Step-by-Step Implementation + +### Phase 1: Backend SSE Testing (Day 1) +1. **Create SSE endpoint integration tests** + - Test `/api/events` connection establishment + - Verify proper SSE headers (`text/event-stream`, `Cache-Control: no-cache`) + - Test event emission for task status changes + - Test event emission for session lifecycle + +2. **Create session activity SSE tests** + - Test `/api/sessions/{id}/activity` endpoint + - Verify session-specific event filtering + - Test with valid and invalid session IDs + - Verify event format and data integrity + +3. **Test EventBuffer functionality** + - Test event buffering for reconnection scenarios + - Verify buffer size limits and cleanup + - Test history replay on reconnection + +### Phase 2: Event Emission Testing (Day 1-2) +4. **Verify orchestrator event emission** + - Test task status change events from `executor.rs` + - Test session started/ended events + - Verify event payload structure matches frontend expectations + +5. **Test event bus reliability** + - Test event delivery across multiple subscribers + - Test event ordering and timing + - Test error handling in event processing + +### Phase 3: Frontend Hook Testing (Day 2) +6. **Unit test useEventStream hook** + - Test connection establishment + - Test auto-reconnection logic + - Test event parsing and state updates + - Test cleanup on unmount + +7. **Unit test useSessionActivitySSE hook** + - Test session-specific event handling + - Test hook behavior with invalid session IDs + - Test event filtering and processing + +### Phase 4: Integration Testing (Day 2-3) +8. **End-to-end SSE flow testing** + - Create task → verify SSE event received + - Execute task → verify status change events + - Test concurrent connections from multiple clients + - Test browser tab switching and reconnection + +9. **Performance and reliability testing** + - Test with high event frequency + - Test connection stability over extended periods + - Test memory usage and cleanup + - Test graceful degradation scenarios + +### Phase 5: Manual Testing & Documentation (Day 3) +10. **Manual testing checklist** + - Browser DevTools Network tab verification + - Real-time UI updates validation + - Cross-browser compatibility check + - Mobile/responsive behavior + +11. **Update documentation** + - Document SSE testing procedures + - Update AGENTS.md with testing information + - Create troubleshooting guide for SSE issues + +## 4. Potential Risks + +### High Risk +- **SSE Connection Instability**: Intermittent connection drops could affect real-time updates +- **Event Loss**: Network issues or server restarts could cause event loss +- **Browser Compatibility**: Older browsers may have SSE limitations + +### Medium Risk +- **Performance Impact**: High-frequency events could impact server performance +- **Memory Leaks**: Improper cleanup of SSE connections or event buffers +- **Race Conditions**: Event ordering issues between task operations and SSE updates + +### Low Risk +- **Test Complexity**: Creating comprehensive SSE tests may require complex setup +- **Debugging Difficulty**: SSE issues can be harder to debug than traditional REST APIs +- **CORS Issues**: Cross-origin SSE requests may need special configuration + +## 5. Testing Strategy + +### Unit Tests +- Mock SSE connections for isolated testing +- Test event parsing and state management +- Test error handling and reconnection logic + +### Integration Tests +- Use real SSE connections within test environment +- Test full event flow from backend to frontend +- Test concurrent connections and scaling + +### Manual Tests +- Browser DevTools for connection monitoring +- Network simulation for connection drops +- UI validation for real-time updates + +### Performance Tests +- Load testing with multiple concurrent SSE connections +- Event frequency stress testing +- Memory usage monitoring over time + +## 6. Success Criteria + +### Functional Requirements +- [ ] SSE endpoints return proper headers and maintain connections +- [ ] Events are delivered correctly to all connected clients +- [ ] Frontend hooks handle events and update UI in real-time +- [ ] Reconnection logic works seamlessly on connection drops +- [ ] Session-specific events are properly filtered + +### Non-Functional Requirements +- [ ] SSE connections remain stable for 30+ minutes +- [ ] Event delivery latency < 100ms under normal load +- [ ] Memory usage remains stable with long-lived connections +- [ ] System handles 50+ concurrent SSE connections +- [ ] Graceful degradation when SSE is unavailable + +### Quality Requirements +- [ ] All unit tests pass (target: 95%+ coverage) +- [ ] All integration tests pass +- [ ] Manual testing checklist completed +- [ ] Documentation updated and reviewed +- [ ] Performance benchmarks meet targets + +## 7. Estimated Complexity: **M (Medium)** + +**Reasoning:** +- **Medium scope**: Testing existing SSE infrastructure rather than building new features +- **Well-defined requirements**: Clear understanding of what needs to be tested +- **Existing codebase**: SSE implementation already exists, reducing complexity +- **Standard testing patterns**: Can use established testing frameworks and patterns +- **Time estimate**: 2-3 days for comprehensive testing suite + +**Complexity breakdown:** +- Backend testing: Simple-Medium (standard HTTP endpoint testing) +- Frontend testing: Medium (SSE mock setup required) +- Integration testing: Medium (requires coordination between backend/frontend) +- Manual testing: Simple (straightforward browser testing) + +## 8. Dependencies + +- Existing SSE implementation in `crates/server/src/routes/events.rs` +- Frontend hooks in `frontend/src/hooks/useEventStream.ts` +- Event bus functionality in `crates/events/src/bus.rs` +- Test infrastructure and frameworks already in place + +## 9. Next Steps + +1. Begin with backend SSE endpoint testing +2. Validate event emission from orchestrator +3. Create frontend hook tests with proper mocking +4. Implement end-to-end integration tests +5. Conduct manual testing and documentation updates + +--- +**Plan Status:** Ready for Implementation +**Assigned:** Pending +**Priority:** Medium \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/4ad1886f-b145-4108-9744-1bd8b7f16460.md b/.opencode-studio/kanban/plans/4ad1886f-b145-4108-9744-1bd8b7f16460.md new file mode 100644 index 0000000..85137df --- /dev/null +++ b/.opencode-studio/kanban/plans/4ad1886f-b145-4108-9744-1bd8b7f16460.md @@ -0,0 +1,186 @@ +# Implementation Plan: Test7 + +**Task ID:** 4ad1886f-b145-4108-9744-1bd8b7f16460 +**Title:** Test7 +**Description:** x +**Generated:** 2026-01-01 01:36:13 + +## 1. Technical Analysis + +### Task Overview +The task "Test7" with minimal description "x" appears to be a test case or placeholder task. Given the extremely limited specification, this analysis assumes this is either: + +1. A test task to verify the OpenCode Studio planning system +2. A placeholder requiring further clarification +3. A minimal reproduction case for testing purposes + +### Context Assessment +- **Project:** OpenCode Studio (AI-powered development orchestration platform) +- **Architecture:** Rust backend (Axum + SQLite) + React frontend +- **Current State:** Phase 6+ (GitHub Integration phase based on supermemory context) +- **Task Lifecycle Position:** Currently in PLANNING phase + +### Technical Constraints +- Must follow OpenCode Studio conventions (tabs, 100 char lines, no type suppression) +- Backend changes require passing `cargo clippy -D warnings` +- Frontend changes require TypeScript compilation success +- All changes must maintain 108+ passing unit tests + +## 2. Files to Modify/Create + +### Analysis-Based Assumptions +Given the minimal specification, the following files might be relevant depending on the actual requirement: + +#### Potential Backend Files +``` +crates/server/src/routes/ +├── health.rs # If testing health endpoints +├── tasks.rs # If testing task operations +└── mod.rs # Route registration + +crates/core/src/domain/ +├── task.rs # Domain model updates +└── session.rs # Session handling + +crates/db/src/repositories/ +└── task_repository.rs # Database operations +``` + +#### Potential Frontend Files +``` +frontend/src/components/ +├── kanban/TaskCard.tsx # Task display +└── dialogs/CreateTaskDialog.tsx # Task creation + +frontend/src/api/generated/ # Auto-generated API hooks +``` + +#### Configuration/Test Files +``` +crates/*/src/lib.rs # Test modules +.opencode-studio/kanban/plans/ # This planning file +``` + +## 3. Step-by-Step Implementation Steps + +### Phase 1: Requirements Clarification +1. **Analyze task intent** - Determine what "Test7" and "x" specifically require +2. **Identify scope** - Backend, frontend, or full-stack change +3. **Review existing tests** - Check if this relates to existing test cases +4. **Validate assumptions** - Confirm interpretation with stakeholders + +### Phase 2: Design & Planning +1. **Define acceptance criteria** based on clarified requirements +2. **Choose implementation approach** (API endpoint, UI component, etc.) +3. **Identify dependencies** - Required crates, external services +4. **Plan testing strategy** - Unit tests, integration tests, E2E tests + +### Phase 3: Implementation +1. **Backend changes** (if applicable): + ```bash + # Create/modify domain models + # Update repositories + # Add/modify API endpoints + # Update OpenAPI schema + ``` + +2. **Frontend changes** (if applicable): + ```bash + # Update/create React components + # Add API integration hooks + # Update routing if needed + # Add styling/UI updates + ``` + +3. **Integration testing**: + ```bash + cargo test --workspace + cargo clippy --workspace --all-features -- -D warnings + cd frontend && pnpm tsc --noEmit + ``` + +### Phase 4: Verification +1. **Run full test suite** - Ensure all 108+ tests pass +2. **Manual testing** - Verify functionality in running application +3. **SSE event verification** - Check task lifecycle events fire correctly +4. **OpenCode integration test** - Verify AI execution pipeline + +### Phase 5: Documentation +1. **Update AGENTS.md** if architectural changes made +2. **Add inline code comments** for complex logic +3. **Update API documentation** if new endpoints added + +## 4. Potential Risks + +### High Risk +- **Undefined requirements** - "Test7" and "x" provide insufficient specification +- **Breaking existing functionality** - Changes could affect 108+ existing tests +- **OpenCode integration failure** - Task execution pipeline disruption + +### Medium Risk +- **Type safety violations** - Accidental use of `as any` or type suppression +- **SSE event system disruption** - Breaking real-time task updates +- **Database migration issues** - Schema changes affecting existing data + +### Low Risk +- **Frontend styling inconsistencies** - UI changes not matching design system +- **Performance degradation** - Inefficient database queries or React renders +- **Documentation drift** - Failing to update docs after implementation + +### Mitigation Strategies +1. **Clarify requirements immediately** before implementation +2. **Implement comprehensive test coverage** for any new functionality +3. **Use feature flags** for risky changes +4. **Maintain backwards compatibility** where possible +5. **Follow established patterns** in the codebase + +## 5. Estimated Complexity + +### Assessment: **S (Small)** + +**Reasoning:** +- **Minimal scope** - Given the placeholder nature of the task +- **Low technical debt** - Project has clean architecture and good test coverage +- **Established patterns** - Well-defined conventions and tooling in place +- **Quick iteration** - Robust CI/CD and development workflow + +### Complexity Factors + +#### Factors Supporting Small (S) Complexity: +- Minimal description suggests small scope +- Existing robust test suite (108+ tests) +- Well-established development patterns +- Clean clippy and strong type safety + +#### Factors That Could Increase Complexity: +- Unclear requirements could lead to scope creep +- Integration with OpenCode AI execution pipeline +- Potential need for database schema changes +- SSE event system integration requirements + +### Time Estimates +- **Requirements clarification:** 30 minutes +- **Implementation:** 1-3 hours (depending on actual scope) +- **Testing & verification:** 1 hour +- **Documentation updates:** 30 minutes + +**Total estimated time:** 3-5 hours + +## 6. Next Steps + +1. **IMMEDIATE:** Clarify the actual requirements for "Test7" task +2. **Upon clarification:** Update this plan with specific technical details +3. **Implementation:** Follow the step-by-step process outlined above +4. **Review:** Conduct code review before marking task complete + +## 7. Notes + +- This plan assumes minimal scope due to placeholder-like task description +- Plan should be updated once actual requirements are clarified +- All implementation must follow OpenCode Studio conventions +- Maintain focus on the established task lifecycle: TODO → PLANNING → PLANNING_REVIEW → IN_PROGRESS → AI_REVIEW → REVIEW → DONE + +--- + +**Plan Status:** DRAFT - Awaiting requirements clarification +**Next Action:** Contact task creator for detailed requirements \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/4d3b9b45-a365-4f23-b0ea-b1f4e59ec9c7.md b/.opencode-studio/kanban/plans/4d3b9b45-a365-4f23-b0ea-b1f4e59ec9c7.md new file mode 100644 index 0000000..0d3380e --- /dev/null +++ b/.opencode-studio/kanban/plans/4d3b9b45-a365-4f23-b0ea-b1f4e59ec9c7.md @@ -0,0 +1,184 @@ +# Implementation Plan: Test6 + +**Task ID:** 4d3b9b45-a365-4f23-b0ea-b1f4e59ec9c7 +**Title:** Test6 +**Description:** Test +**Generated:** 2026-01-01 01:36:13 AM + +## 1. Technical Analysis + +### Task Context +This appears to be a test task with minimal requirements. Based on the OpenCode Studio architecture, this could serve multiple purposes: + +1. **System Test**: Verify the task lifecycle automation (TODO → DONE) +2. **Workflow Test**: Validate the planning and review processes +3. **Integration Test**: Test OpenCode session creation and execution +4. **Performance Test**: Benchmark task execution timing + +### Current System State +- **Backend**: Rust/Axum with SQLite persistence +- **Task Lifecycle**: 7-stage workflow with AI automation +- **OpenCode Integration**: HTTP API via opencode_client SDK +- **Test Coverage**: 108+ unit tests across 9 crates +- **Real-time Events**: SSE-based communication + +### Technical Approach +Given the minimal description, I'll implement this as a **verification test** that: +- Creates a simple test task +- Exercises the basic CRUD operations +- Validates the task status transitions +- Confirms OpenCode integration functionality + +## 2. Files to Modify/Create + +### Backend Files +``` +crates/ +├── core/src/domain/ +│ └── task.rs # Verify task model +├── db/src/repositories/ +│ └── task_repository.rs # Test CRUD operations +├── orchestrator/src/ +│ ├── executor.rs # Test OpenCode integration +│ └── state_machine.rs # Verify status transitions +└── server/src/routes/ + └── tasks.rs # Test API endpoints +``` + +### Test Files +``` +crates/ +├── core/src/domain/ +│ └── task.rs # Add unit tests for Test6 scenario +├── db/src/repositories/ +│ └── task_repository.rs # Add CRUD test cases +└── orchestrator/src/ + └── executor.rs # Add integration test +``` + +### Generated Files (Expected) +``` +.opencode-studio/kanban/ +├── plans/ +│ └── 4d3b9b45-a365-4f23-b0ea-b1f4e59ec9c7.md # This plan +└── reviews/ + └── 4d3b9b45-a365-4f23-b0ea-b1f4e59ec9c7.md # Post-execution review +``` + +## 3. Step-by-Step Implementation + +### Phase 1: Task Creation Verification +1. **Validate Task Model** + - Ensure task creation with minimal description works + - Verify UUID generation and persistence + - Test required field validation + +2. **Database Operations** + - Create task in SQLite database + - Verify storage of minimal task data + - Test retrieval and status queries + +### Phase 2: API Endpoint Testing +1. **REST API Validation** + - `POST /api/tasks` - Create Test6 task + - `GET /api/tasks/{id}` - Retrieve task details + - `PUT /api/tasks/{id}` - Update task properties + - `DELETE /api/tasks/{id}` - Clean up test data + +2. **Status Transition Testing** + - `POST /api/tasks/{id}/start` - Begin execution + - `POST /api/tasks/{id}/execute` - OpenCode integration + - Monitor SSE events for status changes + +### Phase 3: OpenCode Integration +1. **Session Management** + - Verify OpenCode session creation + - Test task execution with minimal prompt + - Validate session state persistence + +2. **Event System** + - Monitor `task.status_changed` events + - Verify `session.started` and `session.ended` events + - Test SSE endpoint `/api/sessions/{id}/activity` + +### Phase 4: Lifecycle Completion +1. **Automated Workflow** + - Execute full TODO → DONE transition + - Verify AI planning and review stages + - Test human approval bypass for simple tasks + +2. **File Generation** + - Confirm plan file creation + - Verify review file generation + - Check workspace state preservation + +## 4. Potential Risks + +### High Risk +- **OpenCode Timeout**: The 30-second timeout issue identified in previous testing + - *Mitigation*: Implement async execution with proper status tracking + - *Fallback*: Manual status update if OpenCode session completes + +### Medium Risk +- **Database Consistency**: Task status discrepancies between Studio DB and OpenCode + - *Mitigation*: Add transaction boundaries and rollback mechanisms + - *Monitoring*: Enhanced logging for status transition failures + +### Low Risk +- **SSE Event Loss**: Missing real-time updates during task execution + - *Mitigation*: Event replay mechanism already implemented + - *Validation*: Test connection recovery scenarios + +### Technical Debt +- **Minimal Task Validation**: Very basic description may expose edge cases + - *Consideration*: Add validation for meaningful task descriptions + - *Documentation*: Update task creation guidelines + +## 5. Estimated Complexity: **S (Small)** + +### Justification +- **Scope**: Single test task with basic operations +- **Complexity**: Exercises existing functionality, no new features +- **Dependencies**: Uses established OpenCode integration +- **Testing**: Validates current system capabilities +- **Time Estimate**: 1-2 hours for complete lifecycle testing + +### Complexity Factors +- ✅ **Simple**: Leverages existing infrastructure +- ✅ **Well-defined**: Clear test objectives despite minimal description +- ✅ **Low Risk**: Uses proven system components +- ✅ **Fast Feedback**: Immediate validation of system health + +## Success Criteria + +### Functional Requirements +- [ ] Task created successfully with ID `4d3b9b45-a365-4f23-b0ea-b1f4e59ec9c7` +- [ ] All status transitions complete without errors +- [ ] OpenCode session executes within timeout limits +- [ ] SSE events fired correctly for all state changes +- [ ] Plan and review files generated in expected locations + +### Non-Functional Requirements +- [ ] Task execution completes within 30 seconds +- [ ] Database operations maintain ACID properties +- [ ] Event system handles concurrent connections +- [ ] API responses conform to OpenAPI specification + +### Quality Gates +- [ ] All existing tests continue passing (108+ tests) +- [ ] Clippy warnings remain at zero (`-D warnings`) +- [ ] No memory leaks or resource exhaustion +- [ ] Proper error handling and logging + +## Notes + +This implementation serves as a **system health check** for OpenCode Studio. The minimal task description is intentional, allowing the system to demonstrate its ability to handle edge cases and provide meaningful automation even with limited input. + +The plan validates the complete technology stack: +- Rust backend architecture +- SQLite persistence layer +- OpenCode AI integration +- React frontend updates +- Real-time event system + +**Next Steps**: Upon plan approval, execute this task to verify system integrity and identify any regression issues from recent migrations (WebSocket → SSE, opencode → opencode_client SDK). \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/4db84480-2f92-48ee-9592-2c73beef95d3.md b/.opencode-studio/kanban/plans/4db84480-2f92-48ee-9592-2c73beef95d3.md new file mode 100644 index 0000000..11a1417 --- /dev/null +++ b/.opencode-studio/kanban/plans/4db84480-2f92-48ee-9592-2c73beef95d3.md @@ -0,0 +1,180 @@ +# Implementation Plan: Test SSE Activity + +**Task ID:** 4db84480-2f92-48ee-9592-2c73beef95d3 +**Title:** Test SSE Activity +**Description:** Test if session activity SSE works +**Created:** 2026-01-01 01:36:13 + +## 1. Technical Analysis + +### Current SSE Infrastructure +- **Backend:** Axum-based SSE endpoints with `EventBuffer` for reconnection support +- **Frontend:** React hooks (`useEventStream`, `useSessionActivitySSE`) for SSE consumption +- **Target Endpoint:** `/api/sessions/{id}/activity` - currently returning empty in tests +- **Event Types:** `task.status_changed`, `session.started`, `session.ended`, session activity messages + +### Known Issues from Previous Testing +- `/api/sessions/{id}/activity` endpoint returned empty during E2E testing +- Task execution timeout after 30 seconds causing status discrepancies +- SSE events for task status changes confirmed working at global level + +### Testing Scope +1. **Backend SSE Generation:** Verify activity messages are properly created and queued +2. **SSE Transport:** Test the HTTP SSE stream delivery mechanism +3. **Frontend Consumption:** Verify React hooks receive and process SSE data +4. **Event Buffering:** Test reconnection scenarios and message replay +5. **Real-time Updates:** Confirm UI updates in response to SSE events + +## 2. Files to Examine/Modify + +### Backend Files to Examine +``` +crates/server/src/routes/sessions.rs # SSE endpoint implementation +crates/events/src/bus.rs # Event emission system +crates/events/src/types.rs # Event type definitions +crates/orchestrator/src/executor.rs # Activity generation during task execution +crates/orchestrator/src/activity_store.rs # Activity message storage/retrieval +crates/server/src/routes/events.rs # Global SSE endpoint (working baseline) +``` + +### Frontend Files to Examine +``` +frontend/src/hooks/useSessionActivitySSE.ts # Session-specific SSE hook +frontend/src/hooks/useEventStream.ts # Generic SSE stream hook +frontend/src/components/activity/ActivityFeed.tsx # Activity display component +frontend/src/components/activity/ActivityItem.tsx # Individual activity rendering +frontend/src/components/sessions/SessionCard.tsx # Session UI with activity +frontend/src/components/task-detail/TaskDetailPanel.tsx # Task detail with activity +``` + +### Test Files to Create +``` +crates/server/tests/integration_sse_activity.rs # Backend SSE integration test +frontend/src/__tests__/sse-activity.test.tsx # Frontend SSE hook tests +test-scripts/manual-sse-test.js # Manual browser testing script +``` + +## 3. Step-by-Step Implementation Steps + +### Phase 1: Backend Activity Generation Verification (2 hours) +1. **Trace Activity Creation Path** + - Add debug logging to `executor.rs` activity generation + - Verify activity messages are created during task execution + - Check `activity_store.rs` for proper message persistence + +2. **Test Activity Storage** + - Create unit test for activity message creation + - Verify database storage of session activities + - Test activity retrieval by session ID + +3. **Debug SSE Endpoint** + - Add logging to `/api/sessions/{id}/activity` route + - Test endpoint manually with curl/browser + - Verify EventBuffer is populated with session activities + +### Phase 2: SSE Transport Testing (1 hour) +1. **Manual SSE Testing** + - Create test session with known activities + - Connect to SSE endpoint via browser/curl + - Verify SSE headers and connection establishment + - Test message format and Content-Type + +2. **Integration Test Development** + - Create Axum test client for SSE endpoint testing + - Test SSE connection lifecycle (connect, receive, disconnect) + - Verify proper EventBuffer behavior and message ordering + +### Phase 3: Frontend SSE Hook Testing (2 hours) +1. **Hook Isolation Testing** + - Unit test `useSessionActivitySSE` hook + - Mock SSE EventSource behavior + - Test reconnection logic and error handling + - Verify activity message parsing + +2. **Component Integration Testing** + - Test ActivityFeed component with mock SSE data + - Verify real-time UI updates + - Test activity message rendering and formatting + +### Phase 4: End-to-End Testing (2 hours) +1. **Live System Testing** + - Start backend server with debug logging + - Create test task and execute it + - Monitor SSE connections in browser DevTools + - Verify activity messages flow through the system + +2. **Edge Case Testing** + - Test SSE reconnection after network interruption + - Verify activity history replay for new connections + - Test multiple concurrent SSE connections + - Verify activity filtering by session ID + +### Phase 5: Performance & Reliability Testing (1 hour) +1. **Load Testing** + - Test multiple sessions with concurrent activity + - Verify EventBuffer memory usage and cleanup + - Test SSE connection limits and scaling + +2. **Error Scenario Testing** + - Test behavior with invalid session IDs + - Verify graceful handling of SSE connection failures + - Test activity generation during OpenCode errors + +## 4. Potential Risks + +### High Risk +- **EventBuffer Memory Leaks:** Improper cleanup of session activity buffers could cause memory growth +- **SSE Connection Exhaustion:** Browser/server connection limits could block new SSE connections +- **Activity Generation Timing:** Race conditions between OpenCode execution and activity creation + +### Medium Risk +- **Cross-Browser SSE Compatibility:** Edge cases with EventSource implementation differences +- **Network Interruption Handling:** SSE reconnection failures in unstable network conditions +- **Activity Message Ordering:** Out-of-order delivery affecting UI state consistency + +### Low Risk +- **SSE Payload Size Limits:** Large activity messages exceeding SSE practical limits +- **CORS Configuration:** SSE-specific CORS requirements not properly configured +- **Content-Type Issues:** Improper SSE headers causing client connection failures + +## 5. Success Criteria + +- [ ] `/api/sessions/{id}/activity` endpoint returns live activity messages +- [ ] Frontend receives and displays activity updates in real-time +- [ ] SSE reconnection works properly after network interruption +- [ ] Activity history is properly replayed on new connections +- [ ] No memory leaks or connection exhaustion under normal load +- [ ] Integration tests pass for SSE activity functionality +- [ ] Manual E2E test demonstrates working activity feed + +## 6. Estimated Complexity + +**Size: M (Medium)** + +**Reasoning:** +- **Not a new feature implementation** - SSE infrastructure already exists +- **Primarily debugging/testing focused** - identifying why activity SSE isn't working +- **Well-defined scope** - specific to session activity SSE functionality +- **Moderate complexity** - involves backend event generation, SSE transport, and frontend consumption +- **Limited file changes expected** - mainly debugging, logging, and test additions + +**Time Estimate: 8 hours** +- Backend verification: 3 hours +- Frontend testing: 2 hours +- E2E testing: 2 hours +- Documentation/cleanup: 1 hour + +## 7. Dependencies & Prerequisites + +- Backend server running with SSE endpoints enabled +- Frontend development environment with React testing setup +- Access to browser DevTools for SSE connection monitoring +- Ability to create test sessions and execute OpenCode tasks +- Database access for activity storage verification + +## 8. Deliverables + +1. **Working SSE Activity Stream** - Live activity updates in browser +2. **Integration Test Suite** - Automated tests for SSE activity functionality +3. **Debug Documentation** - Findings from SSE investigation and fixes applied +4. **Manual Test Script** - Reproducible test procedure for SSE activity verification \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/5442e9b8-791b-4961-9fef-1e18bc3c5ad0.md b/.opencode-studio/kanban/plans/5442e9b8-791b-4961-9fef-1e18bc3c5ad0.md new file mode 100644 index 0000000..3eb569d --- /dev/null +++ b/.opencode-studio/kanban/plans/5442e9b8-791b-4961-9fef-1e18bc3c5ad0.md @@ -0,0 +1,68 @@ +# Planning Analysis: Ahoj + +**Task ID:** 5442e9b8-791b-4961-9fef-1e18bc3c5ad0 +**Created:** 2025-12-31 +**Status:** BLOCKED - Insufficient Information + +--- + +## 1. Technical Analysis + +### Current State +The task contains only a greeting ("Ahoj") with no actionable requirements. + +### Problem Statement +**UNABLE TO PLAN** - The task description does not specify: +- What feature/fix is needed +- Which part of the codebase is involved +- What the expected outcome should be +- Any acceptance criteria + +### Assessment +This appears to be either: +1. A test task created accidentally +2. A placeholder that needs proper description +3. A greeting intended as a message, not a task + +--- + +## 2. Files to Modify/Create + +**Cannot determine** - No requirements specified. + +--- + +## 3. Step-by-Step Implementation + +1. **Clarify Requirements** - Task owner must provide: + - Clear description of what needs to be done + - Expected behavior/outcome + - Any relevant context (error messages, user stories, etc.) + +2. **Re-plan** - Once requirements are clear, create a proper implementation plan + +--- + +## 4. Potential Risks + +| Risk | Impact | Mitigation | +|------|--------|------------| +| Implementing wrong feature | High | Get clarification before proceeding | +| Wasted development time | Medium | Block task until requirements defined | + +--- + +## 5. Estimated Complexity + +**UNDETERMINED** - Cannot estimate without requirements. + +--- + +## Recommendation + +**ACTION REQUIRED:** Please update this task with a proper description including: +- What you want to accomplish +- Why it's needed +- Any specific technical requirements or constraints + +Once updated, this task can be re-planned with concrete implementation steps. diff --git a/.opencode-studio/kanban/plans/59a8e4fb-799b-4449-b025-e30a071820a1.md b/.opencode-studio/kanban/plans/59a8e4fb-799b-4449-b025-e30a071820a1.md new file mode 100644 index 0000000..19807ac --- /dev/null +++ b/.opencode-studio/kanban/plans/59a8e4fb-799b-4449-b025-e30a071820a1.md @@ -0,0 +1,198 @@ +# Implementation Plan: Prompt Test + +**Task ID:** 59a8e4fb-799b-4449-b025-e30a071820a1 +**Title:** Prompt test +**Description:** x +**Generated:** 2025-01-01T01:36:13+01:00 + +## 1. Technical Analysis + +### Problem Statement +The task "Prompt test" with minimal description "x" suggests testing the prompt engineering capabilities within OpenCode Studio. Given the AI-powered nature of the platform and the existing prompt infrastructure, this likely involves: +- Testing the prompt generation and execution system +- Validating prompt templates and their effectiveness +- Ensuring prompt consistency across different task phases +- Testing edge cases and prompt robustness + +### Current System Context +- **Prompt Infrastructure:** Located in `crates/orchestrator/src/prompts.rs` +- **AI Integration:** OpenCode client SDK handles prompt execution +- **Task Lifecycle:** TODO → PLANNING → PLANNING_REVIEW → IN_PROGRESS → AI_REVIEW → REVIEW → DONE +- **Session Management:** Each phase uses separate OpenCode sessions with specific prompts +- **Known Components:** + - `implementation_with_plan()` - Implementation prompts + - `replan()` - Re-planning prompts + - Planning and review prompt templates + +### Proposed Solution +Implement a **Prompt Testing Framework** that: +1. **Prompt Validation:** Test all existing prompt templates for syntax and completeness +2. **Mock Testing:** Create mock scenarios to test prompt behavior +3. **Integration Testing:** Validate prompts work correctly with OpenCode client +4. **Performance Testing:** Measure prompt execution times and token usage +5. **Edge Case Testing:** Test prompts with unusual inputs and edge cases + +## 2. Files to Modify/Create + +### New Files +``` +crates/orchestrator/src/prompt_tests.rs # Core prompt testing logic +crates/orchestrator/src/test_scenarios.rs # Test scenarios and mock data +crates/server/src/routes/prompt_test.rs # Prompt testing API endpoints +tests/integration/prompt_integration_tests.rs # Integration tests for prompts +``` + +### Files to Modify +``` +crates/orchestrator/src/lib.rs # Export new testing modules +crates/orchestrator/src/prompts.rs # Add testing utilities +crates/orchestrator/Cargo.toml # Add testing dependencies (mockall, tokio-test) +crates/server/src/lib.rs # Register prompt test routes +crates/server/src/routes/mod.rs # Add prompt_test module +crates/core/src/domain/mod.rs # Add prompt test domain models +frontend/src/components/prompt-test/ # Frontend testing interface (optional) +``` + +### Configuration Files +``` +.opencode-studio/prompt-test-config.toml # Test configuration +tests/fixtures/prompt_test_data.json # Test data and scenarios +``` + +## 3. Step-by-Step Implementation Steps + +### Phase 1: Infrastructure Setup (2-3 hours) +1. **Create prompt testing module** + - Initialize `crates/orchestrator/src/prompt_tests.rs` + - Define test result structures and enums + - Implement basic prompt validation functions + +2. **Add test scenarios** + - Create `crates/orchestrator/src/test_scenarios.rs` + - Define mock task data, edge cases, and invalid inputs + - Implement scenario generators + +3. **Update dependencies** + - Add `mockall = "0.12"` to orchestrator Cargo.toml + - Add `tokio-test = "0.4"` for async testing + - Update module exports in lib.rs + +### Phase 2: Core Testing Logic (3-4 hours) +1. **Implement prompt validation** + ```rust + pub fn validate_prompt_template(template: &str) -> PromptValidationResult + pub fn test_prompt_with_mock_data(prompt: &str, data: &MockData) -> TestResult + pub fn measure_prompt_performance(prompt: &str) -> PerformanceMetrics + ``` + +2. **Mock OpenCode client** + - Create mock implementation of OpenCode client + - Simulate various response scenarios (success, timeout, error) + - Test prompt execution without actual API calls + +3. **Edge case testing** + - Test with empty task descriptions + - Test with extremely long descriptions + - Test with special characters and unicode + - Test with malformed JSON inputs + +### Phase 3: Integration Testing (2-3 hours) +1. **Create integration tests** + - Test prompts with actual OpenCode client (if available) + - Validate end-to-end prompt execution + - Test prompt behavior across all task phases + +2. **Performance benchmarking** + - Measure token usage for different prompt templates + - Track execution times and response quality + - Generate performance reports + +### Phase 4: API Endpoints (2 hours) +1. **Create prompt test API** + ```rust + GET /api/prompt-test/validate/{template_id} # Validate specific template + POST /api/prompt-test/execute # Execute test scenario + GET /api/prompt-test/results # Get test results + GET /api/prompt-test/performance # Performance metrics + ``` + +2. **Add OpenAPI documentation** + - Document all new endpoints + - Add request/response schemas + - Update Swagger UI + +### Phase 5: Optional Frontend Interface (2-3 hours) +1. **Create testing dashboard** + - Component for running prompt tests + - Display test results and metrics + - Visual prompt template editor + +2. **Integration with existing UI** + - Add prompt test tab to admin interface + - Integrate with existing state management + +## 4. Potential Risks + +### High Risk +- **OpenCode API Dependency:** Testing requires OpenCode server to be running + - *Mitigation:* Implement comprehensive mocking system + - *Fallback:* Offline validation and mock testing only + +- **Prompt Template Changes:** Existing prompts might fail validation + - *Mitigation:* Start with read-only validation before modifying templates + - *Recovery:* Maintain backup of working prompt templates + +### Medium Risk +- **Performance Impact:** Running extensive prompt tests might slow down system + - *Mitigation:* Implement async testing with rate limiting + - *Solution:* Run tests in background with progress tracking + +- **Test Data Management:** Mock data might not represent real scenarios + - *Mitigation:* Use anonymized real task data for testing + - *Validation:* Regularly update test scenarios based on production usage + +### Low Risk +- **Integration Complexity:** Adding new API endpoints might conflict with existing routes + - *Mitigation:* Use `/api/prompt-test/*` namespace to avoid conflicts + - *Testing:* Comprehensive route testing before deployment + +- **Frontend Dependencies:** Optional UI might introduce new dependencies + - *Mitigation:* Keep frontend testing interface minimal and optional + - *Alternative:* CLI-based testing interface only + +## 5. Estimated Complexity: **M (Medium)** + +### Complexity Breakdown +- **Backend Core Logic:** Medium (3-4 hours for prompt testing framework) +- **Integration Testing:** Medium (2-3 hours for OpenCode integration) +- **API Development:** Low-Medium (2 hours for REST endpoints) +- **Frontend Interface:** Low-Medium (2-3 hours, optional) +- **Documentation:** Low (1 hour for API docs and README updates) + +### Total Estimated Time: **10-15 hours** + +### Complexity Justification +- **Medium complexity** due to need for careful prompt validation and mocking +- Well-defined scope with existing prompt infrastructure as foundation +- Limited external dependencies beyond current OpenCode integration +- Clear testing patterns available from existing codebase (109 passing tests) +- Can be implemented incrementally with each phase delivering value + +### Success Criteria +1. ✅ All existing prompt templates pass validation +2. ✅ Mock testing framework executes without errors +3. ✅ Integration tests confirm prompts work with OpenCode client +4. ✅ Performance benchmarks establish baseline metrics +5. ✅ API endpoints respond correctly and are documented +6. ✅ Build passes with `cargo test --workspace` +7. ✅ Clippy warnings remain clean with `-D warnings` + +### Dependencies +- OpenCode client SDK (existing) +- SQLite database (existing) +- Axum server framework (existing) +- No new external service dependencies required + +--- + +**Note:** This is a test scenario plan. The minimal description "x" has been interpreted as a prompt testing requirement based on the AI-powered nature of OpenCode Studio. The plan can be adapted once more specific requirements are provided. \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/67d5bc95-691b-4083-b3a1-81fb89a63ec0.md b/.opencode-studio/kanban/plans/67d5bc95-691b-4083-b3a1-81fb89a63ec0.md new file mode 100644 index 0000000..87c4500 --- /dev/null +++ b/.opencode-studio/kanban/plans/67d5bc95-691b-4083-b3a1-81fb89a63ec0.md @@ -0,0 +1,191 @@ +# Implementation Plan: Test5 + +**Task ID:** 67d5bc95-691b-4083-b3a1-81fb89a63ec0 +**Title:** Test5 +**Description:** Test +**Created:** 2026-01-01T01:36:13+01:00 + +## Executive Summary + +**⚠️ CRITICAL ISSUE: Insufficient Task Specification** + +This task has minimal description ("Test5" / "Test"), making it impossible to create a meaningful implementation plan. This analysis provides a framework for what would be required once proper requirements are established. + +## 1. Technical Analysis + +### Current State Assessment +- **Task Clarity**: ❌ Extremely poor - no functional requirements +- **Scope Definition**: ❌ Undefined - could range from unit test to integration test to feature test +- **Success Criteria**: ❌ None provided +- **Context**: ✅ OpenCode Studio platform (Rust backend + React frontend) + +### Assumptions Based on Context +Given the OpenCode Studio environment, this could be: +1. **Unit Test Addition** - Testing specific backend functionality +2. **Integration Test** - Testing API endpoints or task lifecycle +3. **E2E Test** - Testing complete user workflows +4. **Feature Test** - Testing a new feature implementation +5. **System Test** - Testing overall system behavior + +### Technology Stack Analysis +- **Backend**: Rust (Axum + SQLite + SQLx) +- **Frontend**: React + TypeScript + Vite +- **Testing**: Cargo test (backend), potentially Vitest (frontend) +- **Current Test Status**: 108+ passing backend tests, clean clippy + +## 2. Files to Modify/Create + +### Scenario A: Backend Unit Test +``` +crates/ +├── core/src/domain/task.rs (if testing task logic) +├── db/src/repositories/ (if testing database operations) +├── server/src/routes/ (if testing API endpoints) +└── orchestrator/src/ (if testing task orchestration) +``` + +### Scenario B: Frontend Test +``` +frontend/ +├── src/components/__tests__/ +├── src/hooks/__tests__/ +└── tests/e2e/ (if integration testing) +``` + +### Scenario C: Integration Test +``` +crates/server/tests/ +└── integration_tests.rs +``` + +## 3. Step-by-Step Implementation Steps + +### Phase 1: Requirements Clarification (REQUIRED) +1. **Define Test Purpose** + - What functionality needs testing? + - What behavior should be verified? + - What are the success/failure criteria? + +2. **Identify Test Type** + - Unit test (isolated component testing) + - Integration test (component interaction testing) + - E2E test (full workflow testing) + +3. **Scope Definition** + - Which modules/components are in scope? + - What data/state setup is required? + - What external dependencies need mocking? + +### Phase 2: Test Design (Pending Requirements) +1. **Test Structure Planning** + ```rust + #[cfg(test)] + mod tests { + use super::*; + + #[test] + fn test_placeholder() { + // Setup + // Execute + // Assert + } + } + ``` + +2. **Mock/Fixture Setup** + - Database fixtures (if needed) + - API mocks (if needed) + - Test data preparation + +3. **Test Case Design** + - Happy path scenarios + - Edge cases + - Error conditions + +### Phase 3: Implementation (Pending Requirements) +1. **Write Test Code** + - Follow existing test patterns in codebase + - Use appropriate testing utilities + - Ensure proper cleanup + +2. **Verify Test Execution** + ```bash + cargo test test_name + cargo clippy --workspace + ``` + +3. **Integration Verification** + - Ensure test doesn't break existing functionality + - Verify test isolation + - Confirm CI compatibility + +## 4. Potential Risks + +### High Risk +- **🔴 Undefined Requirements**: Cannot proceed without clear specification +- **🔴 Scope Creep**: "Test" could mean anything from simple unit test to complex system test + +### Medium Risk +- **🟡 Test Environment**: May need specific test data or environment setup +- **🟡 Flaky Tests**: Could introduce timing or state-dependent issues +- **🟡 Performance Impact**: Large test suites might slow CI pipeline + +### Low Risk +- **🟢 Breaking Changes**: Unlikely for test-only changes +- **🟢 API Compatibility**: Test changes shouldn't affect public interfaces + +## 5. Estimated Complexity + +**Current Assessment: CANNOT ESTIMATE** + +Based on potential scenarios: +- **S (Simple)**: Single unit test for existing functionality (1-2 hours) +- **M (Medium)**: Integration test with setup/teardown (4-8 hours) +- **L (Large)**: E2E test suite with complex workflows (1-2 days) +- **XL (Extra Large)**: Comprehensive testing framework overhaul (3-5 days) + +## 6. Dependencies & Prerequisites + +### Must Have Before Implementation +1. **Clear Requirements** - What exactly needs to be tested? +2. **Test Strategy** - Unit/Integration/E2E approach decision +3. **Acceptance Criteria** - How to verify success? + +### Technical Dependencies +- Existing test infrastructure ✅ (109 tests passing) +- Development environment ✅ (Rust toolchain ready) +- CI/CD pipeline ✅ (GitHub Actions configured) + +## 7. Success Metrics + +### Definition of Done (To Be Defined) +- [ ] Test requirements clearly specified +- [ ] Test implementation follows project patterns +- [ ] All tests pass (`cargo test --workspace`) +- [ ] No clippy warnings (`cargo clippy -D warnings`) +- [ ] Test provides meaningful coverage/validation +- [ ] CI pipeline remains green + +## 8. Next Actions Required + +### Immediate (BLOCKING) +1. **🚨 CLARIFY REQUIREMENTS** - This task cannot proceed without proper specification +2. **Define test scope and objectives** +3. **Establish success criteria** + +### Once Requirements Clear +1. Update this plan with specific implementation details +2. Begin implementation following established patterns +3. Execute testing and validation procedures + +## Notes + +- This plan serves as a template until proper requirements are provided +- OpenCode Studio has robust testing infrastructure already in place +- Follow existing patterns in `crates/*/tests/` for consistency +- Consider impact on 108+ existing tests when making changes + +--- + +**Status**: ⏸️ BLOCKED - Awaiting requirement clarification +**Next Reviewer**: Task creator (requirements definition needed) \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/775a800e-bf7a-41b7-a30f-c99cdc2e7d8a.md b/.opencode-studio/kanban/plans/775a800e-bf7a-41b7-a30f-c99cdc2e7d8a.md new file mode 100644 index 0000000..129e1d4 --- /dev/null +++ b/.opencode-studio/kanban/plans/775a800e-bf7a-41b7-a30f-c99cdc2e7d8a.md @@ -0,0 +1,727 @@ +# API Integration Test: Full OpenCode Integration + +## Task Summary +**Task ID:** 775a800e-bf7a-41b7-a30f-c99cdc2e7d8a +**Title:** API Integration Test +**Description:** Test full OpenCode integration +**Updated:** 2025-12-31 + +--- + +## 1. Technical Analysis + +### Current State Assessment + +The codebase has migrated to a single OpenCode integration approach: + +**OpenAPI-Generated SDK** (`crates/opencode-client/`) +- Generated from OpenCode OpenAPI specification +- Used exclusively by `TaskExecutor` in orchestrator crate +- Type-safe with comprehensive coverage of OpenCode API +- No unit tests (generated code, tested via integration) + +### Existing Test Coverage + +| Component | Tests | Coverage | +|-----------|-------|----------| +| Unit Tests (workspace-wide) | 108+ tests | Excellent | +| OpenCode Integration | 0 integration tests | None | +| SSE Event Streaming | 8 event tests | Good | +| Full Task Lifecycle | 0 end-to-end tests | None | +| API Endpoints | 12 server tests | Good (mocked) | + +### Key Integration Points + +``` +HTTP API (/api/tasks/{id}/execute) + ↓ +TaskExecutor (crates/orchestrator/src/executor.rs) + ↓ +opencode-client SDK (crates/opencode-client/) + ↓ +OpenCode HTTP API (OPENCODE_URL, default: localhost:4096) + ↓ +SSE Events (EventBus -> /api/events, /api/sessions/{id}/activity) + ↓ +File Management (.opencode-studio/kanban/plans|reviews) + ↓ +VCS Workspace Management (Jujutsu/Git) +``` + +### Critical Gaps Identified + +1. **No end-to-end API integration tests** - All tests use mocked OpenCode responses +2. **Full task lifecycle untested** - Complete TODO→DONE flow not verified +3. **Concurrent session handling untested** - Multiple OpenCode sessions not tested +4. **Error recovery scenarios untested** - OpenCode failures, network issues, timeouts +5. **VCS workspace integration untested** - Workspace creation/cleanup during OpenCode operations +6. **File persistence untested during failures** - Plan/review file handling edge cases +7. **SSE event emission verification missing** - Real-time events during OpenCode operations +8. **Performance characteristics unknown** - No load or timing tests + +--- + +## 2. Files to Modify/Create + +### New Integration Test Files + +**Primary Test Suite:** +``` +crates/server/tests/ +├── api_integration_test.rs # Main integration test suite +├── common/ +│ ├── mod.rs # Shared test infrastructure +│ ├── opencode_mock.rs # OpenCode server mock/simulator +│ ├── test_fixtures.rs # Test data and factories +│ ├── assertions.rs # Custom assertion helpers +│ └── database_utils.rs # Test database utilities +``` + +**Specialized Test Files:** +``` +crates/orchestrator/tests/ +├── full_lifecycle_test.rs # Complete task lifecycle tests +└── concurrent_execution_test.rs # Concurrent OpenCode session tests + +crates/server/tests/ +├── sse_integration_test.rs # Real-time event verification tests +└── performance_test.rs # Load and timing tests +``` + +### Files to Modify + +| File | Changes Required | +|------|------------------| +| `crates/server/Cargo.toml` | Add integration test dependencies (`wiremock`, `tokio-test`, `tempfile`, `uuid`) | +| `crates/orchestrator/Cargo.toml` | Add test dependencies for async testing | +| `crates/db/src/pool.rs` | Add test database utilities for isolated testing | +| `crates/server/src/lib.rs` | Export test configuration utilities | +| `.github/workflows/ci.yml` | Add integration test job (optional) | + +### Enhanced Monitoring Files + +| File | Purpose | +|------|---------| +| `crates/server/tests/test_config.rs` | Test environment configuration | +| `docs/testing/integration_testing.md` | Integration testing documentation | + +--- + +## 3. Step-by-Step Implementation + +### Phase 1: Test Infrastructure Setup (2 days) + +**Step 1.1: Test Dependencies and Environment** +```rust +// crates/server/tests/common/mod.rs +/// Integration test utilities requiring live OpenCode server +/// Run with: OPENCODE_URL=http://localhost:4096 cargo test --package server --test api_integration_test + +use std::env; +use opencode_client::apis::configuration::Configuration; + +pub fn get_opencode_config() -> Option { + env::var("OPENCODE_URL").ok().map(|url| { + Configuration { + base_path: url, + ..Default::default() + } + }) +} + +pub fn skip_if_no_opencode() -> bool { + env::var("OPENCODE_URL").is_err() +} +``` + +**Step 1.2: OpenCode Mock Server Infrastructure** +```rust +// crates/server/tests/common/opencode_mock.rs +use wiremock::{MockServer, Mock, ResponseTemplate}; +use opencode_client::models::{SessionCreateRequest, SessionPromptRequest}; + +pub struct OpenCodeMock { + pub server: MockServer, + pub base_url: String, +} + +impl OpenCodeMock { + pub async fn start() -> Self { /* Implementation */ } + pub fn mock_session_create(&self) -> Mock { /* Implementation */ } + pub fn mock_session_prompt(&self) -> Mock { /* Implementation */ } + pub fn simulate_delay(&self, ms: u64) { /* Implementation */ } + pub fn simulate_error(&self, status: u16) { /* Implementation */ } +} +``` + +**Step 1.3: Test Database and File System Setup** +```rust +// crates/server/tests/common/test_fixtures.rs +use tempfile::TempDir; +use uuid::Uuid; + +pub struct TestEnvironment { + pub temp_dir: TempDir, + pub db_url: String, + pub task_id: Uuid, + pub opencode_config: Configuration, +} + +impl TestEnvironment { + pub async fn setup() -> Self { /* Implementation */ } + pub async fn cleanup(&self) { /* Implementation */ } + pub fn create_test_task(&self) -> Task { /* Implementation */ } +} +``` + +**Step 1.4: SSE Event Testing Infrastructure** +```rust +// crates/server/tests/common/sse_test_client.rs +use futures::stream::StreamExt; + +pub struct SSETestClient { + client: reqwest::Client, + base_url: String, +} + +impl SSETestClient { + pub async fn connect(&self, endpoint: &str) -> EventStream { /* Implementation */ } + pub async fn collect_events_for(&self, duration: Duration) -> Vec { /* Implementation */ } +} +``` + +### Phase 2: API Endpoint Integration Tests (3 days) + +**Step 2.1: Task CRUD with Real Database** +```rust +// Test: POST /api/tasks creates task in database +#[tokio::test] +async fn test_create_task_integration() { + let env = TestEnvironment::setup().await; + let response = test_client + .post("/api/tasks") + .json(&CreateTaskRequest { + title: "Integration Test Task".to_string(), + description: "Test full OpenCode integration".to_string() + }) + .send().await?; + + assert_eq!(response.status(), 201); + let task: Task = response.json().await?; + assert_eq!(task.status, TaskStatus::Todo); + + // Verify database persistence + let db_task = env.task_repository.find_by_id(task.id).await?.unwrap(); + assert_eq!(db_task.title, "Integration Test Task"); +} +``` + +**Step 2.2: Task State Transitions** +- Test: `POST /api/tasks/{id}/transition` with valid state changes +- Test: Invalid transitions return 400 Bad Request +- Test: Task status persisted to database +- Test: Events emitted via SSE stream + +**Step 2.3: Task Execution Endpoint - Basic Tests** +- Test: `POST /api/tasks/{id}/execute` with mocked OpenCode +- Test: Response format matches `ExecuteResponse` schema +- Test: Task status updated after execution +- Test: Session persistence to database + +### Phase 3: Full Task Lifecycle Integration Tests (4 days) + +**Step 3.1: Live OpenCode Planning Phase** +```rust +#[tokio::test] +async fn test_planning_phase_with_live_opencode() { + if skip_if_no_opencode() { return; } + + let env = TestEnvironment::setup().await; + let task = env.create_test_task(); + + // Execute planning phase + let response = test_client + .post(&format!("/api/tasks/{}/execute", task.id)) + .send().await?; + + let result: ExecuteResponse = response.json().await?; + + // Verify planning completion + assert!(matches!(result.result, PhaseResultDto::PlanCreated { .. })); + assert_eq!(result.task.status, TaskStatus::PlanningReview); + + // Verify plan file created + let plan_path = format!(".opencode-studio/kanban/plans/{}.md", task.id); + assert!(tokio::fs::metadata(&plan_path).await.is_ok()); + + // Verify session persisted + let sessions = env.session_repository.find_by_task_id(task.id).await?; + assert_eq!(sessions.len(), 1); + assert_eq!(sessions[0].phase, SessionPhase::Planning); +} +``` + +**Step 3.2: Implementation Phase with VCS Workspace** +- Test: VCS workspace created for implementation +- Test: Plan file loaded and included in implementation prompt +- Test: OpenCode tool calls executed in workspace context +- Test: Activity messages captured and stored +- Test: Workspace diff available after implementation + +**Step 3.3: AI Review Phase** +- Test: Diff retrieved from VCS workspace +- Test: Review prompt includes actual code changes +- Test: "APPROVED" response format recognized correctly +- Test: "CHANGES_REQUESTED" triggers fix iteration +- Test: Max review iterations enforced (default 3) + +**Step 3.4: Complete Task Lifecycle** +```rust +#[tokio::test] +async fn test_complete_todo_to_done_lifecycle() { + if skip_if_no_opencode() { return; } + + let env = TestEnvironment::setup().await; + let task = env.create_test_task(); + + // Execute full cycle with relaxed approval settings + let executor_config = ExecutorConfig::new(&env.temp_dir.path()) + .with_plan_approval(false) // Auto-approve for testing + .with_human_review(false); // Auto-approve for testing + + let result = env.task_executor + .run_full_cycle(&mut task).await?; + + assert!(matches!(result, PhaseResult::Completed)); + assert_eq!(task.status, TaskStatus::Done); + + // Verify all phases executed + let sessions = env.session_repository.find_by_task_id(task.id).await?; + assert!(sessions.len() >= 2); // At least planning + implementation +} +``` + +### Phase 4: Error Handling and Edge Cases (3 days) + +**Step 4.1: OpenCode Server Failure Scenarios** +```rust +#[tokio::test] +async fn test_opencode_server_unavailable() { + let env = TestEnvironment::setup().await; + let task = env.create_test_task(); + + // Configure with invalid OpenCode URL + env::set_var("OPENCODE_URL", "http://localhost:9999"); + + let response = test_client + .post(&format!("/api/tasks/{}/execute", task.id)) + .send().await?; + + // Should return 500 Internal Server Error + assert_eq!(response.status(), 500); + + // Task status should remain unchanged + let updated_task = env.task_repository.find_by_id(task.id).await?.unwrap(); + assert_eq!(updated_task.status, TaskStatus::Todo); +} +``` + +**Step 4.2: Database Consistency During Failures** +- Test: Session persistence rolled back on OpenCode failure +- Test: Task status remains consistent after network errors +- Test: Activity store cleanup on session failure +- Test: File system cleanup on workspace errors + +**Step 4.3: Concurrent Session Management** +```rust +#[tokio::test] +async fn test_concurrent_task_execution() { + if skip_if_no_opencode() { return; } + + let env = TestEnvironment::setup().await; + let tasks = (0..3).map(|_| env.create_test_task()).collect::>(); + + // Execute all tasks concurrently + let futures = tasks.iter().map(|task| { + test_client.post(&format!("/api/tasks/{}/execute", task.id)).send() + }); + + let results = futures::future::join_all(futures).await; + + // All should succeed + for result in results { + assert_eq!(result?.status(), 200); + } + + // Verify isolated execution (no state pollution) + for task in &tasks { + let updated_task = env.task_repository.find_by_id(task.id).await?.unwrap(); + assert!(updated_task.status != TaskStatus::Todo); + } +} +``` + +**Step 4.4: Resource Cleanup and Limits** +- Test: VCS workspace cleanup after session completion +- Test: Plan/review file cleanup policies +- Test: Activity store memory limits during long sessions +- Test: OpenCode session cleanup on abort + +### Phase 5: SSE Event Verification and Real-time Updates (2 days) + +**Step 5.1: Global Event Stream Testing** +```rust +#[tokio::test] +async fn test_global_event_stream_during_execution() { + if skip_if_no_opencode() { return; } + + let env = TestEnvironment::setup().await; + let task = env.create_test_task(); + + // Connect to global events stream + let sse_client = SSETestClient::new(&env.server_url); + let mut event_stream = sse_client.connect("/api/events").await?; + + // Trigger task execution + let _response = test_client + .post(&format!("/api/tasks/{}/execute", task.id)) + .send().await?; + + // Collect events for 30 seconds + let events = sse_client.collect_events_for(Duration::from_secs(30)).await; + + // Verify expected event sequence + assert!(events.iter().any(|e| matches!(e, Event::SessionStarted { task_id, .. } if *task_id == task.id))); + assert!(events.iter().any(|e| matches!(e, Event::TaskStatusChanged { task_id, .. } if *task_id == task.id))); + assert!(events.iter().any(|e| matches!(e, Event::SessionEnded { task_id, .. } if *task_id == task.id))); +} +``` + +**Step 5.2: Session-Specific Activity Stream** +- Test: `/api/sessions/{id}/activity` returns live OpenCode activity +- Test: Activity history + real-time streaming pattern +- Test: Reconnection delivers missed events +- Test: Activity parsing from OpenCode message parts + +**Step 5.3: Event Buffer and Reconnection** +```rust +#[tokio::test] +async fn test_activity_reconnection_with_history() { + if skip_if_no_opencode() { return; } + + let env = TestEnvironment::setup().await; + let task = env.create_test_task(); + + // Start execution to generate activity + let execute_future = test_client.post(&format!("/api/tasks/{}/execute", task.id)).send(); + + // Wait for session to start, then connect to activity stream + tokio::time::sleep(Duration::from_secs(2)).await; + + let session = env.session_repository.find_by_task_id(task.id).await?.first().unwrap().clone(); + let activity_stream = sse_client.connect(&format!("/api/sessions/{}/activity", session.id)).await?; + + // Should receive history + live updates + let activities = sse_client.collect_events_for(Duration::from_secs(20)).await; + assert!(!activities.is_empty()); + + execute_future.await?; +} +``` + +### Phase 6: Performance and Documentation (2 days) + +**Step 6.1: Performance Benchmarks** +- Test: API response times under normal load +- Test: Memory usage during multiple concurrent sessions +- Test: Database query performance during complex operations +- Test: File system I/O performance for plan/review operations + +**Step 6.2: Load Testing** +```rust +#[tokio::test] +async fn test_sustained_load_performance() { + if skip_if_no_opencode() { return; } + + let env = TestEnvironment::setup().await; + let start_time = Instant::now(); + + // Create 10 tasks and execute them sequentially + for i in 0..10 { + let task = env.create_test_task(); + let response = test_client + .post(&format!("/api/tasks/{}/execute", task.id)) + .send().await?; + assert_eq!(response.status(), 200); + } + + let total_time = start_time.elapsed(); + println!("10 sequential executions took: {:?}", total_time); + assert!(total_time < Duration::from_secs(300)); // 5 minute limit +} +``` + +**Step 6.3: Test Documentation and CI Integration** +- Create `docs/testing/integration_testing.md` with setup instructions +- Add integration test job to `.github/workflows/ci.yml` (optional) +- Document test environment variables and dependencies +- Add troubleshooting guide for common test failures + +--- + +## 4. Potential Risks + +### High Risk + +| Risk | Impact | Mitigation | +|------|--------|------------| +| **OpenCode server dependency for tests** | Tests cannot run without external service | Use comprehensive mocking with wiremock, implement optional integration mode with `OPENCODE_URL` env var | +| **Non-deterministic AI responses** | Flaky test failures due to varying OpenCode outputs | Assert on response structure/format rather than content, use controlled prompts, implement response validation patterns | +| **Long test execution times** | CI slowdown, developer workflow interruption | Implement test timeouts (5-30s per test), categorize fast vs. slow tests, use concurrent execution where safe | +| **Test data isolation failures** | Tests interfere with each other through shared state | Use isolated test databases per test case, implement thorough cleanup, use UUID-based test identifiers | + +### Medium Risk + +| Risk | Impact | Mitigation | +|------|--------|------------| +| **VCS workspace conflicts** | Tests fail due to workspace state pollution | Use temporary directories for each test, implement workspace cleanup, use isolated Git/Jujutsu repos | +| **Database transaction deadlocks** | Concurrent tests fail with database errors | Use test database connection pooling, implement retry logic, serialize database-heavy tests | +| **SSE connection management** | Event streams leak or fail to close properly | Implement connection timeouts, proper stream cleanup, connection pooling limits | +| **File system race conditions** | Plan/review file operations conflict | Use file locking, atomic write operations, unique file names per test | + +### Low Risk + +| Risk | Impact | Mitigation | +|------|--------|------------| +| **CI resource exhaustion** | Tests consume excessive CI resources | Monitor resource usage, implement resource limits, optimize test efficiency | +| **OpenCode API rate limiting** | Tests throttled during rapid execution | Add delays between OpenCode requests, implement request queuing | +| **Environment variable conflicts** | Test configuration interferes with development | Use test-specific environment variable prefixes, document configuration clearly | + +--- + +## 5. Estimated Complexity + +**Overall: XL (Extra Large)** + +| Phase | Complexity | Days | Rationale | +|-------|------------|------|-----------| +| Test Infrastructure Setup | L | 2 | Complex async test framework, OpenCode mocking, database setup | +| API Endpoint Integration | M | 3 | HTTP integration testing, database verification | +| Full Task Lifecycle | XL | 4 | Multi-phase OpenCode integration, VCS workspace management, file operations | +| Error Handling & Edge Cases | L | 3 | Network failures, concurrent scenarios, resource cleanup | +| SSE Events & Real-time | M | 2 | Event streaming, timing-sensitive tests | +| Performance & Documentation | S | 2 | Benchmarking, documentation | + +**Detailed Effort Breakdown:** +- **Test Infrastructure (2 days)**: OpenCode mock server, test database utilities, SSE test client, file system mocking +- **API Integration (3 days)**: CRUD operations, state transitions, basic execution endpoint testing +- **Lifecycle Testing (4 days)**: Planning → Implementation → Review → Done flow, VCS integration, file persistence +- **Error Scenarios (3 days)**: Network failures, database consistency, concurrent execution, resource limits +- **Real-time Events (2 days)**: SSE stream verification, activity streaming, reconnection logic +- **Performance & Docs (2 days)**: Load testing, benchmarks, documentation, CI integration + +**Total Estimated Effort: 16 days** + +### Complexity Factors + +**High Complexity Elements:** +- Async coordination between API, database, OpenCode, VCS, and file system +- OpenCode response parsing and activity message handling +- Concurrent session management and isolation +- State consistency verification across distributed operations +- SSE event timing and sequence verification + +**Medium Complexity Elements:** +- Test database setup and migration management +- HTTP integration testing patterns +- File system operations testing +- Error simulation and recovery testing + +**Low Complexity Elements:** +- Basic API endpoint testing +- Simple state transition verification +- Test fixture creation and cleanup +- Documentation writing + +--- + +## 6. Test Strategy + +### Test Pyramid Enhancement + +``` + /\ + / \ + / E2E \ (10-15 integration tests) + / \ + /--------\ + / Integration \ (35-50 tests total) + / \ + /----------------\ + / Unit Tests \ (existing 108+ tests) + /____________________\ +``` + +**Test Categories:** +- **Unit Tests (108+)**: Existing crate-level tests covering individual components +- **Integration Tests (35-50)**: New API integration tests with live/mocked OpenCode +- **End-to-End (10-15)**: Complete task lifecycle tests with full system integration + +### Test Execution Modes + +**Mode 1: Mock-Only Integration Tests (Default)** +```bash +# Fast execution, no external dependencies +cargo test --package server --test api_integration_test +``` + +**Mode 2: Live OpenCode Integration Tests** +```bash +# Requires running OpenCode server +OPENCODE_URL=http://localhost:4096 cargo test --package server --test api_integration_test +``` + +**Mode 3: Performance and Load Tests** +```bash +# Long-running performance tests +OPENCODE_URL=http://localhost:4096 cargo test --package server --test performance_test --release +``` + +### Environment Configuration + +```toml +# crates/server/Cargo.toml +[dev-dependencies] +wiremock = "0.6" +tokio-test = "0.4" +tempfile = "3.10" +uuid = { version = "1.6", features = ["v4"] } +futures = "0.3" + +[[test]] +name = "api_integration_test" +path = "tests/api_integration_test.rs" + +[[test]] +name = "performance_test" +path = "tests/performance_test.rs" +``` + +### Test Data Management + +```rust +// Test isolation strategy +pub struct TestEnvironment { + pub temp_dir: TempDir, // Isolated file system + pub db_url: String, // Unique test database + pub opencode_config: Configuration, + pub test_id: Uuid, // Test run identifier +} + +impl Drop for TestEnvironment { + fn drop(&mut self) { + // Automatic cleanup of all test resources + } +} +``` + +--- + +## 7. Success Criteria + +### Must Have (Required for Completion) +- [ ] **Full task lifecycle tested end-to-end** - Complete TODO→DONE automation verified +- [ ] **All OpenCode integration points covered** - Planning, implementation, review phases tested +- [ ] **Error handling scenarios verified** - OpenCode failures, network issues, timeouts handled gracefully +- [ ] **Database consistency maintained** - All operations maintain data integrity during failures +- [ ] **SSE event emission verified** - Real-time events properly emitted during task execution +- [ ] **VCS workspace integration tested** - Workspace creation, diff retrieval, cleanup working correctly +- [ ] **Concurrent session support** - Multiple OpenCode sessions can run simultaneously without interference + +### Should Have (Highly Desirable) +- [ ] **Performance benchmarks established** - Response time and resource usage metrics documented +- [ ] **Test execution time optimized** - Full integration test suite completes in under 10 minutes +- [ ] **Comprehensive error scenarios** - Network failures, database errors, file system issues covered +- [ ] **Activity stream verification** - Real-time activity updates tested end-to-end +- [ ] **Resource cleanup verified** - No resource leaks or orphaned processes after test completion + +### Nice to Have (Optional Enhancement) +- [ ] **CI integration configured** - Tests run automatically in CI environment +- [ ] **Load testing implemented** - System behavior under sustained load documented +- [ ] **Test documentation comprehensive** - Setup, troubleshooting, and maintenance guides available +- [ ] **Mock vs. live test modes** - Tests can run with both mocked and real OpenCode server + +--- + +## 8. Dependencies + +### Critical Dependencies +- **OpenCode Server**: Live OpenCode instance required for integration testing +- **Database**: SQLite database with migration capabilities +- **VCS**: Git or Jujutsu for workspace management testing +- **File System**: Write permissions for plan/review file operations + +### Development Dependencies +- **Rust Test Framework**: tokio-test, wiremock for async testing +- **Temporary Resources**: tempfile for isolated test environments +- **HTTP Client**: reqwest for API testing +- **Event Streaming**: SSE client capabilities for real-time verification + +### Optional Dependencies +- **Docker**: For containerized OpenCode testing environment +- **CI Environment**: GitHub Actions or similar for automated testing +- **Monitoring Tools**: Performance measurement and resource tracking + +--- + +## 9. Implementation Notes + +### Current Codebase Integration + +**Generated OpenCode Client Usage:** +```rust +// Current implementation in crates/orchestrator/src/executor.rs +use opencode_client::apis::configuration::Configuration; +use opencode_client::apis::default_api; +use opencode_client::models::{SessionCreateRequest, SessionPromptRequest}; +``` + +**Key Architectural Components:** +- `TaskExecutor` in `crates/orchestrator/src/executor.rs` - Main OpenCode integration point +- `SessionActivityRegistry` - Real-time activity management +- `FileManager` - Plan/review file persistence +- `WorkspaceManager` - VCS integration for code changes + +### Test Infrastructure Patterns + +**Following Existing Patterns from Current Tests:** +1. **Isolated Test Databases**: Each test uses separate SQLite database +2. **Temporary Directories**: Use tempfile crate for file system isolation +3. **Async Test Coordination**: tokio-test for async test execution +4. **Mock Server Integration**: wiremock for controlled OpenCode simulation + +### Critical Testing Areas + +**State Machine Verification:** +- Task status transitions follow defined state machine rules +- Invalid transitions properly rejected +- Database and memory state remain consistent + +**Event System Testing:** +- EventBus properly emits events during operations +- SSE streams deliver events in correct order +- Event buffers handle reconnection scenarios + +**Resource Management:** +- VCS workspaces created and cleaned up properly +- OpenCode sessions properly terminated +- Activity stores don't leak memory during long operations + +--- + +**Next Steps:** +1. **Environment Setup**: Configure development environment with required dependencies +2. **Phase 1 Implementation**: Begin with test infrastructure setup (OpenCode mock, database utils) +3. **Incremental Development**: Implement one test phase at a time with regular verification +4. **Stabilization**: Run tests repeatedly to identify and fix flaky behavior +5. **Documentation**: Document test setup, execution, and troubleshooting procedures diff --git a/.opencode-studio/kanban/plans/7ae0d472-d61f-41db-9451-6da9e344654b.md b/.opencode-studio/kanban/plans/7ae0d472-d61f-41db-9451-6da9e344654b.md new file mode 100644 index 0000000..2f3cac5 --- /dev/null +++ b/.opencode-studio/kanban/plans/7ae0d472-d61f-41db-9451-6da9e344654b.md @@ -0,0 +1,246 @@ +# Implementation Plan: Final Test + +**Task ID:** 7ae0d472-d61f-41db-9451-6da9e344654b +**Title:** Final test +**Description:** x +**Created:** 2025-01-01T01:36:13+01:00 + +## 1. Technical Analysis + +### Context Assessment +Based on the minimal task description "x", this appears to be a comprehensive system validation test for OpenCode Studio. Given the project's current state: + +- **Recent migrations completed:** WebSocket → SSE, OpenCode client SDK migration +- **Backend state:** 108+ passing tests, clean clippy, 9 crates in workspace +- **Frontend state:** Next.js integration with Rust backend, Orval-generated API hooks +- **Integration status:** Full task lifecycle automation (TODO→DONE) implemented + +### Interpretation +This "Final test" likely represents a comprehensive end-to-end validation of: +1. Complete task lifecycle automation +2. SSE real-time communication +3. OpenCode integration functionality +4. CLI user experience +5. Frontend/backend API integration + +### Technical Scope +- **System integration testing:** Full stack validation +- **Workflow testing:** Complete task lifecycle (7 states) +- **Real-time features:** SSE events and activity streaming +- **OpenCode integration:** AI-powered task execution +- **User experience:** CLI + Web UI workflows + +## 2. Files to Modify/Create + +### Test Files to Create +``` +tests/ +├── integration/ +│ ├── final_system_test.rs # Main integration test suite +│ ├── task_lifecycle_test.rs # Complete workflow validation +│ ├── sse_integration_test.rs # Real-time communication tests +│ └── opencode_integration_test.rs # OpenCode execution validation +├── e2e/ +│ ├── cli_workflow_test.rs # CLI user experience tests +│ └── web_ui_workflow_test.rs # Frontend workflow tests +└── fixtures/ + ├── test_project/ # Sample project for testing + └── test_scenarios.json # Test case definitions +``` + +### Configuration Files +``` +.opencode-studio/ +├── test-config.toml # Test environment configuration +└── kanban/ + ├── test-plans/ # Test plan storage + └── test-reviews/ # Test review storage +``` + +### Documentation Files +``` +docs/ +├── testing/ +│ ├── final-test-results.md # Test execution results +│ ├── performance-benchmarks.md # Performance validation +│ └── integration-report.md # Integration test report +└── TESTING.md # Updated testing documentation +``` + +## 3. Step-by-Step Implementation Steps + +### Phase 1: Test Infrastructure Setup +1. **Create test workspace** + - Initialize isolated test environment + - Set up test database and configuration + - Prepare test project fixtures + +2. **Configure test harness** + - Set up integration test framework + - Configure mock OpenCode server if needed + - Initialize test data and scenarios + +### Phase 2: Backend Integration Testing +1. **Database and persistence tests** + - Verify all 9 crate interactions + - Test task/session CRUD operations + - Validate data consistency across operations + +2. **OpenCode integration validation** + - Test OpenCode client SDK functionality + - Verify session creation and management + - Validate file modification tracking + +3. **SSE communication testing** + - Test event broadcasting (TaskStatusChanged, SessionStarted, etc.) + - Verify event buffer and reconnection logic + - Validate activity streaming per session + +### Phase 3: Task Lifecycle Validation +1. **Complete workflow automation** + ``` + TODO → PLANNING → PLANNING_REVIEW → IN_PROGRESS → AI_REVIEW → REVIEW → DONE + ``` + - Test each state transition + - Verify OpenCode session creation per phase + - Validate file generation (plans, reviews) + +2. **Error handling and recovery** + - Test timeout scenarios (30s execution limit) + - Validate failure state handling + - Test retry mechanisms + +3. **VCS integration testing** + - Test Jujutsu workspace management + - Validate Git fallback functionality + - Test conflict resolution workflows + +### Phase 4: Frontend Integration Testing +1. **API connectivity validation** + - Test all 25+ REST endpoints + - Verify Orval-generated types and hooks + - Validate real-time updates via SSE + +2. **UI workflow testing** + - Test Kanban board functionality + - Validate task detail panel updates + - Test session activity feed + +3. **Type safety validation** + - Verify no TypeScript compilation errors + - Test proper error boundary functionality + - Validate loading states and error handling + +### Phase 5: CLI Experience Testing +1. **Single-command workflow** + - Test `opencode-studio` auto-initialization + - Verify frontend download and serving + - Validate browser auto-opening + +2. **Project management** + - Test project initialization + - Verify workspace detection (jj/git) + - Test configuration management + +### Phase 6: Performance and Load Testing +1. **Concurrent operations** + - Test multiple task executions + - Verify SSE connection scaling + - Test database performance under load + +2. **Resource usage validation** + - Monitor memory usage during long operations + - Test OpenCode session cleanup + - Verify file system resource management + +### Phase 7: End-to-End Scenarios +1. **Complete user workflows** + - New user onboarding (`opencode-studio init`) + - Task creation → execution → completion + - Multiple project management + +2. **Integration scenarios** + - GitHub integration workflows + - Complex task dependencies + - Error recovery and human intervention + +### Phase 8: Documentation and Reporting +1. **Generate comprehensive test report** + - Performance benchmarks + - Feature coverage analysis + - Integration status summary + +2. **Update documentation** + - Test results and findings + - Known limitations or issues + - Recommendations for production deployment + +## 4. Potential Risks + +### High Risk +- **OpenCode integration timeouts:** The 30-second timeout issue previously identified + - *Mitigation:* Implement proper async handling and status polling + +- **SSE connection stability:** New SSE implementation under load + - *Mitigation:* Stress testing and connection recovery validation + +- **Database concurrency issues:** SQLite under concurrent access + - *Mitigation:* Transaction testing and lock contention analysis + +### Medium Risk +- **VCS workspace conflicts:** Jujutsu/Git operation conflicts + - *Mitigation:* Comprehensive conflict scenario testing + +- **Frontend state synchronization:** Real-time UI updates with SSE + - *Mitigation:* Race condition testing and state consistency validation + +- **File system race conditions:** Concurrent file operations + - *Mitigation:* Atomic operation testing and file locking validation + +### Low Risk +- **Test environment isolation:** Test data contamination + - *Mitigation:* Proper test cleanup and isolation + +- **Performance degradation:** Resource leaks during testing + - *Mitigation:* Memory and resource monitoring + +## 5. Estimated Complexity: **L (Large)** + +### Justification +- **Scope:** Comprehensive system-wide validation across 9 crates +- **Dependencies:** Integration of multiple complex systems (OpenCode, VCS, SSE) +- **Test coverage:** End-to-end workflows with real external dependencies +- **Risk factors:** Multiple integration points with potential failure modes +- **Time estimate:** 2-3 days for complete implementation and validation + +### Complexity Breakdown +- **Test infrastructure setup:** Medium (1 day) +- **Integration test implementation:** High (1-2 days) +- **Frontend/UI testing:** Medium (0.5 days) +- **Documentation and reporting:** Low (0.5 days) + +### Success Criteria +1. All existing 108+ backend tests continue to pass +2. New integration tests achieve >90% coverage of critical paths +3. Complete task lifecycle executes successfully in <30 seconds +4. SSE communication remains stable under normal load +5. CLI workflow completes successfully from init to task completion +6. Frontend UI reflects backend state changes in real-time +7. OpenCode integration executes tasks without timeout errors +8. Documentation accurately reflects current system capabilities + +### Dependencies +- OpenCode server must be running and accessible +- Test project fixtures must be prepared +- Database migrations must be current +- Frontend build must be successful +- All recent migrations (SSE, OpenCode client) must be stable + +--- + +**Next Steps:** +1. Review and approve this implementation plan +2. Set up test environment and fixtures +3. Begin Phase 1 test infrastructure setup +4. Execute phases sequentially with validation checkpoints +5. Generate final test report and recommendations \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/92361bd1-a25e-414a-a417-5a7f733c96cc.md b/.opencode-studio/kanban/plans/92361bd1-a25e-414a-a417-5a7f733c96cc.md new file mode 100644 index 0000000..e256b55 --- /dev/null +++ b/.opencode-studio/kanban/plans/92361bd1-a25e-414a-a417-5a7f733c96cc.md @@ -0,0 +1,335 @@ +# Implementation Plan: Add Greeting Function + +## Task Overview +**Title:** Add greeting function +**Description:** Create a simple greeting.rs file in crates/core/src/ with a pub fn greet(name: &str) -> String function that returns Hello, {name}! +**Task ID:** 92361bd1-a25e-414a-a417-5a7f733c96cc +**Generated:** 2025-12-31T19:55:51Z +**Updated:** 2025-12-31T20:55:51Z +**Complexity:** S (Small) +**Estimated Time:** 5-10 minutes + +## 1. Technical Analysis + +### Current State +- The `opencode_core` crate follows a clean domain-driven architecture +- Current structure in `crates/core/src/`: + - `lib.rs` - Main module file that re-exports domain modules + - `domain/mod.rs` - Domain module aggregator (contains session.rs, task.rs) + - `error.rs` - Error handling types +- The crate exports as `opencode_core` to avoid Rust reserved word conflicts +- No existing greeting functionality present + +### Proposed Solution +Add a simple utility function at the root level of the crate. This placement is appropriate since greeting functionality is a utility function rather than core business logic, and should remain outside the domain layer. + +### Architecture Considerations +- The greeting function must be pure (no I/O) to align with the core crate's constraints +- Should follow standard Rust conventions for public APIs +- Minimal implementation with clear, testable behavior +- Follows the "NO I/O" rule for the core crate as specified in AGENTS.md + +### Dependencies & Integration +- No external dependencies required (uses only std library) +- No impact on existing workspace dependency graph +- Will be accessible as `opencode_core::greet` from other crates + +## 2. Files to Create/Modify + +### 2.1 Create `crates/core/src/greeting.rs` +**Type:** New File +**Purpose:** Contains the greeting function implementation + +**Content Structure:** +```rust +/// Generates a greeting message for the given name +/// +/// # Arguments +/// * `name` - The name to include in the greeting +/// +/// # Returns +/// A String containing "Hello, {name}!" +/// +/// # Examples +/// ``` +/// use opencode_core::greet; +/// +/// let message = greet("World"); +/// assert_eq!(message, "Hello, World!"); +/// ``` +pub fn greet(name: &str) -> String { + format!("Hello, {}!", name) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_greet_simple() { + let result = greet("World"); + assert_eq!(result, "Hello, World!"); + } + + #[test] + fn test_greet_empty_string() { + let result = greet(""); + assert_eq!(result, "Hello, !"); + } + + #[test] + fn test_greet_with_spaces() { + let result = greet("John Doe"); + assert_eq!(result, "Hello, John Doe!"); + } + + #[test] + fn test_greet_unicode() { + let result = greet("世界"); + assert_eq!(result, "Hello, 世界!"); + } +} +``` + +### 2.2 Modify `crates/core/src/lib.rs` +**Type:** File Modification +**Purpose:** Add module declaration and public re-export + +**Current Content (lines 1-6):** +```rust +pub mod domain; +pub mod error; + +pub use domain::*; +pub use error::*; +``` + +**Required Changes:** +```rust +pub mod domain; +pub mod error; +pub mod greeting; // ADD THIS LINE + +pub use domain::*; +pub use error::*; +pub use greeting::*; // ADD THIS LINE +``` + +## 3. Step-by-Step Implementation + +### Step 1: Create the greeting module +1. Navigate to `crates/core/src/` +2. Create new file `greeting.rs` +3. Implement the function with: + - Complete rustdoc documentation with examples + - Main `greet` function implementation using `format!` macro + - Comprehensive test suite covering edge cases: + - Basic functionality test + - Empty string handling + - Multi-word names with spaces + - Unicode character support + +### Step 2: Update module system +1. Open `crates/core/src/lib.rs` +2. Add `pub mod greeting;` declaration after existing module declarations +3. Add `pub use greeting::*;` re-export after existing re-exports +4. Maintain consistent formatting with existing code + +### Step 3: Verify implementation +1. **Compilation check:** `cargo check -p opencode_core` +2. **Test execution:** `cargo test -p opencode_core` +3. **Lint verification:** `cargo clippy -p opencode_core -- -D warnings` +4. **Format check:** `cargo fmt` +5. **Documentation test:** Verify rustdoc examples work correctly + +### Step 4: Integration verification +1. Verify the function can be imported as `opencode_core::greet` +2. Check that existing exports still work correctly +3. Ensure no breaking changes to the public API +4. Confirm workspace-level tests still pass: `cargo test --workspace` + +## 4. Potential Risks + +### Low Risk Items + +**4.1 Module System Integration** +- **Risk:** The module might not be properly exposed through lib.rs +- **Impact:** Function not accessible from other crates +- **Mitigation:** Follow exact pattern used by existing modules (domain, error) +- **Detection:** Test import with `use opencode_core::greet;` + +**4.2 Function Signature Compliance** +- **Risk:** Function might not match exact specification +- **Impact:** Does not meet requirements +- **Mitigation:** Implement exactly as specified: `pub fn greet(name: &str) -> String` +- **Detection:** Unit tests verify exact output format + +### Minimal Risk Items + +**4.3 Breaking Changes** +- **Risk:** New public API might conflict with existing code +- **Impact:** Build failures in dependent crates +- **Assessment:** Extremely unlikely - this is purely additive +- **Mitigation:** New function addition only, no modifications to existing code + +**4.4 Performance Impact** +- **Risk:** String allocation on each call +- **Impact:** Slight memory overhead +- **Assessment:** Acceptable for a utility function +- **Mitigation:** Using efficient `format!` macro, standard approach + +**4.5 Memory Safety** +- **Risk:** String handling issues +- **Impact:** Runtime errors or memory leaks +- **Assessment:** Negligible - using standard library functions +- **Mitigation:** Rust's memory safety guarantees apply, no unsafe code + +### Risk Mitigation Matrix + +| Risk | Likelihood | Impact | Mitigation Strategy | +|------|------------|---------|-------------------| +| Module integration | Low | Medium | Follow existing patterns exactly | +| Function signature | Very Low | Medium | Implement per spec, test thoroughly | +| Breaking changes | Very Low | High | Additive changes only | +| Performance | Low | Low | Accept trade-off for simplicity | +| Memory safety | Very Low | High | Use standard library only | + +## 5. Testing Strategy + +### 5.1 Unit Tests (Included in implementation) +```rust +#[test] +fn test_greet_simple() { + let result = greet("World"); + assert_eq!(result, "Hello, World!"); +} + +#[test] +fn test_greet_empty_string() { + let result = greet(""); + assert_eq!(result, "Hello, !"); +} + +#[test] +fn test_greet_with_spaces() { + let result = greet("John Doe"); + assert_eq!(result, "Hello, John Doe!"); +} + +#[test] +fn test_greet_unicode() { + let result = greet("世界"); + assert_eq!(result, "Hello, 世界!"); +} +``` + +### 5.2 Integration Tests +- **Module Export Test:** Verify `use opencode_core::greet` works from external code +- **Documentation Test:** Ensure rustdoc examples compile and run correctly +- **Workspace Test:** Confirm no regressions in other crates + +### 5.3 Verification Commands +```bash +# 1. Compilation verification +cargo check -p opencode_core + +# 2. Test execution +cargo test -p opencode_core + +# 3. Lint checking (strict warnings) +cargo clippy -p opencode_core -- -D warnings + +# 4. Format verification +cargo fmt --check + +# 5. Workspace-wide test +cargo test --workspace + +# 6. Documentation test +cargo test --doc -p opencode_core +``` + +### 5.4 Test Coverage Expectations +- **Function coverage:** 100% (all branches covered) +- **Edge case coverage:** 90%+ (empty strings, Unicode, spaces) +- **Documentation coverage:** 100% (all examples tested) + +## 6. Estimated Complexity: S (Small) + +### 6.1 Complexity Justification +- **Single function implementation** - minimal scope +- **No external dependencies** - uses only std library +- **No database changes** - pure function only +- **No API modifications** - internal utility function +- **Straightforward testing** - clear input/output relationship +- **Well-defined scope** - exact specification provided +- **Zero breaking changes** - additive only + +### 6.2 Time Estimation Breakdown +| Activity | Estimated Time | Percentage | +|----------|---------------|------------| +| File creation & function implementation | 3-5 minutes | 40% | +| Test suite development | 2-3 minutes | 25% | +| Module integration (lib.rs) | 1-2 minutes | 15% | +| Documentation & rustdoc | 2-3 minutes | 20% | +| **Total Implementation Time** | **8-13 minutes** | **100%** | + +### 6.3 Confidence Assessment +- **Confidence Level:** Very High (95%+) +- **Risk of overrun:** Very Low +- **Complexity creep potential:** None (scope well-defined) +- **Dependency on external factors:** None + +## 7. Success Criteria + +### 7.1 Functional Requirements +- [ ] Function `greet(name: &str) -> String` exists and is publicly accessible +- [ ] Function returns exactly `"Hello, {name}!"` format for any input +- [ ] Function handles edge cases gracefully (empty strings, Unicode, spaces) +- [ ] Function is accessible as `opencode_core::greet` from external crates +- [ ] All test cases pass successfully + +### 7.2 Technical Requirements +- [ ] Code compiles without errors: `cargo check -p opencode_core` +- [ ] All tests pass: `cargo test -p opencode_core` +- [ ] Lint checks pass: `cargo clippy -p opencode_core -- -D warnings` +- [ ] Code formatting is correct: `cargo fmt --check` +- [ ] Documentation tests pass: `cargo test --doc -p opencode_core` +- [ ] Workspace tests still pass: `cargo test --workspace` + +### 7.3 Code Quality Requirements +- [ ] Function includes comprehensive rustdoc documentation +- [ ] Documentation includes working examples +- [ ] Test coverage > 90% for new code +- [ ] Follows project Rust conventions and style guidelines +- [ ] No new clippy warnings introduced +- [ ] Maintains crate's "no I/O" constraint + +### 7.4 Integration Requirements +- [ ] Module properly declared in `lib.rs` +- [ ] Function properly exported through `pub use` +- [ ] No conflicts with existing module names +- [ ] No breaking changes to existing API surface +- [ ] Function works from other crates in workspace + +## 8. Implementation Notes + +### 8.1 Design Decisions +- **Placement:** Root level of crate (not in domain/) since this is utility functionality +- **Error Handling:** Minimal - `format!` cannot fail with basic string inputs +- **Performance:** Accepting String allocation for simplicity and clarity +- **API Design:** Using `&str` parameter for efficiency (no unnecessary allocations) + +### 8.2 Code Style Adherence +- Follow existing rustdoc comment patterns +- Use consistent indentation and formatting +- Include comprehensive examples in documentation +- Maintain inline test pattern: `#[cfg(test)] mod tests` + +### 8.3 Future Extensibility +- Function is designed to be self-contained +- Could be extended later for internationalization +- Template-based greeting formats could be added +- No architectural constraints for future enhancements + +This implementation plan ensures a clean, well-tested, and properly integrated greeting function that follows all project conventions and requirements. \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/9976ffdf-9ff8-44f7-85c4-b71602352831.md b/.opencode-studio/kanban/plans/9976ffdf-9ff8-44f7-85c4-b71602352831.md new file mode 100644 index 0000000..3a17e78 --- /dev/null +++ b/.opencode-studio/kanban/plans/9976ffdf-9ff8-44f7-85c4-b71602352831.md @@ -0,0 +1,262 @@ +# SSE Test 3 - Implementation Plan + +## Task Overview +**Title:** SSE Test 3 +**Description:** test +**Complexity:** M (Medium) +**Estimated Time:** 4-6 hours + +## Technical Analysis + +### Context +This is the third iteration of Server-Sent Events (SSE) testing for OpenCode Studio. Previous tests identified several issues: + +1. `/api/sessions/{id}/activity` endpoint returning empty responses +2. `POST /api/tasks/{id}/execute` timing out after 30 seconds +3. Task status discrepancies between OpenCode completion and Studio DB +4. Need for comprehensive real-time event verification + +### Current SSE Infrastructure Status +- ✅ Backend SSE Infrastructure (Feature 1) - Complete +- ✅ Frontend SSE Hooks (Feature 2) - Complete +- ✅ Backend Activity Message Serialization (Feature 3) - Complete +- 🔄 WebSocket Code Cleanup (Feature 4) - In progress +- ⏳ Documentation & Testing (Feature 5) - Pending + +### Test Objectives +Based on the migration status and previous test results, this test should focus on: + +1. **Session Activity Stream Validation** - Fix empty activity responses +2. **Task Lifecycle Event Integrity** - Ensure real-time status updates work end-to-end +3. **SSE Connection Resilience** - Test auto-reconnect and event replay +4. **Frontend Hook Integration** - Verify `useEventStream` and `useSessionActivitySSE` +5. **Load Testing** - Multiple concurrent SSE connections + +## Files to Modify/Create + +### Test Files to Create +``` +tests/integration/ +├── sse_test_3.rs # Main integration test +├── helpers/ +│ ├── sse_client.rs # SSE client for testing +│ └── task_lifecycle_helper.rs # Task creation/execution helpers +└── fixtures/ + └── test_tasks.json # Test task definitions +``` + +### Files to Potentially Modify +``` +crates/server/src/ +├── routes/sessions.rs # Session activity endpoint fixes +├── routes/events.rs # Global SSE endpoint improvements +└── routes/tasks.rs # Task execution timeout handling + +crates/orchestrator/src/ +├── executor.rs # Event emission during task execution +└── activity_store.rs # Activity message persistence + +crates/events/src/ +├── bus.rs # Event bus reliability improvements +└── types.rs # Event type definitions + +frontend/src/ +├── hooks/useEventStream.ts # Connection resilience testing +├── hooks/useSessionActivitySSE.ts # Session-specific SSE testing +└── __tests__/ + └── sse-hooks.test.tsx # Frontend hook unit tests +``` + +## Step-by-Step Implementation + +### Phase 1: Diagnostic Investigation (1-2 hours) +1. **Reproduce Previous Issues** + - Set up task execution with SSE monitoring + - Capture network traffic for `/api/sessions/{id}/activity` + - Document exact failure scenarios + +2. **Activity Store Audit** + - Verify `ActivityStore` is properly storing session messages + - Check database state after task execution + - Validate event emission timing + +3. **SSE Endpoint Analysis** + - Test `/api/events` global stream + - Test `/api/sessions/{id}/activity` per-session stream + - Verify EventBuffer functionality + +### Phase 2: Backend Fixes (1-2 hours) +1. **Session Activity Endpoint Fix** + ```rust + // In crates/server/src/routes/sessions.rs + async fn get_session_activity( + Path(session_id): Path, + State(app_state): State, + ) -> Result { + // Fix: Ensure activity messages are properly retrieved + // Fix: Verify SSE formatting of activity events + } + ``` + +2. **Task Execution Timeout Handling** + ```rust + // In crates/server/src/routes/tasks.rs + async fn execute_task( + Path(task_id): Path, + State(app_state): State, + ) -> Result { + // Fix: Implement proper async task execution + // Fix: Return immediately with 202 Accepted + // Fix: Use background processing for long-running tasks + } + ``` + +3. **Event Emission Verification** + ```rust + // In crates/orchestrator/src/executor.rs + // Ensure proper event emission at each lifecycle stage: + // - task.status_changed (TODO → PLANNING → IN_PROGRESS → etc.) + // - session.started + // - session.activity (for each OpenCode interaction) + // - session.completed + ``` + +### Phase 3: Comprehensive Integration Test (1-2 hours) +1. **Create SSE Test Client** + ```rust + // tests/integration/helpers/sse_client.rs + struct SSETestClient { + client: reqwest::Client, + base_url: String, + } + + impl SSETestClient { + async fn connect_global_stream(&self) -> SSEStream; + async fn connect_session_stream(&self, session_id: Uuid) -> SSEStream; + async fn wait_for_event(&mut self, event_type: &str, timeout: Duration) -> Option; + } + ``` + +2. **Full Task Lifecycle Test** + ```rust + // tests/integration/sse_test_3.rs + #[tokio::test] + async fn test_complete_task_lifecycle_with_sse() { + // 1. Connect to global SSE stream + // 2. Create a test task + // 3. Execute task (non-blocking) + // 4. Monitor SSE events for: + // - task.status_changed events + // - session.started event + // - session.activity events + // - session.completed event + // 5. Verify final task status in database + // 6. Verify session activity history + } + ``` + +3. **Concurrent Connection Test** + ```rust + #[tokio::test] + async fn test_multiple_concurrent_sse_connections() { + // Test 5-10 concurrent SSE connections + // Verify all receive the same events + // Test connection drops and reconnects + } + ``` + +### Phase 4: Frontend Integration Verification (30-60 minutes) +1. **Hook Testing** + ```typescript + // frontend/src/__tests__/sse-hooks.test.tsx + describe('SSE Hooks', () => { + test('useEventStream handles reconnection', () => { + // Test auto-reconnect functionality + }); + + test('useSessionActivitySSE receives activity events', () => { + // Test session-specific activity stream + }); + }); + ``` + +2. **Manual Browser Testing** + - Open developer tools Network tab + - Execute a task through the UI + - Verify SSE connections in Network tab + - Verify real-time UI updates + +### Phase 5: Documentation and Cleanup (30 minutes) +1. **Update Test Documentation** + - Document test results in AGENTS.md + - Update SSE migration status + - Note any remaining issues + +2. **Clean Up Test Artifacts** + - Remove temporary test files if needed + - Ensure no test data pollution in database + +## Potential Risks + +### High Risk +1. **Activity Store Race Conditions** + - Risk: Events emitted before ActivityStore is ready + - Mitigation: Add proper synchronization and event ordering + +2. **Database Transaction Issues** + - Risk: Task status updates in separate transactions causing inconsistency + - Mitigation: Use database transactions properly for state changes + +### Medium Risk +1. **SSE Connection Limits** + - Risk: Too many concurrent connections could overwhelm server + - Mitigation: Implement connection limits and graceful degradation + +2. **Event Message Size** + - Risk: Large activity messages could cause SSE performance issues + - Mitigation: Implement message size limits and pagination + +### Low Risk +1. **Browser SSE Implementation Differences** + - Risk: Different browsers handle SSE differently + - Mitigation: Test in multiple browsers, use EventSource polyfill if needed + +2. **Network Connectivity Issues** + - Risk: Flaky network causing test failures + - Mitigation: Implement proper retry logic in tests + +## Expected Outcomes + +### Success Criteria +1. ✅ `/api/sessions/{id}/activity` returns proper activity events +2. ✅ Task execution no longer times out on the API level +3. ✅ Real-time task status updates work end-to-end +4. ✅ Multiple concurrent SSE connections work reliably +5. ✅ Frontend hooks properly handle reconnection and event replay +6. ✅ All existing tests continue to pass (108+ backend tests) +7. ✅ Clean clippy run with `-D warnings` + +### Performance Targets +- SSE connection establishment: < 100ms +- Event delivery latency: < 50ms +- Support for 20+ concurrent SSE connections +- Task execution API response: < 1 second (returns 202 Accepted) + +### Deliverables +1. **Fixed SSE Endpoints** - Session activity and global event streams working properly +2. **Comprehensive Integration Tests** - Full task lifecycle with SSE monitoring +3. **Performance Validation** - Concurrent connection handling verified +4. **Updated Documentation** - AGENTS.md reflects SSE testing status +5. **Frontend Validation** - UI real-time updates working properly + +## Next Steps After Completion + +1. **Feature 4 Completion** - Continue WebSocket code cleanup +2. **Feature 5 Implementation** - Complete documentation & testing phase +3. **Production Readiness** - Implement monitoring and alerting for SSE health +4. **Load Testing** - More comprehensive performance testing with realistic loads + +--- + +*Generated: 2025-01-01T01:36:13Z* +*Task ID: 9976ffdf-9ff8-44f7-85c4-b71602352831* \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/9f333a20-9cff-4b76-82a3-b33115066584.md b/.opencode-studio/kanban/plans/9f333a20-9cff-4b76-82a3-b33115066584.md new file mode 100644 index 0000000..3c2c759 --- /dev/null +++ b/.opencode-studio/kanban/plans/9f333a20-9cff-4b76-82a3-b33115066584.md @@ -0,0 +1,132 @@ +# Implementation Plan: Změň title aplikace na BiCom Platform v2 + +**Task ID:** 9f333a20-9cff-4b76-82a3-b33115066584 +**Created:** 2025-01-01T01:36:00Z +**Estimated Complexity:** S (Small) + +## Technical Analysis + +The task requires changing the application title from "OpenCode Studio" to "BiCom Platform v2" across multiple locations in the codebase. Based on codebase analysis, the application name appears in: + +1. **Frontend HTML title** - Main browser tab title +2. **Backend API specification** - OpenAPI documentation +3. **CLI tool descriptions** - Command-line interface messages +4. **Package metadata** - NPM package naming +5. **Generated API files** - Auto-generated from OpenAPI spec (will update automatically) + +The change is primarily cosmetic and affects user-facing strings without modifying core functionality. + +## Files to Modify + +### Primary Files (Manual Changes Required) + +| File | Line(s) | Current Value | New Value | +|------|---------|---------------|-----------| +| `frontend/index.html` | 7 | `OpenCode Studio` | `BiCom Platform v2` | +| `crates/server/src/lib.rs` | 19 | `title = "OpenCode Studio API"` | `title = "BiCom Platform v2 API"` | +| `crates/server/src/lib.rs` | 21 | `description = "API for OpenCode Studio - AI-powered development platform"` | `description = "API for BiCom Platform v2 - AI-powered development platform"` | +| `crates/cli/src/main.rs` | 52, 58, 248, 308, 423, 549, 617 | Various "OpenCode Studio" references | Replace with "BiCom Platform v2" | +| `crates/cli/Cargo.toml` | 5 | `description = "CLI for OpenCode Studio - AI-powered development platform"` | `description = "CLI for BiCom Platform v2 - AI-powered development platform"` | +| `frontend/package.json` | 2 | `"name": "opencode-studio"` | `"name": "bicom-platform-v2"` | + +### Auto-Generated Files (No Manual Changes) + +- **All files in `frontend/src/api/generated/`** - These will be automatically updated when the OpenAPI spec is regenerated after changing `crates/server/src/lib.rs` + +### Documentation Files (Optional - Depends on Scope) + +- `agents.md` - Root documentation +- `product-prd.md` - Product requirements document +- `frontend/AGENTS.md` - Frontend documentation +- `crates/AGENTS.md` - Backend documentation +- Various roadmap files + +## Step-by-Step Implementation + +### Phase 1: Core Application Files +1. **Update frontend HTML title** + - Modify `frontend/index.html` line 7 + - Change `OpenCode Studio` to `BiCom Platform v2` + +2. **Update backend API specification** + - Modify `crates/server/src/lib.rs` lines 19 and 21 + - Update OpenAPI title and description + +3. **Update CLI package description** + - Modify `crates/cli/Cargo.toml` line 5 + - Update package description + +### Phase 2: CLI Messages +4. **Update CLI user messages** + - Modify `crates/cli/src/main.rs` + - Replace all instances of "OpenCode Studio" with "BiCom Platform v2" in user-facing messages + - Lines to update: 52, 58, 248, 308, 423, 549, 617 + +### Phase 3: Package Metadata +5. **Update frontend package name** + - Modify `frontend/package.json` line 2 + - Change package name from "opencode-studio" to "bicom-platform-v2" + +### Phase 4: Regenerate API Client +6. **Regenerate frontend API client** + - Run `cd frontend && pnpm generate:api` + - This will update all auto-generated API files with new titles + +### Phase 5: Verification +7. **Build and test** + - Run `pnpm build` to ensure no build errors + - Test frontend in browser to verify title appears correctly + - Verify CLI help messages show new name + - Check OpenAPI documentation at `/swagger-ui` + +## Potential Risks + +### Low Risk Issues +- **Browser caching:** Users might need to hard refresh to see the new title +- **Package name conflicts:** New NPM package name might conflict (unlikely with private package) + +### Medium Risk Issues +- **Documentation inconsistency:** Documentation files might contain stale references if not updated +- **CLI script references:** Any deployment or build scripts referencing the old name might break + +### Mitigation Strategies +- **Test thoroughly:** Run full build and manual testing +- **Clear documentation:** Update key documentation files if within scope +- **Gradual rollout:** Deploy to staging environment first + +## Testing Checklist + +- [ ] Frontend title displays "BiCom Platform v2" in browser tab +- [ ] CLI `--help` shows new application name +- [ ] OpenAPI documentation at `/swagger-ui` shows new API title +- [ ] Build completes without errors (`pnpm build`) +- [ ] Frontend package installs correctly +- [ ] Generated API client files contain new references + +## Success Criteria + +1. **Browser tab title** shows "BiCom Platform v2" +2. **CLI tool** references new name in all user messages +3. **API documentation** reflects new branding +4. **No build errors** after changes +5. **All generated files** updated automatically + +## Estimated Complexity: S (Small) + +**Rationale:** +- Simple string replacements in known locations +- No logic changes required +- Auto-generation handles most derivative files +- Low risk of breaking functionality +- Estimated time: 30-60 minutes including testing + +## Dependencies + +- **None** - This is a standalone cosmetic change +- **Build tools** - Requires functional build environment for regeneration and testing + +## Notes + +- Consider updating major documentation files (`agents.md`, `product-prd.md`) if this is part of a larger rebranding effort +- The package name change in `frontend/package.json` is cosmetic for a private package but maintains consistency +- All generated API client files will automatically reflect the new name after regeneration \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/aaa6885f-7257-47ad-b1a9-d0818708cd49.md b/.opencode-studio/kanban/plans/aaa6885f-7257-47ad-b1a9-d0818708cd49.md new file mode 100644 index 0000000..e9e1c54 --- /dev/null +++ b/.opencode-studio/kanban/plans/aaa6885f-7257-47ad-b1a9-d0818708cd49.md @@ -0,0 +1,173 @@ +# Implementation Plan: SSE Test 2 + +## Task Overview +- **Title:** SSE Test 2 +- **Description:** test +- **Type:** Testing/Verification +- **Priority:** Medium + +## Technical Analysis + +### Context +This task appears to be a follow-up test for the Server-Sent Events (SSE) functionality in OpenCode Studio. The system has recently migrated from WebSocket to SSE for real-time communication, and previous testing revealed some issues that need verification. + +### Current SSE Infrastructure +- **Backend SSE Endpoints:** + - `/api/events` - Global SSE event stream + - `/api/sessions/{id}/activity` - Per-session activity stream +- **Frontend Hooks:** + - `useEventStream` - Global events with auto-reconnect + - `useSessionActivitySSE` - Session-specific activity with history replay +- **Event Types:** + - `task.status_changed` - Task lifecycle updates + - `session.started` - OpenCode session initialization + - `session.ended` - OpenCode session completion + - Activity messages for ongoing session operations + +### Known Issues from Previous Testing +1. `/api/sessions/{id}/activity` endpoint returning empty responses +2. Potential task status synchronization issues between Studio DB and OpenCode +3. 30-second timeout on `/api/tasks/{id}/execute` endpoint +4. Need to verify SSE reconnection and history replay functionality + +## Files to Modify/Create + +### Test Files to Create +1. **`tests/integration/sse_integration_test.rs`** - Comprehensive SSE integration tests +2. **`frontend/src/__tests__/hooks/useEventStream.test.ts`** - Frontend SSE hook tests +3. **`frontend/src/__tests__/hooks/useSessionActivitySSE.test.ts`** - Session activity hook tests + +### Files to Potentially Modify +1. **`crates/server/src/routes/events.rs`** - Event stream endpoint (if issues found) +2. **`crates/server/src/routes/sessions.rs`** - Session activity endpoint (if fixes needed) +3. **`crates/events/src/bus.rs`** - Event bus logic (if event propagation issues) +4. **`frontend/src/hooks/useEventStream.ts`** - Global event stream hook (if improvements needed) +5. **`frontend/src/hooks/useSessionActivitySSE.ts`** - Session activity hook (if fixes required) + +### Configuration/Documentation +1. **Update test documentation in relevant README files** +2. **Add SSE testing guidelines to AGENTS.md if patterns are established** + +## Step-by-Step Implementation Steps + +### Phase 1: Backend SSE Testing (2-3 hours) +1. **Create integration test framework** + - Set up test client for SSE connections + - Create helper functions for event assertion + - Test connection establishment and basic event flow + +2. **Test global events endpoint (`/api/events`)** + - Verify connection establishment + - Test event broadcasting for task status changes + - Test session lifecycle events (started/ended) + - Verify event format and JSON serialization + +3. **Test session activity endpoint (`/api/sessions/{id}/activity`)** + - Create test session and verify activity stream + - Test real-time activity message propagation + - Verify session-specific filtering + - Test behavior with non-existent session IDs + +4. **Test reconnection and buffering** + - Verify EventBuffer functionality for missed events + - Test client disconnect/reconnect scenarios + - Validate event ordering and deduplication + +### Phase 2: Frontend SSE Testing (2-3 hours) +1. **Test useEventStream hook** + - Mock SSE connection and verify hook behavior + - Test auto-reconnect functionality + - Verify proper cleanup on unmount + - Test error handling and retry logic + +2. **Test useSessionActivitySSE hook** + - Verify session-specific event filtering + - Test history replay functionality + - Test real-time activity updates + - Verify proper subscription management + +3. **Integration testing with backend** + - Test end-to-end event flow from backend to frontend + - Verify proper React state updates + - Test multiple concurrent connections + +### Phase 3: Task Lifecycle Integration Testing (2-4 hours) +1. **Test complete task execution flow** + - Create task via API + - Execute task and monitor SSE events + - Verify status transitions via SSE + - Confirm session activity stream updates + +2. **Test edge cases** + - Task execution failures + - Network interruptions during execution + - Concurrent task operations + - Session timeout scenarios + +3. **Performance testing** + - Test with multiple concurrent SSE connections + - Verify memory usage with EventBuffer + - Test event throughput under load + +### Phase 4: Documentation and Cleanup (1 hour) +1. **Document test patterns and findings** +2. **Update AGENTS.md with SSE testing guidelines** +3. **Clean up any temporary test utilities** +4. **Ensure all tests pass in CI/CD pipeline** + +## Potential Risks + +### High Risk +- **Event loss during reconnection**: If EventBuffer isn't working correctly, clients might miss critical events +- **Memory leaks**: Improper SSE connection cleanup could cause server memory issues +- **Race conditions**: Concurrent task operations might cause event ordering issues + +### Medium Risk +- **Frontend state synchronization**: React state updates from SSE events might cause rendering issues +- **Authentication in SSE**: Long-lived SSE connections might face auth token expiration +- **Cross-browser compatibility**: SSE implementation might behave differently across browsers + +### Low Risk +- **Test environment setup**: Integration tests might require specific database states +- **Mock complexity**: Frontend tests might need complex SSE mocking +- **Documentation drift**: Test documentation might become outdated + +## Mitigation Strategies + +1. **For event loss**: Implement comprehensive integration tests that verify EventBuffer behavior +2. **For memory leaks**: Add monitoring and stress tests for SSE connections +3. **For race conditions**: Use proper event sequencing and add concurrent operation tests +4. **For state sync**: Test React state updates thoroughly with SSE event mocks +5. **For auth issues**: Test SSE connections with token refresh scenarios + +## Success Criteria + +- [ ] All SSE endpoints respond correctly with proper event formatting +- [ ] Frontend hooks handle SSE events reliably with proper state updates +- [ ] Event buffering and reconnection work as expected +- [ ] Complete task lifecycle generates appropriate SSE events +- [ ] No memory leaks or connection issues under normal load +- [ ] All integration tests pass consistently +- [ ] Documentation updated with testing patterns + +## Estimated Complexity: **M (Medium)** + +**Justification:** +- **Moderate scope**: Testing existing SSE infrastructure rather than building new features +- **Known domain**: SSE patterns are well-established, testing approaches are standard +- **Existing codebase**: Building on completed SSE migration work +- **Clear requirements**: Verification of known functionality with specific issue areas identified +- **Manageable risk**: Issues are likely configuration or edge-case related rather than architectural + +**Time Estimate:** 6-10 hours total +- Backend testing: 2-3 hours +- Frontend testing: 2-3 hours +- Integration testing: 2-4 hours +- Documentation: 1 hour + +## Notes + +- This test should focus on validating the completed SSE migration rather than implementing new features +- Pay special attention to the session activity endpoint which showed issues in previous testing +- Consider adding automated tests to prevent regression of SSE functionality +- The "test" description suggests this might be exploratory - be prepared to expand scope based on findings \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/c36bdcae-886d-4f9d-bb2c-0de0056bd07c.md b/.opencode-studio/kanban/plans/c36bdcae-886d-4f9d-bb2c-0de0056bd07c.md new file mode 100644 index 0000000..820d300 --- /dev/null +++ b/.opencode-studio/kanban/plans/c36bdcae-886d-4f9d-bb2c-0de0056bd07c.md @@ -0,0 +1,59 @@ +# Planning: Ahoj + +**Task ID:** c36bdcae-886d-4f9d-bb2c-0de0056bd07c +**Created:** 2025-12-31 + +--- + +## 1. Technical Analysis + +**Status: BLOCKED - Insufficient Specification** + +The task title "Ahoj" and description "Ahoj" contain no actionable requirements. "Ahoj" is a Czech/Slovak greeting meaning "Hello" - this appears to be either: +- A test/placeholder task +- An incomplete task submission +- A greeting intended for a human, not a task specification + +**No technical analysis possible** without understanding: +- What feature, fix, or change is requested? +- What problem needs to be solved? +- What is the expected outcome? + +--- + +## 2. Files to Modify/Create + +**Unknown** - Cannot determine without task specification. + +--- + +## 3. Step-by-Step Implementation + +**Cannot be determined** - No requirements provided. + +--- + +## 4. Potential Risks + +| Risk | Impact | Mitigation | +|------|--------|------------| +| Implementing without clear requirements | High | Request clarification before proceeding | +| Misinterpreting intent | High | Confirm understanding with stakeholder | + +--- + +## 5. Estimated Complexity + +**N/A** - Cannot estimate without understanding scope. + +--- + +## Recommendation + +**ACTION REQUIRED:** Please provide a clear task description that includes: +1. What needs to be done (feature, bug fix, refactor, etc.) +2. Where in the codebase this applies +3. Expected behavior or outcome +4. Any relevant context or constraints + +Once specification is provided, this plan will be updated with actionable implementation steps. diff --git a/.opencode-studio/kanban/plans/ce214e5a-749c-444b-9f51-dac91cc93389.md b/.opencode-studio/kanban/plans/ce214e5a-749c-444b-9f51-dac91cc93389.md new file mode 100644 index 0000000..2e32191 --- /dev/null +++ b/.opencode-studio/kanban/plans/ce214e5a-749c-444b-9f51-dac91cc93389.md @@ -0,0 +1,149 @@ +# E2E SSE Test Implementation Plan + +**Task:** E2E SSE Test +**Description:** Say hello world and nothing else +**Created:** 2025-01-01T18:55:51Z +**Complexity:** S (Small) + +## Technical Analysis + +### Overview +Create a simple end-to-end test for the Server-Sent Events (SSE) infrastructure that verifies a "hello world" message can be sent and received through the SSE pipeline. This test will validate the complete SSE flow from backend emission to frontend reception. + +### Current SSE Infrastructure (Based on Existing Codebase) +- **Backend SSE Infrastructure:** ✅ Complete with SSE endpoints and EventBuffer +- **Frontend SSE Hooks:** ✅ Complete with `useEventStream` and `useSessionActivitySSE` +- **Event System:** Events crate with tokio::broadcast bus +- **Existing Endpoints:** `/api/events` (global), `/api/sessions/{id}/activity` (per-session) + +### Test Scope +- **Type:** Integration test (E2E) +- **Objective:** Verify SSE message delivery with minimal "hello world" payload +- **Coverage:** Backend emission → Network transport → Frontend reception + +## Files to Modify/Create + +### 1. Test Endpoint (Backend) +**Create:** `crates/server/src/routes/test_sse.rs` +- Simple test-only SSE endpoint that emits "hello world" +- Should be conditionally compiled for test builds only + +### 2. Route Registration +**Modify:** `crates/server/src/routes/mod.rs` +- Add test_sse module import (conditional) +- Register test route in router + +### 3. E2E Test File +**Create:** `crates/server/tests/e2e_sse_test.rs` +- Integration test that starts server and connects to SSE endpoint +- Validates "hello world" message reception + +### 4. Test Configuration +**Modify:** `crates/server/Cargo.toml` +- Add any additional test dependencies if needed + +## Step-by-Step Implementation + +### Phase 1: Create Test SSE Endpoint +1. **Create test endpoint** (`crates/server/src/routes/test_sse.rs`) + ```rust + #[cfg(test)] + use axum::response::sse::{Event, Sse}; + + // Simple endpoint that sends "hello world" via SSE + pub async fn hello_world_sse() -> Sse>> { + // Implementation details... + } + ``` + +2. **Register route conditionally** in `crates/server/src/routes/mod.rs` + ```rust + #[cfg(test)] + pub mod test_sse; + ``` + +3. **Add route to router** (test builds only) + +### Phase 2: Create E2E Test +1. **Create integration test** (`crates/server/tests/e2e_sse_test.rs`) + - Use `tokio_test` or similar for async testing + - Start test server instance + - Create SSE client connection + - Listen for "hello world" message + - Assert message content and timing + +2. **Test structure:** + ```rust + #[tokio::test] + async fn test_hello_world_sse() { + // 1. Start test server + // 2. Connect SSE client to /test/hello-world-sse + // 3. Wait for "hello world" message + // 4. Assert message received correctly + // 5. Cleanup + } + ``` + +### Phase 3: Validation & Cleanup +1. **Run test:** `cargo test test_hello_world_sse` +2. **Verify:** Test passes and SSE message flows correctly +3. **Documentation:** Add test description to codebase docs +4. **Cleanup:** Ensure test endpoint is only available in test builds + +## Potential Risks + +### Low Risk +- **Test Isolation:** Test endpoint might interfere with production routes + - *Mitigation:* Use `#[cfg(test)]` conditional compilation +- **Port Conflicts:** Test server might conflict with running dev server + - *Mitigation:* Use dynamic port allocation in tests + +### Medium Risk +- **SSE Connection Timing:** Race conditions between server start and client connect + - *Mitigation:* Add proper wait mechanisms and timeouts +- **Test Flakiness:** Network-dependent test might be unstable + - *Mitigation:* Use localhost only, reasonable timeouts + +### Very Low Risk +- **Message Format:** SSE event format might not match expectations + - *Mitigation:* Use existing SSE infrastructure patterns + +## Success Criteria + +1. ✅ Test endpoint successfully emits "hello world" via SSE +2. ✅ E2E test successfully receives the message +3. ✅ Test runs reliably in CI environment +4. ✅ No impact on production code (test-only compilation) +5. ✅ Test completes within reasonable time (< 5 seconds) + +## Complexity Assessment: S (Small) + +**Justification:** +- **SSE Infrastructure:** Already exists and working +- **Test Pattern:** Follows existing integration test patterns +- **Scope:** Minimal ("hello world" only) +- **Dependencies:** Uses existing libraries +- **Time Estimate:** 1-2 hours + +**Complexity Breakdown:** +- Backend endpoint: 30 minutes +- E2E test setup: 45 minutes +- Testing & refinement: 30 minutes +- Documentation: 15 minutes + +## Dependencies + +**Required:** +- Existing SSE infrastructure (✅ Available) +- Axum testing utilities (✅ Available) +- Tokio test runtime (✅ Available) + +**Optional:** +- Additional SSE client libraries (if eventsource crate insufficient) + +## Notes + +- This test serves as a foundation for more complex SSE testing +- Can be extended later for multi-message scenarios +- Validates the complete SSE pipeline with minimal overhead +- Aligns with existing test patterns in the codebase \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/d0f5a117-4a01-446f-9073-e08298aee88b.md b/.opencode-studio/kanban/plans/d0f5a117-4a01-446f-9073-e08298aee88b.md new file mode 100644 index 0000000..8aeb05c --- /dev/null +++ b/.opencode-studio/kanban/plans/d0f5a117-4a01-446f-9073-e08298aee88b.md @@ -0,0 +1,218 @@ +# Test SSE Implementation Plan + +**Task ID:** d0f5a117-4a01-446f-9073-e08298aee88b +**Title:** Test SSE +**Description:** test +**Generated:** 2026-01-01T01:36:13Z + +## 1. Technical Analysis + +### Current SSE Implementation State +Based on the codebase analysis, OpenCode Studio has completed a migration from WebSocket to Server-Sent Events (SSE) for real-time communication. The current implementation includes: + +**Backend SSE Infrastructure:** +- Global events endpoint: `/api/events` +- Session-specific events: `/api/sessions/{id}/activity` +- `EventBuffer` for reconnection handling +- Event types: `task.status_changed`, `session.started`, `session.ended` + +**Frontend SSE Hooks:** +- `useEventStream` for global events with auto-reconnect +- `useSessionActivitySSE` for per-session activity with history replay + +**Known Issues to Address:** +- `/api/sessions/{id}/activity` endpoint returning empty (identified in previous testing) +- Task status update failures after OpenCode execution completion +- Potential synchronous behavior issues in execute endpoint + +### Testing Scope +This task requires comprehensive testing of: +1. SSE connection establishment and maintenance +2. Event delivery reliability and ordering +3. Reconnection behavior and history replay +4. Cross-browser compatibility +5. Concurrent connection handling +6. Performance under load +7. Error handling and edge cases + +## 2. Files to Modify/Create + +### New Test Files +``` +crates/server/src/routes/events_test.rs # Backend SSE endpoint tests +crates/orchestrator/src/activity_store_test.rs # Event buffer tests +frontend/src/hooks/useEventStream.test.ts # Frontend SSE hook tests +frontend/src/hooks/useSessionActivitySSE.test.ts # Session SSE tests +tests/integration/sse_integration_test.rs # E2E SSE tests +tests/performance/sse_load_test.rs # Load testing +``` + +### Existing Files to Modify +``` +crates/server/src/routes/events.rs # Add test utilities +crates/orchestrator/src/activity_store.rs # Add test helpers +frontend/src/hooks/useEventStream.ts # Add debug logging +frontend/src/hooks/useSessionActivitySSE.ts # Add debug logging +``` + +### Test Utilities to Create +``` +tests/utils/sse_test_server.rs # Mock SSE server +tests/utils/sse_client.rs # Test SSE client +frontend/src/test-utils/sse-mocks.ts # Frontend SSE mocks +``` + +## 3. Step-by-Step Implementation Steps + +### Phase 1: Backend Unit Tests (Days 1-2) +1. **EventBuffer Testing** + - Test event storage and retrieval + - Test buffer size limits and cleanup + - Test concurrent access safety + - Test history replay functionality + +2. **SSE Endpoints Testing** + - Test `/api/events` connection establishment + - Test event serialization and delivery + - Test connection lifecycle management + - Test error handling for invalid connections + +3. **Event Bus Testing** + - Test event publishing reliability + - Test subscriber management + - Test event filtering and routing + - Test memory cleanup on disconnect + +### Phase 2: Frontend Unit Tests (Days 2-3) +1. **useEventStream Hook Testing** + - Test connection establishment with EventSource API + - Test auto-reconnection logic and backoff + - Test event parsing and state management + - Test cleanup on unmount + +2. **useSessionActivitySSE Hook Testing** + - Test session-specific event filtering + - Test history replay from EventBuffer + - Test connection management per session + - Test error boundary behavior + +3. **Component Integration Testing** + - Test SSE hooks integration with React Query + - Test real-time UI updates from SSE events + - Test loading states during connection + - Test error states and user feedback + +### Phase 3: Integration Tests (Days 3-4) +1. **End-to-End SSE Flow** + - Test complete task lifecycle with SSE events + - Test session creation → progress → completion flow + - Test event ordering and consistency + - Test data synchronization between frontend/backend + +2. **Cross-Component Event Flow** + - Test Kanban board real-time updates + - Test session activity feed updates + - Test task detail panel synchronization + - Test notification system integration + +3. **Error Scenario Testing** + - Test network interruption and recovery + - Test server restart during active connections + - Test invalid session ID handling + - Test malformed event data handling + +### Phase 4: Performance & Load Tests (Day 4-5) +1. **Connection Load Testing** + - Test multiple concurrent SSE connections + - Test memory usage under load + - Test event delivery latency + - Test server resource consumption + +2. **Event Volume Testing** + - Test high-frequency event publishing + - Test large event payloads + - Test EventBuffer performance under load + - Test garbage collection impact + +3. **Browser Compatibility Testing** + - Test SSE behavior across major browsers + - Test mobile browser compatibility + - Test connection limits per domain + - Test EventSource API edge cases + +### Phase 5: Documentation & Bug Fixes (Day 5) +1. **Test Documentation** + - Document SSE testing patterns + - Create debugging guides for SSE issues + - Update AGENTS.md with SSE testing info + - Create troubleshooting playbook + +2. **Bug Fix Implementation** + - Fix identified `/api/sessions/{id}/activity` empty response issue + - Address task status synchronization problems + - Fix any performance bottlenecks found + - Improve error handling based on test results + +## 4. Potential Risks + +### High Risk +- **EventSource Browser Limitations**: Different browsers have varying SSE connection limits and behaviors +- **Memory Leaks**: EventBuffer and long-lived connections could cause memory issues +- **Race Conditions**: Concurrent event publishing and connection management may cause inconsistencies + +### Medium Risk +- **Performance Degradation**: High event frequency could impact server performance +- **Data Synchronization**: Events arriving out of order could cause UI inconsistencies +- **Network Reliability**: Poor network conditions may cause frequent reconnections + +### Low Risk +- **Test Environment Setup**: Creating realistic SSE test scenarios may be complex +- **Debug Complexity**: SSE issues can be difficult to reproduce and debug +- **Cross-Platform Issues**: Different OS/browser combinations may behave differently + +### Risk Mitigation Strategies +1. Implement comprehensive integration tests with realistic scenarios +2. Add extensive logging and monitoring for SSE connections +3. Create mock servers for controlled testing environments +4. Implement circuit breaker patterns for connection failures +5. Add performance monitoring and alerting for SSE endpoints + +## 5. Estimated Complexity: **L (Large)** + +### Complexity Justification +- **Scope**: Comprehensive testing of real-time system across frontend/backend +- **Technical Depth**: Requires understanding of SSE protocol, browser APIs, and concurrent systems +- **Integration Complexity**: Testing spans multiple layers (HTTP, SSE, React, state management) +- **Performance Testing**: Load testing and browser compatibility require specialized setup +- **Bug Fixing**: May uncover complex issues requiring significant debugging + +### Time Estimate: 5 days +- Backend tests: 1.5 days +- Frontend tests: 1 day +- Integration tests: 1.5 days +- Performance/load tests: 0.5 days +- Documentation & fixes: 0.5 days + +### Dependencies +- Existing SSE implementation must be stable +- Test infrastructure and CI pipeline must be available +- Access to multiple browsers/devices for compatibility testing +- Performance testing environment setup + +### Success Criteria +- [ ] 95%+ test coverage for SSE-related code +- [ ] All identified SSE bugs fixed and verified +- [ ] Performance benchmarks established and documented +- [ ] Cross-browser compatibility verified +- [ ] Integration tests passing in CI pipeline +- [ ] Documentation updated with SSE testing practices + +## Implementation Notes + +1. **Test Strategy**: Focus on realistic scenarios that match production usage patterns +2. **Debugging**: Add comprehensive logging that can be enabled during development +3. **Monitoring**: Implement metrics collection for SSE connection health +4. **Fallback**: Ensure graceful degradation when SSE is not available +5. **Security**: Verify SSE endpoints respect authentication and authorization + +This plan provides comprehensive coverage for testing the SSE implementation while addressing the known issues and ensuring robust real-time communication in OpenCode Studio. \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/da6912ec-2191-4cee-ac12-e627da4be4a7.md b/.opencode-studio/kanban/plans/da6912ec-2191-4cee-ac12-e627da4be4a7.md new file mode 100644 index 0000000..5e23f95 --- /dev/null +++ b/.opencode-studio/kanban/plans/da6912ec-2191-4cee-ac12-e627da4be4a7.md @@ -0,0 +1,163 @@ +# Implementation Plan: Test v3 + +**Task ID:** da6912ec-2191-4cee-ac12-e627da4be4a7 +**Title:** Test v3 +**Description:** Another test +**Generated:** 2026-01-01 01:36:13 AM + +## 1. Technical Analysis + +### Context +This appears to be a test task within the OpenCode Studio platform. Given the minimal description "Another test", this likely represents a validation or experimental feature to verify system functionality. + +### Scope Assessment +- **Type**: Test/Validation task +- **Impact**: Likely minimal system changes required +- **Integration**: May involve testing existing OpenCode Studio components +- **Dependencies**: Existing task lifecycle, OpenCode integration, and SSE event system + +### Assumptions +- This is a test to validate current system functionality +- May involve testing the full task lifecycle (TODO → DONE) +- Could be testing recent SSE migration or OpenCode client integration +- Minimal new functionality required + +## 2. Files to Modify/Create + +### Backend (Rust) +``` +crates/ +├── server/src/routes/ +│ └── test.rs # New test endpoint (if needed) +├── orchestrator/src/ +│ └── test_executor.rs # Test-specific execution logic (if needed) +└── db/migrations/ + └── 00X_test_data.sql # Test data migration (if needed) +``` + +### Frontend (React) +``` +frontend/src/ +├── components/test/ +│ └── TestComponent.tsx # Test UI component (if needed) +├── api/generated/ +│ └── [auto-generated] # Updated API hooks (if backend changes) +└── types/generated/ + └── [auto-generated] # Updated types (if backend changes) +``` + +### Configuration +``` +.opencode-studio/ +├── kanban/plans/ +│ └── da6912ec-2191-4cee-ac12-e627da4be4a7.md # This plan file +└── kanban/reviews/ + └── da6912ec-2191-4cee-ac12-e627da4be4a7.md # Future review file +``` + +## 3. Step-by-Step Implementation Steps + +### Phase 1: Analysis & Setup +1. **Clarify Requirements** + - Determine specific test objectives + - Identify which components need validation + - Define success criteria + +2. **Environment Preparation** + - Ensure development environment is running (`pnpm dev`) + - Verify database connectivity (`studio.db`) + - Confirm OpenCode integration is available + +### Phase 2: Implementation +1. **Backend Changes** (if required) + - Add test endpoint in `crates/server/src/routes/test.rs` + - Update route registration in `crates/server/src/lib.rs` + - Add test logic in orchestrator if needed + - Update OpenAPI schema + +2. **Frontend Changes** (if required) + - Generate new API hooks: `cd frontend && pnpm generate:api` + - Create test component if UI validation needed + - Add test route/navigation if applicable + +3. **Database Changes** (if required) + - Create migration for test data if needed + - Run migration: `sqlx migrate run` + +### Phase 3: Testing & Validation +1. **Unit Tests** + - Add tests to relevant crates + - Run: `cargo test --workspace` + - Ensure clippy passes: `cargo clippy --workspace -- -D warnings` + +2. **Integration Tests** + - Test full task lifecycle if applicable + - Verify SSE events are emitted correctly + - Test OpenCode integration if involved + +3. **Manual Testing** + - Start development server + - Execute test functionality via UI or API + - Verify expected behavior + +### Phase 4: Documentation & Cleanup +1. **Update Documentation** + - Update relevant sections in `AGENTS.md` if needed + - Document any new API endpoints + +2. **Code Review** + - Self-review implementation + - Ensure code follows project conventions + - Check for anti-patterns (no `@ts-ignore`, empty catch blocks, etc.) + +## 4. Potential Risks + +### Technical Risks +- **Low Risk**: Task appears to be simple test validation +- **Integration Risk**: If testing OpenCode integration, external dependency could fail +- **Database Risk**: Minimal - likely no schema changes needed +- **SSE Risk**: If testing real-time features, ensure proper event handling + +### Development Risks +- **Scope Creep**: Minimal description could lead to unclear requirements +- **Time Estimation**: Without clear requirements, timing could vary significantly +- **Testing Gaps**: Test task might not have clear acceptance criteria + +### Mitigation Strategies +- Clarify requirements early in implementation phase +- Start with minimal viable implementation +- Leverage existing patterns and infrastructure +- Use transaction rollback for any database changes during testing + +## 5. Estimated Complexity: **S (Small)** + +### Justification +- **Scope**: Minimal description suggests simple test case +- **Technical Complexity**: Likely leveraging existing infrastructure +- **Integration**: Uses established patterns in OpenCode Studio +- **Time Estimate**: 2-4 hours maximum + +### Complexity Breakdown +- **Analysis**: 30 minutes +- **Implementation**: 1-2 hours +- **Testing**: 30-60 minutes +- **Documentation**: 15-30 minutes + +### Dependencies +- No external dependencies expected +- Leverages existing OpenCode Studio infrastructure +- May depend on OpenCode service availability for integration tests + +## Next Steps + +1. **Immediate**: Clarify specific test requirements with stakeholder +2. **Implementation**: Begin with minimal implementation following existing patterns +3. **Validation**: Test against current system to ensure no regressions +4. **Completion**: Mark task complete in OpenCode Studio workflow + +--- + +**Plan Status**: Ready for implementation +**Estimated Start**: Immediate +**Estimated Completion**: Same day +**Review Required**: No (unless implementation reveals complexity) \ No newline at end of file diff --git a/.opencode-studio/kanban/plans/f35484e8-c2a7-4786-8ed9-68e38251f4c1.md b/.opencode-studio/kanban/plans/f35484e8-c2a7-4786-8ed9-68e38251f4c1.md new file mode 100644 index 0000000..9ccd2c7 --- /dev/null +++ b/.opencode-studio/kanban/plans/f35484e8-c2a7-4786-8ed9-68e38251f4c1.md @@ -0,0 +1,214 @@ +# Implementation Plan: Activity Test - Say Hello + +**Task ID:** f35484e8-c2a7-4786-8ed9-68e38251f4c1 +**Title:** Activity Test +**Description:** Say hello +**Plan Generated:** 2025-01-01 01:36:13 +**Estimated Complexity:** S (Small) + +--- + +## 1. Technical Analysis + +### Purpose & Context +This task serves as a lightweight integration test for the OpenCode Studio orchestration pipeline. While the surface requirement is simple ("say hello"), the underlying goal is to validate: + +- Task lifecycle execution (TODO → PLANNING → IN_PROGRESS → DONE) +- OpenCode session creation and management +- File system operations within the workspace +- Status tracking and event emission +- VCS integration (Jujutsu/Git) + +### System Components Involved +- **Orchestrator**: Task state machine and execution logic +- **OpenCode Client**: Session creation and prompt execution +- **VCS Workspace**: Version control operations +- **Event Bus**: Status change notifications +- **Database**: Task and session persistence +- **File Manager**: Plan/review file creation + +### Implementation Strategy +Create a minimal, observable change that exercises the full pipeline without adding complexity. The "hello" output will be implemented as: +1. A simple text file creation or modification +2. A log entry or comment in existing code +3. A basic test file addition + +--- + +## 2. Files to Modify/Create + +### Primary Target (Choose One) +``` +Option A: Create new file +├── hello.txt # Simple text file with greeting +└── .opencode-studio/ + └── activity-test-output.log # Execution log + +Option B: Modify existing file +├── crates/server/src/main.rs # Add hello log on startup +└── README.md # Add activity test section + +Option C: Create test file +├── crates/core/src/lib.rs # Add hello() function +└── crates/core/src/tests/ # Add integration test +``` + +### Supporting Files (Auto-generated) +``` +.opencode-studio/ +├── kanban/ +│ ├── plans/f35484e8-c2a7-4786-8ed9-68e38251f4c1.md # This file +│ └── reviews/f35484e8-c2a7-4786-8ed9-68e38251f4c1.md # Post-implementation +└── sessions/ + └── {session-id}.json # OpenCode session metadata +``` + +--- + +## 3. Step-by-Step Implementation + +### Phase 1: Pre-Implementation Setup +1. **Workspace Validation** + - Verify current working directory is clean (`jj status` / `git status`) + - Ensure no conflicting changes in progress + - Validate OpenCode connection is active + +2. **Session Initialization** + - Create OpenCode session via `/api/sessions` + - Initialize workspace if needed + - Set task status to `IN_PROGRESS` + +### Phase 2: Core Implementation +3. **Choose Implementation Path** + - **Recommended**: Option A (new file) - least invasive + - Create `hello.txt` with content: "Hello from OpenCode Studio Activity Test!" + - Add timestamp and task ID for traceability + +4. **File Operations** + ```bash + echo "Hello from OpenCode Studio Activity Test!" > hello.txt + echo "Generated: $(date)" >> hello.txt + echo "Task ID: f35484e8-c2a7-4786-8ed9-68e38251f4c1" >> hello.txt + ``` + +5. **Verification Steps** + - Confirm file creation successful + - Validate file content matches expectations + - Check file permissions and ownership + +### Phase 3: Integration Validation +6. **VCS Operations** + - Stage changes (`jj add` / `git add`) + - Create commit with descriptive message + - Verify workspace status clean + +7. **Event Emission** + - Emit `task.file_created` event + - Emit `task.status_changed` to `AI_REVIEW` + - Log activity to session activity stream + +8. **Session Completion** + - Mark OpenCode session as completed + - Update task status to `AI_REVIEW` → `REVIEW` → `DONE` + - Generate review file with implementation summary + +--- + +## 4. Potential Risks & Mitigations + +### Risk 1: OpenCode Session Timeout +**Impact:** Medium - Task may remain in `IN_PROGRESS` state +**Probability:** Medium (known issue from previous testing) +**Mitigation:** +- Implement 30-second timeout handling +- Add retry logic for failed sessions +- Graceful fallback to manual completion + +### Risk 2: File System Permissions +**Impact:** Low - File creation might fail +**Probability:** Low +**Mitigation:** +- Validate write permissions before execution +- Use temporary file + rename pattern +- Clear error messaging for permission issues + +### Risk 3: VCS Conflicts +**Impact:** Medium - Workspace state corruption +**Probability:** Low +**Mitigation:** +- Pre-check for clean workspace state +- Use atomic operations where possible +- Implement rollback on failure + +### Risk 4: Event Bus Failure +**Impact:** Low - Silent status update failures +**Probability:** Low +**Mitigation:** +- Add event emission verification +- Implement retry mechanism for critical events +- Log all event attempts for debugging + +--- + +## 5. Success Criteria + +### Primary Objectives +- [ ] Task transitions through complete lifecycle (TODO → DONE) +- [ ] OpenCode session created and completed successfully +- [ ] "Hello" output generated and persisted +- [ ] No errors in application logs +- [ ] VCS workspace remains clean + +### Secondary Objectives +- [ ] SSE events emitted for status changes +- [ ] Session activity logged to database +- [ ] Review file generated with implementation details +- [ ] Execution time < 30 seconds (within timeout window) + +### Verification Commands +```bash +# Check file creation +ls -la hello.txt +cat hello.txt + +# Verify VCS status +jj status # or git status + +# Check database state +sqlite3 studio.db "SELECT status FROM tasks WHERE id = 'f35484e8-c2a7-4786-8ed9-68e38251f4c1';" + +# Validate session completion +sqlite3 studio.db "SELECT status FROM sessions WHERE task_id = 'f35484e8-c2a7-4786-8ed9-68e38251f4c1';" +``` + +--- + +## 6. Estimated Complexity: S (Small) + +**Rationale:** +- Minimal code changes required (single file creation) +- Well-understood system components +- Low risk of breaking existing functionality +- Fast execution time expected +- Clear success/failure indicators + +**Time Estimate:** 5-10 minutes for execution + validation + +**Dependencies:** None (self-contained test) + +--- + +## 7. Post-Implementation Notes + +This task primarily serves as a system health check rather than feature development. Success indicates: +- OpenCode integration is functional +- Task lifecycle automation works end-to-end +- VCS workspace management operates correctly +- Event system and database persistence are stable + +Failure modes will help identify specific areas needing attention in the OpenCode Studio pipeline. + +--- + +**Plan Status:** Ready for Implementation +**Next Phase:** Await execution trigger via task management system \ No newline at end of file diff --git a/.opencode-studio/studio.db b/.opencode-studio/studio.db new file mode 100644 index 0000000..7338346 Binary files /dev/null and b/.opencode-studio/studio.db differ diff --git a/.opencode-studio/studio.db-shm b/.opencode-studio/studio.db-shm new file mode 100644 index 0000000..fe9ac28 Binary files /dev/null and b/.opencode-studio/studio.db-shm differ diff --git a/.opencode-studio/studio.db-wal b/.opencode-studio/studio.db-wal new file mode 100644 index 0000000..e69de29 diff --git a/Cargo.lock b/Cargo.lock index 18a1e97..62251f2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -8,6 +8,17 @@ version = "2.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa" +[[package]] +name = "aes" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0" +dependencies = [ + "cfg-if", + "cipher", + "cpufeatures", +] + [[package]] name = "aho-corasick" version = "1.1.4" @@ -298,6 +309,25 @@ version = "2.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6bd91ee7b2422bcb158d90ef4d14f75ef67f340943fc4149891dcce8f8b972a3" +[[package]] +name = "bzip2" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49ecfb22d906f800d4fe833b6282cf4dc1c298f5057ca0b5445e5c209735ca47" +dependencies = [ + "bzip2-sys", +] + +[[package]] +name = "bzip2-sys" +version = "0.1.13+1.0.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "225bff33b2141874fe80d71e07d6eec4f85c5c216453dd96388240f96e1acc14" +dependencies = [ + "cc", + "pkg-config", +] + [[package]] name = "cc" version = "1.2.51" @@ -305,6 +335,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7a0aeaff4ff1a90589618835a598e545176939b97874f7abc7851caa0618f203" dependencies = [ "find-msvc-tools", + "jobserver", + "libc", "shlex", ] @@ -314,6 +346,12 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" +[[package]] +name = "cfg_aliases" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" + [[package]] name = "chrono" version = "0.4.42" @@ -328,6 +366,16 @@ dependencies = [ "windows-link", ] +[[package]] +name = "cipher" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" +dependencies = [ + "crypto-common", + "inout", +] + [[package]] name = "clap" version = "4.5.53" @@ -374,6 +422,16 @@ version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75" +[[package]] +name = "colored" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "117725a109d387c937a1533ce01b450cbde6b88abceea8473c4d7a85853cda3c" +dependencies = [ + "lazy_static", + "windows-sys 0.59.0", +] + [[package]] name = "concurrent-queue" version = "2.5.0" @@ -383,12 +441,31 @@ dependencies = [ "crossbeam-utils", ] +[[package]] +name = "console" +version = "0.15.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8" +dependencies = [ + "encode_unicode", + "libc", + "once_cell", + "unicode-width", + "windows-sys 0.59.0", +] + [[package]] name = "const-oid" version = "0.9.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8" +[[package]] +name = "constant_time_eq" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c74b8349d32d297c9134b8c88677813a227df8f779daa29bfc29c183fe3dca6" + [[package]] name = "cookie" version = "0.18.1" @@ -483,6 +560,41 @@ dependencies = [ "typenum", ] +[[package]] +name = "darling" +version = "0.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0" +dependencies = [ + "darling_core", + "darling_macro", +] + +[[package]] +name = "darling_core" +version = "0.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1247195ecd7e3c85f83c8d2a366e4210d588e802133e1e355180a9870b517ea4" +dependencies = [ + "fnv", + "ident_case", + "proc-macro2", + "quote", + "strsim", + "syn", +] + +[[package]] +name = "darling_macro" +version = "0.21.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81" +dependencies = [ + "darling_core", + "quote", + "syn", +] + [[package]] name = "data-encoding" version = "2.9.0" @@ -495,8 +607,9 @@ version = "0.1.0" dependencies = [ "chrono", "opencode_core", + "serde_json", "sqlx", - "thiserror", + "thiserror 2.0.17", "tokio", "tracing", "uuid", @@ -520,6 +633,12 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "092966b41edc516079bdf31ec78a2e0588d1d0c08f78b91d8307215928642b2b" +[[package]] +name = "deflate64" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26bf8fc351c5ed29b5c2f0cbbac1b209b74f60ecd62e675a998df72c49af5204" + [[package]] name = "der" version = "0.7.10" @@ -569,6 +688,27 @@ dependencies = [ "subtle", ] +[[package]] +name = "dirs" +version = "5.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225" +dependencies = [ + "dirs-sys", +] + +[[package]] +name = "dirs-sys" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c" +dependencies = [ + "libc", + "option-ext", + "redox_users", + "windows-sys 0.48.0", +] + [[package]] name = "displaydoc" version = "0.2.5" @@ -586,6 +726,12 @@ version = "0.15.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1aaf95b3e5c8f23aa320147307562d361db0ae0d51242340f558153b4eb2439b" +[[package]] +name = "dyn-clone" +version = "1.0.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555" + [[package]] name = "either" version = "1.15.0" @@ -604,6 +750,12 @@ dependencies = [ "serde", ] +[[package]] +name = "encode_unicode" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0" + [[package]] name = "encoding_rs" version = "0.8.35" @@ -669,7 +821,7 @@ dependencies = [ "chrono", "serde", "serde_json", - "thiserror", + "thiserror 2.0.17", "tokio", "ts-rs", "utoipa", @@ -700,7 +852,7 @@ dependencies = [ "regex", "serde", "serde_json", - "thiserror", + "thiserror 2.0.17", "typetag", "uuid", ] @@ -916,9 +1068,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd" dependencies = [ "cfg-if", + "js-sys", "libc", "r-efi", "wasip2", + "wasm-bindgen", ] [[package]] @@ -932,7 +1086,7 @@ dependencies = [ "serde", "serde_json", "tempfile", - "thiserror", + "thiserror 2.0.17", "tokio", "tracing", "wiremock", @@ -1061,6 +1215,12 @@ dependencies = [ "pin-project-lite", ] +[[package]] +name = "http-range-header" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9171a2ea8a68358193d15dd5d70c1c10a2afc3e7e4c5bc92bc9f025cebd7359c" + [[package]] name = "httparse" version = "1.10.1" @@ -1112,6 +1272,7 @@ dependencies = [ "tokio", "tokio-rustls", "tower-service", + "webpki-roots", ] [[package]] @@ -1274,6 +1435,12 @@ dependencies = [ "zerovec", ] +[[package]] +name = "ident_case" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" + [[package]] name = "idna" version = "1.1.0" @@ -1307,6 +1474,28 @@ dependencies = [ "serde_core", ] +[[package]] +name = "indicatif" +version = "0.17.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "183b3088984b400f4cfac3620d5e076c84da5364016b4f49473de574b2586235" +dependencies = [ + "console", + "number_prefix", + "portable-atomic", + "unicode-width", + "web-time", +] + +[[package]] +name = "inout" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01" +dependencies = [ + "generic-array", +] + [[package]] name = "inventory" version = "0.3.21" @@ -1363,6 +1552,16 @@ version = "1.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2" +[[package]] +name = "jobserver" +version = "0.1.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33" +dependencies = [ + "getrandom 0.3.4", + "libc", +] + [[package]] name = "js-sys" version = "0.3.83" @@ -1373,6 +1572,28 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "json-patch" +version = "3.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "863726d7afb6bc2590eeff7135d923545e5e964f004c2ccf8716c25e70a86f08" +dependencies = [ + "jsonptr", + "serde", + "serde_json", + "thiserror 1.0.69", +] + +[[package]] +name = "jsonptr" +version = "0.6.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5dea2b27dd239b2556ed7a25ba842fe47fd602e7fc7433c2a8d6106d4d9edd70" +dependencies = [ + "serde", + "serde_json", +] + [[package]] name = "jsonwebtoken" version = "9.3.1" @@ -1467,6 +1688,33 @@ version = "0.4.29" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" +[[package]] +name = "lru-slab" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154" + +[[package]] +name = "lzma-rs" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "297e814c836ae64db86b36cf2a557ba54368d03f6afcd7d947c266692f71115e" +dependencies = [ + "byteorder", + "crc", +] + +[[package]] +name = "lzma-sys" +version = "0.1.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5fda04ab3764e6cde78b9974eec4f779acaba7c4e84b36eca3cf77c581b85d27" +dependencies = [ + "cc", + "libc", + "pkg-config", +] + [[package]] name = "matchers" version = "0.2.0" @@ -1482,6 +1730,25 @@ version = "0.8.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "47e1ffaa40ddd1f3ed91f717a33c8c0ee23fff369e3aa8772b9605cc1d22f4c3" +[[package]] +name = "mcp-findings" +version = "0.1.0" +dependencies = [ + "anyhow", + "async-trait", + "chrono", + "orchestrator", + "rmcp", + "schemars", + "serde", + "serde_json", + "thiserror 2.0.17", + "tokio", + "tracing", + "tracing-subscriber", + "uuid", +] + [[package]] name = "md-5" version = "0.10.6" @@ -1683,6 +1950,12 @@ dependencies = [ "libc", ] +[[package]] +name = "number_prefix" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "830b246a0e5f20af87141b25c173cd1b609bd7779a4617d6ec582abaf90870f3" + [[package]] name = "octocrab" version = "0.41.2" @@ -1745,24 +2018,6 @@ dependencies = [ "pathdiff", ] -[[package]] -name = "opencode" -version = "0.1.0" -dependencies = [ - "bytes", - "chrono", - "eventsource-stream", - "futures", - "opencode_core", - "reqwest", - "serde", - "serde_json", - "thiserror", - "tokio", - "tracing", - "uuid", -] - [[package]] name = "opencode-studio" version = "0.1.0" @@ -1770,8 +2025,14 @@ dependencies = [ "anyhow", "axum", "clap", + "colored", + "console", "db", + "dirs", + "futures-util", + "indicatif", "open", + "reqwest", "serde", "serde_json", "server", @@ -1779,6 +2040,18 @@ dependencies = [ "toml", "tracing", "tracing-subscriber", + "zip 2.4.2", +] + +[[package]] +name = "opencode_client" +version = "0.1.0" +dependencies = [ + "reqwest", + "serde", + "serde_json", + "serde_repr", + "url", ] [[package]] @@ -1788,7 +2061,7 @@ dependencies = [ "chrono", "serde", "serde_json", - "thiserror", + "thiserror 2.0.17", "tokio", "ts-rs", "utoipa", @@ -1845,22 +2118,38 @@ dependencies = [ "vcpkg", ] +[[package]] +name = "option-ext" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" + [[package]] name = "orchestrator" version = "0.1.0" dependencies = [ "async-trait", + "axum", + "bytes", "chrono", "db", "events", - "opencode", + "eventsource-stream", + "futures", + "json-patch", + "opencode_client", "opencode_core", + "reqwest", "serde", "serde_json", "tempfile", - "thiserror", + "thiserror 2.0.17", "tokio", + "tokio-stream", "tracing", + "ts-rs", + "urlencoding", + "utoipa", "uuid", "vcs", ] @@ -1906,6 +2195,16 @@ version = "0.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "df94ce210e5bc13cb6651479fa48d14f601d9858cfe0467f43ae157023b938d3" +[[package]] +name = "pbkdf2" +version = "0.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2" +dependencies = [ + "digest", + "hmac", +] + [[package]] name = "pem" version = "3.0.6" @@ -1990,6 +2289,12 @@ version = "0.3.32" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c" +[[package]] +name = "portable-atomic" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f89776e4d69bb58bc6993e99ffa1d11f228b839984854c7daeb5d37f87cbe950" + [[package]] name = "potential_utf" version = "0.1.4" @@ -2033,6 +2338,61 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "quinn" +version = "0.11.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20" +dependencies = [ + "bytes", + "cfg_aliases", + "pin-project-lite", + "quinn-proto", + "quinn-udp", + "rustc-hash", + "rustls", + "socket2", + "thiserror 2.0.17", + "tokio", + "tracing", + "web-time", +] + +[[package]] +name = "quinn-proto" +version = "0.11.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1906b49b0c3bc04b5fe5d86a77925ae6524a19b816ae38ce1e426255f1d8a31" +dependencies = [ + "bytes", + "getrandom 0.3.4", + "lru-slab", + "rand 0.9.2", + "ring", + "rustc-hash", + "rustls", + "rustls-pki-types", + "slab", + "thiserror 2.0.17", + "tinyvec", + "tracing", + "web-time", +] + +[[package]] +name = "quinn-udp" +version = "0.5.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd" +dependencies = [ + "cfg_aliases", + "libc", + "once_cell", + "socket2", + "tracing", + "windows-sys 0.60.2", +] + [[package]] name = "quote" version = "1.0.42" @@ -2125,6 +2485,37 @@ dependencies = [ "bitflags", ] +[[package]] +name = "redox_users" +version = "0.4.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba009ff324d1fc1b900bd1fdb31564febe58a8ccc8a6fdbb93b543d33b13ca43" +dependencies = [ + "getrandom 0.2.16", + "libredox", + "thiserror 1.0.69", +] + +[[package]] +name = "ref-cast" +version = "1.0.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d" +dependencies = [ + "ref-cast-impl", +] + +[[package]] +name = "ref-cast-impl" +version = "1.0.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "regex" version = "1.12.2" @@ -2176,9 +2567,12 @@ dependencies = [ "js-sys", "log", "mime", + "mime_guess", "native-tls", "percent-encoding", "pin-project-lite", + "quinn", + "rustls", "rustls-pki-types", "serde", "serde_json", @@ -2186,6 +2580,7 @@ dependencies = [ "sync_wrapper", "tokio", "tokio-native-tls", + "tokio-rustls", "tokio-util", "tower", "tower-http 0.6.8", @@ -2195,6 +2590,7 @@ dependencies = [ "wasm-bindgen-futures", "wasm-streams", "web-sys", + "webpki-roots", ] [[package]] @@ -2203,7 +2599,7 @@ version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "21918d6644020c6f6ef1993242989bf6d4952d2e025617744f184c02df51c356" dependencies = [ - "thiserror", + "thiserror 2.0.17", ] [[package]] @@ -2220,6 +2616,40 @@ dependencies = [ "windows-sys 0.52.0", ] +[[package]] +name = "rmcp" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1f0d0d5493be0d181a62db489eab7838669b81885972ca00ceca893cf6ac2883" +dependencies = [ + "base64", + "chrono", + "futures", + "paste", + "pin-project-lite", + "rmcp-macros", + "schemars", + "serde", + "serde_json", + "thiserror 2.0.17", + "tokio", + "tokio-util", + "tracing", +] + +[[package]] +name = "rmcp-macros" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4aebc912b8fa7d54999adc4e45601d1d95fe458f97eb0a1277eddcd6382cf4b1" +dependencies = [ + "darling", + "proc-macro2", + "quote", + "serde_json", + "syn", +] + [[package]] name = "rsa" version = "0.9.9" @@ -2286,9 +2716,15 @@ dependencies = [ "http", "mime", "rand 0.9.2", - "thiserror", + "thiserror 2.0.17", ] +[[package]] +name = "rustc-hash" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d" + [[package]] name = "rustix" version = "1.1.3" @@ -2335,6 +2771,7 @@ version = "1.13.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "21e6f2ab2928ca4291b86736a8bd920a277a399bba1589409d72154ff87c1282" dependencies = [ + "web-time", "zeroize", ] @@ -2379,6 +2816,32 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "schemars" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "54e910108742c57a770f492731f99be216a52fadd361b06c8fb59d74ccc267d2" +dependencies = [ + "chrono", + "dyn-clone", + "ref-cast", + "schemars_derive", + "serde", + "serde_json", +] + +[[package]] +name = "schemars_derive" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4908ad288c5035a8eb12cfdf0d49270def0a268ee162b75eeee0f85d155a7c45" +dependencies = [ + "proc-macro2", + "quote", + "serde_derive_internals", + "syn", +] + [[package]] name = "scopeguard" version = "1.2.0" @@ -2460,6 +2923,17 @@ dependencies = [ "syn", ] +[[package]] +name = "serde_derive_internals" +version = "0.29.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "18d26a20a969b9e3fdf2fc2d9f21eda6c40e2de84c9408bb5d3b05d499aae711" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "serde_json" version = "1.0.148" @@ -2484,6 +2958,17 @@ dependencies = [ "serde_core", ] +[[package]] +name = "serde_repr" +version = "0.1.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "serde_spanned" version = "0.6.9" @@ -2514,17 +2999,22 @@ dependencies = [ "axum-test", "chrono", "db", + "dirs", "events", + "futures", + "futures-util", "github", - "opencode", + "opencode_client", "opencode_core", "orchestrator", "serde", "serde_json", "sqlx", "tempfile", - "thiserror", + "thiserror 2.0.17", "tokio", + "tokio-stream", + "toml", "tower-http 0.5.2", "tracing", "tracing-subscriber", @@ -2534,7 +3024,6 @@ dependencies = [ "utoipa-swagger-ui", "uuid", "vcs", - "websocket", "wiremock", ] @@ -2609,7 +3098,7 @@ checksum = "297f631f50729c8c99b84667867963997ec0b50f32b2a7dbcab828ef0541e8bb" dependencies = [ "num-bigint", "num-traits", - "thiserror", + "thiserror 2.0.17", "time", ] @@ -2718,7 +3207,7 @@ dependencies = [ "serde_json", "sha2", "smallvec", - "thiserror", + "thiserror 2.0.17", "tokio", "tokio-stream", "tracing", @@ -2800,7 +3289,7 @@ dependencies = [ "smallvec", "sqlx-core", "stringprep", - "thiserror", + "thiserror 2.0.17", "tracing", "whoami", ] @@ -2837,7 +3326,7 @@ dependencies = [ "smallvec", "sqlx-core", "stringprep", - "thiserror", + "thiserror 2.0.17", "tracing", "whoami", ] @@ -2861,7 +3350,7 @@ dependencies = [ "serde", "serde_urlencoded", "sqlx-core", - "thiserror", + "thiserror 2.0.17", "tracing", "url", ] @@ -2969,13 +3458,33 @@ dependencies = [ "winapi-util", ] +[[package]] +name = "thiserror" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" +dependencies = [ + "thiserror-impl 1.0.69", +] + [[package]] name = "thiserror" version = "2.0.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8" dependencies = [ - "thiserror-impl", + "thiserror-impl 2.0.17", +] + +[[package]] +name = "thiserror-impl" +version = "1.0.69" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" +dependencies = [ + "proc-macro2", + "quote", + "syn", ] [[package]] @@ -3111,6 +3620,7 @@ dependencies = [ "futures-core", "pin-project-lite", "tokio", + "tokio-util", ] [[package]] @@ -3204,10 +3714,18 @@ checksum = "1e9cd434a998747dd2c4276bc96ee2e0c7a2eadf3cae88e52be55a05fa9053f5" dependencies = [ "bitflags", "bytes", + "futures-util", "http", "http-body", "http-body-util", + "http-range-header", + "httpdate", + "mime", + "mime_guess", + "percent-encoding", "pin-project-lite", + "tokio", + "tokio-util", "tower-layer", "tower-service", "tracing", @@ -3320,7 +3838,7 @@ checksum = "e640d9b0964e9d39df633548591090ab92f7a4567bc31d3891af23471a3365c6" dependencies = [ "chrono", "lazy_static", - "thiserror", + "thiserror 2.0.17", "ts-rs-macros", "uuid", ] @@ -3350,7 +3868,7 @@ dependencies = [ "log", "rand 0.9.2", "sha1", - "thiserror", + "thiserror 2.0.17", "utf-8", ] @@ -3423,6 +3941,12 @@ version = "0.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7df058c713841ad818f1dc5d3fd88063241cc61f49f5fbea4b951e8cf5a8d71d" +[[package]] +name = "unicode-width" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254" + [[package]] name = "untrusted" version = "0.9.0" @@ -3441,6 +3965,12 @@ dependencies = [ "serde", ] +[[package]] +name = "urlencoding" +version = "2.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da" + [[package]] name = "utf-8" version = "0.7.6" @@ -3512,7 +4042,7 @@ dependencies = [ "serde_json", "url", "utoipa", - "zip", + "zip 3.0.0", ] [[package]] @@ -3549,7 +4079,7 @@ dependencies = [ "serde", "serde_json", "tempfile", - "thiserror", + "thiserror 2.0.17", "tokio", "tracing", "ts-rs", @@ -3684,18 +4214,22 @@ dependencies = [ ] [[package]] -name = "websocket" -version = "0.1.0" +name = "web-time" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb" dependencies = [ - "axum", - "events", - "futures-util", - "serde", - "serde_json", - "tokio", - "tracing", - "ts-rs", - "uuid", + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "webpki-roots" +version = "1.0.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2878ef029c47c6e8cf779119f20fcf52bde7ad42a731b2a304bc221df17571e" +dependencies = [ + "rustls-pki-types", ] [[package]] @@ -3805,6 +4339,15 @@ dependencies = [ "windows-targets 0.52.6", ] +[[package]] +name = "windows-sys" +version = "0.59.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +dependencies = [ + "windows-targets 0.52.6", +] + [[package]] name = "windows-sys" version = "0.60.2" @@ -4053,6 +4596,15 @@ version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9" +[[package]] +name = "xz2" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "388c44dc09d76f1536602ead6d325eb532f5c122f17782bd57fb47baeeb767e2" +dependencies = [ + "lzma-sys", +] + [[package]] name = "yansi" version = "1.0.1" @@ -4128,6 +4680,20 @@ name = "zeroize" version = "1.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0" +dependencies = [ + "zeroize_derive", +] + +[[package]] +name = "zeroize_derive" +version = "1.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] [[package]] name = "zerotrie" @@ -4162,6 +4728,36 @@ dependencies = [ "syn", ] +[[package]] +name = "zip" +version = "2.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fabe6324e908f85a1c52063ce7aa26b68dcb7eb6dbc83a2d148403c9bc3eba50" +dependencies = [ + "aes", + "arbitrary", + "bzip2", + "constant_time_eq", + "crc32fast", + "crossbeam-utils", + "deflate64", + "displaydoc", + "flate2", + "getrandom 0.3.4", + "hmac", + "indexmap", + "lzma-rs", + "memchr", + "pbkdf2", + "sha1", + "thiserror 2.0.17", + "time", + "xz2", + "zeroize", + "zopfli", + "zstd", +] + [[package]] name = "zip" version = "3.0.0" @@ -4199,3 +4795,31 @@ dependencies = [ "log", "simd-adler32", ] + +[[package]] +name = "zstd" +version = "0.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a" +dependencies = [ + "zstd-safe", +] + +[[package]] +name = "zstd-safe" +version = "7.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d" +dependencies = [ + "zstd-sys", +] + +[[package]] +name = "zstd-sys" +version = "2.0.16+zstd.1.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748" +dependencies = [ + "cc", + "pkg-config", +] diff --git a/Cargo.toml b/Cargo.toml index a578ff5..707ea39 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,12 +5,12 @@ members = [ "crates/core", "crates/db", "crates/server", - "crates/opencode", + "crates/opencode-client", "crates/orchestrator", "crates/vcs", "crates/events", - "crates/websocket", "crates/github", + "crates/mcp-findings", ] [workspace.package] @@ -22,12 +22,12 @@ rust-version = "1.75" # Internal crates opencode_core = { path = "crates/core" } db = { path = "crates/db" } -opencode = { path = "crates/opencode" } +opencode_client = { path = "crates/opencode-client" } # OpenAPI Generator SDK orchestrator = { path = "crates/orchestrator" } vcs = { path = "crates/vcs" } events = { path = "crates/events" } -websocket = { path = "crates/websocket" } github = { path = "crates/github" } +mcp-findings = { path = "crates/mcp-findings" } # HTTP client reqwest = { version = "0.12", features = ["json", "stream"] } @@ -40,7 +40,7 @@ tokio = { version = "1.0", features = ["full"] } # Web framework axum = { version = "0.8", features = ["macros", "ws"] } -tower-http = { version = "0.5", features = ["cors", "trace"] } +tower-http = { version = "0.5", features = ["cors", "trace", "fs"] } # Database sqlx = { version = "0.8", features = ["runtime-tokio", "sqlite"] } diff --git a/agents.md b/agents.md index d2936a6..dc36c01 100644 --- a/agents.md +++ b/agents.md @@ -1,514 +1,143 @@ -# OpenCode Studio - Agent Context +# OpenCode Studio -> Tento dokument slouzi jako kontext pro AI agenty pracujici na projektu. -> Posledni aktualizace: 2025-12-30 +**Generated:** 2025-12-31 | **Commit:** 1f74380 | **Branch:** ui ---- +## OVERVIEW -## 1. Co je OpenCode Studio +AI-powered development orchestration platform. Rust backend (Axum + SQLite) + React frontend. Automates task lifecycle TODO→DONE via OpenCode sessions. -**OpenCode Studio** je autonomni AI-powered development platform, ktera orchestruje OpenCode sessions pro automatizovany vyvoj software. +## STRUCTURE -### Klicove principy -- **Autonomie**: Minimalni lidska intervence behem vyvoje -- **Transparentnost**: Komunikace pres soubory (plany, reviews, roadmapa) -- **Modularita**: Plugovatelne moduly pro ruzne AI-powered funkce -- **Skalovatnost**: Paralelni beh vice agentu - -### Dvouvrstva architektura ``` -ROADMAP (produktova vrstva) - "Co a proc" - │ - │ [Presunout do vyvoje] - ▼ -KANBAN (implementacni vrstva) - "Jak" +opencode-os/ +├── crates/ # Rust workspace (9 crates) → see crates/AGENTS.md +│ ├── server/ # Axum HTTP + SSE (entry: main.rs) +│ ├── cli/ # opencode-studio CLI binary +│ ├── orchestrator/ # Task lifecycle, state machine, prompts +│ ├── opencode-client/ # OpenAPI-generated OpenCode SDK +│ ├── db/ # SQLite persistence (sqlx) +│ ├── vcs/ # Jujutsu/Git abstraction +│ ├── events/ # Event bus (tokio::broadcast) +│ ├── github/ # GitHub API (octocrab) +│ └── core/ # Domain models (NO I/O) → exports as opencode_core +├── frontend/ # React + Vite → see frontend/AGENTS.md +├── docs/ # Architecture docs +└── .opencode-studio/ # Runtime: config.toml, studio.db, kanban/{plans,reviews} ``` ---- +## WHERE TO LOOK + +| Task | Location | Notes | +|------|----------|-------| +| Add API endpoint | `crates/server/src/routes/` | Add to lib.rs OpenAPI schema | +| Task state logic | `crates/orchestrator/src/state_machine.rs` | TaskStateMachine | +| OpenCode integration | `crates/orchestrator/src/executor.rs` | Uses opencode-client SDK | +| VCS operations | `crates/vcs/src/` | jj.rs primary, git.rs fallback | +| Frontend component | `frontend/src/components/` | Feature dirs: kanban/, sessions/, task-detail/ | +| Generated types | `frontend/src/types/generated/` | ts-rs from Rust | +| Generated API hooks | `frontend/src/api/generated/` | Orval from OpenAPI | +| Domain models | `crates/core/src/domain/` | Task, Session, TaskStatus | +| DB migrations | `crates/db/migrations/` | SQLite schema | +| AI prompts | `crates/orchestrator/src/prompts.rs` | Planning/review prompts | -## 2. Task Lifecycle (State Machine) +## TASK LIFECYCLE ``` TODO → PLANNING → PLANNING_REVIEW → IN_PROGRESS → AI_REVIEW → REVIEW → DONE (AI plan) (optional) (OpenCode) (AI check) (human) ``` -### Prechody stavu -| From | Allowed To | -|------|------------| -| Todo | Planning | -| Planning | PlanningReview, Todo | -| PlanningReview | InProgress, Planning | -| InProgress | AiReview, PlanningReview | -| AiReview | Review, InProgress | -| Review | Done, InProgress | -| Done | (terminal) | - -### Session Strategy -Kazda faze = vlastni OpenCode session, komunikace pres soubory: - -| Faze | Input | Output | -|------|-------|--------| -| PLANNING | task description | `plans/{id}.md` | -| IN_PROGRESS | plan | kod ve workspace | -| AI_REVIEW | diff, task | `reviews/{id}.md` | +Each phase = separate OpenCode session. Files in `.opencode-studio/kanban/`. ---- - -## 3. Crates Architecture - -``` -crates/ -├── core/ # Domain models, traits (NO I/O) -│ └── domain/ # Task, Session, TaskStatus -├── db/ # SQLite persistence (sqlx) -│ ├── models/ # DB models -│ └── repositories/ # TaskRepository, SessionRepository -├── opencode/ # OpenCode HTTP client -│ ├── client.rs # OpenCodeClient (create_session, send_message, etc.) -│ ├── types.rs # Session, Message, SendMessageRequest -│ └── events.rs # SSE EventStream, OpenCodeEvent -├── orchestrator/ # Task lifecycle, scheduling -│ ├── executor.rs # TaskExecutor (execute_phase, run_planning_session, etc.) -│ ├── state_machine.rs # TaskStateMachine (validate_transition) -│ ├── prompts.rs # PhasePrompts (planning, implementation, review) -│ └── files.rs # FileManager (plans/reviews in .opencode-studio/kanban/) -├── events/ # Event system -│ ├── types.rs # Event, EventEnvelope, AgentMessageData, ToolExecutionData -│ └── bus.rs # EventBus (tokio::sync::broadcast) -├── websocket/ # WebSocket real-time updates -│ ├── handler.rs # ws_handler, WsState -│ └── messages.rs # ClientMessage, ServerMessage, SubscriptionFilter -├── vcs/ # Version control (jj, git) -│ ├── traits.rs # VersionControl trait, Workspace, MergeResult -│ ├── jj.rs # Jujutsu implementation -│ ├── git.rs # Git fallback -│ └── workspace.rs # WorkspaceManager, WorkspaceConfig -├── server/ # Axum HTTP server -│ └── routes/ # health, tasks, sessions, workspaces, ws -└── github/ # GitHub integration (octocrab) - ├── client.rs # GitHubClient (create_pull_request, merge, get_ci_status, import_issue) - ├── types.rs # PullRequest, Issue, CiStatus, CiState, CreatePrRequest, RepoConfig - └── error.rs # GitHubError -``` +## KEY TYPES -### Dependency Graph -``` - server - │ - ┌─────────┼─────────┐ - │ │ │ -orchestrator db opencode - │ │ │ - └─────────┼─────────┘ - │ - core -``` - ---- - -## 4. Current API Endpoints - -### Tasks -| Method | Path | Description | -|--------|------|-------------| -| GET | `/api/tasks` | List all tasks | -| POST | `/api/tasks` | Create task | -| GET | `/api/tasks/{id}` | Get task detail | -| PATCH | `/api/tasks/{id}` | Update task | -| DELETE | `/api/tasks/{id}` | Delete task | -| POST | `/api/tasks/{id}/transition` | Change task status | -| POST | `/api/tasks/{id}/execute` | Execute current phase | -| GET | `/api/tasks/{id}/sessions` | List sessions for task | - -### Sessions -| Method | Path | Description | -|--------|------|-------------| -| GET | `/api/sessions` | List all sessions | -| GET | `/api/sessions/{id}` | Get session detail | -| DELETE | `/api/sessions/{id}` | Delete session | - -### Workspaces -| Method | Path | Description | -|--------|------|-------------| -| POST | `/api/tasks/{id}/workspace` | Create workspace for task | -| GET | `/api/workspaces` | List all workspaces | -| GET | `/api/workspaces/{id}` | Get workspace status | -| GET | `/api/workspaces/{id}/diff` | Get workspace diff | -| POST | `/api/workspaces/{id}/merge` | Merge workspace | -| DELETE | `/api/workspaces/{id}` | Delete/cleanup workspace | - -### WebSocket -| Method | Path | Description | -|--------|------|-------------| -| GET | `/ws` | WebSocket connection for real-time events | - -### Health -| Method | Path | Description | -|--------|------|-------------| -| GET | `/health` | Health check | - ---- - -## 5. OpenCode Integration - -### OpenCodeClient methods ```rust -create_session(title: Option) -> Session -get_session(session_id: &str) -> Session -list_sessions() -> Vec -send_message(session_id, prompt, model) -> MessageResponse -send_message_async(session_id, prompt) -> () -abort_session(session_id) -> () -get_messages(session_id) -> Vec -``` +// crates/core/src/domain/task.rs +struct Task { id, title, description, status: TaskStatus, roadmap_item_id, workspace_path } +enum TaskStatus { Todo, Planning, PlanningReview, InProgress, AiReview, Review, Done } -### SSE Events -```rust -enum OpenCodeEvent { - SessionMessage { session_id, content } - SessionCompleted { session_id } - SessionError { session_id, error } - TaskStatusChanged { task_id, status } -} +// crates/core/src/domain/session.rs +struct Session { id, task_id, opencode_session_id, phase: SessionPhase, status: SessionStatus } +enum SessionPhase { Planning, Implementation, Review } +enum SessionStatus { Pending, Running, Completed, Failed, Aborted } ``` -### EventStream usage -```rust -let stream = EventStream::new("http://localhost:4096"); -let mut receiver = stream.connect().await?; -while let Some(event) = receiver.next_event().await { - // handle event -} -``` +## DEPENDENCY GRAPH ---- - -## 6. Key Domain Types - -### Task (core) -```rust -struct Task { - id: Uuid, - title: String, - description: String, - status: TaskStatus, - roadmap_item_id: Option, - workspace_path: Option, - created_at: DateTime, - updated_at: DateTime, -} ``` - -### TaskStatus (core) -```rust -enum TaskStatus { - Todo, - Planning, - PlanningReview, - InProgress, - AiReview, - Review, - Done, -} -``` - -### Session (core) -```rust -struct Session { - id: Uuid, - task_id: Uuid, - opencode_session_id: Option, - phase: SessionPhase, // Planning, Implementation, Review - status: SessionStatus, // Pending, Running, Completed, Failed - started_at: Option>, - completed_at: Option>, - created_at: DateTime, -} +cli → db, server +server → core, opencode_client, orchestrator, db, vcs, events, github +orchestrator → core, opencode_client, db, vcs, events +github, vcs, db → core +events, opencode_client, core → (no internal deps) ``` ---- - -## 7. Implementation Phases - -### Phase 1: Foundation ✅ DONE -- [x] Workspace setup (core, db, server crates) -- [x] Domain models (Task, Session, TaskStatus) -- [x] SQLite database s migraci -- [x] Basic CRUD API pro tasks -- [x] Health endpoint -- [x] Tracing/logging setup - -### Phase 2: OpenCode Integration ✅ DONE -- [x] OpenCode SDK (HTTP client wrapper) -- [x] SSE event stream handling -- [x] Task executor s phase logic -- [x] State machine pro task transitions -- [x] Session tracking v DB -- [x] API endpoints pro sessions - -### Phase 3: VCS & Workspace Management ✅ DONE -- [x] VCS trait + Jujutsu implementation -- [x] Git fallback implementation -- [x] Workspace manager -- [x] Init/cleanup script runner -- [x] API endpoints pro workspaces - -### Phase 4: WebSocket & Real-time ✅ DONE -- [x] WebSocket handler v Axum -- [x] Event bus (tokio::sync::broadcast) -- [x] Event types (Task, Session, Workspace, Error events) -- [x] WebSocket route at /ws -- [x] Event emission from task routes - -### Phase 5: Full Kanban Flow ✅ DONE -- [x] Planning phase implementation (run_planning_session with file output) -- [x] Implementation phase (run_implementation_session with workspace integration) -- [x] AI Review phase (run_ai_review with diff and review file output) -- [x] Human Review support (approve_plan, reject_plan, approve_review, reject_review) -- [x] Retry logic pro failed reviews (max_review_iterations enforcement) -- [x] File management module (plans/reviews in .opencode-studio/kanban/) -- [x] VCS WorkspaceManager integration for real diffs -- [x] EventBus integration for event emission -- [x] Session persistence to DB -- [x] run_full_cycle() for complete TODO→DONE automation - -### Phase 6: GitHub Integration ✅ DONE -- [x] GitHub client (octocrab wrapper) -- [x] Auto PR creation (create_pull_request, merge_pull_request, close_pull_request) -- [x] CI status polling (get_ci_status, wait_for_ci, get_pr_ci_status) -- [x] Issue import (get_issue, list_issues, import_issue) - -### Phase 7: Frontend Integration ✅ DONE -- [x] ts-rs setup pro vsechny typy -- [x] Generated types v frontend/src/types/generated/ -- [x] OpenAPI spec (utoipa) + Swagger UI -- [x] React Query hooks (Orval generated) -- [x] WebSocket hook (`useStudioWebSocket`) - -#### OpenAPI & SDK Generation -```bash -# Start server (required for OpenAPI spec) -DATABASE_URL=sqlite:./studio.db cargo run --package server --bin server +## API SURFACE -# Generate React Query SDK from OpenAPI -cd frontend && pnpm generate:api -``` +25+ REST endpoints across 8 modules: +- `/api/tasks` - Task CRUD + lifecycle transitions +- `/api/sessions` - Session management + activity SSE +- `/api/workspaces` - VCS workspace operations +- `/api/projects` - Project open/init/validate +- `/api/events` - Global SSE event stream +- `/api/openapi.json` - Generated spec +- `/swagger-ui` - Interactive docs -**Available endpoints:** -- `GET /api/openapi.json` - OpenAPI 3.1 spec -- `GET /swagger-ui` - Swagger UI documentation - -**Generated SDK location:** `frontend/src/api/generated/` -- 50 TypeScript files (hooks + models) -- React Query hooks: `useListTasks`, `useCreateTask`, `useGetTask`, `useUpdateTask`, `useDeleteTask`, `useTransitionTask`, `useExecuteTask` -- Sessions: `useListSessions`, `useGetSession`, `useDeleteSession`, `useListSessionsForTask` -- Workspaces: `useListWorkspaces`, `useGetWorkspaceStatus`, `useGetWorkspaceDiff`, `useMergeWorkspace`, `useDeleteWorkspace`, `useCreateWorkspaceForTask` -- Health: `useHealthCheck` - -**Usage example:** -```tsx -import { useListTasks, useCreateTask } from '~/api/generated/tasks/tasks'; -import { Task } from '~/api/generated/model'; - -function TaskList() { - const { data: tasks, isLoading } = useListTasks(); - const createTask = useCreateTask(); - - const handleCreate = () => { - createTask.mutate({ data: { title: 'New Task', description: 'Description' } }); - }; - - return
{tasks?.map(t =>
{t.title}
)}
; -} -``` +## CONVENTIONS -#### WebSocket Hook - -**Location:** `frontend/src/hooks/useStudioWebSocket.ts` - -Real-time event streaming from the backend. Auto-connects, handles reconnection with exponential backoff, and provides typed events. - -**Features:** -- Auto-connect on mount -- Reconnection with exponential backoff (max 5 attempts) -- Ping/pong keep-alive (30s interval) -- Task-specific subscription filtering -- Fully typed events from `~/types/generated` - -**Usage example:** -```tsx -import { useStudioWebSocket } from '~/hooks/useStudioWebSocket'; -import type { Event, EventEnvelope } from '~/types/generated'; - -function TaskMonitor({ taskId }: { taskId: string }) { - const { connectionState, isSubscribed } = useStudioWebSocket({ - taskIds: [taskId], - onEvent: (event: Event, envelope: EventEnvelope) => { - switch (event.type) { - case 'task.status_changed': - console.log(`Task ${event.task_id}: ${event.from_status} → ${event.to_status}`); - break; - case 'agent.message': - console.log(`Agent: ${event.message.content}`); - break; - case 'session.ended': - console.log(`Session ended: ${event.success ? 'success' : 'failed'}`); - break; - } - }, - onConnectionChange: (state) => console.log('WS:', state), - }); - - return
Connection: {connectionState}, Subscribed: {isSubscribed}
; -} -``` +- **Crate naming**: `core` → `opencode_core` (reserved word) +- **Error handling**: `thiserror` for crate errors, `anyhow` for app errors +- **Parsing**: `str.parse()` not `FromStr::from_str()` +- **Type safety**: NEVER `as any`, `@ts-ignore`, `@ts-expect-error` +- **Biome**: Tabs, 100 char lines, double quotes, trailing commas +- **CI**: `clippy -D warnings`, `cargo fmt --check` -**Environment variable:** `NEXT_PUBLIC_WS_URL` (default: `ws://localhost:3001/ws`) +## ANTI-PATTERNS -### Phase 8: CLI Tool ✅ DONE -- [x] `opencode-studio` CLI binary -- [x] `init` command - initialize project -- [x] `serve` command - start server + open browser -- [x] `status` command - show project status -- [x] `/api/project` endpoint for project info +- Empty catch blocks (`noEmptyBlockStatements: warn`) +- Barrel files (`noBarrelFile` + `noReExportAll` enabled) +- Floating promises (`noFloatingPromises: error`) +- `console.log` in prod (`noConsole: warn`) +- Hardcoded secrets (`noSecrets: error`) +- Path deps instead of workspace deps (known tech debt in cli crate) -#### CLI Installation -```bash -cargo install --path crates/cli -``` +## COMMANDS -#### CLI Usage ```bash -# Initialize a new project -cd /path/to/my-project -opencode-studio init - -# Start the server (opens browser automatically) -opencode-studio - -# Start server on custom port -opencode-studio --port 4000 - -# Start server without opening browser -opencode-studio serve --no-browser - -# Check project status -opencode-studio status -``` - -#### Project Structure After Init -``` -my-project/ -├── .opencode-studio/ -│ ├── config.toml # Project configuration -│ ├── studio.db # SQLite database -│ └── kanban/ -│ ├── plans/ # Generated plans -│ └── reviews/ # AI reviews -├── .git/ or .jj/ # VCS (auto-detected) -└── ... your project files -``` - -#### config.toml Format -```toml -[project] -name = "my-project" - -[server] -port = 3001 -opencode_url = "http://localhost:4096" -frontend_url = "http://localhost:3000" -``` - ---- - -## 8. Tech Stack +# Dev (backend + frontend concurrent) +pnpm dev -| Layer | Technology | -|-------|------------| -| Runtime | Rust + Tokio | -| HTTP Server | Axum 0.8 | -| Database | SQLite + sqlx 0.8 | -| Serialization | serde + serde_json | -| Error handling | anyhow + thiserror | -| Logging | tracing | -| OpenCode | HTTP client (reqwest) + SSE (eventsource-stream) | -| GitHub | octocrab 0.41 | - ---- - -## 9. File Structure - -``` -.opencode-studio/ -├── config.toml -├── studio.db -├── kanban/ -│ ├── tasks/{id}.md -│ ├── plans/{id}.md -│ └── reviews/{id}.md -├── roadmap/ -│ ├── roadmap.md -│ └── items/{id}.md -├── scripts/ -│ ├── workspace-init.sh -│ └── workspace-cleanup.sh -└── sessions/ - └── {module}_{timestamp}.log -``` - ---- +# Backend only +DATABASE_URL=sqlite:./studio.db cargo run --package server -## 10. Running the Project +# Frontend only +cd frontend && pnpm dev -```bash -# Run all tests +# Tests (109 unit tests across 9 crates) cargo test --workspace +cargo clippy --workspace --all-features -- -D warnings -# Run server -DATABASE_URL=sqlite:./studio.db cargo run --package server +# Generate frontend SDK +cd frontend && pnpm generate:api -# Server runs on http://localhost:3001 +# CLI +cargo install --path crates/cli +opencode-studio init # Initialize project +opencode-studio serve # Start server ``` -### Environment Variables +## ENV VARIABLES + | Variable | Default | Description | |----------|---------|-------------| | DATABASE_URL | sqlite:./studio.db | SQLite connection | -| OPENCODE_URL | http://localhost:4096 | OpenCode server URL | -| PORT | 3001 | Server port | - ---- - -## 11. Coding Conventions - -1. **Crate naming**: Avoid reserved names (`core` → `opencode_core`) -2. **Error handling**: Use `thiserror` for custom errors, `anyhow` for application errors -3. **Parsing**: Use `str.parse()` instead of `FromStr::from_str()` -4. **Type safety**: Never use `as any`, `@ts-ignore`, `@ts-expect-error` -5. **Tests**: Each module should have unit tests - ---- - -## 12. Test Coverage - -| Crate | Tests | Status | -|-------|-------|--------| -| db | 10 | ✅ | -| events | 12 | ✅ | -| github | 11 | ✅ | -| opencode | 2 | ✅ | -| opencode_core | 8 | ✅ | -| orchestrator | 24 | ✅ | -| vcs | 12 | ✅ | -| websocket | 9 | ✅ | -| server (integration) | 31 | ✅ | -| **Total** | **119** | ✅ All passing | - -### Server Integration Tests Breakdown -- **L1 API Tests (14)**: CRUD, transitions, health, sessions, validation -- **L2 Flow Tests (4)**: Kanban flow, planning phase, session DB, auto-transitions -- **L3 Workspace Tests (6)**: Create, list, status, diff, delete, not-found (git worktree) -- **L3 E2E jj Tests (5)**: Create, multiple, cleanup, diff, status (real jj workspaces) -- **Additional (2)**: Health, workspaces empty list +| OPENCODE_URL | http://localhost:4096 | OpenCode server | +| PORT | 3001 | Backend port | + +## NOTES + +- **OpenAPI**: `/api/openapi.json`, Swagger at `/swagger-ui` +- **SSE**: `/api/events` (global), `/api/sessions/{id}/activity` (per-session) +- **VCS**: Jujutsu preferred, Git fallback auto-detected +- **Type gen**: ts-rs (Rust→TS), Orval (OpenAPI→React Query) +- **Test pattern**: Inline `#[cfg(test)]` modules, no separate test dirs diff --git a/biome.json b/biome.json index 6aabacb..86334aa 100644 --- a/biome.json +++ b/biome.json @@ -78,7 +78,7 @@ }, { "selector": { "kind": "objectLiteralProperty" }, - "formats": ["camelCase", "PascalCase", "CONSTANT_CASE"] + "formats": ["camelCase", "PascalCase", "CONSTANT_CASE", "snake_case"] } ] } diff --git a/crates/AGENTS.md b/crates/AGENTS.md new file mode 100644 index 0000000..83aa9cd --- /dev/null +++ b/crates/AGENTS.md @@ -0,0 +1,68 @@ +# OpenCode Studio: Crates + +## OVERVIEW + +9-crate Rust workspace. Core domain logic, persistence, orchestration, and HTTP server. + +## CRATE MAP + +| Crate | Purpose | Key Exports | Tests | +|:------|:--------|:------------|:------| +| `core` | Domain models (NO I/O) | `Task`, `Session`, `TaskStatus`, `SessionPhase` | 10 | +| `db` | SQLite persistence (sqlx) | `TaskRepository`, `SessionRepository`, `create_pool` | 12 | +| `opencode-client` | OpenAPI-generated SDK | `apis::DefaultApi`, `Configuration` | 0 | +| `orchestrator` | Task lifecycle engine | `TaskExecutor`, `TaskStateMachine`, `FileManager` | 36 | +| `vcs` | VCS abstraction | `VersionControl`, `WorkspaceManager`, `JujutsuVcs`, `GitVcs` | 20 | +| `events` | Event bus | `EventBus`, `TaskEvent`, `SessionEvent` | 8 | +| `github` | GitHub API (octocrab) | `GitHubClient`, `PullRequest`, `Issue` | 11 | +| `server` | Axum HTTP + SSE | `AppState`, `router`, `OpenApi` | 12 | +| `cli` | Binary: `opencode-studio` | Commands: init, serve, status, update | 0 | + +## DEPENDENCY GRAPH + +``` +server (aggregates all) +├── orchestrator → core, opencode-client, db, vcs, events +├── db → core +├── vcs → core +├── github → core +└── cli → db, server (uses path deps - tech debt) + +Foundational (no internal deps): core, events, opencode-client +``` + +## WHERE TO LOOK + +| Task | Crate | File | +|:-----|:------|:-----| +| Add domain type | `core` | `src/domain/mod.rs` | +| Add DB table | `db` | `migrations/*.sql` + `src/models/` + `src/repositories/` | +| Add API route | `server` | `src/routes/` + update `src/lib.rs` OpenAPI | +| Task state transitions | `orchestrator` | `src/state_machine.rs` | +| AI prompts | `orchestrator` | `src/prompts.rs` | +| VCS operations | `vcs` | `src/jj.rs` (primary), `src/git.rs` (fallback) | +| Event emission | `events` | `src/types.rs` for new event types | +| GitHub integration | `github` | `src/client.rs` | + +## CONVENTIONS + +- `core` exports as `opencode_core` (reserved word collision) +- Crate errors: `thiserror` with dedicated `error.rs` +- Workspace deps in root `Cargo.toml`, not per-crate +- All domain mutations through `orchestrator` state machine +- Inline tests: `#[cfg(test)] mod tests { ... }` + +## ANTI-PATTERNS + +- Direct `Task`/`Session` status mutation (use state machine) +- I/O in `core` crate (pure domain only) +- `unwrap()` in non-test code (use `?` or explicit error) +- `len() > 0` (use `!is_empty()`) + +## TEST COMMANDS + +```bash +cargo test --workspace # All 109 tests +cargo test -p orchestrator # Single crate +cargo test -p server -- --nocapture # With output +``` diff --git a/crates/cli/Cargo.toml b/crates/cli/Cargo.toml index 2153f63..6f3458e 100644 --- a/crates/cli/Cargo.toml +++ b/crates/cli/Cargo.toml @@ -18,7 +18,14 @@ toml = "0.8" serde = { version = "1", features = ["derive"] } serde_json = "1" open = "5" +dirs = "5" axum = { workspace = true } +colored = "2" +console = "0.15" +reqwest = { workspace = true } +zip = "2" +futures-util = "0.3" +indicatif = "0.17" db = { path = "../db" } server = { path = "../server" } diff --git a/crates/cli/src/main.rs b/crates/cli/src/main.rs index 798db95..cdb57f6 100644 --- a/crates/cli/src/main.rs +++ b/crates/cli/src/main.rs @@ -1,14 +1,36 @@ use anyhow::{Context, Result}; use clap::{Parser, Subcommand}; +use colored::Colorize; +use console::Term; +use futures_util::StreamExt; +use indicatif::{ProgressBar, ProgressStyle}; use serde::{Deserialize, Serialize}; use server::{create_router, state::AppState}; +use std::io::Write; +use std::path::PathBuf; use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt}; const STUDIO_DIR: &str = ".opencode-studio"; const CONFIG_FILE: &str = "config.toml"; +const GLOBAL_CONFIG_FILE: &str = "global.toml"; const DEFAULT_DB_NAME: &str = "studio.db"; const DEFAULT_PORT: u16 = 3001; -const DEFAULT_FRONTEND_PORT: u16 = 3000; +const MAX_RECENT_PROJECTS: usize = 10; + +const APP_DIR: &str = "app"; +const APP_VERSION_FILE: &str = "version.txt"; +const FRONTEND_RELEASE_URL: &str = + "https://github.com/souky-byte/opencode-studio/releases/latest/download/frontend.zip"; +const CURRENT_VERSION: &str = env!("CARGO_PKG_VERSION"); + +const LOGO: &str = r#" + ____ ______ __ + / __ \____ ___ ____ / ____/___ ____/ /__ + / / / / __ \/ _ \/ __ \/ / / __ \/ __ / _ \ +/ /_/ / /_/ / __/ / / / /___/ /_/ / /_/ / __/ +\____/ .___/\___/_/ /_/\____/\____/\__,_/\___/ + /_/ Studio +"#; #[derive(Parser)] #[command(name = "opencode-studio")] @@ -27,8 +49,18 @@ struct Cli { #[derive(Subcommand)] enum Commands { - Init, + /// Initialize OpenCode Studio in a project directory + Init { + /// Path to the project directory (defaults to current directory) + #[arg(value_name = "PATH")] + path: Option, + }, + /// Start the OpenCode Studio server Serve { + /// Path to the project directory (defaults to current directory) + #[arg(value_name = "PATH")] + path: Option, + #[arg(short, long, default_value_t = DEFAULT_PORT)] port: u16, @@ -38,25 +70,31 @@ enum Commands { #[arg(long)] no_browser: bool, }, - Status, + /// Show project status + Status { + /// Path to the project directory (defaults to current directory) + #[arg(value_name = "PATH")] + path: Option, + }, + /// Update the frontend app to the latest version + Update, } -#[derive(Debug, Serialize, Deserialize)] +#[derive(Debug, Serialize, Deserialize, Clone)] struct StudioConfig { project: ProjectConfig, server: ServerConfig, } -#[derive(Debug, Serialize, Deserialize)] +#[derive(Debug, Serialize, Deserialize, Clone)] struct ProjectConfig { name: String, } -#[derive(Debug, Serialize, Deserialize)] +#[derive(Debug, Serialize, Deserialize, Clone)] struct ServerConfig { port: u16, opencode_url: String, - frontend_url: String, } impl Default for StudioConfig { @@ -68,38 +106,281 @@ impl Default for StudioConfig { server: ServerConfig { port: DEFAULT_PORT, opencode_url: "http://localhost:4096".to_string(), - frontend_url: format!("http://localhost:{}", DEFAULT_FRONTEND_PORT), }, } } } +#[derive(Debug, Serialize, Deserialize, Default)] +struct GlobalConfig { + #[serde(default)] + recent_projects: Vec, + last_project: Option, +} + +fn get_global_config_dir() -> Result { + let home = dirs::home_dir().context("Could not determine home directory")?; + Ok(home.join(STUDIO_DIR)) +} + +fn get_app_dir() -> Result { + Ok(get_global_config_dir()?.join(APP_DIR)) +} + +async fn load_global_config() -> GlobalConfig { + let Ok(config_dir) = get_global_config_dir() else { + return GlobalConfig::default(); + }; + let config_path = config_dir.join(GLOBAL_CONFIG_FILE); + + if !config_path.exists() { + return GlobalConfig::default(); + } + + match tokio::fs::read_to_string(&config_path).await { + Ok(content) => toml::from_str(&content).unwrap_or_default(), + Err(_) => GlobalConfig::default(), + } +} + +async fn save_global_config(config: &GlobalConfig) -> Result<()> { + let config_dir = get_global_config_dir()?; + tokio::fs::create_dir_all(&config_dir).await?; + + let config_path = config_dir.join(GLOBAL_CONFIG_FILE); + let content = toml::to_string_pretty(config)?; + tokio::fs::write(&config_path, content).await?; + Ok(()) +} + +async fn add_recent_project(path: &std::path::Path) { + let path_str = path.display().to_string(); + let mut config = load_global_config().await; + + config.recent_projects.retain(|p| p != &path_str); + config.recent_projects.insert(0, path_str.clone()); + config.recent_projects.truncate(MAX_RECENT_PROJECTS); + config.last_project = Some(path_str); + + let _ = save_global_config(&config).await; +} + +async fn check_app_version(app_dir: &std::path::Path) -> Option { + let version_file = app_dir.join(APP_VERSION_FILE); + tokio::fs::read_to_string(version_file).await.ok() +} + +async fn download_frontend(app_dir: &PathBuf, show_progress: bool) -> Result<()> { + let temp_zip = app_dir.parent().unwrap().join("frontend.zip"); + + tokio::fs::create_dir_all(app_dir).await?; + + let client = reqwest::Client::new(); + let response = client + .get(FRONTEND_RELEASE_URL) + .send() + .await + .context("Failed to download frontend")?; + + if !response.status().is_success() { + anyhow::bail!( + "Failed to download frontend: HTTP {}", + response.status() + ); + } + + let total_size = response.content_length().unwrap_or(0); + + let pb = if show_progress && total_size > 0 { + let pb = ProgressBar::new(total_size); + pb.set_style( + ProgressStyle::default_bar() + .template(" {spinner:.cyan} [{bar:30.cyan/dim}] {bytes}/{total_bytes}") + .unwrap() + .progress_chars("█▓░"), + ); + Some(pb) + } else { + None + }; + + let mut file = std::fs::File::create(&temp_zip)?; + let mut stream = response.bytes_stream(); + + while let Some(chunk) = stream.next().await { + let chunk = chunk.context("Error downloading chunk")?; + file.write_all(&chunk)?; + if let Some(ref pb) = pb { + pb.inc(chunk.len() as u64); + } + } + + if let Some(pb) = pb { + pb.finish_and_clear(); + } + + let zip_file = std::fs::File::open(&temp_zip)?; + let mut archive = zip::ZipArchive::new(zip_file)?; + + if app_dir.exists() { + tokio::fs::remove_dir_all(app_dir).await?; + } + tokio::fs::create_dir_all(app_dir).await?; + + archive.extract(app_dir)?; + + tokio::fs::remove_file(&temp_zip).await?; + + let version_file = app_dir.join(APP_VERSION_FILE); + tokio::fs::write(&version_file, CURRENT_VERSION).await?; + + Ok(()) +} + +async fn ensure_frontend_app() -> Result { + let app_dir = get_app_dir()?; + + if !app_dir.exists() || !app_dir.join("index.html").exists() { + println!(); + println!( + " {} {}", + "📦".yellow(), + "Downloading OpenCode Studio app...".white() + ); + + match download_frontend(&app_dir, true).await { + Ok(()) => { + println!( + " {} {}", + "✓".green().bold(), + "App downloaded successfully".green() + ); + } + Err(e) => { + println!( + " {} {}", + "✗".red(), + format!("Failed to download app: {}", e).red() + ); + println!(); + println!( + " {}", + "The app will still work, but you'll need the frontend running separately." + .dimmed() + ); + println!( + " {}", + "Or run 'opencode-studio update' to retry the download.".dimmed() + ); + return Err(e); + } + } + } + + Ok(app_dir) +} + #[tokio::main] async fn main() -> Result<()> { let cli = Cli::parse(); match cli.command { - Some(Commands::Init) => init_project().await, + Some(Commands::Init { path }) => init_project(path).await, Some(Commands::Serve { + path, port, opencode_url, no_browser, - }) => serve(port, &opencode_url, !no_browser).await, - Some(Commands::Status) => status().await, - None => serve(cli.port, &cli.opencode_url, true).await, + }) => serve(path, port, &opencode_url, !no_browser).await, + Some(Commands::Status { path }) => status(path).await, + Some(Commands::Update) => update_frontend().await, + None => serve(None, cli.port, &cli.opencode_url, true).await, } } -async fn init_project() -> Result<()> { - let cwd = std::env::current_dir()?; - let studio_dir = cwd.join(STUDIO_DIR); +async fn update_frontend() -> Result<()> { + let app_dir = get_app_dir()?; - if studio_dir.exists() { - println!("Project already initialized at {}", studio_dir.display()); - return Ok(()); + println!(); + println!( + " {} {}", + "🔄".cyan(), + "Updating OpenCode Studio app...".white() + ); + + if let Some(current) = check_app_version(&app_dir).await { + println!(" {} {}", "Current version:".dimmed(), current.trim()); + } + + download_frontend(&app_dir, true).await?; + + println!( + " {} {} {}", + "✓".green().bold(), + "Updated to version".green(), + CURRENT_VERSION.cyan() + ); + println!(); + + Ok(()) +} + +async fn resolve_project_path(path: Option) -> Result { + let project_path = match path { + Some(p) => { + if p.is_absolute() { + p + } else { + std::env::current_dir()?.join(p) + } + } + None => { + let cwd = std::env::current_dir()?; + if cwd.join(STUDIO_DIR).exists() + || cwd.join(".git").exists() + || cwd.join(".jj").exists() + { + cwd + } else { + let global_config = load_global_config().await; + if let Some(last) = global_config.last_project { + let last_path = PathBuf::from(&last); + if last_path.exists() { + println!("{} Using last project: {}", "→".cyan(), last.dimmed()); + last_path + } else { + cwd + } + } else { + cwd + } + } + } + }; + + let canonical = project_path + .canonicalize() + .with_context(|| format!("Path does not exist: {}", project_path.display()))?; + + Ok(canonical) +} + +fn validate_vcs_project(path: &std::path::Path) -> Result<()> { + let has_git = path.join(".git").exists(); + let has_jj = path.join(".jj").exists(); + + if !has_git && !has_jj { + anyhow::bail!( + "Not a git/jj repository: {}\nInitialize with 'git init' or 'jj init' first.", + path.display() + ); } - println!("Initializing OpenCode Studio in {}", cwd.display()); + Ok(()) +} + +async fn init_project_internal(cwd: &std::path::Path, silent: bool) -> Result { + let studio_dir = cwd.join(STUDIO_DIR); tokio::fs::create_dir_all(&studio_dir).await?; tokio::fs::create_dir_all(studio_dir.join("kanban/plans")).await?; @@ -127,78 +408,196 @@ async fn init_project() -> Result<()> { let pool = db::create_pool(&database_url).await?; db::run_migrations(&pool).await?; + if !silent { + print_init_success(&project_name); + } + + add_recent_project(cwd).await; + + Ok(config) +} + +fn print_init_success(project_name: &str) { println!(); - println!("Initialized OpenCode Studio for '{}'", project_name); + println!( + " {} Initialized OpenCode Studio for '{}'", + "✓".green().bold(), + project_name.cyan() + ); println!(); - println!("Created:"); - println!(" {}/ ", STUDIO_DIR); - println!(" ├── {} ", CONFIG_FILE); - println!(" ├── {} ", DEFAULT_DB_NAME); - println!(" └── kanban/"); - println!(" ├── plans/"); - println!(" └── reviews/"); + println!(" {}", "Created:".dimmed()); + println!(" {}/ ", STUDIO_DIR.yellow()); + println!(" ├── {} ", CONFIG_FILE.dimmed()); + println!(" ├── {} ", DEFAULT_DB_NAME.dimmed()); + println!(" └── {}/", "kanban".dimmed()); + println!(" ├── {}/", "plans".dimmed()); + println!(" └── {}/", "reviews".dimmed()); + println!(); +} + +async fn init_project(path: Option) -> Result<()> { + let cwd = resolve_project_path(path).await?; + validate_vcs_project(&cwd)?; + let studio_dir = cwd.join(STUDIO_DIR); + + if studio_dir.exists() { + println!( + " {} Project already initialized at {}", + "ℹ".blue(), + studio_dir.display().to_string().dimmed() + ); + return Ok(()); + } + + println!( + " {} Initializing in {}", + "→".cyan(), + cwd.display().to_string().dimmed() + ); + + init_project_internal(&cwd, false).await?; + + println!(" {}", "Next steps:".bold()); + println!( + " {} Run {} to start", + "1.".dimmed(), + "opencode-studio".cyan() + ); println!(); - println!("Next steps:"); - println!(" 1. Run 'opencode-studio' to start the server"); - println!(" 2. Open http://localhost:{} in your browser", DEFAULT_FRONTEND_PORT); Ok(()) } -async fn serve(port: u16, opencode_url: &str, open_browser: bool) -> Result<()> { - let cwd = std::env::current_dir()?; - let studio_dir = cwd.join(STUDIO_DIR); +async fn load_studio_config(studio_dir: &std::path::Path) -> Result { + let config_path = studio_dir.join(CONFIG_FILE); + if config_path.exists() { + let content = tokio::fs::read_to_string(&config_path).await?; + Ok(toml::from_str(&content)?) + } else { + Ok(StudioConfig::default()) + } +} + +fn print_banner(project_name: &str, port: u16) { + let term = Term::stdout(); + let _ = term.clear_screen(); - let (config, db_path) = if studio_dir.exists() { - let config_path = studio_dir.join(CONFIG_FILE); - let config: StudioConfig = if config_path.exists() { - let content = tokio::fs::read_to_string(&config_path).await?; - toml::from_str(&content)? - } else { - StudioConfig::default() + for (i, line) in LOGO.lines().enumerate() { + let colored_line = match i % 3 { + 0 => line.cyan(), + 1 => line.blue(), + _ => line.magenta(), }; - let db_path = studio_dir.join(DEFAULT_DB_NAME); - (config, db_path) + println!("{}", colored_line); + } + + println!(); + + let box_width = 50; + let separator = "─".repeat(box_width); + + println!(" {}", format!("┌{}┐", separator).dimmed()); + println!( + " {} {} {}{}", + "│".dimmed(), + "Project:".dimmed(), + project_name.white().bold(), + " ".repeat(box_width.saturating_sub(11 + project_name.len())) + &"│".dimmed().to_string() + ); + println!(" {}", format!("├{}┤", separator).dimmed()); + + let app_url = format!("http://localhost:{}", port); + let api_url = format!("http://localhost:{}/api", port); + let docs_url = format!("http://localhost:{}/swagger-ui", port); + + print_url_line("App", &app_url, box_width); + print_url_line("API", &api_url, box_width); + print_url_line("Docs", &docs_url, box_width); + + println!(" {}", format!("└{}┘", separator).dimmed()); + println!(); + + println!( + " {} {} {}", + "●".green(), + "Server running".green(), + "Press Ctrl+C to stop".dimmed() + ); + println!(); +} + +fn print_url_line(label: &str, url: &str, box_width: usize) { + let content = format!(" {}: {}", label.dimmed(), url.cyan()); + let visible_len = label.len() + url.len() + 4; + let padding = box_width.saturating_sub(visible_len); + println!( + " {} {}{}{}", + "│".dimmed(), + content, + " ".repeat(padding), + "│".dimmed() + ); +} + +fn print_auto_init_banner() { + println!(); + println!( + " {} {}", + "⚡".yellow(), + "First time setup detected".white().bold() + ); + println!(" {}", "Initializing OpenCode Studio...".dimmed()); + println!(); +} + +async fn serve( + path: Option, + port: u16, + opencode_url: &str, + open_browser: bool, +) -> Result<()> { + let cwd = resolve_project_path(path).await?; + validate_vcs_project(&cwd)?; + add_recent_project(&cwd).await; + let studio_dir = cwd.join(STUDIO_DIR); + + let config = if studio_dir.exists() { + load_studio_config(&studio_dir).await? } else { - println!("No .opencode-studio directory found."); - println!("Run 'opencode-studio init' first, or using default configuration."); - println!(); - (StudioConfig::default(), cwd.join(DEFAULT_DB_NAME)) + print_auto_init_banner(); + init_project_internal(&cwd, true).await? }; + let app_dir = ensure_frontend_app().await.ok(); + init_tracing(); - let database_url = format!("sqlite:{}", db_path.display()); - tracing::info!("Database: {}", db_path.display()); - tracing::info!("OpenCode URL: {}", opencode_url); + tracing::debug!("Project: {}", cwd.display()); + tracing::debug!("OpenCode URL: {}", opencode_url); - let pool = db::create_pool(&database_url) + let state = AppState::new(opencode_url); + let state = if let Some(ref app_dir) = app_dir { + state.with_app_dir(app_dir.clone()) + } else { + state + }; + + state + .open_project(&cwd) .await - .context("Failed to create database pool")?; - db::run_migrations(&pool).await?; + .context("Failed to open project")?; - let state = AppState::new(pool, opencode_url); let app = create_router(state); let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{}", port)).await?; - let project_name = &config.project.name; - println!(); - println!("OpenCode Studio - {}", project_name); - println!("════════════════════════════════════════"); - println!(); - println!(" API Server: http://localhost:{}", port); - println!(" Swagger UI: http://localhost:{}/swagger-ui", port); - println!(" Frontend: {}", config.server.frontend_url); - println!(); - println!("Press Ctrl+C to stop"); - println!(); + print_banner(&config.project.name, port); if open_browser { - let frontend_url = config.server.frontend_url.clone(); + let url = format!("http://localhost:{}", port); tokio::spawn(async move { tokio::time::sleep(tokio::time::Duration::from_millis(500)).await; - if let Err(e) = open::that(&frontend_url) { + if let Err(e) = open::that(&url) { tracing::warn!("Failed to open browser: {}", e); } }); @@ -209,28 +608,33 @@ async fn serve(port: u16, opencode_url: &str, open_browser: bool) -> Result<()> Ok(()) } -async fn status() -> Result<()> { - let cwd = std::env::current_dir()?; +async fn status(path: Option) -> Result<()> { + let cwd = resolve_project_path(path).await?; let studio_dir = cwd.join(STUDIO_DIR); if !studio_dir.exists() { - println!("Not an OpenCode Studio project."); - println!("Run 'opencode-studio init' to initialize."); + println!(); + println!(" {} Not an OpenCode Studio project.", "✗".red()); + println!( + " Run {} to initialize.", + "opencode-studio init".cyan() + ); + println!(); return Ok(()); } - let config_path = studio_dir.join(CONFIG_FILE); - let config: StudioConfig = if config_path.exists() { - let content = tokio::fs::read_to_string(&config_path).await?; - toml::from_str(&content)? - } else { - StudioConfig::default() - }; - + let config = load_studio_config(&studio_dir).await?; let db_path = studio_dir.join(DEFAULT_DB_NAME); if !db_path.exists() { - println!("Project: {} (database not initialized)", config.project.name); + println!(); + println!( + " {} Project: {} {}", + "ℹ".blue(), + config.project.name.cyan(), + "(database not initialized)".dimmed() + ); + println!(); return Ok(()); } @@ -241,28 +645,52 @@ async fn status() -> Result<()> { let tasks = task_repo.find_all().await?; println!(); - println!("Project: {}", config.project.name); - println!("Path: {}", cwd.display()); + println!( + " {} {}", + "◆".magenta(), + config.project.name.white().bold() + ); + println!(" {}", cwd.display().to_string().dimmed()); println!(); if tasks.is_empty() { - println!("No tasks yet."); + println!(" {} No tasks yet.", "○".dimmed()); } else { - println!("Tasks ({}):", tasks.len()); + println!(" {} ({}):", "Tasks".bold(), tasks.len()); + println!(); + for task in &tasks { let status_str = serde_json::to_string(&task.status) .unwrap_or_default() .trim_matches('"') .to_string(); - let status_icon = match status_str.as_str() { - "todo" => "○", - "planning" | "planning_review" => "◐", - "in_progress" | "ai_review" => "◑", - "review" => "◕", - "done" => "●", - _ => "?", + + let (icon, color) = match status_str.as_str() { + "todo" => ("○", "white"), + "planning" => ("◐", "yellow"), + "planning_review" => ("◑", "yellow"), + "in_progress" => ("◑", "blue"), + "ai_review" => ("◕", "cyan"), + "review" => ("◕", "magenta"), + "done" => ("●", "green"), + _ => ("?", "white"), + }; + + let colored_icon = match color { + "yellow" => icon.yellow(), + "blue" => icon.blue(), + "cyan" => icon.cyan(), + "magenta" => icon.magenta(), + "green" => icon.green(), + _ => icon.white(), }; - println!(" {} [{}] {}", status_icon, status_str, task.title); + + println!( + " {} {} {}", + colored_icon, + task.title.white(), + format!("[{}]", status_str).dimmed() + ); } } @@ -273,10 +701,10 @@ async fn status() -> Result<()> { fn init_tracing() { tracing_subscriber::registry() - .with(tracing_subscriber::fmt::layer()) + .with(tracing_subscriber::fmt::layer().with_target(false)) .with( tracing_subscriber::EnvFilter::try_from_default_env() - .unwrap_or_else(|_| "opencode_studio=info,server=info,tower_http=info".into()), + .unwrap_or_else(|_| "warn".into()), ) .init(); } diff --git a/crates/core/src/domain/session.rs b/crates/core/src/domain/session.rs index dc86510..ccc8871 100644 --- a/crates/core/src/domain/session.rs +++ b/crates/core/src/domain/session.rs @@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize}; use utoipa::ToSchema; use uuid::Uuid; -#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default, ToSchema)] +#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Default, ToSchema, Hash)] #[cfg_attr(feature = "typescript", derive(ts_rs::TS))] #[cfg_attr(feature = "typescript", ts(export))] #[serde(rename_all = "snake_case")] @@ -12,6 +12,8 @@ pub enum SessionPhase { Planning, Implementation, Review, + /// Fix phase - used to fix issues found during review + Fix, } impl SessionPhase { @@ -20,6 +22,7 @@ impl SessionPhase { Self::Planning => "planning", Self::Implementation => "implementation", Self::Review => "review", + Self::Fix => "fix", } } @@ -28,6 +31,7 @@ impl SessionPhase { "planning" => Some(Self::Planning), "implementation" => Some(Self::Implementation), "review" => Some(Self::Review), + "fix" => Some(Self::Fix), _ => None, } } diff --git a/crates/core/src/domain/task.rs b/crates/core/src/domain/task.rs index 7d81006..8abdbc5 100644 --- a/crates/core/src/domain/task.rs +++ b/crates/core/src/domain/task.rs @@ -14,6 +14,8 @@ pub enum TaskStatus { PlanningReview, InProgress, AiReview, + /// Fix phase - AI fixes issues found during AI review + Fix, Review, Done, } @@ -26,6 +28,7 @@ impl TaskStatus { Self::PlanningReview => "planning_review", Self::InProgress => "in_progress", Self::AiReview => "ai_review", + Self::Fix => "fix", Self::Review => "review", Self::Done => "done", } @@ -38,6 +41,7 @@ impl TaskStatus { "planning_review" => Some(Self::PlanningReview), "in_progress" => Some(Self::InProgress), "ai_review" => Some(Self::AiReview), + "fix" => Some(Self::Fix), "review" => Some(Self::Review), "done" => Some(Self::Done), _ => None, diff --git a/crates/db/Cargo.toml b/crates/db/Cargo.toml index daa265d..8e07c34 100644 --- a/crates/db/Cargo.toml +++ b/crates/db/Cargo.toml @@ -11,6 +11,8 @@ uuid = { workspace = true } chrono = { workspace = true } thiserror = { workspace = true } tracing = { workspace = true } +serde_json = { workspace = true } [dev-dependencies] tokio = { workspace = true } +serde_json = { workspace = true } diff --git a/crates/db/migrations/002_session_activities.sql b/crates/db/migrations/002_session_activities.sql new file mode 100644 index 0000000..1c7a893 --- /dev/null +++ b/crates/db/migrations/002_session_activities.sql @@ -0,0 +1,12 @@ +-- Session activities table for persisting real-time activity stream +CREATE TABLE IF NOT EXISTS session_activities ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE, + activity_type TEXT NOT NULL, + activity_id TEXT, + data TEXT NOT NULL, + created_at INTEGER NOT NULL +); + +CREATE INDEX IF NOT EXISTS idx_session_activities_session_id ON session_activities(session_id); +CREATE INDEX IF NOT EXISTS idx_session_activities_created_at ON session_activities(created_at); diff --git a/crates/db/src/lib.rs b/crates/db/src/lib.rs index c1aecf9..09df704 100644 --- a/crates/db/src/lib.rs +++ b/crates/db/src/lib.rs @@ -4,5 +4,6 @@ mod pool; pub mod repositories; pub use error::*; +pub use models::{CreateSessionActivity, SessionActivity, SessionActivityRow}; pub use pool::*; pub use repositories::*; diff --git a/crates/db/src/models/mod.rs b/crates/db/src/models/mod.rs index 6783b75..380254d 100644 --- a/crates/db/src/models/mod.rs +++ b/crates/db/src/models/mod.rs @@ -1,5 +1,7 @@ mod session; +mod session_activity; mod task; pub use session::*; +pub use session_activity::*; pub use task::*; diff --git a/crates/db/src/models/session_activity.rs b/crates/db/src/models/session_activity.rs new file mode 100644 index 0000000..fb7213d --- /dev/null +++ b/crates/db/src/models/session_activity.rs @@ -0,0 +1,69 @@ +use chrono::{DateTime, TimeZone, Utc}; +use uuid::Uuid; + +#[derive(Debug, Clone, sqlx::FromRow)] +pub struct SessionActivityRow { + pub id: i64, + pub session_id: String, + pub activity_type: String, + pub activity_id: Option, + pub data: String, + pub created_at: i64, +} + +/// Domain model for session activity +#[derive(Debug, Clone)] +pub struct SessionActivity { + pub id: i64, + pub session_id: Uuid, + pub activity_type: String, + pub activity_id: Option, + pub data: serde_json::Value, + pub created_at: DateTime, +} + +impl SessionActivityRow { + pub fn into_domain(self) -> SessionActivity { + SessionActivity { + id: self.id, + session_id: Uuid::parse_str(&self.session_id).unwrap_or_default(), + activity_type: self.activity_type, + activity_id: self.activity_id, + data: serde_json::from_str(&self.data).unwrap_or(serde_json::Value::Null), + created_at: timestamp_to_datetime(self.created_at), + } + } +} + +/// Input for creating a new activity +#[derive(Debug, Clone)] +pub struct CreateSessionActivity { + pub session_id: Uuid, + pub activity_type: String, + pub activity_id: Option, + pub data: serde_json::Value, +} + +impl CreateSessionActivity { + pub fn new( + session_id: Uuid, + activity_type: impl Into, + activity_id: Option, + data: serde_json::Value, + ) -> Self { + Self { + session_id, + activity_type: activity_type.into(), + activity_id, + data, + } + } +} + +fn timestamp_to_datetime(ts: i64) -> DateTime { + Utc.timestamp_opt(ts, 0).unwrap() +} + +pub fn datetime_to_timestamp(dt: DateTime) -> i64 { + dt.timestamp() +} diff --git a/crates/db/src/repositories/mod.rs b/crates/db/src/repositories/mod.rs index d1d8b76..ee38b4f 100644 --- a/crates/db/src/repositories/mod.rs +++ b/crates/db/src/repositories/mod.rs @@ -1,5 +1,7 @@ +mod session_activity_repository; mod session_repository; mod task_repository; +pub use session_activity_repository::*; pub use session_repository::*; pub use task_repository::*; diff --git a/crates/db/src/repositories/session_activity_repository.rs b/crates/db/src/repositories/session_activity_repository.rs new file mode 100644 index 0000000..776274d --- /dev/null +++ b/crates/db/src/repositories/session_activity_repository.rs @@ -0,0 +1,228 @@ +use crate::error::DbError; +use crate::models::{CreateSessionActivity, SessionActivity, SessionActivityRow}; +use sqlx::SqlitePool; +use uuid::Uuid; + +#[derive(Clone)] +pub struct SessionActivityRepository { + pool: SqlitePool, +} + +impl SessionActivityRepository { + pub fn new(pool: SqlitePool) -> Self { + Self { pool } + } + + pub async fn create(&self, activity: &CreateSessionActivity) -> Result { + let data_json = serde_json::to_string(&activity.data).unwrap_or_else(|_| "null".to_string()); + let created_at = chrono::Utc::now().timestamp(); + + let result = sqlx::query( + r#" + INSERT INTO session_activities (session_id, activity_type, activity_id, data, created_at) + VALUES (?, ?, ?, ?, ?) + "#, + ) + .bind(activity.session_id.to_string()) + .bind(&activity.activity_type) + .bind(&activity.activity_id) + .bind(&data_json) + .bind(created_at) + .execute(&self.pool) + .await?; + + Ok(result.last_insert_rowid()) + } + + pub async fn find_by_session_id(&self, session_id: Uuid) -> Result, DbError> { + let rows: Vec = sqlx::query_as( + r#" + SELECT id, session_id, activity_type, activity_id, data, created_at + FROM session_activities + WHERE session_id = ? + ORDER BY created_at ASC, id ASC + "#, + ) + .bind(session_id.to_string()) + .fetch_all(&self.pool) + .await?; + + Ok(rows.into_iter().map(|r| r.into_domain()).collect()) + } + + pub async fn find_by_session_id_since( + &self, + session_id: Uuid, + since_id: i64, + ) -> Result, DbError> { + let rows: Vec = sqlx::query_as( + r#" + SELECT id, session_id, activity_type, activity_id, data, created_at + FROM session_activities + WHERE session_id = ? AND id > ? + ORDER BY created_at ASC, id ASC + "#, + ) + .bind(session_id.to_string()) + .bind(since_id) + .fetch_all(&self.pool) + .await?; + + Ok(rows.into_iter().map(|r| r.into_domain()).collect()) + } + + pub async fn count_by_session_id(&self, session_id: Uuid) -> Result { + let count: (i64,) = sqlx::query_as( + "SELECT COUNT(*) FROM session_activities WHERE session_id = ?", + ) + .bind(session_id.to_string()) + .fetch_one(&self.pool) + .await?; + + Ok(count.0) + } + + pub async fn delete_by_session_id(&self, session_id: Uuid) -> Result { + let result = sqlx::query("DELETE FROM session_activities WHERE session_id = ?") + .bind(session_id.to_string()) + .execute(&self.pool) + .await?; + + Ok(result.rows_affected()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{create_pool, run_migrations, SessionRepository, TaskRepository}; + use opencode_core::{Session, SessionPhase, Task}; + use serde_json::json; + + async fn setup_test_db() -> SqlitePool { + let pool = create_pool("sqlite::memory:").await.unwrap(); + run_migrations(&pool).await.unwrap(); + pool + } + + async fn create_test_session(pool: &SqlitePool) -> Session { + let task_repo = TaskRepository::new(pool.clone()); + let task = Task::new("Test Task", "Test Description"); + task_repo.create(&task).await.unwrap(); + + let session_repo = SessionRepository::new(pool.clone()); + let session = Session::new(task.id, SessionPhase::Planning); + session_repo.create(&session).await.unwrap(); + session + } + + #[tokio::test] + async fn test_create_activity() { + let pool = setup_test_db().await; + let session = create_test_session(&pool).await; + let repo = SessionActivityRepository::new(pool); + + let activity = CreateSessionActivity::new( + session.id, + "tool_call", + Some("tc-1".to_string()), + json!({"tool_name": "read_file", "args": {"path": "/test.txt"}}), + ); + + let id = repo.create(&activity).await.unwrap(); + assert!(id > 0); + } + + #[tokio::test] + async fn test_find_by_session_id() { + let pool = setup_test_db().await; + let session = create_test_session(&pool).await; + let repo = SessionActivityRepository::new(pool); + + // Create multiple activities + for i in 0..3 { + let activity = CreateSessionActivity::new( + session.id, + "agent_message", + Some(format!("msg-{}", i)), + json!({"content": format!("Message {}", i)}), + ); + repo.create(&activity).await.unwrap(); + } + + let activities = repo.find_by_session_id(session.id).await.unwrap(); + assert_eq!(activities.len(), 3); + + // Check ordering (oldest first) + assert!(activities[0].id < activities[1].id); + assert!(activities[1].id < activities[2].id); + } + + #[tokio::test] + async fn test_find_by_session_id_since() { + let pool = setup_test_db().await; + let session = create_test_session(&pool).await; + let repo = SessionActivityRepository::new(pool); + + // Create activities and track IDs + let mut ids = vec![]; + for i in 0..5 { + let activity = CreateSessionActivity::new( + session.id, + "tool_call", + Some(format!("tc-{}", i)), + json!({"tool": format!("tool_{}", i)}), + ); + ids.push(repo.create(&activity).await.unwrap()); + } + + // Get activities since id[2] + let activities = repo.find_by_session_id_since(session.id, ids[2]).await.unwrap(); + assert_eq!(activities.len(), 2); + assert_eq!(activities[0].id, ids[3]); + assert_eq!(activities[1].id, ids[4]); + } + + #[tokio::test] + async fn test_count_by_session_id() { + let pool = setup_test_db().await; + let session = create_test_session(&pool).await; + let repo = SessionActivityRepository::new(pool); + + for i in 0..5 { + let activity = CreateSessionActivity::new( + session.id, + "tool_result", + Some(format!("tr-{}", i)), + json!({"result": "ok"}), + ); + repo.create(&activity).await.unwrap(); + } + + let count = repo.count_by_session_id(session.id).await.unwrap(); + assert_eq!(count, 5); + } + + #[tokio::test] + async fn test_delete_by_session_id() { + let pool = setup_test_db().await; + let session = create_test_session(&pool).await; + let repo = SessionActivityRepository::new(pool); + + for i in 0..3 { + let activity = CreateSessionActivity::new( + session.id, + "finished", + None, + json!({"success": true, "index": i}), + ); + repo.create(&activity).await.unwrap(); + } + + let deleted = repo.delete_by_session_id(session.id).await.unwrap(); + assert_eq!(deleted, 3); + + let remaining = repo.find_by_session_id(session.id).await.unwrap(); + assert!(remaining.is_empty()); + } +} diff --git a/crates/events/src/types.rs b/crates/events/src/types.rs index 69e8e3c..5311d21 100644 --- a/crates/events/src/types.rs +++ b/crates/events/src/types.rs @@ -51,7 +51,18 @@ pub enum Event { // Session events /// OpenCode session started #[serde(rename = "session.started")] - SessionStarted { session_id: Uuid, task_id: Uuid }, + SessionStarted { + session_id: Uuid, + task_id: Uuid, + /// Session phase (planning, implementation, review, etc.) + phase: String, + /// Session status (pending, running, completed, failed) + status: String, + /// OpenCode session ID (when connected) + opencode_session_id: Option, + /// When the session was created + created_at: DateTime, + }, /// OpenCode session ended #[serde(rename = "session.ended")] @@ -90,6 +101,19 @@ pub enum Event { #[serde(rename = "workspace.deleted")] WorkspaceDeleted { task_id: Uuid }, + // Project events + /// A project was opened/switched + #[serde(rename = "project.opened")] + ProjectOpened { + path: String, + name: String, + was_initialized: bool, + }, + + /// The current project was closed + #[serde(rename = "project.closed")] + ProjectClosed { path: String }, + // System events /// Generic error event #[serde(rename = "error")] @@ -126,7 +150,6 @@ pub struct ToolExecutionData { } impl Event { - /// Get the task ID associated with this event, if any pub fn task_id(&self) -> Option { match self { Event::TaskCreated { task_id, .. } => Some(*task_id), @@ -139,6 +162,8 @@ impl Event { Event::WorkspaceCreated { task_id, .. } => Some(*task_id), Event::WorkspaceMerged { task_id, .. } => Some(*task_id), Event::WorkspaceDeleted { task_id } => Some(*task_id), + Event::ProjectOpened { .. } => None, + Event::ProjectClosed { .. } => None, Event::Error { .. } => None, } } diff --git a/crates/mcp-findings/Cargo.toml b/crates/mcp-findings/Cargo.toml new file mode 100644 index 0000000..ea2ae4b --- /dev/null +++ b/crates/mcp-findings/Cargo.toml @@ -0,0 +1,37 @@ +[package] +name = "mcp-findings" +version.workspace = true +edition.workspace = true +rust-version.workspace = true + +[[bin]] +name = "opencode-mcp-findings" +path = "src/main.rs" + +[dependencies] +# MCP SDK +rmcp = { version = "0.3", features = ["server", "transport-io"] } + +# Internal crates +orchestrator = { path = "../orchestrator" } + +# Async runtime +tokio = { workspace = true } + +# Serialization +serde = { workspace = true } +serde_json = { workspace = true } +schemars = "1.0" + +# Error handling +anyhow = { workspace = true } +thiserror = { workspace = true } + +# Logging +tracing = { workspace = true } +tracing-subscriber = { workspace = true } + +# Utils +uuid = { workspace = true } +chrono = { workspace = true } +async-trait = { workspace = true } diff --git a/crates/mcp-findings/src/lib.rs b/crates/mcp-findings/src/lib.rs new file mode 100644 index 0000000..eeaab33 --- /dev/null +++ b/crates/mcp-findings/src/lib.rs @@ -0,0 +1,477 @@ +//! MCP Server for AI Review Findings +//! +//! This crate provides an MCP (Model Context Protocol) server that enables +//! AI models to create structured review findings during code review sessions. +//! +//! The server exposes tools like: +//! - `create_finding` - Create a new code review finding +//! - `list_findings` - List all findings for the current task +//! - `approve_review` - Mark the review as approved (no issues found) +//! - `complete_review` - Complete the review with findings + +use orchestrator::{FileManager, FindingSeverity, FindingStatus, ReviewFinding, ReviewFindings}; +use rmcp::{ + handler::server::{router::tool::ToolRouter, tool::Parameters}, + model::{ErrorData as McpError, *}, + schemars, tool, tool_handler, tool_router, ServerHandler, +}; +use serde::Deserialize; +use std::borrow::Cow; +use std::future::Future; +use std::path::PathBuf; +use std::sync::Arc; +use tokio::sync::Mutex; +use tracing::{info, warn}; +use uuid::Uuid; + +/// Request to create a new finding +#[derive(Debug, Deserialize, schemars::JsonSchema)] +pub struct CreateFindingRequest { + /// The file path where the issue was found (optional for general findings) + #[schemars(description = "The file path where the issue was found")] + pub file_path: Option, + + /// Starting line number (optional) + #[schemars(description = "Starting line number of the issue")] + pub line_start: Option, + + /// Ending line number (optional) + #[schemars(description = "Ending line number of the issue")] + pub line_end: Option, + + /// Short title describing the issue (max 100 chars) + #[schemars(description = "Short title describing the issue (max 100 chars)")] + pub title: String, + + /// Detailed description of the issue + #[schemars(description = "Detailed description of the issue and why it should be fixed")] + pub description: String, + + /// Severity level: "error", "warning", or "info" + #[schemars(description = "Severity level: error (must fix), warning (should fix), info (suggestion)")] + pub severity: String, +} + +/// Request to complete the review +#[derive(Debug, Deserialize, schemars::JsonSchema)] +pub struct CompleteReviewRequest { + /// Overall summary of the review + #[schemars(description = "Overall summary of the code review")] + pub summary: String, + + /// Whether the code is approved (no blocking issues) + #[schemars(description = "Whether the code is approved (true if no error-level issues)")] + pub approved: bool, +} + +/// Request to get a specific finding +#[derive(Debug, Deserialize, schemars::JsonSchema)] +pub struct GetFindingRequest { + /// The ID of the finding to get + #[schemars(description = "The ID of the finding (e.g., 'finding-1')")] + pub finding_id: String, +} + +/// Request to mark a finding as fixed +#[derive(Debug, Deserialize, schemars::JsonSchema)] +pub struct MarkFixedRequest { + /// The ID of the finding to mark as fixed + #[schemars(description = "The ID of the finding to mark as fixed (e.g., 'finding-1')")] + pub finding_id: String, +} + +/// MCP Findings Service for code review +#[derive(Clone)] +pub struct FindingsService { + task_id: Uuid, + session_id: Uuid, + workspace_path: PathBuf, + findings: Arc>>, + summary: Arc>>, + approved: Arc>>, + file_manager: Arc, + tool_router: ToolRouter, +} + +impl FindingsService { + /// Create a new findings service for a specific task and session + pub fn new(task_id: Uuid, session_id: Uuid, workspace_path: PathBuf) -> Self { + let file_manager = Arc::new(FileManager::new(workspace_path.clone())); + Self { + task_id, + session_id, + workspace_path, + findings: Arc::new(Mutex::new(Vec::new())), + summary: Arc::new(Mutex::new(None)), + approved: Arc::new(Mutex::new(None)), + file_manager, + tool_router: Self::tool_router(), + } + } + + /// Get the collected findings + pub async fn get_findings(&self) -> ReviewFindings { + let findings = self.findings.lock().await.clone(); + let summary = self.summary.lock().await.clone().unwrap_or_default(); + + ReviewFindings::with_findings(self.task_id, self.session_id, summary, findings) + } + + /// Check if review is complete + pub async fn is_complete(&self) -> bool { + self.approved.lock().await.is_some() + } + + /// Save findings to file + pub async fn save_findings(&self) -> anyhow::Result<()> { + let review_findings = self.get_findings().await; + self.file_manager + .write_findings(self.task_id, &review_findings) + .await?; + info!( + task_id = %self.task_id, + finding_count = review_findings.findings.len(), + "Findings saved to file" + ); + Ok(()) + } +} + +#[tool_router] +impl FindingsService { + #[tool(description = "Create a new code review finding. Use this to report issues found during review.")] + async fn create_finding( + &self, + Parameters(request): Parameters, + ) -> Result { + let mut findings = self.findings.lock().await; + let finding_id = format!("finding-{}", findings.len() + 1); + + let severity = match request.severity.to_lowercase().as_str() { + "error" => FindingSeverity::Error, + "info" => FindingSeverity::Info, + _ => FindingSeverity::Warning, + }; + + let finding = ReviewFinding { + id: finding_id.clone(), + file_path: request.file_path.clone(), + line_start: request.line_start, + line_end: request.line_end, + title: request.title.clone(), + description: request.description.clone(), + severity, + status: FindingStatus::Pending, + }; + + findings.push(finding); + + info!( + task_id = %self.task_id, + finding_id = %finding_id, + title = %request.title, + severity = %request.severity, + "Created finding" + ); + + Ok(CallToolResult::success(vec![Content::text(format!( + "Finding created: {} ({})", + finding_id, request.title + ))])) + } + + #[tool(description = "List all findings for this task. Returns both existing findings from file and any newly created in this session.")] + async fn list_findings(&self) -> Result { + // First try to load existing findings from file + let file_findings = match self.file_manager.read_findings(self.task_id).await { + Ok(Some(existing)) => existing.findings, + _ => Vec::new(), + }; + + // Combine with session findings + let session_findings = self.findings.lock().await; + let mut all_findings: Vec<_> = file_findings + .iter() + .chain(session_findings.iter()) + .collect(); + + // Deduplicate by ID + all_findings.sort_by(|a, b| a.id.cmp(&b.id)); + all_findings.dedup_by(|a, b| a.id == b.id); + + if all_findings.is_empty() { + return Ok(CallToolResult::success(vec![Content::text( + "No findings found.", + )])); + } + + let list = all_findings + .iter() + .map(|f| { + let location = match (&f.file_path, f.line_start) { + (Some(path), Some(line)) => format!(" at {}:{}", path, line), + (Some(path), None) => format!(" in {}", path), + _ => String::new(), + }; + let status = match f.status { + FindingStatus::Pending => "", + FindingStatus::Fixed => " [FIXED]", + FindingStatus::Skipped => " [SKIPPED]", + }; + format!( + "- {} [{}]{}{}: {}", + f.id, + f.severity.as_str(), + status, + location, + f.title + ) + }) + .collect::>() + .join("\n"); + + Ok(CallToolResult::success(vec![Content::text(format!( + "Findings ({}):\n{}", + all_findings.len(), + list + ))])) + } + + #[tool(description = "Get detailed information about a specific finding by its ID.")] + async fn get_finding( + &self, + Parameters(request): Parameters, + ) -> Result { + // First check session findings + let session_findings = self.findings.lock().await; + if let Some(f) = session_findings.iter().find(|f| f.id == request.finding_id) { + let location = match (&f.file_path, f.line_start, f.line_end) { + (Some(path), Some(start), Some(end)) if start != end => { + format!("Location: {}:{}-{}", path, start, end) + } + (Some(path), Some(line), _) => format!("Location: {}:{}", path, line), + (Some(path), None, _) => format!("File: {}", path), + _ => "Location: Not specified".to_string(), + }; + return Ok(CallToolResult::success(vec![Content::text(format!( + "Finding: {}\n\nTitle: {}\nSeverity: {}\nStatus: {:?}\n{}\n\nDescription:\n{}", + f.id, f.title, f.severity.as_str(), f.status, location, f.description + ))])); + } + drop(session_findings); + + // Then check file findings + if let Ok(Some(existing)) = self.file_manager.read_findings(self.task_id).await { + if let Some(f) = existing.findings.iter().find(|f| f.id == request.finding_id) { + let location = match (&f.file_path, f.line_start, f.line_end) { + (Some(path), Some(start), Some(end)) if start != end => { + format!("Location: {}:{}-{}", path, start, end) + } + (Some(path), Some(line), _) => format!("Location: {}:{}", path, line), + (Some(path), None, _) => format!("File: {}", path), + _ => "Location: Not specified".to_string(), + }; + return Ok(CallToolResult::success(vec![Content::text(format!( + "Finding: {}\n\nTitle: {}\nSeverity: {}\nStatus: {:?}\n{}\n\nDescription:\n{}", + f.id, f.title, f.severity.as_str(), f.status, location, f.description + ))])); + } + } + + Ok(CallToolResult::success(vec![Content::text(format!( + "Finding '{}' not found.", + request.finding_id + ))])) + } + + #[tool(description = "Mark a finding as fixed after you've addressed the issue. This updates the findings file.")] + async fn mark_fixed( + &self, + Parameters(request): Parameters, + ) -> Result { + // Load existing findings from file + let mut review_findings = match self.file_manager.read_findings(self.task_id).await { + Ok(Some(existing)) => existing, + Ok(None) => { + return Ok(CallToolResult::success(vec![Content::text( + "No findings file found. Nothing to mark as fixed.", + )])); + } + Err(e) => { + return Err(McpError { + code: ErrorCode(-32603), + message: Cow::from(format!("Failed to read findings: {}", e)), + data: None, + }); + } + }; + + // Find and update the finding + let mut found = false; + for finding in &mut review_findings.findings { + if finding.id == request.finding_id { + finding.status = FindingStatus::Fixed; + found = true; + break; + } + } + + if !found { + return Ok(CallToolResult::success(vec![Content::text(format!( + "Finding '{}' not found.", + request.finding_id + ))])); + } + + // Save updated findings to file + if let Err(e) = self + .file_manager + .write_findings(self.task_id, &review_findings) + .await + { + return Err(McpError { + code: ErrorCode(-32603), + message: Cow::from(format!("Failed to save findings: {}", e)), + data: None, + }); + } + + info!( + task_id = %self.task_id, + finding_id = %request.finding_id, + "Finding marked as fixed" + ); + + Ok(CallToolResult::success(vec![Content::text(format!( + "Finding '{}' marked as fixed.", + request.finding_id + ))])) + } + + #[tool(description = "Approve the review. Use this when the code has no issues or only info-level suggestions.")] + async fn approve_review( + &self, + Parameters(request): Parameters, + ) -> Result { + *self.summary.lock().await = Some(request.summary.clone()); + *self.approved.lock().await = Some(true); + + // Save findings to file + if let Err(e) = self.save_findings().await { + warn!(error = %e, "Failed to save findings"); + return Err(McpError { + code: ErrorCode(-32603), + message: Cow::from(format!("Failed to save findings: {}", e)), + data: None, + }); + } + + info!( + task_id = %self.task_id, + "Review approved" + ); + + Ok(CallToolResult::success(vec![Content::text( + "Review approved. No blocking issues found.", + )])) + } + + #[tool(description = "Complete the review with findings. Use this when there are issues that need to be fixed.")] + async fn complete_review( + &self, + Parameters(request): Parameters, + ) -> Result { + let findings = self.findings.lock().await; + let error_count = findings + .iter() + .filter(|f| matches!(f.severity, FindingSeverity::Error)) + .count(); + let warning_count = findings + .iter() + .filter(|f| matches!(f.severity, FindingSeverity::Warning)) + .count(); + drop(findings); + + *self.summary.lock().await = Some(request.summary.clone()); + *self.approved.lock().await = Some(request.approved && error_count == 0); + + // Save findings to file + if let Err(e) = self.save_findings().await { + warn!(error = %e, "Failed to save findings"); + return Err(McpError { + code: ErrorCode(-32603), + message: Cow::from(format!("Failed to save findings: {}", e)), + data: None, + }); + } + + info!( + task_id = %self.task_id, + error_count = error_count, + warning_count = warning_count, + approved = request.approved, + "Review completed" + ); + + Ok(CallToolResult::success(vec![Content::text(format!( + "Review completed. {} errors, {} warnings. Approved: {}", + error_count, warning_count, request.approved + ))])) + } +} + +#[tool_handler] +impl ServerHandler for FindingsService { + fn get_info(&self) -> ServerInfo { + ServerInfo { + protocol_version: ProtocolVersion::V_2024_11_05, + capabilities: ServerCapabilities::builder().enable_tools().build(), + server_info: Implementation { + name: "opencode-findings".to_string(), + version: env!("CARGO_PKG_VERSION").to_string(), + }, + instructions: Some( + "Use this server to report code review findings. \ + Call create_finding for each issue found, then call \ + approve_review (if no issues) or complete_review (if issues found)." + .to_string(), + ), + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[tokio::test] + async fn test_create_finding() { + let service = FindingsService::new( + Uuid::new_v4(), + Uuid::new_v4(), + PathBuf::from("/tmp/test"), + ); + + // Create a finding + let request = CreateFindingRequest { + file_path: Some("src/main.rs".to_string()), + line_start: Some(42), + line_end: Some(45), + title: "Missing error handling".to_string(), + description: "Function should handle errors".to_string(), + severity: "error".to_string(), + }; + + let result = service + .create_finding(Parameters(request)) + .await + .unwrap(); + + assert!(matches!(result, CallToolResult { .. })); + + // Check findings + let findings = service.get_findings().await; + assert_eq!(findings.findings.len(), 1); + assert_eq!(findings.findings[0].title, "Missing error handling"); + } +} diff --git a/crates/mcp-findings/src/main.rs b/crates/mcp-findings/src/main.rs new file mode 100644 index 0000000..3bd6132 --- /dev/null +++ b/crates/mcp-findings/src/main.rs @@ -0,0 +1,65 @@ +//! MCP Findings Server Binary +//! +//! This binary runs the MCP server for AI code review findings. +//! It communicates via stdio and is configured through environment variables. +//! +//! Environment variables: +//! - OPENCODE_TASK_ID: UUID of the task being reviewed +//! - OPENCODE_SESSION_ID: UUID of the review session +//! - OPENCODE_WORKSPACE_PATH: Path to the workspace directory + +use anyhow::{Context, Result}; +use mcp_findings::FindingsService; +use rmcp::{transport::stdio, ServiceExt}; +use std::path::PathBuf; +use tracing::info; +use uuid::Uuid; + +#[tokio::main] +async fn main() -> Result<()> { + // Initialize tracing (log to stderr to not interfere with stdio) + tracing_subscriber::fmt() + .with_writer(std::io::stderr) + .with_env_filter( + tracing_subscriber::EnvFilter::from_default_env() + .add_directive(tracing::Level::INFO.into()), + ) + .init(); + + // Read configuration from environment + let task_id = std::env::var("OPENCODE_TASK_ID") + .context("OPENCODE_TASK_ID environment variable not set")?; + let task_id: Uuid = task_id + .parse() + .context("OPENCODE_TASK_ID is not a valid UUID")?; + + let session_id = std::env::var("OPENCODE_SESSION_ID") + .context("OPENCODE_SESSION_ID environment variable not set")?; + let session_id: Uuid = session_id + .parse() + .context("OPENCODE_SESSION_ID is not a valid UUID")?; + + let workspace_path = std::env::var("OPENCODE_WORKSPACE_PATH") + .context("OPENCODE_WORKSPACE_PATH environment variable not set")?; + let workspace_path = PathBuf::from(workspace_path); + + info!( + task_id = %task_id, + session_id = %session_id, + workspace_path = %workspace_path.display(), + "Starting MCP Findings Server" + ); + + // Create the service and start serving + let service = FindingsService::new(task_id, session_id, workspace_path); + let server = service.serve(stdio()).await?; + + info!("MCP Findings Server running"); + + // Wait for the server to finish (client disconnects) + server.waiting().await?; + + info!("MCP Findings Server shutting down"); + + Ok(()) +} diff --git a/crates/opencode-client/Cargo.toml b/crates/opencode-client/Cargo.toml new file mode 100644 index 0000000..775fbff --- /dev/null +++ b/crates/opencode-client/Cargo.toml @@ -0,0 +1,18 @@ +[package] +name = "opencode_client" +version.workspace = true +edition.workspace = true +rust-version.workspace = true +description = "OpenCode API client generated from OpenAPI spec" + +[dependencies] +serde = { version = "1", features = ["derive"] } +serde_json = "1" +serde_repr = "0.1" +url = "2.5" +reqwest = { version = "0.12", default-features = false, features = ["json", "multipart"] } + +[features] +default = ["native-tls"] +native-tls = ["reqwest/native-tls"] +rustls-tls = ["reqwest/rustls-tls"] diff --git a/crates/opencode-client/generated/.gitignore b/crates/opencode-client/generated/.gitignore new file mode 100644 index 0000000..6aa1064 --- /dev/null +++ b/crates/opencode-client/generated/.gitignore @@ -0,0 +1,3 @@ +/target/ +**/*.rs.bk +Cargo.lock diff --git a/crates/opencode-client/generated/.openapi-generator-ignore b/crates/opencode-client/generated/.openapi-generator-ignore new file mode 100644 index 0000000..7484ee5 --- /dev/null +++ b/crates/opencode-client/generated/.openapi-generator-ignore @@ -0,0 +1,23 @@ +# OpenAPI Generator Ignore +# Generated by openapi-generator https://github.com/openapitools/openapi-generator + +# Use this file to prevent files from being overwritten by the generator. +# The patterns follow closely to .gitignore or .dockerignore. + +# As an example, the C# client generator defines ApiClient.cs. +# You can make changes and tell OpenAPI Generator to ignore just this file by uncommenting the following line: +#ApiClient.cs + +# You can match any string of characters against a directory, file or extension with a single asterisk (*): +#foo/*/qux +# The above matches foo/bar/qux and foo/baz/qux, but not foo/bar/baz/qux + +# You can recursively match patterns against a directory, file or extension with a double asterisk (**): +#foo/**/qux +# This matches foo/bar/qux, foo/baz/qux, and foo/bar/baz/qux + +# You can also negate patterns with an exclamation (!). +# For example, you can ignore all files in a docs folder with the file extension .md: +#docs/*.md +# Then explicitly reverse the ignore rule for a single file: +#!docs/README.md diff --git a/crates/opencode-client/generated/.openapi-generator/FILES b/crates/opencode-client/generated/.openapi-generator/FILES new file mode 100644 index 0000000..f570ddb --- /dev/null +++ b/crates/opencode-client/generated/.openapi-generator/FILES @@ -0,0 +1,516 @@ +.gitignore +.openapi-generator-ignore +.travis.yml +Cargo.toml +README.md +docs/Agent.md +docs/AgentConfig.md +docs/AgentConfigPermission.md +docs/AgentConfigPermissionBash.md +docs/AgentPart.md +docs/AgentPartInput.md +docs/AgentPartSource.md +docs/AgentPermission.md +docs/ApiAuth.md +docs/ApiError.md +docs/ApiErrorData.md +docs/AppLogRequest.md +docs/AssistantMessage.md +docs/AssistantMessageError.md +docs/AssistantMessagePath.md +docs/AssistantMessageTime.md +docs/AssistantMessageTokens.md +docs/AssistantMessageTokensCache.md +docs/Auth.md +docs/BadRequestError.md +docs/Command.md +docs/CommandTemplate.md +docs/CompactionPart.md +docs/Config.md +docs/ConfigAgent.md +docs/ConfigAutoupdate.md +docs/ConfigCommandValue.md +docs/ConfigCompaction.md +docs/ConfigEnterprise.md +docs/ConfigExperimental.md +docs/ConfigExperimentalHook.md +docs/ConfigExperimentalHookFileEditedValueInner.md +docs/ConfigFormatter.md +docs/ConfigFormatterAnyOfValue.md +docs/ConfigLsp.md +docs/ConfigLspAnyOfValue.md +docs/ConfigLspAnyOfValueAnyOf.md +docs/ConfigLspAnyOfValueAnyOf1.md +docs/ConfigMode.md +docs/ConfigProviders200Response.md +docs/ConfigTui.md +docs/ConfigTuiScrollAcceleration.md +docs/ConfigWatcher.md +docs/DefaultApi.md +docs/Event.md +docs/EventCommandExecuted.md +docs/EventCommandExecutedProperties.md +docs/EventFileEdited.md +docs/EventFileEditedProperties.md +docs/EventFileWatcherUpdated.md +docs/EventFileWatcherUpdatedProperties.md +docs/EventGlobalDisposed.md +docs/EventInstallationUpdateAvailable.md +docs/EventInstallationUpdated.md +docs/EventInstallationUpdatedProperties.md +docs/EventLspClientDiagnostics.md +docs/EventLspClientDiagnosticsProperties.md +docs/EventLspUpdated.md +docs/EventMcpToolsChanged.md +docs/EventMcpToolsChangedProperties.md +docs/EventMessagePartRemoved.md +docs/EventMessagePartRemovedProperties.md +docs/EventMessagePartUpdated.md +docs/EventMessagePartUpdatedProperties.md +docs/EventMessageRemoved.md +docs/EventMessageRemovedProperties.md +docs/EventMessageUpdated.md +docs/EventMessageUpdatedProperties.md +docs/EventPermissionReplied.md +docs/EventPermissionRepliedProperties.md +docs/EventPermissionUpdated.md +docs/EventProjectUpdated.md +docs/EventPtyCreated.md +docs/EventPtyCreatedProperties.md +docs/EventPtyDeleted.md +docs/EventPtyDeletedProperties.md +docs/EventPtyExited.md +docs/EventPtyExitedProperties.md +docs/EventPtyUpdated.md +docs/EventServerConnected.md +docs/EventServerInstanceDisposed.md +docs/EventServerInstanceDisposedProperties.md +docs/EventSessionCompacted.md +docs/EventSessionCreated.md +docs/EventSessionCreatedProperties.md +docs/EventSessionDeleted.md +docs/EventSessionDiff.md +docs/EventSessionDiffProperties.md +docs/EventSessionError.md +docs/EventSessionErrorProperties.md +docs/EventSessionIdle.md +docs/EventSessionIdleProperties.md +docs/EventSessionStatus.md +docs/EventSessionStatusProperties.md +docs/EventSessionUpdated.md +docs/EventTodoUpdated.md +docs/EventTodoUpdatedProperties.md +docs/EventTuiCommandExecute.md +docs/EventTuiCommandExecuteProperties.md +docs/EventTuiCommandExecutePropertiesCommand.md +docs/EventTuiPromptAppend.md +docs/EventTuiToastShow.md +docs/EventVcsBranchUpdated.md +docs/EventVcsBranchUpdatedProperties.md +docs/File.md +docs/FileContent.md +docs/FileContentPatch.md +docs/FileContentPatchHunksInner.md +docs/FileDiff.md +docs/FileNode.md +docs/FilePart.md +docs/FilePartInput.md +docs/FilePartSource.md +docs/FilePartSourceText.md +docs/FileSource.md +docs/FindText200ResponseInner.md +docs/FindText200ResponseInnerPath.md +docs/FindText200ResponseInnerSubmatchesInner.md +docs/FormatterStatus.md +docs/GlobalEvent.md +docs/GlobalHealth200Response.md +docs/KeybindsConfig.md +docs/LayoutConfig.md +docs/LogLevel.md +docs/LspStatus.md +docs/McpAddRequest.md +docs/McpAddRequestConfig.md +docs/McpAuthCallbackRequest.md +docs/McpAuthRemove200Response.md +docs/McpAuthStart200Response.md +docs/McpLocalConfig.md +docs/McpOAuthConfig.md +docs/McpRemoteConfig.md +docs/McpRemoteConfigOauth.md +docs/McpStatus.md +docs/McpStatusConnected.md +docs/McpStatusDisabled.md +docs/McpStatusFailed.md +docs/McpStatusNeedsAuth.md +docs/McpStatusNeedsClientRegistration.md +docs/Message.md +docs/MessageAbortedError.md +docs/MessageOutputLengthError.md +docs/Model.md +docs/ModelApi.md +docs/ModelCapabilities.md +docs/ModelCapabilitiesInput.md +docs/ModelCapabilitiesInterleaved.md +docs/ModelCapabilitiesInterleavedAnyOf.md +docs/ModelCost.md +docs/ModelCostExperimentalOver200K.md +docs/NotFoundError.md +docs/OAuth.md +docs/Part.md +docs/PartAnyOf.md +docs/PatchPart.md +docs/Path.md +docs/Permission.md +docs/PermissionPattern.md +docs/PermissionRespondRequest.md +docs/Project.md +docs/ProjectTime.md +docs/ProjectUpdateRequest.md +docs/ProjectUpdateRequestIcon.md +docs/Provider.md +docs/ProviderAuthAuthorization.md +docs/ProviderAuthError.md +docs/ProviderAuthErrorData.md +docs/ProviderAuthMethod.md +docs/ProviderConfig.md +docs/ProviderConfigModelsValue.md +docs/ProviderConfigModelsValueInterleaved.md +docs/ProviderConfigModelsValueInterleavedAnyOf.md +docs/ProviderConfigModelsValueVariantsValue.md +docs/ProviderConfigOptions.md +docs/ProviderConfigOptionsTimeout.md +docs/ProviderList200Response.md +docs/ProviderList200ResponseAllInner.md +docs/ProviderList200ResponseAllInnerModelsValue.md +docs/ProviderList200ResponseAllInnerModelsValueCost.md +docs/ProviderList200ResponseAllInnerModelsValueCostContextOver200k.md +docs/ProviderList200ResponseAllInnerModelsValueInterleaved.md +docs/ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf.md +docs/ProviderList200ResponseAllInnerModelsValueLimit.md +docs/ProviderList200ResponseAllInnerModelsValueModalities.md +docs/ProviderList200ResponseAllInnerModelsValueProvider.md +docs/ProviderOauthAuthorizeRequest.md +docs/ProviderOauthCallbackRequest.md +docs/Pty.md +docs/PtyCreateRequest.md +docs/PtyUpdateRequest.md +docs/PtyUpdateRequestSize.md +docs/Range.md +docs/RangeStart.md +docs/ReasoningPart.md +docs/RetryPart.md +docs/ServerConfig.md +docs/Session.md +docs/SessionApi.md +docs/SessionCommandRequest.md +docs/SessionCreateRequest.md +docs/SessionForkRequest.md +docs/SessionInitRequest.md +docs/SessionMessages200ResponseInner.md +docs/SessionPrompt200Response.md +docs/SessionPromptRequest.md +docs/SessionPromptRequestModel.md +docs/SessionPromptRequestPartsInner.md +docs/SessionRevert.md +docs/SessionRevertRequest.md +docs/SessionShare.md +docs/SessionShellRequest.md +docs/SessionStatus.md +docs/SessionStatusAnyOf.md +docs/SessionStatusAnyOf1.md +docs/SessionStatusAnyOf2.md +docs/SessionSummarizeRequest.md +docs/SessionSummary.md +docs/SessionTime.md +docs/SessionUpdateRequest.md +docs/SessionUpdateRequestTime.md +docs/SnapshotPart.md +docs/StepFinishPart.md +docs/StepStartPart.md +docs/SubtaskPartInput.md +docs/Symbol.md +docs/SymbolLocation.md +docs/SymbolSource.md +docs/TextPart.md +docs/TextPartInput.md +docs/TextPartTime.md +docs/Todo.md +docs/ToolListItem.md +docs/ToolPart.md +docs/ToolState.md +docs/ToolStateCompleted.md +docs/ToolStateCompletedTime.md +docs/ToolStateError.md +docs/ToolStateErrorTime.md +docs/ToolStatePending.md +docs/ToolStateRunning.md +docs/ToolStateRunningTime.md +docs/TuiControlNext200Response.md +docs/TuiExecuteCommandRequest.md +docs/TuiPublishRequest.md +docs/TuiShowToastRequest.md +docs/UnknownError.md +docs/UnknownErrorData.md +docs/UserMessage.md +docs/UserMessageSummary.md +docs/UserMessageTime.md +docs/VcsInfo.md +docs/WellKnownAuth.md +git_push.sh +src/apis/configuration.rs +src/apis/default_api.rs +src/apis/mod.rs +src/apis/session_api.rs +src/lib.rs +src/models/agent.rs +src/models/agent_config.rs +src/models/agent_config_permission.rs +src/models/agent_config_permission_bash.rs +src/models/agent_part.rs +src/models/agent_part_input.rs +src/models/agent_part_source.rs +src/models/agent_permission.rs +src/models/api_auth.rs +src/models/api_error.rs +src/models/api_error_data.rs +src/models/app_log_request.rs +src/models/assistant_message.rs +src/models/assistant_message_error.rs +src/models/assistant_message_path.rs +src/models/assistant_message_time.rs +src/models/assistant_message_tokens.rs +src/models/assistant_message_tokens_cache.rs +src/models/auth.rs +src/models/bad_request_error.rs +src/models/command.rs +src/models/command_template.rs +src/models/compaction_part.rs +src/models/config.rs +src/models/config_agent.rs +src/models/config_autoupdate.rs +src/models/config_command_value.rs +src/models/config_compaction.rs +src/models/config_enterprise.rs +src/models/config_experimental.rs +src/models/config_experimental_hook.rs +src/models/config_experimental_hook_file_edited_value_inner.rs +src/models/config_formatter.rs +src/models/config_formatter_any_of_value.rs +src/models/config_lsp.rs +src/models/config_lsp_any_of_value.rs +src/models/config_lsp_any_of_value_any_of.rs +src/models/config_lsp_any_of_value_any_of_1.rs +src/models/config_mode.rs +src/models/config_providers_200_response.rs +src/models/config_tui.rs +src/models/config_tui_scroll_acceleration.rs +src/models/config_watcher.rs +src/models/event.rs +src/models/event_command_executed.rs +src/models/event_command_executed_properties.rs +src/models/event_file_edited.rs +src/models/event_file_edited_properties.rs +src/models/event_file_watcher_updated.rs +src/models/event_file_watcher_updated_properties.rs +src/models/event_global_disposed.rs +src/models/event_installation_update_available.rs +src/models/event_installation_updated.rs +src/models/event_installation_updated_properties.rs +src/models/event_lsp_client_diagnostics.rs +src/models/event_lsp_client_diagnostics_properties.rs +src/models/event_lsp_updated.rs +src/models/event_mcp_tools_changed.rs +src/models/event_mcp_tools_changed_properties.rs +src/models/event_message_part_removed.rs +src/models/event_message_part_removed_properties.rs +src/models/event_message_part_updated.rs +src/models/event_message_part_updated_properties.rs +src/models/event_message_removed.rs +src/models/event_message_removed_properties.rs +src/models/event_message_updated.rs +src/models/event_message_updated_properties.rs +src/models/event_permission_replied.rs +src/models/event_permission_replied_properties.rs +src/models/event_permission_updated.rs +src/models/event_project_updated.rs +src/models/event_pty_created.rs +src/models/event_pty_created_properties.rs +src/models/event_pty_deleted.rs +src/models/event_pty_deleted_properties.rs +src/models/event_pty_exited.rs +src/models/event_pty_exited_properties.rs +src/models/event_pty_updated.rs +src/models/event_server_connected.rs +src/models/event_server_instance_disposed.rs +src/models/event_server_instance_disposed_properties.rs +src/models/event_session_compacted.rs +src/models/event_session_created.rs +src/models/event_session_created_properties.rs +src/models/event_session_deleted.rs +src/models/event_session_diff.rs +src/models/event_session_diff_properties.rs +src/models/event_session_error.rs +src/models/event_session_error_properties.rs +src/models/event_session_idle.rs +src/models/event_session_idle_properties.rs +src/models/event_session_status.rs +src/models/event_session_status_properties.rs +src/models/event_session_updated.rs +src/models/event_todo_updated.rs +src/models/event_todo_updated_properties.rs +src/models/event_tui_command_execute.rs +src/models/event_tui_command_execute_properties.rs +src/models/event_tui_command_execute_properties_command.rs +src/models/event_tui_prompt_append.rs +src/models/event_tui_toast_show.rs +src/models/event_vcs_branch_updated.rs +src/models/event_vcs_branch_updated_properties.rs +src/models/file.rs +src/models/file_content.rs +src/models/file_content_patch.rs +src/models/file_content_patch_hunks_inner.rs +src/models/file_diff.rs +src/models/file_node.rs +src/models/file_part.rs +src/models/file_part_input.rs +src/models/file_part_source.rs +src/models/file_part_source_text.rs +src/models/file_source.rs +src/models/find_text_200_response_inner.rs +src/models/find_text_200_response_inner_path.rs +src/models/find_text_200_response_inner_submatches_inner.rs +src/models/formatter_status.rs +src/models/global_event.rs +src/models/global_health_200_response.rs +src/models/keybinds_config.rs +src/models/layout_config.rs +src/models/log_level.rs +src/models/lsp_status.rs +src/models/mcp_add_request.rs +src/models/mcp_add_request_config.rs +src/models/mcp_auth_callback_request.rs +src/models/mcp_auth_remove_200_response.rs +src/models/mcp_auth_start_200_response.rs +src/models/mcp_local_config.rs +src/models/mcp_o_auth_config.rs +src/models/mcp_remote_config.rs +src/models/mcp_remote_config_oauth.rs +src/models/mcp_status.rs +src/models/mcp_status_connected.rs +src/models/mcp_status_disabled.rs +src/models/mcp_status_failed.rs +src/models/mcp_status_needs_auth.rs +src/models/mcp_status_needs_client_registration.rs +src/models/message.rs +src/models/message_aborted_error.rs +src/models/message_output_length_error.rs +src/models/mod.rs +src/models/model.rs +src/models/model_api.rs +src/models/model_capabilities.rs +src/models/model_capabilities_input.rs +src/models/model_capabilities_interleaved.rs +src/models/model_capabilities_interleaved_any_of.rs +src/models/model_cost.rs +src/models/model_cost_experimental_over200_k.rs +src/models/not_found_error.rs +src/models/o_auth.rs +src/models/part.rs +src/models/part_any_of.rs +src/models/patch_part.rs +src/models/path.rs +src/models/permission.rs +src/models/permission_pattern.rs +src/models/permission_respond_request.rs +src/models/project.rs +src/models/project_time.rs +src/models/project_update_request.rs +src/models/project_update_request_icon.rs +src/models/provider.rs +src/models/provider_auth_authorization.rs +src/models/provider_auth_error.rs +src/models/provider_auth_error_data.rs +src/models/provider_auth_method.rs +src/models/provider_config.rs +src/models/provider_config_models_value.rs +src/models/provider_config_models_value_interleaved.rs +src/models/provider_config_models_value_interleaved_any_of.rs +src/models/provider_config_models_value_variants_value.rs +src/models/provider_config_options.rs +src/models/provider_config_options_timeout.rs +src/models/provider_list_200_response.rs +src/models/provider_list_200_response_all_inner.rs +src/models/provider_list_200_response_all_inner_models_value.rs +src/models/provider_list_200_response_all_inner_models_value_cost.rs +src/models/provider_list_200_response_all_inner_models_value_cost_context_over_200k.rs +src/models/provider_list_200_response_all_inner_models_value_interleaved.rs +src/models/provider_list_200_response_all_inner_models_value_interleaved_any_of.rs +src/models/provider_list_200_response_all_inner_models_value_limit.rs +src/models/provider_list_200_response_all_inner_models_value_modalities.rs +src/models/provider_list_200_response_all_inner_models_value_provider.rs +src/models/provider_oauth_authorize_request.rs +src/models/provider_oauth_callback_request.rs +src/models/pty.rs +src/models/pty_create_request.rs +src/models/pty_update_request.rs +src/models/pty_update_request_size.rs +src/models/range.rs +src/models/range_start.rs +src/models/reasoning_part.rs +src/models/retry_part.rs +src/models/server_config.rs +src/models/session.rs +src/models/session_command_request.rs +src/models/session_create_request.rs +src/models/session_fork_request.rs +src/models/session_init_request.rs +src/models/session_messages_200_response_inner.rs +src/models/session_prompt_200_response.rs +src/models/session_prompt_request.rs +src/models/session_prompt_request_model.rs +src/models/session_prompt_request_parts_inner.rs +src/models/session_revert.rs +src/models/session_revert_request.rs +src/models/session_share.rs +src/models/session_shell_request.rs +src/models/session_status.rs +src/models/session_status_any_of.rs +src/models/session_status_any_of_1.rs +src/models/session_status_any_of_2.rs +src/models/session_summarize_request.rs +src/models/session_summary.rs +src/models/session_time.rs +src/models/session_update_request.rs +src/models/session_update_request_time.rs +src/models/snapshot_part.rs +src/models/step_finish_part.rs +src/models/step_start_part.rs +src/models/subtask_part_input.rs +src/models/symbol.rs +src/models/symbol_location.rs +src/models/symbol_source.rs +src/models/text_part.rs +src/models/text_part_input.rs +src/models/text_part_time.rs +src/models/todo.rs +src/models/tool_list_item.rs +src/models/tool_part.rs +src/models/tool_state.rs +src/models/tool_state_completed.rs +src/models/tool_state_completed_time.rs +src/models/tool_state_error.rs +src/models/tool_state_error_time.rs +src/models/tool_state_pending.rs +src/models/tool_state_running.rs +src/models/tool_state_running_time.rs +src/models/tui_control_next_200_response.rs +src/models/tui_execute_command_request.rs +src/models/tui_publish_request.rs +src/models/tui_show_toast_request.rs +src/models/unknown_error.rs +src/models/unknown_error_data.rs +src/models/user_message.rs +src/models/user_message_summary.rs +src/models/user_message_time.rs +src/models/vcs_info.rs +src/models/well_known_auth.rs diff --git a/crates/opencode-client/generated/.openapi-generator/VERSION b/crates/opencode-client/generated/.openapi-generator/VERSION new file mode 100644 index 0000000..1b2d969 --- /dev/null +++ b/crates/opencode-client/generated/.openapi-generator/VERSION @@ -0,0 +1 @@ +7.18.0 diff --git a/crates/opencode-client/generated/.travis.yml b/crates/opencode-client/generated/.travis.yml new file mode 100644 index 0000000..22761ba --- /dev/null +++ b/crates/opencode-client/generated/.travis.yml @@ -0,0 +1 @@ +language: rust diff --git a/crates/opencode-client/generated/Cargo.toml b/crates/opencode-client/generated/Cargo.toml new file mode 100644 index 0000000..e048d1f --- /dev/null +++ b/crates/opencode-client/generated/Cargo.toml @@ -0,0 +1,20 @@ +[package] +name = "opencode_client" +version = "0.0.3" +authors = ["OpenAPI Generator team and contributors"] +description = "opencode api" +# Override this license by providing a License Object in the OpenAPI. +license = "Unlicense" +edition = "2021" + +[dependencies] +serde = { version = "^1.0", features = ["derive"] } +serde_json = "^1.0" +serde_repr = "^0.1" +url = "^2.5" +reqwest = { version = "^0.12", default-features = false, features = ["json", "multipart"] } + +[features] +default = ["native-tls"] +native-tls = ["reqwest/native-tls"] +rustls-tls = ["reqwest/rustls-tls"] diff --git a/crates/opencode-client/generated/README.md b/crates/opencode-client/generated/README.md new file mode 100644 index 0000000..c8e9259 --- /dev/null +++ b/crates/opencode-client/generated/README.md @@ -0,0 +1,379 @@ +# Rust API client for opencode_client + +opencode api + + +## Overview + +This API client was generated by the [OpenAPI Generator](https://openapi-generator.tech) project. By using the [openapi-spec](https://openapis.org) from a remote server, you can easily generate an API client. + +- API version: 0.0.3 +- Package version: 0.0.3 +- Generator version: 7.18.0 +- Build package: `org.openapitools.codegen.languages.RustClientCodegen` + +## Installation + +Put the package under your project folder in a directory named `opencode_client` and add the following to `Cargo.toml` under `[dependencies]`: + +``` +opencode_client = { path = "./opencode_client" } +``` + +## Documentation for API Endpoints + +All URIs are relative to *http://localhost* + +Class | Method | HTTP request | Description +------------ | ------------- | ------------- | ------------- +*DefaultApi* | [**app_agents**](docs/DefaultApi.md#app_agents) | **GET** /agent | List agents +*DefaultApi* | [**app_log**](docs/DefaultApi.md#app_log) | **POST** /log | Write log +*DefaultApi* | [**auth_set**](docs/DefaultApi.md#auth_set) | **PUT** /auth/{providerID} | Set auth credentials +*DefaultApi* | [**command_list**](docs/DefaultApi.md#command_list) | **GET** /command | List commands +*DefaultApi* | [**config_get**](docs/DefaultApi.md#config_get) | **GET** /config | Get configuration +*DefaultApi* | [**config_providers**](docs/DefaultApi.md#config_providers) | **GET** /config/providers | List config providers +*DefaultApi* | [**config_update**](docs/DefaultApi.md#config_update) | **PATCH** /config | Update configuration +*DefaultApi* | [**event_subscribe**](docs/DefaultApi.md#event_subscribe) | **GET** /event | Subscribe to events +*DefaultApi* | [**file_list**](docs/DefaultApi.md#file_list) | **GET** /file | List files +*DefaultApi* | [**file_read**](docs/DefaultApi.md#file_read) | **GET** /file/content | Read file +*DefaultApi* | [**file_status**](docs/DefaultApi.md#file_status) | **GET** /file/status | Get file status +*DefaultApi* | [**find_files**](docs/DefaultApi.md#find_files) | **GET** /find/file | Find files +*DefaultApi* | [**find_symbols**](docs/DefaultApi.md#find_symbols) | **GET** /find/symbol | Find symbols +*DefaultApi* | [**find_text**](docs/DefaultApi.md#find_text) | **GET** /find | Find text +*DefaultApi* | [**formatter_status**](docs/DefaultApi.md#formatter_status) | **GET** /formatter | Get formatter status +*DefaultApi* | [**global_dispose**](docs/DefaultApi.md#global_dispose) | **POST** /global/dispose | Dispose instance +*DefaultApi* | [**global_event**](docs/DefaultApi.md#global_event) | **GET** /global/event | Get global events +*DefaultApi* | [**global_health**](docs/DefaultApi.md#global_health) | **GET** /global/health | Get health +*DefaultApi* | [**instance_dispose**](docs/DefaultApi.md#instance_dispose) | **POST** /instance/dispose | Dispose instance +*DefaultApi* | [**lsp_status**](docs/DefaultApi.md#lsp_status) | **GET** /lsp | Get LSP status +*DefaultApi* | [**mcp_add**](docs/DefaultApi.md#mcp_add) | **POST** /mcp | Add MCP server +*DefaultApi* | [**mcp_auth_authenticate**](docs/DefaultApi.md#mcp_auth_authenticate) | **POST** /mcp/{name}/auth/authenticate | Authenticate MCP OAuth +*DefaultApi* | [**mcp_auth_callback**](docs/DefaultApi.md#mcp_auth_callback) | **POST** /mcp/{name}/auth/callback | Complete MCP OAuth +*DefaultApi* | [**mcp_auth_remove**](docs/DefaultApi.md#mcp_auth_remove) | **DELETE** /mcp/{name}/auth | Remove MCP OAuth +*DefaultApi* | [**mcp_auth_start**](docs/DefaultApi.md#mcp_auth_start) | **POST** /mcp/{name}/auth | Start MCP OAuth +*DefaultApi* | [**mcp_connect**](docs/DefaultApi.md#mcp_connect) | **POST** /mcp/{name}/connect | +*DefaultApi* | [**mcp_disconnect**](docs/DefaultApi.md#mcp_disconnect) | **POST** /mcp/{name}/disconnect | +*DefaultApi* | [**mcp_status**](docs/DefaultApi.md#mcp_status) | **GET** /mcp | Get MCP status +*DefaultApi* | [**part_delete**](docs/DefaultApi.md#part_delete) | **DELETE** /session/{sessionID}/message/{messageID}/part/{partID} | +*DefaultApi* | [**part_update**](docs/DefaultApi.md#part_update) | **PATCH** /session/{sessionID}/message/{messageID}/part/{partID} | +*DefaultApi* | [**path_get**](docs/DefaultApi.md#path_get) | **GET** /path | Get paths +*DefaultApi* | [**permission_list**](docs/DefaultApi.md#permission_list) | **GET** /permission | List pending permissions +*DefaultApi* | [**permission_respond**](docs/DefaultApi.md#permission_respond) | **POST** /session/{sessionID}/permissions/{permissionID} | Respond to permission +*DefaultApi* | [**project_current**](docs/DefaultApi.md#project_current) | **GET** /project/current | Get current project +*DefaultApi* | [**project_list**](docs/DefaultApi.md#project_list) | **GET** /project | List all projects +*DefaultApi* | [**project_update**](docs/DefaultApi.md#project_update) | **PATCH** /project/{projectID} | Update project +*DefaultApi* | [**provider_auth**](docs/DefaultApi.md#provider_auth) | **GET** /provider/auth | Get provider auth methods +*DefaultApi* | [**provider_list**](docs/DefaultApi.md#provider_list) | **GET** /provider | List providers +*DefaultApi* | [**provider_oauth_authorize**](docs/DefaultApi.md#provider_oauth_authorize) | **POST** /provider/{providerID}/oauth/authorize | OAuth authorize +*DefaultApi* | [**provider_oauth_callback**](docs/DefaultApi.md#provider_oauth_callback) | **POST** /provider/{providerID}/oauth/callback | OAuth callback +*DefaultApi* | [**pty_connect**](docs/DefaultApi.md#pty_connect) | **GET** /pty/{ptyID}/connect | Connect to PTY session +*DefaultApi* | [**pty_create**](docs/DefaultApi.md#pty_create) | **POST** /pty | Create PTY session +*DefaultApi* | [**pty_get**](docs/DefaultApi.md#pty_get) | **GET** /pty/{ptyID} | Get PTY session +*DefaultApi* | [**pty_list**](docs/DefaultApi.md#pty_list) | **GET** /pty | List PTY sessions +*DefaultApi* | [**pty_remove**](docs/DefaultApi.md#pty_remove) | **DELETE** /pty/{ptyID} | Remove PTY session +*DefaultApi* | [**pty_update**](docs/DefaultApi.md#pty_update) | **PUT** /pty/{ptyID} | Update PTY session +*DefaultApi* | [**session_abort**](docs/DefaultApi.md#session_abort) | **POST** /session/{sessionID}/abort | Abort session +*DefaultApi* | [**session_command**](docs/DefaultApi.md#session_command) | **POST** /session/{sessionID}/command | Send command +*DefaultApi* | [**session_create**](docs/DefaultApi.md#session_create) | **POST** /session | Create session +*DefaultApi* | [**session_delete**](docs/DefaultApi.md#session_delete) | **DELETE** /session/{sessionID} | Delete session +*DefaultApi* | [**session_diff**](docs/DefaultApi.md#session_diff) | **GET** /session/{sessionID}/diff | Get session diff +*DefaultApi* | [**session_fork**](docs/DefaultApi.md#session_fork) | **POST** /session/{sessionID}/fork | Fork session +*DefaultApi* | [**session_init**](docs/DefaultApi.md#session_init) | **POST** /session/{sessionID}/init | Initialize session +*DefaultApi* | [**session_list**](docs/DefaultApi.md#session_list) | **GET** /session | List sessions +*DefaultApi* | [**session_message**](docs/DefaultApi.md#session_message) | **GET** /session/{sessionID}/message/{messageID} | Get message +*DefaultApi* | [**session_messages**](docs/DefaultApi.md#session_messages) | **GET** /session/{sessionID}/message | Get session messages +*DefaultApi* | [**session_prompt**](docs/DefaultApi.md#session_prompt) | **POST** /session/{sessionID}/message | Send message +*DefaultApi* | [**session_prompt_async**](docs/DefaultApi.md#session_prompt_async) | **POST** /session/{sessionID}/prompt_async | Send async message +*DefaultApi* | [**session_revert**](docs/DefaultApi.md#session_revert) | **POST** /session/{sessionID}/revert | Revert message +*DefaultApi* | [**session_share**](docs/DefaultApi.md#session_share) | **POST** /session/{sessionID}/share | Share session +*DefaultApi* | [**session_shell**](docs/DefaultApi.md#session_shell) | **POST** /session/{sessionID}/shell | Run shell command +*DefaultApi* | [**session_status**](docs/DefaultApi.md#session_status) | **GET** /session/status | Get session status +*DefaultApi* | [**session_summarize**](docs/DefaultApi.md#session_summarize) | **POST** /session/{sessionID}/summarize | Summarize session +*DefaultApi* | [**session_todo**](docs/DefaultApi.md#session_todo) | **GET** /session/{sessionID}/todo | Get session todos +*DefaultApi* | [**session_unrevert**](docs/DefaultApi.md#session_unrevert) | **POST** /session/{sessionID}/unrevert | Restore reverted messages +*DefaultApi* | [**session_unshare**](docs/DefaultApi.md#session_unshare) | **DELETE** /session/{sessionID}/share | Unshare session +*DefaultApi* | [**session_update**](docs/DefaultApi.md#session_update) | **PATCH** /session/{sessionID} | Update session +*DefaultApi* | [**tool_ids**](docs/DefaultApi.md#tool_ids) | **GET** /experimental/tool/ids | List tool IDs +*DefaultApi* | [**tool_list**](docs/DefaultApi.md#tool_list) | **GET** /experimental/tool | List tools +*DefaultApi* | [**tui_append_prompt**](docs/DefaultApi.md#tui_append_prompt) | **POST** /tui/append-prompt | Append TUI prompt +*DefaultApi* | [**tui_clear_prompt**](docs/DefaultApi.md#tui_clear_prompt) | **POST** /tui/clear-prompt | Clear TUI prompt +*DefaultApi* | [**tui_control_next**](docs/DefaultApi.md#tui_control_next) | **GET** /tui/control/next | Get next TUI request +*DefaultApi* | [**tui_control_response**](docs/DefaultApi.md#tui_control_response) | **POST** /tui/control/response | Submit TUI response +*DefaultApi* | [**tui_execute_command**](docs/DefaultApi.md#tui_execute_command) | **POST** /tui/execute-command | Execute TUI command +*DefaultApi* | [**tui_open_help**](docs/DefaultApi.md#tui_open_help) | **POST** /tui/open-help | Open help dialog +*DefaultApi* | [**tui_open_models**](docs/DefaultApi.md#tui_open_models) | **POST** /tui/open-models | Open models dialog +*DefaultApi* | [**tui_open_sessions**](docs/DefaultApi.md#tui_open_sessions) | **POST** /tui/open-sessions | Open sessions dialog +*DefaultApi* | [**tui_open_themes**](docs/DefaultApi.md#tui_open_themes) | **POST** /tui/open-themes | Open themes dialog +*DefaultApi* | [**tui_publish**](docs/DefaultApi.md#tui_publish) | **POST** /tui/publish | Publish TUI event +*DefaultApi* | [**tui_show_toast**](docs/DefaultApi.md#tui_show_toast) | **POST** /tui/show-toast | Show TUI toast +*DefaultApi* | [**tui_submit_prompt**](docs/DefaultApi.md#tui_submit_prompt) | **POST** /tui/submit-prompt | Submit TUI prompt +*DefaultApi* | [**vcs_get**](docs/DefaultApi.md#vcs_get) | **GET** /vcs | Get VCS info +*SessionApi* | [**session_children**](docs/SessionApi.md#session_children) | **GET** /session/{sessionID}/children | Get session children +*SessionApi* | [**session_get**](docs/SessionApi.md#session_get) | **GET** /session/{sessionID} | Get session + + +## Documentation For Models + + - [Agent](docs/Agent.md) + - [AgentConfig](docs/AgentConfig.md) + - [AgentConfigPermission](docs/AgentConfigPermission.md) + - [AgentConfigPermissionBash](docs/AgentConfigPermissionBash.md) + - [AgentPart](docs/AgentPart.md) + - [AgentPartInput](docs/AgentPartInput.md) + - [AgentPartSource](docs/AgentPartSource.md) + - [AgentPermission](docs/AgentPermission.md) + - [ApiAuth](docs/ApiAuth.md) + - [ApiError](docs/ApiError.md) + - [ApiErrorData](docs/ApiErrorData.md) + - [AppLogRequest](docs/AppLogRequest.md) + - [AssistantMessage](docs/AssistantMessage.md) + - [AssistantMessageError](docs/AssistantMessageError.md) + - [AssistantMessagePath](docs/AssistantMessagePath.md) + - [AssistantMessageTime](docs/AssistantMessageTime.md) + - [AssistantMessageTokens](docs/AssistantMessageTokens.md) + - [AssistantMessageTokensCache](docs/AssistantMessageTokensCache.md) + - [Auth](docs/Auth.md) + - [BadRequestError](docs/BadRequestError.md) + - [Command](docs/Command.md) + - [CommandTemplate](docs/CommandTemplate.md) + - [CompactionPart](docs/CompactionPart.md) + - [Config](docs/Config.md) + - [ConfigAgent](docs/ConfigAgent.md) + - [ConfigAutoupdate](docs/ConfigAutoupdate.md) + - [ConfigCommandValue](docs/ConfigCommandValue.md) + - [ConfigCompaction](docs/ConfigCompaction.md) + - [ConfigEnterprise](docs/ConfigEnterprise.md) + - [ConfigExperimental](docs/ConfigExperimental.md) + - [ConfigExperimentalHook](docs/ConfigExperimentalHook.md) + - [ConfigExperimentalHookFileEditedValueInner](docs/ConfigExperimentalHookFileEditedValueInner.md) + - [ConfigFormatter](docs/ConfigFormatter.md) + - [ConfigFormatterAnyOfValue](docs/ConfigFormatterAnyOfValue.md) + - [ConfigLsp](docs/ConfigLsp.md) + - [ConfigLspAnyOfValue](docs/ConfigLspAnyOfValue.md) + - [ConfigLspAnyOfValueAnyOf](docs/ConfigLspAnyOfValueAnyOf.md) + - [ConfigLspAnyOfValueAnyOf1](docs/ConfigLspAnyOfValueAnyOf1.md) + - [ConfigMode](docs/ConfigMode.md) + - [ConfigProviders200Response](docs/ConfigProviders200Response.md) + - [ConfigTui](docs/ConfigTui.md) + - [ConfigTuiScrollAcceleration](docs/ConfigTuiScrollAcceleration.md) + - [ConfigWatcher](docs/ConfigWatcher.md) + - [Event](docs/Event.md) + - [EventCommandExecuted](docs/EventCommandExecuted.md) + - [EventCommandExecutedProperties](docs/EventCommandExecutedProperties.md) + - [EventFileEdited](docs/EventFileEdited.md) + - [EventFileEditedProperties](docs/EventFileEditedProperties.md) + - [EventFileWatcherUpdated](docs/EventFileWatcherUpdated.md) + - [EventFileWatcherUpdatedProperties](docs/EventFileWatcherUpdatedProperties.md) + - [EventGlobalDisposed](docs/EventGlobalDisposed.md) + - [EventInstallationUpdateAvailable](docs/EventInstallationUpdateAvailable.md) + - [EventInstallationUpdated](docs/EventInstallationUpdated.md) + - [EventInstallationUpdatedProperties](docs/EventInstallationUpdatedProperties.md) + - [EventLspClientDiagnostics](docs/EventLspClientDiagnostics.md) + - [EventLspClientDiagnosticsProperties](docs/EventLspClientDiagnosticsProperties.md) + - [EventLspUpdated](docs/EventLspUpdated.md) + - [EventMcpToolsChanged](docs/EventMcpToolsChanged.md) + - [EventMcpToolsChangedProperties](docs/EventMcpToolsChangedProperties.md) + - [EventMessagePartRemoved](docs/EventMessagePartRemoved.md) + - [EventMessagePartRemovedProperties](docs/EventMessagePartRemovedProperties.md) + - [EventMessagePartUpdated](docs/EventMessagePartUpdated.md) + - [EventMessagePartUpdatedProperties](docs/EventMessagePartUpdatedProperties.md) + - [EventMessageRemoved](docs/EventMessageRemoved.md) + - [EventMessageRemovedProperties](docs/EventMessageRemovedProperties.md) + - [EventMessageUpdated](docs/EventMessageUpdated.md) + - [EventMessageUpdatedProperties](docs/EventMessageUpdatedProperties.md) + - [EventPermissionReplied](docs/EventPermissionReplied.md) + - [EventPermissionRepliedProperties](docs/EventPermissionRepliedProperties.md) + - [EventPermissionUpdated](docs/EventPermissionUpdated.md) + - [EventProjectUpdated](docs/EventProjectUpdated.md) + - [EventPtyCreated](docs/EventPtyCreated.md) + - [EventPtyCreatedProperties](docs/EventPtyCreatedProperties.md) + - [EventPtyDeleted](docs/EventPtyDeleted.md) + - [EventPtyDeletedProperties](docs/EventPtyDeletedProperties.md) + - [EventPtyExited](docs/EventPtyExited.md) + - [EventPtyExitedProperties](docs/EventPtyExitedProperties.md) + - [EventPtyUpdated](docs/EventPtyUpdated.md) + - [EventServerConnected](docs/EventServerConnected.md) + - [EventServerInstanceDisposed](docs/EventServerInstanceDisposed.md) + - [EventServerInstanceDisposedProperties](docs/EventServerInstanceDisposedProperties.md) + - [EventSessionCompacted](docs/EventSessionCompacted.md) + - [EventSessionCreated](docs/EventSessionCreated.md) + - [EventSessionCreatedProperties](docs/EventSessionCreatedProperties.md) + - [EventSessionDeleted](docs/EventSessionDeleted.md) + - [EventSessionDiff](docs/EventSessionDiff.md) + - [EventSessionDiffProperties](docs/EventSessionDiffProperties.md) + - [EventSessionError](docs/EventSessionError.md) + - [EventSessionErrorProperties](docs/EventSessionErrorProperties.md) + - [EventSessionIdle](docs/EventSessionIdle.md) + - [EventSessionIdleProperties](docs/EventSessionIdleProperties.md) + - [EventSessionStatus](docs/EventSessionStatus.md) + - [EventSessionStatusProperties](docs/EventSessionStatusProperties.md) + - [EventSessionUpdated](docs/EventSessionUpdated.md) + - [EventTodoUpdated](docs/EventTodoUpdated.md) + - [EventTodoUpdatedProperties](docs/EventTodoUpdatedProperties.md) + - [EventTuiCommandExecute](docs/EventTuiCommandExecute.md) + - [EventTuiCommandExecuteProperties](docs/EventTuiCommandExecuteProperties.md) + - [EventTuiCommandExecutePropertiesCommand](docs/EventTuiCommandExecutePropertiesCommand.md) + - [EventTuiPromptAppend](docs/EventTuiPromptAppend.md) + - [EventTuiToastShow](docs/EventTuiToastShow.md) + - [EventVcsBranchUpdated](docs/EventVcsBranchUpdated.md) + - [EventVcsBranchUpdatedProperties](docs/EventVcsBranchUpdatedProperties.md) + - [File](docs/File.md) + - [FileContent](docs/FileContent.md) + - [FileContentPatch](docs/FileContentPatch.md) + - [FileContentPatchHunksInner](docs/FileContentPatchHunksInner.md) + - [FileDiff](docs/FileDiff.md) + - [FileNode](docs/FileNode.md) + - [FilePart](docs/FilePart.md) + - [FilePartInput](docs/FilePartInput.md) + - [FilePartSource](docs/FilePartSource.md) + - [FilePartSourceText](docs/FilePartSourceText.md) + - [FileSource](docs/FileSource.md) + - [FindText200ResponseInner](docs/FindText200ResponseInner.md) + - [FindText200ResponseInnerPath](docs/FindText200ResponseInnerPath.md) + - [FindText200ResponseInnerSubmatchesInner](docs/FindText200ResponseInnerSubmatchesInner.md) + - [FormatterStatus](docs/FormatterStatus.md) + - [GlobalEvent](docs/GlobalEvent.md) + - [GlobalHealth200Response](docs/GlobalHealth200Response.md) + - [KeybindsConfig](docs/KeybindsConfig.md) + - [LayoutConfig](docs/LayoutConfig.md) + - [LogLevel](docs/LogLevel.md) + - [LspStatus](docs/LspStatus.md) + - [McpAddRequest](docs/McpAddRequest.md) + - [McpAddRequestConfig](docs/McpAddRequestConfig.md) + - [McpAuthCallbackRequest](docs/McpAuthCallbackRequest.md) + - [McpAuthRemove200Response](docs/McpAuthRemove200Response.md) + - [McpAuthStart200Response](docs/McpAuthStart200Response.md) + - [McpLocalConfig](docs/McpLocalConfig.md) + - [McpOAuthConfig](docs/McpOAuthConfig.md) + - [McpRemoteConfig](docs/McpRemoteConfig.md) + - [McpRemoteConfigOauth](docs/McpRemoteConfigOauth.md) + - [McpStatus](docs/McpStatus.md) + - [McpStatusConnected](docs/McpStatusConnected.md) + - [McpStatusDisabled](docs/McpStatusDisabled.md) + - [McpStatusFailed](docs/McpStatusFailed.md) + - [McpStatusNeedsAuth](docs/McpStatusNeedsAuth.md) + - [McpStatusNeedsClientRegistration](docs/McpStatusNeedsClientRegistration.md) + - [Message](docs/Message.md) + - [MessageAbortedError](docs/MessageAbortedError.md) + - [MessageOutputLengthError](docs/MessageOutputLengthError.md) + - [Model](docs/Model.md) + - [ModelApi](docs/ModelApi.md) + - [ModelCapabilities](docs/ModelCapabilities.md) + - [ModelCapabilitiesInput](docs/ModelCapabilitiesInput.md) + - [ModelCapabilitiesInterleaved](docs/ModelCapabilitiesInterleaved.md) + - [ModelCapabilitiesInterleavedAnyOf](docs/ModelCapabilitiesInterleavedAnyOf.md) + - [ModelCost](docs/ModelCost.md) + - [ModelCostExperimentalOver200K](docs/ModelCostExperimentalOver200K.md) + - [NotFoundError](docs/NotFoundError.md) + - [OAuth](docs/OAuth.md) + - [Part](docs/Part.md) + - [PartAnyOf](docs/PartAnyOf.md) + - [PatchPart](docs/PatchPart.md) + - [Path](docs/Path.md) + - [Permission](docs/Permission.md) + - [PermissionPattern](docs/PermissionPattern.md) + - [PermissionRespondRequest](docs/PermissionRespondRequest.md) + - [Project](docs/Project.md) + - [ProjectTime](docs/ProjectTime.md) + - [ProjectUpdateRequest](docs/ProjectUpdateRequest.md) + - [ProjectUpdateRequestIcon](docs/ProjectUpdateRequestIcon.md) + - [Provider](docs/Provider.md) + - [ProviderAuthAuthorization](docs/ProviderAuthAuthorization.md) + - [ProviderAuthError](docs/ProviderAuthError.md) + - [ProviderAuthErrorData](docs/ProviderAuthErrorData.md) + - [ProviderAuthMethod](docs/ProviderAuthMethod.md) + - [ProviderConfig](docs/ProviderConfig.md) + - [ProviderConfigModelsValue](docs/ProviderConfigModelsValue.md) + - [ProviderConfigModelsValueInterleaved](docs/ProviderConfigModelsValueInterleaved.md) + - [ProviderConfigModelsValueInterleavedAnyOf](docs/ProviderConfigModelsValueInterleavedAnyOf.md) + - [ProviderConfigModelsValueVariantsValue](docs/ProviderConfigModelsValueVariantsValue.md) + - [ProviderConfigOptions](docs/ProviderConfigOptions.md) + - [ProviderConfigOptionsTimeout](docs/ProviderConfigOptionsTimeout.md) + - [ProviderList200Response](docs/ProviderList200Response.md) + - [ProviderList200ResponseAllInner](docs/ProviderList200ResponseAllInner.md) + - [ProviderList200ResponseAllInnerModelsValue](docs/ProviderList200ResponseAllInnerModelsValue.md) + - [ProviderList200ResponseAllInnerModelsValueCost](docs/ProviderList200ResponseAllInnerModelsValueCost.md) + - [ProviderList200ResponseAllInnerModelsValueCostContextOver200k](docs/ProviderList200ResponseAllInnerModelsValueCostContextOver200k.md) + - [ProviderList200ResponseAllInnerModelsValueInterleaved](docs/ProviderList200ResponseAllInnerModelsValueInterleaved.md) + - [ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf](docs/ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf.md) + - [ProviderList200ResponseAllInnerModelsValueLimit](docs/ProviderList200ResponseAllInnerModelsValueLimit.md) + - [ProviderList200ResponseAllInnerModelsValueModalities](docs/ProviderList200ResponseAllInnerModelsValueModalities.md) + - [ProviderList200ResponseAllInnerModelsValueProvider](docs/ProviderList200ResponseAllInnerModelsValueProvider.md) + - [ProviderOauthAuthorizeRequest](docs/ProviderOauthAuthorizeRequest.md) + - [ProviderOauthCallbackRequest](docs/ProviderOauthCallbackRequest.md) + - [Pty](docs/Pty.md) + - [PtyCreateRequest](docs/PtyCreateRequest.md) + - [PtyUpdateRequest](docs/PtyUpdateRequest.md) + - [PtyUpdateRequestSize](docs/PtyUpdateRequestSize.md) + - [Range](docs/Range.md) + - [RangeStart](docs/RangeStart.md) + - [ReasoningPart](docs/ReasoningPart.md) + - [RetryPart](docs/RetryPart.md) + - [ServerConfig](docs/ServerConfig.md) + - [Session](docs/Session.md) + - [SessionCommandRequest](docs/SessionCommandRequest.md) + - [SessionCreateRequest](docs/SessionCreateRequest.md) + - [SessionForkRequest](docs/SessionForkRequest.md) + - [SessionInitRequest](docs/SessionInitRequest.md) + - [SessionMessages200ResponseInner](docs/SessionMessages200ResponseInner.md) + - [SessionPrompt200Response](docs/SessionPrompt200Response.md) + - [SessionPromptRequest](docs/SessionPromptRequest.md) + - [SessionPromptRequestModel](docs/SessionPromptRequestModel.md) + - [SessionPromptRequestPartsInner](docs/SessionPromptRequestPartsInner.md) + - [SessionRevert](docs/SessionRevert.md) + - [SessionRevertRequest](docs/SessionRevertRequest.md) + - [SessionShare](docs/SessionShare.md) + - [SessionShellRequest](docs/SessionShellRequest.md) + - [SessionStatus](docs/SessionStatus.md) + - [SessionStatusAnyOf](docs/SessionStatusAnyOf.md) + - [SessionStatusAnyOf1](docs/SessionStatusAnyOf1.md) + - [SessionStatusAnyOf2](docs/SessionStatusAnyOf2.md) + - [SessionSummarizeRequest](docs/SessionSummarizeRequest.md) + - [SessionSummary](docs/SessionSummary.md) + - [SessionTime](docs/SessionTime.md) + - [SessionUpdateRequest](docs/SessionUpdateRequest.md) + - [SessionUpdateRequestTime](docs/SessionUpdateRequestTime.md) + - [SnapshotPart](docs/SnapshotPart.md) + - [StepFinishPart](docs/StepFinishPart.md) + - [StepStartPart](docs/StepStartPart.md) + - [SubtaskPartInput](docs/SubtaskPartInput.md) + - [Symbol](docs/Symbol.md) + - [SymbolLocation](docs/SymbolLocation.md) + - [SymbolSource](docs/SymbolSource.md) + - [TextPart](docs/TextPart.md) + - [TextPartInput](docs/TextPartInput.md) + - [TextPartTime](docs/TextPartTime.md) + - [Todo](docs/Todo.md) + - [ToolListItem](docs/ToolListItem.md) + - [ToolPart](docs/ToolPart.md) + - [ToolState](docs/ToolState.md) + - [ToolStateCompleted](docs/ToolStateCompleted.md) + - [ToolStateCompletedTime](docs/ToolStateCompletedTime.md) + - [ToolStateError](docs/ToolStateError.md) + - [ToolStateErrorTime](docs/ToolStateErrorTime.md) + - [ToolStatePending](docs/ToolStatePending.md) + - [ToolStateRunning](docs/ToolStateRunning.md) + - [ToolStateRunningTime](docs/ToolStateRunningTime.md) + - [TuiControlNext200Response](docs/TuiControlNext200Response.md) + - [TuiExecuteCommandRequest](docs/TuiExecuteCommandRequest.md) + - [TuiPublishRequest](docs/TuiPublishRequest.md) + - [TuiShowToastRequest](docs/TuiShowToastRequest.md) + - [UnknownError](docs/UnknownError.md) + - [UnknownErrorData](docs/UnknownErrorData.md) + - [UserMessage](docs/UserMessage.md) + - [UserMessageSummary](docs/UserMessageSummary.md) + - [UserMessageTime](docs/UserMessageTime.md) + - [VcsInfo](docs/VcsInfo.md) + - [WellKnownAuth](docs/WellKnownAuth.md) + + +To get access to the crate's generated documentation, use: + +``` +cargo doc --open +``` + +## Author + + + diff --git a/crates/opencode-client/generated/docs/Agent.md b/crates/opencode-client/generated/docs/Agent.md new file mode 100644 index 0000000..d072e3b --- /dev/null +++ b/crates/opencode-client/generated/docs/Agent.md @@ -0,0 +1,25 @@ +# Agent + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**name** | **String** | | +**description** | Option<**String**> | | [optional] +**mode** | **String** | | +**native** | Option<**bool**> | | [optional] +**hidden** | Option<**bool**> | | [optional] +**default** | Option<**bool**> | | [optional] +**top_p** | Option<**f64**> | | [optional] +**temperature** | Option<**f64**> | | [optional] +**color** | Option<**String**> | | [optional] +**permission** | [**models::AgentPermission**](Agent_permission.md) | | +**model** | Option<[**models::SessionPromptRequestModel**](session_prompt_request_model.md)> | | [optional] +**prompt** | Option<**String**> | | [optional] +**tools** | **std::collections::HashMap** | | +**options** | [**std::collections::HashMap**](serde_json::Value.md) | | +**max_steps** | Option<**i32**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/AgentConfig.md b/crates/opencode-client/generated/docs/AgentConfig.md new file mode 100644 index 0000000..982c764 --- /dev/null +++ b/crates/opencode-client/generated/docs/AgentConfig.md @@ -0,0 +1,21 @@ +# AgentConfig + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**model** | Option<**String**> | | [optional] +**temperature** | Option<**f64**> | | [optional] +**top_p** | Option<**f64**> | | [optional] +**prompt** | Option<**String**> | | [optional] +**tools** | Option<**std::collections::HashMap**> | | [optional] +**disable** | Option<**bool**> | | [optional] +**description** | Option<**String**> | Description of when to use the agent | [optional] +**mode** | Option<**String**> | | [optional] +**color** | Option<**String**> | Hex color code for the agent (e.g., #FF5733) | [optional] +**max_steps** | Option<**i32**> | Maximum number of agentic iterations before forcing text-only response | [optional] +**permission** | Option<[**models::AgentConfigPermission**](AgentConfig_permission.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/AgentConfigPermission.md b/crates/opencode-client/generated/docs/AgentConfigPermission.md new file mode 100644 index 0000000..561a997 --- /dev/null +++ b/crates/opencode-client/generated/docs/AgentConfigPermission.md @@ -0,0 +1,16 @@ +# AgentConfigPermission + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**edit** | Option<**String**> | | [optional] +**bash** | Option<[**models::AgentConfigPermissionBash**](AgentConfig_permission_bash.md)> | | [optional] +**skill** | Option<[**models::AgentConfigPermissionBash**](AgentConfig_permission_bash.md)> | | [optional] +**webfetch** | Option<**String**> | | [optional] +**doom_loop** | Option<**String**> | | [optional] +**external_directory** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/AgentConfigPermissionBash.md b/crates/opencode-client/generated/docs/AgentConfigPermissionBash.md new file mode 100644 index 0000000..10f72cf --- /dev/null +++ b/crates/opencode-client/generated/docs/AgentConfigPermissionBash.md @@ -0,0 +1,10 @@ +# AgentConfigPermissionBash + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/AgentPart.md b/crates/opencode-client/generated/docs/AgentPart.md new file mode 100644 index 0000000..fd47b1f --- /dev/null +++ b/crates/opencode-client/generated/docs/AgentPart.md @@ -0,0 +1,16 @@ +# AgentPart + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**session_id** | **String** | | +**message_id** | **String** | | +**r#type** | **String** | | +**name** | **String** | | +**source** | Option<[**models::AgentPartSource**](AgentPart_source.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/AgentPartInput.md b/crates/opencode-client/generated/docs/AgentPartInput.md new file mode 100644 index 0000000..e995b4d --- /dev/null +++ b/crates/opencode-client/generated/docs/AgentPartInput.md @@ -0,0 +1,14 @@ +# AgentPartInput + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | Option<**String**> | | [optional] +**r#type** | **String** | | +**name** | **String** | | +**source** | Option<[**models::AgentPartSource**](AgentPart_source.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/AgentPartSource.md b/crates/opencode-client/generated/docs/AgentPartSource.md new file mode 100644 index 0000000..a68db9f --- /dev/null +++ b/crates/opencode-client/generated/docs/AgentPartSource.md @@ -0,0 +1,13 @@ +# AgentPartSource + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**value** | **String** | | +**start** | **i32** | | +**end** | **i32** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/AgentPermission.md b/crates/opencode-client/generated/docs/AgentPermission.md new file mode 100644 index 0000000..32e926e --- /dev/null +++ b/crates/opencode-client/generated/docs/AgentPermission.md @@ -0,0 +1,16 @@ +# AgentPermission + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**edit** | **String** | | +**bash** | **std::collections::HashMap** | | +**skill** | **std::collections::HashMap** | | +**webfetch** | Option<**String**> | | [optional] +**doom_loop** | Option<**String**> | | [optional] +**external_directory** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ApiAuth.md b/crates/opencode-client/generated/docs/ApiAuth.md new file mode 100644 index 0000000..fe4906a --- /dev/null +++ b/crates/opencode-client/generated/docs/ApiAuth.md @@ -0,0 +1,12 @@ +# ApiAuth + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**key** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ApiError.md b/crates/opencode-client/generated/docs/ApiError.md new file mode 100644 index 0000000..30dc60a --- /dev/null +++ b/crates/opencode-client/generated/docs/ApiError.md @@ -0,0 +1,12 @@ +# ApiError + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**name** | **String** | | +**data** | [**models::ApiErrorData**](APIError_data.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ApiErrorData.md b/crates/opencode-client/generated/docs/ApiErrorData.md new file mode 100644 index 0000000..49c49f5 --- /dev/null +++ b/crates/opencode-client/generated/docs/ApiErrorData.md @@ -0,0 +1,16 @@ +# ApiErrorData + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**message** | **String** | | +**status_code** | Option<**f64**> | | [optional] +**is_retryable** | **bool** | | +**response_headers** | Option<**std::collections::HashMap**> | | [optional] +**response_body** | Option<**String**> | | [optional] +**metadata** | Option<**std::collections::HashMap**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/AppLogRequest.md b/crates/opencode-client/generated/docs/AppLogRequest.md new file mode 100644 index 0000000..154f58d --- /dev/null +++ b/crates/opencode-client/generated/docs/AppLogRequest.md @@ -0,0 +1,14 @@ +# AppLogRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**service** | **String** | Service name for the log entry | +**level** | **String** | Log level | +**message** | **String** | Log message | +**extra** | Option<[**std::collections::HashMap**](serde_json::Value.md)> | Additional metadata for the log entry | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/AssistantMessage.md b/crates/opencode-client/generated/docs/AssistantMessage.md new file mode 100644 index 0000000..a63bc0c --- /dev/null +++ b/crates/opencode-client/generated/docs/AssistantMessage.md @@ -0,0 +1,25 @@ +# AssistantMessage + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**session_id** | **String** | | +**role** | **String** | | +**time** | [**models::AssistantMessageTime**](AssistantMessage_time.md) | | +**error** | Option<[**models::AssistantMessageError**](AssistantMessage_error.md)> | | [optional] +**parent_id** | **String** | | +**model_id** | **String** | | +**provider_id** | **String** | | +**mode** | **String** | | +**agent** | **String** | | +**path** | [**models::AssistantMessagePath**](AssistantMessage_path.md) | | +**summary** | Option<**bool**> | | [optional] +**cost** | **f64** | | +**tokens** | [**models::AssistantMessageTokens**](AssistantMessage_tokens.md) | | +**finish** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/AssistantMessageError.md b/crates/opencode-client/generated/docs/AssistantMessageError.md new file mode 100644 index 0000000..93c57a9 --- /dev/null +++ b/crates/opencode-client/generated/docs/AssistantMessageError.md @@ -0,0 +1,12 @@ +# AssistantMessageError + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**name** | **String** | | +**data** | [**models::ApiErrorData**](APIError_data.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/AssistantMessagePath.md b/crates/opencode-client/generated/docs/AssistantMessagePath.md new file mode 100644 index 0000000..d074216 --- /dev/null +++ b/crates/opencode-client/generated/docs/AssistantMessagePath.md @@ -0,0 +1,12 @@ +# AssistantMessagePath + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**cwd** | **String** | | +**root** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/AssistantMessageTime.md b/crates/opencode-client/generated/docs/AssistantMessageTime.md new file mode 100644 index 0000000..e0a01e8 --- /dev/null +++ b/crates/opencode-client/generated/docs/AssistantMessageTime.md @@ -0,0 +1,12 @@ +# AssistantMessageTime + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**created** | **f64** | | +**completed** | Option<**f64**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/AssistantMessageTokens.md b/crates/opencode-client/generated/docs/AssistantMessageTokens.md new file mode 100644 index 0000000..8c29d59 --- /dev/null +++ b/crates/opencode-client/generated/docs/AssistantMessageTokens.md @@ -0,0 +1,14 @@ +# AssistantMessageTokens + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**input** | **f64** | | +**output** | **f64** | | +**reasoning** | **f64** | | +**cache** | [**models::AssistantMessageTokensCache**](AssistantMessage_tokens_cache.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/AssistantMessageTokensCache.md b/crates/opencode-client/generated/docs/AssistantMessageTokensCache.md new file mode 100644 index 0000000..6ca349c --- /dev/null +++ b/crates/opencode-client/generated/docs/AssistantMessageTokensCache.md @@ -0,0 +1,12 @@ +# AssistantMessageTokensCache + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**read** | **f64** | | +**write** | **f64** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/Auth.md b/crates/opencode-client/generated/docs/Auth.md new file mode 100644 index 0000000..1806e34 --- /dev/null +++ b/crates/opencode-client/generated/docs/Auth.md @@ -0,0 +1,17 @@ +# Auth + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**refresh** | **String** | | +**access** | **String** | | +**expires** | **f64** | | +**enterprise_url** | Option<**String**> | | [optional] +**key** | **String** | | +**token** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/BadRequestError.md b/crates/opencode-client/generated/docs/BadRequestError.md new file mode 100644 index 0000000..e837c5e --- /dev/null +++ b/crates/opencode-client/generated/docs/BadRequestError.md @@ -0,0 +1,13 @@ +# BadRequestError + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**data** | Option<[**serde_json::Value**](.md)> | | +**errors** | [**Vec>**](std::collections::HashMap.md) | | +**success** | **bool** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/Command.md b/crates/opencode-client/generated/docs/Command.md new file mode 100644 index 0000000..d240563 --- /dev/null +++ b/crates/opencode-client/generated/docs/Command.md @@ -0,0 +1,17 @@ +# Command + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**name** | **String** | | +**description** | Option<**String**> | | [optional] +**agent** | Option<**String**> | | [optional] +**model** | Option<**String**> | | [optional] +**template** | [**models::CommandTemplate**](Command_template.md) | | +**subtask** | Option<**bool**> | | [optional] +**hints** | **Vec** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/CommandTemplate.md b/crates/opencode-client/generated/docs/CommandTemplate.md new file mode 100644 index 0000000..695c7d9 --- /dev/null +++ b/crates/opencode-client/generated/docs/CommandTemplate.md @@ -0,0 +1,10 @@ +# CommandTemplate + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/CompactionPart.md b/crates/opencode-client/generated/docs/CompactionPart.md new file mode 100644 index 0000000..b0506da --- /dev/null +++ b/crates/opencode-client/generated/docs/CompactionPart.md @@ -0,0 +1,15 @@ +# CompactionPart + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**session_id** | **String** | | +**message_id** | **String** | | +**r#type** | **String** | | +**auto** | **bool** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/Config.md b/crates/opencode-client/generated/docs/Config.md new file mode 100644 index 0000000..f4e0e2c --- /dev/null +++ b/crates/opencode-client/generated/docs/Config.md @@ -0,0 +1,42 @@ +# Config + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**dollar_schema** | Option<**String**> | JSON schema reference for configuration validation | [optional] +**theme** | Option<**String**> | Theme name to use for the interface | [optional] +**keybinds** | Option<[**models::KeybindsConfig**](KeybindsConfig.md)> | | [optional] +**log_level** | Option<[**models::LogLevel**](LogLevel.md)> | | [optional] +**tui** | Option<[**models::ConfigTui**](Config_tui.md)> | | [optional] +**server** | Option<[**models::ServerConfig**](ServerConfig.md)> | | [optional] +**command** | Option<[**std::collections::HashMap**](Config_command_value.md)> | Command configuration, see https://opencode.ai/docs/commands | [optional] +**watcher** | Option<[**models::ConfigWatcher**](Config_watcher.md)> | | [optional] +**plugin** | Option<**Vec**> | | [optional] +**snapshot** | Option<**bool**> | | [optional] +**share** | Option<**String**> | Control sharing behavior:'manual' allows manual sharing via commands, 'auto' enables automatic sharing, 'disabled' disables all sharing | [optional] +**autoshare** | Option<**bool**> | @deprecated Use 'share' field instead. Share newly created sessions automatically | [optional] +**autoupdate** | Option<[**models::ConfigAutoupdate**](Config_autoupdate.md)> | | [optional] +**disabled_providers** | Option<**Vec**> | Disable providers that are loaded automatically | [optional] +**enabled_providers** | Option<**Vec**> | When set, ONLY these providers will be enabled. All other providers will be ignored | [optional] +**model** | Option<**String**> | Model to use in the format of provider/model, eg anthropic/claude-2 | [optional] +**small_model** | Option<**String**> | Small model to use for tasks like title generation in the format of provider/model | [optional] +**default_agent** | Option<**String**> | Default agent to use when none is specified. Must be a primary agent. Falls back to 'build' if not set or if the specified agent is invalid. | [optional] +**username** | Option<**String**> | Custom username to display in conversations instead of system username | [optional] +**mode** | Option<[**models::ConfigMode**](Config_mode.md)> | | [optional] +**agent** | Option<[**models::ConfigAgent**](Config_agent.md)> | | [optional] +**provider** | Option<[**std::collections::HashMap**](ProviderConfig.md)> | Custom provider configurations and model overrides | [optional] +**mcp** | Option<[**std::collections::HashMap**](mcp_add_request_config.md)> | MCP (Model Context Protocol) server configurations | [optional] +**formatter** | Option<[**models::ConfigFormatter**](Config_formatter.md)> | | [optional] +**lsp** | Option<[**models::ConfigLsp**](Config_lsp.md)> | | [optional] +**instructions** | Option<**Vec**> | Additional instruction files or patterns to include | [optional] +**layout** | Option<[**models::LayoutConfig**](LayoutConfig.md)> | | [optional] +**permission** | Option<[**models::AgentConfigPermission**](AgentConfig_permission.md)> | | [optional] +**tools** | Option<**std::collections::HashMap**> | | [optional] +**enterprise** | Option<[**models::ConfigEnterprise**](Config_enterprise.md)> | | [optional] +**compaction** | Option<[**models::ConfigCompaction**](Config_compaction.md)> | | [optional] +**experimental** | Option<[**models::ConfigExperimental**](Config_experimental.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigAgent.md b/crates/opencode-client/generated/docs/ConfigAgent.md new file mode 100644 index 0000000..4a16024 --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigAgent.md @@ -0,0 +1,17 @@ +# ConfigAgent + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**plan** | Option<[**models::AgentConfig**](AgentConfig.md)> | | [optional] +**build** | Option<[**models::AgentConfig**](AgentConfig.md)> | | [optional] +**general** | Option<[**models::AgentConfig**](AgentConfig.md)> | | [optional] +**explore** | Option<[**models::AgentConfig**](AgentConfig.md)> | | [optional] +**title** | Option<[**models::AgentConfig**](AgentConfig.md)> | | [optional] +**summary** | Option<[**models::AgentConfig**](AgentConfig.md)> | | [optional] +**compaction** | Option<[**models::AgentConfig**](AgentConfig.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigAutoupdate.md b/crates/opencode-client/generated/docs/ConfigAutoupdate.md new file mode 100644 index 0000000..4787ab0 --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigAutoupdate.md @@ -0,0 +1,10 @@ +# ConfigAutoupdate + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigCommandValue.md b/crates/opencode-client/generated/docs/ConfigCommandValue.md new file mode 100644 index 0000000..da28938 --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigCommandValue.md @@ -0,0 +1,15 @@ +# ConfigCommandValue + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**template** | **String** | | +**description** | Option<**String**> | | [optional] +**agent** | Option<**String**> | | [optional] +**model** | Option<**String**> | | [optional] +**subtask** | Option<**bool**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigCompaction.md b/crates/opencode-client/generated/docs/ConfigCompaction.md new file mode 100644 index 0000000..ee9818d --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigCompaction.md @@ -0,0 +1,12 @@ +# ConfigCompaction + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**auto** | Option<**bool**> | Enable automatic compaction when context is full (default: true) | [optional] +**prune** | Option<**bool**> | Enable pruning of old tool outputs (default: true) | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigEnterprise.md b/crates/opencode-client/generated/docs/ConfigEnterprise.md new file mode 100644 index 0000000..6beeb71 --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigEnterprise.md @@ -0,0 +1,11 @@ +# ConfigEnterprise + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**url** | Option<**String**> | Enterprise URL | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigExperimental.md b/crates/opencode-client/generated/docs/ConfigExperimental.md new file mode 100644 index 0000000..bf3395a --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigExperimental.md @@ -0,0 +1,18 @@ +# ConfigExperimental + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**hook** | Option<[**models::ConfigExperimentalHook**](Config_experimental_hook.md)> | | [optional] +**chat_max_retries** | Option<**f64**> | Number of retries for chat completions on failure | [optional] +**disable_paste_summary** | Option<**bool**> | | [optional] +**batch_tool** | Option<**bool**> | Enable the batch tool | [optional] +**open_telemetry** | Option<**bool**> | Enable OpenTelemetry spans for AI SDK calls (using the 'experimental_telemetry' flag) | [optional] +**primary_tools** | Option<**Vec**> | Tools that should only be available to primary agents. | [optional] +**continue_loop_on_deny** | Option<**bool**> | Continue the agent loop when a tool call is denied | [optional] +**mcp_timeout** | Option<**i32**> | Timeout in milliseconds for model context protocol (MCP) requests | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigExperimentalHook.md b/crates/opencode-client/generated/docs/ConfigExperimentalHook.md new file mode 100644 index 0000000..84c2dfd --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigExperimentalHook.md @@ -0,0 +1,12 @@ +# ConfigExperimentalHook + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**file_edited** | Option<[**std::collections::HashMap>**](Vec.md)> | | [optional] +**session_completed** | Option<[**Vec**](Config_experimental_hook_file_edited_value_inner.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigExperimentalHookFileEditedValueInner.md b/crates/opencode-client/generated/docs/ConfigExperimentalHookFileEditedValueInner.md new file mode 100644 index 0000000..06c3578 --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigExperimentalHookFileEditedValueInner.md @@ -0,0 +1,12 @@ +# ConfigExperimentalHookFileEditedValueInner + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**command** | **Vec** | | +**environment** | Option<**std::collections::HashMap**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigFormatter.md b/crates/opencode-client/generated/docs/ConfigFormatter.md new file mode 100644 index 0000000..a37add7 --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigFormatter.md @@ -0,0 +1,10 @@ +# ConfigFormatter + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigFormatterAnyOfValue.md b/crates/opencode-client/generated/docs/ConfigFormatterAnyOfValue.md new file mode 100644 index 0000000..5c21239 --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigFormatterAnyOfValue.md @@ -0,0 +1,14 @@ +# ConfigFormatterAnyOfValue + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**disabled** | Option<**bool**> | | [optional] +**command** | Option<**Vec**> | | [optional] +**environment** | Option<**std::collections::HashMap**> | | [optional] +**extensions** | Option<**Vec**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigLsp.md b/crates/opencode-client/generated/docs/ConfigLsp.md new file mode 100644 index 0000000..490e9d4 --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigLsp.md @@ -0,0 +1,10 @@ +# ConfigLsp + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigLspAnyOfValue.md b/crates/opencode-client/generated/docs/ConfigLspAnyOfValue.md new file mode 100644 index 0000000..e30861f --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigLspAnyOfValue.md @@ -0,0 +1,15 @@ +# ConfigLspAnyOfValue + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**disabled** | **bool** | | +**command** | **Vec** | | +**extensions** | Option<**Vec**> | | [optional] +**env** | Option<**std::collections::HashMap**> | | [optional] +**initialization** | Option<[**std::collections::HashMap**](serde_json::Value.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigLspAnyOfValueAnyOf.md b/crates/opencode-client/generated/docs/ConfigLspAnyOfValueAnyOf.md new file mode 100644 index 0000000..3ab865e --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigLspAnyOfValueAnyOf.md @@ -0,0 +1,11 @@ +# ConfigLspAnyOfValueAnyOf + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**disabled** | **bool** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigLspAnyOfValueAnyOf1.md b/crates/opencode-client/generated/docs/ConfigLspAnyOfValueAnyOf1.md new file mode 100644 index 0000000..af2f41d --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigLspAnyOfValueAnyOf1.md @@ -0,0 +1,15 @@ +# ConfigLspAnyOfValueAnyOf1 + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**command** | **Vec** | | +**extensions** | Option<**Vec**> | | [optional] +**disabled** | Option<**bool**> | | [optional] +**env** | Option<**std::collections::HashMap**> | | [optional] +**initialization** | Option<[**std::collections::HashMap**](serde_json::Value.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigMode.md b/crates/opencode-client/generated/docs/ConfigMode.md new file mode 100644 index 0000000..a4be86c --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigMode.md @@ -0,0 +1,12 @@ +# ConfigMode + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**build** | Option<[**models::AgentConfig**](AgentConfig.md)> | | [optional] +**plan** | Option<[**models::AgentConfig**](AgentConfig.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigProviders200Response.md b/crates/opencode-client/generated/docs/ConfigProviders200Response.md new file mode 100644 index 0000000..80dd010 --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigProviders200Response.md @@ -0,0 +1,12 @@ +# ConfigProviders200Response + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**providers** | [**Vec**](Provider.md) | | +**default** | **std::collections::HashMap** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigTui.md b/crates/opencode-client/generated/docs/ConfigTui.md new file mode 100644 index 0000000..db5ccee --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigTui.md @@ -0,0 +1,13 @@ +# ConfigTui + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**scroll_speed** | Option<**f64**> | TUI scroll speed | [optional] +**scroll_acceleration** | Option<[**models::ConfigTuiScrollAcceleration**](Config_tui_scroll_acceleration.md)> | | [optional] +**diff_style** | Option<**String**> | Control diff rendering style: 'auto' adapts to terminal width, 'stacked' always shows single column | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigTuiScrollAcceleration.md b/crates/opencode-client/generated/docs/ConfigTuiScrollAcceleration.md new file mode 100644 index 0000000..d6f5709 --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigTuiScrollAcceleration.md @@ -0,0 +1,11 @@ +# ConfigTuiScrollAcceleration + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**enabled** | **bool** | Enable scroll acceleration | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ConfigWatcher.md b/crates/opencode-client/generated/docs/ConfigWatcher.md new file mode 100644 index 0000000..92bd493 --- /dev/null +++ b/crates/opencode-client/generated/docs/ConfigWatcher.md @@ -0,0 +1,11 @@ +# ConfigWatcher + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**ignore** | Option<**Vec**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/DefaultApi.md b/crates/opencode-client/generated/docs/DefaultApi.md new file mode 100644 index 0000000..0141cc5 --- /dev/null +++ b/crates/opencode-client/generated/docs/DefaultApi.md @@ -0,0 +1,2621 @@ +# \DefaultApi + +All URIs are relative to *http://localhost* + +Method | HTTP request | Description +------------- | ------------- | ------------- +[**app_agents**](DefaultApi.md#app_agents) | **GET** /agent | List agents +[**app_log**](DefaultApi.md#app_log) | **POST** /log | Write log +[**auth_set**](DefaultApi.md#auth_set) | **PUT** /auth/{providerID} | Set auth credentials +[**command_list**](DefaultApi.md#command_list) | **GET** /command | List commands +[**config_get**](DefaultApi.md#config_get) | **GET** /config | Get configuration +[**config_providers**](DefaultApi.md#config_providers) | **GET** /config/providers | List config providers +[**config_update**](DefaultApi.md#config_update) | **PATCH** /config | Update configuration +[**event_subscribe**](DefaultApi.md#event_subscribe) | **GET** /event | Subscribe to events +[**file_list**](DefaultApi.md#file_list) | **GET** /file | List files +[**file_read**](DefaultApi.md#file_read) | **GET** /file/content | Read file +[**file_status**](DefaultApi.md#file_status) | **GET** /file/status | Get file status +[**find_files**](DefaultApi.md#find_files) | **GET** /find/file | Find files +[**find_symbols**](DefaultApi.md#find_symbols) | **GET** /find/symbol | Find symbols +[**find_text**](DefaultApi.md#find_text) | **GET** /find | Find text +[**formatter_status**](DefaultApi.md#formatter_status) | **GET** /formatter | Get formatter status +[**global_dispose**](DefaultApi.md#global_dispose) | **POST** /global/dispose | Dispose instance +[**global_event**](DefaultApi.md#global_event) | **GET** /global/event | Get global events +[**global_health**](DefaultApi.md#global_health) | **GET** /global/health | Get health +[**instance_dispose**](DefaultApi.md#instance_dispose) | **POST** /instance/dispose | Dispose instance +[**lsp_status**](DefaultApi.md#lsp_status) | **GET** /lsp | Get LSP status +[**mcp_add**](DefaultApi.md#mcp_add) | **POST** /mcp | Add MCP server +[**mcp_auth_authenticate**](DefaultApi.md#mcp_auth_authenticate) | **POST** /mcp/{name}/auth/authenticate | Authenticate MCP OAuth +[**mcp_auth_callback**](DefaultApi.md#mcp_auth_callback) | **POST** /mcp/{name}/auth/callback | Complete MCP OAuth +[**mcp_auth_remove**](DefaultApi.md#mcp_auth_remove) | **DELETE** /mcp/{name}/auth | Remove MCP OAuth +[**mcp_auth_start**](DefaultApi.md#mcp_auth_start) | **POST** /mcp/{name}/auth | Start MCP OAuth +[**mcp_connect**](DefaultApi.md#mcp_connect) | **POST** /mcp/{name}/connect | +[**mcp_disconnect**](DefaultApi.md#mcp_disconnect) | **POST** /mcp/{name}/disconnect | +[**mcp_status**](DefaultApi.md#mcp_status) | **GET** /mcp | Get MCP status +[**part_delete**](DefaultApi.md#part_delete) | **DELETE** /session/{sessionID}/message/{messageID}/part/{partID} | +[**part_update**](DefaultApi.md#part_update) | **PATCH** /session/{sessionID}/message/{messageID}/part/{partID} | +[**path_get**](DefaultApi.md#path_get) | **GET** /path | Get paths +[**permission_list**](DefaultApi.md#permission_list) | **GET** /permission | List pending permissions +[**permission_respond**](DefaultApi.md#permission_respond) | **POST** /session/{sessionID}/permissions/{permissionID} | Respond to permission +[**project_current**](DefaultApi.md#project_current) | **GET** /project/current | Get current project +[**project_list**](DefaultApi.md#project_list) | **GET** /project | List all projects +[**project_update**](DefaultApi.md#project_update) | **PATCH** /project/{projectID} | Update project +[**provider_auth**](DefaultApi.md#provider_auth) | **GET** /provider/auth | Get provider auth methods +[**provider_list**](DefaultApi.md#provider_list) | **GET** /provider | List providers +[**provider_oauth_authorize**](DefaultApi.md#provider_oauth_authorize) | **POST** /provider/{providerID}/oauth/authorize | OAuth authorize +[**provider_oauth_callback**](DefaultApi.md#provider_oauth_callback) | **POST** /provider/{providerID}/oauth/callback | OAuth callback +[**pty_connect**](DefaultApi.md#pty_connect) | **GET** /pty/{ptyID}/connect | Connect to PTY session +[**pty_create**](DefaultApi.md#pty_create) | **POST** /pty | Create PTY session +[**pty_get**](DefaultApi.md#pty_get) | **GET** /pty/{ptyID} | Get PTY session +[**pty_list**](DefaultApi.md#pty_list) | **GET** /pty | List PTY sessions +[**pty_remove**](DefaultApi.md#pty_remove) | **DELETE** /pty/{ptyID} | Remove PTY session +[**pty_update**](DefaultApi.md#pty_update) | **PUT** /pty/{ptyID} | Update PTY session +[**session_abort**](DefaultApi.md#session_abort) | **POST** /session/{sessionID}/abort | Abort session +[**session_command**](DefaultApi.md#session_command) | **POST** /session/{sessionID}/command | Send command +[**session_create**](DefaultApi.md#session_create) | **POST** /session | Create session +[**session_delete**](DefaultApi.md#session_delete) | **DELETE** /session/{sessionID} | Delete session +[**session_diff**](DefaultApi.md#session_diff) | **GET** /session/{sessionID}/diff | Get session diff +[**session_fork**](DefaultApi.md#session_fork) | **POST** /session/{sessionID}/fork | Fork session +[**session_init**](DefaultApi.md#session_init) | **POST** /session/{sessionID}/init | Initialize session +[**session_list**](DefaultApi.md#session_list) | **GET** /session | List sessions +[**session_message**](DefaultApi.md#session_message) | **GET** /session/{sessionID}/message/{messageID} | Get message +[**session_messages**](DefaultApi.md#session_messages) | **GET** /session/{sessionID}/message | Get session messages +[**session_prompt**](DefaultApi.md#session_prompt) | **POST** /session/{sessionID}/message | Send message +[**session_prompt_async**](DefaultApi.md#session_prompt_async) | **POST** /session/{sessionID}/prompt_async | Send async message +[**session_revert**](DefaultApi.md#session_revert) | **POST** /session/{sessionID}/revert | Revert message +[**session_share**](DefaultApi.md#session_share) | **POST** /session/{sessionID}/share | Share session +[**session_shell**](DefaultApi.md#session_shell) | **POST** /session/{sessionID}/shell | Run shell command +[**session_status**](DefaultApi.md#session_status) | **GET** /session/status | Get session status +[**session_summarize**](DefaultApi.md#session_summarize) | **POST** /session/{sessionID}/summarize | Summarize session +[**session_todo**](DefaultApi.md#session_todo) | **GET** /session/{sessionID}/todo | Get session todos +[**session_unrevert**](DefaultApi.md#session_unrevert) | **POST** /session/{sessionID}/unrevert | Restore reverted messages +[**session_unshare**](DefaultApi.md#session_unshare) | **DELETE** /session/{sessionID}/share | Unshare session +[**session_update**](DefaultApi.md#session_update) | **PATCH** /session/{sessionID} | Update session +[**tool_ids**](DefaultApi.md#tool_ids) | **GET** /experimental/tool/ids | List tool IDs +[**tool_list**](DefaultApi.md#tool_list) | **GET** /experimental/tool | List tools +[**tui_append_prompt**](DefaultApi.md#tui_append_prompt) | **POST** /tui/append-prompt | Append TUI prompt +[**tui_clear_prompt**](DefaultApi.md#tui_clear_prompt) | **POST** /tui/clear-prompt | Clear TUI prompt +[**tui_control_next**](DefaultApi.md#tui_control_next) | **GET** /tui/control/next | Get next TUI request +[**tui_control_response**](DefaultApi.md#tui_control_response) | **POST** /tui/control/response | Submit TUI response +[**tui_execute_command**](DefaultApi.md#tui_execute_command) | **POST** /tui/execute-command | Execute TUI command +[**tui_open_help**](DefaultApi.md#tui_open_help) | **POST** /tui/open-help | Open help dialog +[**tui_open_models**](DefaultApi.md#tui_open_models) | **POST** /tui/open-models | Open models dialog +[**tui_open_sessions**](DefaultApi.md#tui_open_sessions) | **POST** /tui/open-sessions | Open sessions dialog +[**tui_open_themes**](DefaultApi.md#tui_open_themes) | **POST** /tui/open-themes | Open themes dialog +[**tui_publish**](DefaultApi.md#tui_publish) | **POST** /tui/publish | Publish TUI event +[**tui_show_toast**](DefaultApi.md#tui_show_toast) | **POST** /tui/show-toast | Show TUI toast +[**tui_submit_prompt**](DefaultApi.md#tui_submit_prompt) | **POST** /tui/submit-prompt | Submit TUI prompt +[**vcs_get**](DefaultApi.md#vcs_get) | **GET** /vcs | Get VCS info + + + +## app_agents + +> Vec app_agents(directory) +List agents + +Get a list of all available AI agents in the OpenCode system. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**Vec**](Agent.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## app_log + +> bool app_log(directory, app_log_request) +Write log + +Write a log entry to the server logs with specified level and metadata. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | +**app_log_request** | Option<[**AppLogRequest**](AppLogRequest.md)> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## auth_set + +> bool auth_set(provider_id, directory, auth) +Set auth credentials + +Set authentication credentials + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**provider_id** | **String** | | [required] | +**directory** | Option<**String**> | | | +**auth** | Option<[**Auth**](Auth.md)> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## command_list + +> Vec command_list(directory) +List commands + +Get a list of all available commands in the OpenCode system. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**Vec**](Command.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## config_get + +> models::Config config_get(directory) +Get configuration + +Retrieve the current OpenCode configuration settings and preferences. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**models::Config**](Config.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## config_providers + +> models::ConfigProviders200Response config_providers(directory) +List config providers + +Get a list of all configured AI providers and their default models. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**models::ConfigProviders200Response**](config_providers_200_response.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## config_update + +> models::Config config_update(directory, config) +Update configuration + +Update OpenCode configuration settings and preferences. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | +**config** | Option<[**Config**](Config.md)> | | | + +### Return type + +[**models::Config**](Config.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## event_subscribe + +> models::Event event_subscribe(directory) +Subscribe to events + +Get events + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**models::Event**](Event.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: text/event-stream + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## file_list + +> Vec file_list(path, directory) +List files + +List files and directories in a specified path. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**path** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +[**Vec**](FileNode.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## file_read + +> models::FileContent file_read(path, directory) +Read file + +Read the content of a specified file. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**path** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +[**models::FileContent**](FileContent.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## file_status + +> Vec file_status(directory) +Get file status + +Get the git status of all files in the project. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**Vec**](File.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## find_files + +> Vec find_files(query, directory, dirs, r#type, limit) +Find files + +Search for files or directories by name or pattern in the project directory. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**query** | **String** | | [required] | +**directory** | Option<**String**> | | | +**dirs** | Option<**String**> | | | +**r#type** | Option<**String**> | | | +**limit** | Option<**i32**> | | | + +### Return type + +**Vec** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## find_symbols + +> Vec find_symbols(query, directory) +Find symbols + +Search for workspace symbols like functions, classes, and variables using LSP. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**query** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +[**Vec**](Symbol.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## find_text + +> Vec find_text(pattern, directory) +Find text + +Search for text patterns across files in the project using ripgrep. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**pattern** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +[**Vec**](find_text_200_response_inner.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## formatter_status + +> Vec formatter_status(directory) +Get formatter status + +Get formatter status + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**Vec**](FormatterStatus.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## global_dispose + +> bool global_dispose() +Dispose instance + +Clean up and dispose all OpenCode instances, releasing all resources. + +### Parameters + +This endpoint does not need any parameter. + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## global_event + +> models::GlobalEvent global_event() +Get global events + +Subscribe to global events from the OpenCode system using server-sent events. + +### Parameters + +This endpoint does not need any parameter. + +### Return type + +[**models::GlobalEvent**](GlobalEvent.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: text/event-stream + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## global_health + +> models::GlobalHealth200Response global_health() +Get health + +Get health information about the OpenCode server. + +### Parameters + +This endpoint does not need any parameter. + +### Return type + +[**models::GlobalHealth200Response**](global_health_200_response.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## instance_dispose + +> bool instance_dispose(directory) +Dispose instance + +Clean up and dispose the current OpenCode instance, releasing all resources. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## lsp_status + +> Vec lsp_status(directory) +Get LSP status + +Get LSP server status + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**Vec**](LSPStatus.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## mcp_add + +> std::collections::HashMap mcp_add(directory, mcp_add_request) +Add MCP server + +Dynamically add a new Model Context Protocol (MCP) server to the system. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | +**mcp_add_request** | Option<[**McpAddRequest**](McpAddRequest.md)> | | | + +### Return type + +[**std::collections::HashMap**](MCPStatus.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## mcp_auth_authenticate + +> models::McpStatus mcp_auth_authenticate(name, directory) +Authenticate MCP OAuth + +Start OAuth flow and wait for callback (opens browser) + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**name** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +[**models::McpStatus**](MCPStatus.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## mcp_auth_callback + +> models::McpStatus mcp_auth_callback(name, directory, mcp_auth_callback_request) +Complete MCP OAuth + +Complete OAuth authentication for a Model Context Protocol (MCP) server using the authorization code. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**name** | **String** | | [required] | +**directory** | Option<**String**> | | | +**mcp_auth_callback_request** | Option<[**McpAuthCallbackRequest**](McpAuthCallbackRequest.md)> | | | + +### Return type + +[**models::McpStatus**](MCPStatus.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## mcp_auth_remove + +> models::McpAuthRemove200Response mcp_auth_remove(name, directory) +Remove MCP OAuth + +Remove OAuth credentials for an MCP server + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**name** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +[**models::McpAuthRemove200Response**](mcp_auth_remove_200_response.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## mcp_auth_start + +> models::McpAuthStart200Response mcp_auth_start(name, directory) +Start MCP OAuth + +Start OAuth authentication flow for a Model Context Protocol (MCP) server. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**name** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +[**models::McpAuthStart200Response**](mcp_auth_start_200_response.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## mcp_connect + +> bool mcp_connect(name, directory) + + +Connect an MCP server + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**name** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## mcp_disconnect + +> bool mcp_disconnect(name, directory) + + +Disconnect an MCP server + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**name** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## mcp_status + +> std::collections::HashMap mcp_status(directory) +Get MCP status + +Get the status of all Model Context Protocol (MCP) servers. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**std::collections::HashMap**](MCPStatus.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## part_delete + +> bool part_delete(session_id, message_id, part_id, directory) + + +Delete a part from a message + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | Session ID | [required] | +**message_id** | **String** | Message ID | [required] | +**part_id** | **String** | Part ID | [required] | +**directory** | Option<**String**> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## part_update + +> models::Part part_update(session_id, message_id, part_id, directory, part) + + +Update a part in a message + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | Session ID | [required] | +**message_id** | **String** | Message ID | [required] | +**part_id** | **String** | Part ID | [required] | +**directory** | Option<**String**> | | | +**part** | Option<[**Part**](Part.md)> | | | + +### Return type + +[**models::Part**](Part.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## path_get + +> models::Path path_get(directory) +Get paths + +Retrieve the current working directory and related path information for the OpenCode instance. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**models::Path**](Path.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## permission_list + +> Vec permission_list(directory) +List pending permissions + +Get all pending permission requests across all sessions. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**Vec**](Permission.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## permission_respond + +> bool permission_respond(session_id, permission_id, directory, permission_respond_request) +Respond to permission + +Approve or deny a permission request from the AI assistant. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | | [required] | +**permission_id** | **String** | | [required] | +**directory** | Option<**String**> | | | +**permission_respond_request** | Option<[**PermissionRespondRequest**](PermissionRespondRequest.md)> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## project_current + +> models::Project project_current(directory) +Get current project + +Retrieve the currently active project that OpenCode is working with. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**models::Project**](Project.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## project_list + +> Vec project_list(directory) +List all projects + +Get a list of projects that have been opened with OpenCode. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**Vec**](Project.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## project_update + +> models::Project project_update(project_id, directory, project_update_request) +Update project + +Update project properties such as name, icon and color. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**project_id** | **String** | | [required] | +**directory** | Option<**String**> | | | +**project_update_request** | Option<[**ProjectUpdateRequest**](ProjectUpdateRequest.md)> | | | + +### Return type + +[**models::Project**](Project.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## provider_auth + +> std::collections::HashMap> provider_auth(directory) +Get provider auth methods + +Retrieve available authentication methods for all AI providers. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**std::collections::HashMap>**](Vec.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## provider_list + +> models::ProviderList200Response provider_list(directory) +List providers + +Get a list of all available AI providers, including both available and connected ones. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**models::ProviderList200Response**](provider_list_200_response.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## provider_oauth_authorize + +> models::ProviderAuthAuthorization provider_oauth_authorize(provider_id, directory, provider_oauth_authorize_request) +OAuth authorize + +Initiate OAuth authorization for a specific AI provider to get an authorization URL. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**provider_id** | **String** | Provider ID | [required] | +**directory** | Option<**String**> | | | +**provider_oauth_authorize_request** | Option<[**ProviderOauthAuthorizeRequest**](ProviderOauthAuthorizeRequest.md)> | | | + +### Return type + +[**models::ProviderAuthAuthorization**](ProviderAuthAuthorization.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## provider_oauth_callback + +> bool provider_oauth_callback(provider_id, directory, provider_oauth_callback_request) +OAuth callback + +Handle the OAuth callback from a provider after user authorization. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**provider_id** | **String** | Provider ID | [required] | +**directory** | Option<**String**> | | | +**provider_oauth_callback_request** | Option<[**ProviderOauthCallbackRequest**](ProviderOauthCallbackRequest.md)> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## pty_connect + +> bool pty_connect(pty_id, directory) +Connect to PTY session + +Establish a WebSocket connection to interact with a pseudo-terminal (PTY) session in real-time. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**pty_id** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## pty_create + +> models::Pty pty_create(directory, pty_create_request) +Create PTY session + +Create a new pseudo-terminal (PTY) session for running shell commands and processes. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | +**pty_create_request** | Option<[**PtyCreateRequest**](PtyCreateRequest.md)> | | | + +### Return type + +[**models::Pty**](Pty.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## pty_get + +> models::Pty pty_get(pty_id, directory) +Get PTY session + +Retrieve detailed information about a specific pseudo-terminal (PTY) session. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**pty_id** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +[**models::Pty**](Pty.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## pty_list + +> Vec pty_list(directory) +List PTY sessions + +Get a list of all active pseudo-terminal (PTY) sessions managed by OpenCode. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**Vec**](Pty.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## pty_remove + +> bool pty_remove(pty_id, directory) +Remove PTY session + +Remove and terminate a specific pseudo-terminal (PTY) session. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**pty_id** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## pty_update + +> models::Pty pty_update(pty_id, directory, pty_update_request) +Update PTY session + +Update properties of an existing pseudo-terminal (PTY) session. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**pty_id** | **String** | | [required] | +**directory** | Option<**String**> | | | +**pty_update_request** | Option<[**PtyUpdateRequest**](PtyUpdateRequest.md)> | | | + +### Return type + +[**models::Pty**](Pty.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_abort + +> bool session_abort(session_id, directory) +Abort session + +Abort an active session and stop any ongoing AI processing or command execution. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_command + +> models::SessionPrompt200Response session_command(session_id, directory, session_command_request) +Send command + +Send a new command to a session for execution by the AI assistant. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | Session ID | [required] | +**directory** | Option<**String**> | | | +**session_command_request** | Option<[**SessionCommandRequest**](SessionCommandRequest.md)> | | | + +### Return type + +[**models::SessionPrompt200Response**](session_prompt_200_response.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_create + +> models::Session session_create(directory, session_create_request) +Create session + +Create a new OpenCode session for interacting with AI assistants and managing conversations. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | +**session_create_request** | Option<[**SessionCreateRequest**](SessionCreateRequest.md)> | | | + +### Return type + +[**models::Session**](Session.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_delete + +> bool session_delete(session_id, directory) +Delete session + +Delete a session and permanently remove all associated data, including messages and history. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_diff + +> Vec session_diff(session_id, directory, message_id) +Get session diff + +Get all file changes (diffs) made during this session. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | Session ID | [required] | +**directory** | Option<**String**> | | | +**message_id** | Option<**String**> | | | + +### Return type + +[**Vec**](FileDiff.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_fork + +> models::Session session_fork(session_id, directory, session_fork_request) +Fork session + +Create a new session by forking an existing session at a specific message point. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | | [required] | +**directory** | Option<**String**> | | | +**session_fork_request** | Option<[**SessionForkRequest**](SessionForkRequest.md)> | | | + +### Return type + +[**models::Session**](Session.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_init + +> bool session_init(session_id, directory, session_init_request) +Initialize session + +Analyze the current application and create an AGENTS.md file with project-specific agent configurations. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | Session ID | [required] | +**directory** | Option<**String**> | | | +**session_init_request** | Option<[**SessionInitRequest**](SessionInitRequest.md)> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_list + +> Vec session_list(directory) +List sessions + +Get a list of all OpenCode sessions, sorted by most recently updated. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**Vec**](Session.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_message + +> models::SessionMessages200ResponseInner session_message(session_id, message_id, directory) +Get message + +Retrieve a specific message from a session by its message ID. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | Session ID | [required] | +**message_id** | **String** | Message ID | [required] | +**directory** | Option<**String**> | | | + +### Return type + +[**models::SessionMessages200ResponseInner**](session_messages_200_response_inner.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_messages + +> Vec session_messages(session_id, directory, limit) +Get session messages + +Retrieve all messages in a session, including user prompts and AI responses. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | Session ID | [required] | +**directory** | Option<**String**> | | | +**limit** | Option<**f64**> | | | + +### Return type + +[**Vec**](session_messages_200_response_inner.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_prompt + +> models::SessionPrompt200Response session_prompt(session_id, directory, session_prompt_request) +Send message + +Create and send a new message to a session, streaming the AI response. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | Session ID | [required] | +**directory** | Option<**String**> | | | +**session_prompt_request** | Option<[**SessionPromptRequest**](SessionPromptRequest.md)> | | | + +### Return type + +[**models::SessionPrompt200Response**](session_prompt_200_response.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_prompt_async + +> session_prompt_async(session_id, directory, session_prompt_request) +Send async message + +Create and send a new message to a session asynchronously, starting the session if needed and returning immediately. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | Session ID | [required] | +**directory** | Option<**String**> | | | +**session_prompt_request** | Option<[**SessionPromptRequest**](SessionPromptRequest.md)> | | | + +### Return type + + (empty response body) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_revert + +> models::Session session_revert(session_id, directory, session_revert_request) +Revert message + +Revert a specific message in a session, undoing its effects and restoring the previous state. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | | [required] | +**directory** | Option<**String**> | | | +**session_revert_request** | Option<[**SessionRevertRequest**](SessionRevertRequest.md)> | | | + +### Return type + +[**models::Session**](Session.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_share + +> models::Session session_share(session_id, directory) +Share session + +Create a shareable link for a session, allowing others to view the conversation. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +[**models::Session**](Session.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_shell + +> models::AssistantMessage session_shell(session_id, directory, session_shell_request) +Run shell command + +Execute a shell command within the session context and return the AI's response. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | Session ID | [required] | +**directory** | Option<**String**> | | | +**session_shell_request** | Option<[**SessionShellRequest**](SessionShellRequest.md)> | | | + +### Return type + +[**models::AssistantMessage**](AssistantMessage.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_status + +> std::collections::HashMap session_status(directory) +Get session status + +Retrieve the current status of all sessions, including active, idle, and completed states. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**std::collections::HashMap**](SessionStatus.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_summarize + +> bool session_summarize(session_id, directory, session_summarize_request) +Summarize session + +Generate a concise summary of the session using AI compaction to preserve key information. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | Session ID | [required] | +**directory** | Option<**String**> | | | +**session_summarize_request** | Option<[**SessionSummarizeRequest**](SessionSummarizeRequest.md)> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_todo + +> Vec session_todo(session_id, directory) +Get session todos + +Retrieve the todo list associated with a specific session, showing tasks and action items. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | Session ID | [required] | +**directory** | Option<**String**> | | | + +### Return type + +[**Vec**](Todo.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_unrevert + +> models::Session session_unrevert(session_id, directory) +Restore reverted messages + +Restore all previously reverted messages in a session. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +[**models::Session**](Session.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_unshare + +> models::Session session_unshare(session_id, directory) +Unshare session + +Remove the shareable link for a session, making it private again. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +[**models::Session**](Session.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_update + +> models::Session session_update(session_id, directory, session_update_request) +Update session + +Update properties of an existing session, such as title or other metadata. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | | [required] | +**directory** | Option<**String**> | | | +**session_update_request** | Option<[**SessionUpdateRequest**](SessionUpdateRequest.md)> | | | + +### Return type + +[**models::Session**](Session.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## tool_ids + +> Vec tool_ids(directory) +List tool IDs + +Get a list of all available tool IDs, including both built-in tools and dynamically registered tools. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +**Vec** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## tool_list + +> Vec tool_list(provider, model, directory) +List tools + +Get a list of available tools with their JSON schema parameters for a specific provider and model combination. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**provider** | **String** | | [required] | +**model** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +[**Vec**](ToolListItem.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## tui_append_prompt + +> bool tui_append_prompt(directory, find_text200_response_inner_path) +Append TUI prompt + +Append prompt to the TUI + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | +**find_text200_response_inner_path** | Option<[**FindText200ResponseInnerPath**](FindText200ResponseInnerPath.md)> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## tui_clear_prompt + +> bool tui_clear_prompt(directory) +Clear TUI prompt + +Clear the prompt + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## tui_control_next + +> models::TuiControlNext200Response tui_control_next(directory) +Get next TUI request + +Retrieve the next TUI (Terminal User Interface) request from the queue for processing. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**models::TuiControlNext200Response**](tui_control_next_200_response.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## tui_control_response + +> bool tui_control_response(directory, body) +Submit TUI response + +Submit a response to the TUI request queue to complete a pending request. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | +**body** | Option<**serde_json::Value**> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## tui_execute_command + +> bool tui_execute_command(directory, tui_execute_command_request) +Execute TUI command + +Execute a TUI command (e.g. agent_cycle) + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | +**tui_execute_command_request** | Option<[**TuiExecuteCommandRequest**](TuiExecuteCommandRequest.md)> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## tui_open_help + +> bool tui_open_help(directory) +Open help dialog + +Open the help dialog in the TUI to display user assistance information. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## tui_open_models + +> bool tui_open_models(directory) +Open models dialog + +Open the model dialog + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## tui_open_sessions + +> bool tui_open_sessions(directory) +Open sessions dialog + +Open the session dialog + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## tui_open_themes + +> bool tui_open_themes(directory) +Open themes dialog + +Open the theme dialog + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## tui_publish + +> bool tui_publish(directory, tui_publish_request) +Publish TUI event + +Publish a TUI event + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | +**tui_publish_request** | Option<[**TuiPublishRequest**](TuiPublishRequest.md)> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## tui_show_toast + +> bool tui_show_toast(directory, tui_show_toast_request) +Show TUI toast + +Show a toast notification in the TUI + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | +**tui_show_toast_request** | Option<[**TuiShowToastRequest**](TuiShowToastRequest.md)> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: application/json +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## tui_submit_prompt + +> bool tui_submit_prompt(directory) +Submit TUI prompt + +Submit the prompt + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +**bool** + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## vcs_get + +> models::VcsInfo vcs_get(directory) +Get VCS info + +Retrieve version control system (VCS) information for the current project, such as git branch. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**directory** | Option<**String**> | | | + +### Return type + +[**models::VcsInfo**](VcsInfo.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + diff --git a/crates/opencode-client/generated/docs/Event.md b/crates/opencode-client/generated/docs/Event.md new file mode 100644 index 0000000..edbdd44 --- /dev/null +++ b/crates/opencode-client/generated/docs/Event.md @@ -0,0 +1,12 @@ +# Event + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**serde_json::Value**](.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventCommandExecuted.md b/crates/opencode-client/generated/docs/EventCommandExecuted.md new file mode 100644 index 0000000..b7fe606 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventCommandExecuted.md @@ -0,0 +1,12 @@ +# EventCommandExecuted + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventCommandExecutedProperties**](Event_command_executed_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventCommandExecutedProperties.md b/crates/opencode-client/generated/docs/EventCommandExecutedProperties.md new file mode 100644 index 0000000..5a70c62 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventCommandExecutedProperties.md @@ -0,0 +1,14 @@ +# EventCommandExecutedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**name** | **String** | | +**session_id** | **String** | | +**arguments** | **String** | | +**message_id** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventFileEdited.md b/crates/opencode-client/generated/docs/EventFileEdited.md new file mode 100644 index 0000000..1bafccf --- /dev/null +++ b/crates/opencode-client/generated/docs/EventFileEdited.md @@ -0,0 +1,12 @@ +# EventFileEdited + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventFileEditedProperties**](Event_file_edited_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventFileEditedProperties.md b/crates/opencode-client/generated/docs/EventFileEditedProperties.md new file mode 100644 index 0000000..c9d9ebf --- /dev/null +++ b/crates/opencode-client/generated/docs/EventFileEditedProperties.md @@ -0,0 +1,11 @@ +# EventFileEditedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**file** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventFileWatcherUpdated.md b/crates/opencode-client/generated/docs/EventFileWatcherUpdated.md new file mode 100644 index 0000000..a35760e --- /dev/null +++ b/crates/opencode-client/generated/docs/EventFileWatcherUpdated.md @@ -0,0 +1,12 @@ +# EventFileWatcherUpdated + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventFileWatcherUpdatedProperties**](Event_file_watcher_updated_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventFileWatcherUpdatedProperties.md b/crates/opencode-client/generated/docs/EventFileWatcherUpdatedProperties.md new file mode 100644 index 0000000..ef86266 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventFileWatcherUpdatedProperties.md @@ -0,0 +1,12 @@ +# EventFileWatcherUpdatedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**file** | **String** | | +**event** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventGlobalDisposed.md b/crates/opencode-client/generated/docs/EventGlobalDisposed.md new file mode 100644 index 0000000..b5c5147 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventGlobalDisposed.md @@ -0,0 +1,12 @@ +# EventGlobalDisposed + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**serde_json::Value**](.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventInstallationUpdateAvailable.md b/crates/opencode-client/generated/docs/EventInstallationUpdateAvailable.md new file mode 100644 index 0000000..3dc8a13 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventInstallationUpdateAvailable.md @@ -0,0 +1,12 @@ +# EventInstallationUpdateAvailable + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventInstallationUpdatedProperties**](Event_installation_updated_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventInstallationUpdated.md b/crates/opencode-client/generated/docs/EventInstallationUpdated.md new file mode 100644 index 0000000..496a99a --- /dev/null +++ b/crates/opencode-client/generated/docs/EventInstallationUpdated.md @@ -0,0 +1,12 @@ +# EventInstallationUpdated + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventInstallationUpdatedProperties**](Event_installation_updated_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventInstallationUpdatedProperties.md b/crates/opencode-client/generated/docs/EventInstallationUpdatedProperties.md new file mode 100644 index 0000000..e0c0f1b --- /dev/null +++ b/crates/opencode-client/generated/docs/EventInstallationUpdatedProperties.md @@ -0,0 +1,11 @@ +# EventInstallationUpdatedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**version** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventLspClientDiagnostics.md b/crates/opencode-client/generated/docs/EventLspClientDiagnostics.md new file mode 100644 index 0000000..6a7146a --- /dev/null +++ b/crates/opencode-client/generated/docs/EventLspClientDiagnostics.md @@ -0,0 +1,12 @@ +# EventLspClientDiagnostics + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventLspClientDiagnosticsProperties**](Event_lsp_client_diagnostics_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventLspClientDiagnosticsProperties.md b/crates/opencode-client/generated/docs/EventLspClientDiagnosticsProperties.md new file mode 100644 index 0000000..37526c8 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventLspClientDiagnosticsProperties.md @@ -0,0 +1,12 @@ +# EventLspClientDiagnosticsProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**server_id** | **String** | | +**path** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventLspUpdated.md b/crates/opencode-client/generated/docs/EventLspUpdated.md new file mode 100644 index 0000000..aa186ce --- /dev/null +++ b/crates/opencode-client/generated/docs/EventLspUpdated.md @@ -0,0 +1,12 @@ +# EventLspUpdated + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**serde_json::Value**](.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventMcpToolsChanged.md b/crates/opencode-client/generated/docs/EventMcpToolsChanged.md new file mode 100644 index 0000000..44a7e0c --- /dev/null +++ b/crates/opencode-client/generated/docs/EventMcpToolsChanged.md @@ -0,0 +1,12 @@ +# EventMcpToolsChanged + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventMcpToolsChangedProperties**](Event_mcp_tools_changed_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventMcpToolsChangedProperties.md b/crates/opencode-client/generated/docs/EventMcpToolsChangedProperties.md new file mode 100644 index 0000000..a860247 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventMcpToolsChangedProperties.md @@ -0,0 +1,11 @@ +# EventMcpToolsChangedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**server** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventMessagePartRemoved.md b/crates/opencode-client/generated/docs/EventMessagePartRemoved.md new file mode 100644 index 0000000..58a16cd --- /dev/null +++ b/crates/opencode-client/generated/docs/EventMessagePartRemoved.md @@ -0,0 +1,12 @@ +# EventMessagePartRemoved + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventMessagePartRemovedProperties**](Event_message_part_removed_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventMessagePartRemovedProperties.md b/crates/opencode-client/generated/docs/EventMessagePartRemovedProperties.md new file mode 100644 index 0000000..f010720 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventMessagePartRemovedProperties.md @@ -0,0 +1,13 @@ +# EventMessagePartRemovedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**session_id** | **String** | | +**message_id** | **String** | | +**part_id** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventMessagePartUpdated.md b/crates/opencode-client/generated/docs/EventMessagePartUpdated.md new file mode 100644 index 0000000..c92221d --- /dev/null +++ b/crates/opencode-client/generated/docs/EventMessagePartUpdated.md @@ -0,0 +1,12 @@ +# EventMessagePartUpdated + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventMessagePartUpdatedProperties**](Event_message_part_updated_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventMessagePartUpdatedProperties.md b/crates/opencode-client/generated/docs/EventMessagePartUpdatedProperties.md new file mode 100644 index 0000000..e536d41 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventMessagePartUpdatedProperties.md @@ -0,0 +1,12 @@ +# EventMessagePartUpdatedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**part** | [**models::Part**](Part.md) | | +**delta** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventMessageRemoved.md b/crates/opencode-client/generated/docs/EventMessageRemoved.md new file mode 100644 index 0000000..02e4f46 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventMessageRemoved.md @@ -0,0 +1,12 @@ +# EventMessageRemoved + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventMessageRemovedProperties**](Event_message_removed_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventMessageRemovedProperties.md b/crates/opencode-client/generated/docs/EventMessageRemovedProperties.md new file mode 100644 index 0000000..0f8032a --- /dev/null +++ b/crates/opencode-client/generated/docs/EventMessageRemovedProperties.md @@ -0,0 +1,12 @@ +# EventMessageRemovedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**session_id** | **String** | | +**message_id** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventMessageUpdated.md b/crates/opencode-client/generated/docs/EventMessageUpdated.md new file mode 100644 index 0000000..bd3245f --- /dev/null +++ b/crates/opencode-client/generated/docs/EventMessageUpdated.md @@ -0,0 +1,12 @@ +# EventMessageUpdated + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventMessageUpdatedProperties**](Event_message_updated_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventMessageUpdatedProperties.md b/crates/opencode-client/generated/docs/EventMessageUpdatedProperties.md new file mode 100644 index 0000000..b4322ce --- /dev/null +++ b/crates/opencode-client/generated/docs/EventMessageUpdatedProperties.md @@ -0,0 +1,11 @@ +# EventMessageUpdatedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**info** | [**models::Message**](Message.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventPermissionReplied.md b/crates/opencode-client/generated/docs/EventPermissionReplied.md new file mode 100644 index 0000000..e08e427 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventPermissionReplied.md @@ -0,0 +1,12 @@ +# EventPermissionReplied + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventPermissionRepliedProperties**](Event_permission_replied_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventPermissionRepliedProperties.md b/crates/opencode-client/generated/docs/EventPermissionRepliedProperties.md new file mode 100644 index 0000000..da6ed9c --- /dev/null +++ b/crates/opencode-client/generated/docs/EventPermissionRepliedProperties.md @@ -0,0 +1,13 @@ +# EventPermissionRepliedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**session_id** | **String** | | +**permission_id** | **String** | | +**response** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventPermissionUpdated.md b/crates/opencode-client/generated/docs/EventPermissionUpdated.md new file mode 100644 index 0000000..7ea0cb5 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventPermissionUpdated.md @@ -0,0 +1,12 @@ +# EventPermissionUpdated + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::Permission**](Permission.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventProjectUpdated.md b/crates/opencode-client/generated/docs/EventProjectUpdated.md new file mode 100644 index 0000000..427e7e8 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventProjectUpdated.md @@ -0,0 +1,12 @@ +# EventProjectUpdated + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::Project**](Project.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventPtyCreated.md b/crates/opencode-client/generated/docs/EventPtyCreated.md new file mode 100644 index 0000000..2736b8d --- /dev/null +++ b/crates/opencode-client/generated/docs/EventPtyCreated.md @@ -0,0 +1,12 @@ +# EventPtyCreated + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventPtyCreatedProperties**](Event_pty_created_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventPtyCreatedProperties.md b/crates/opencode-client/generated/docs/EventPtyCreatedProperties.md new file mode 100644 index 0000000..4882216 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventPtyCreatedProperties.md @@ -0,0 +1,11 @@ +# EventPtyCreatedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**info** | [**models::Pty**](Pty.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventPtyDeleted.md b/crates/opencode-client/generated/docs/EventPtyDeleted.md new file mode 100644 index 0000000..cf0f07e --- /dev/null +++ b/crates/opencode-client/generated/docs/EventPtyDeleted.md @@ -0,0 +1,12 @@ +# EventPtyDeleted + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventPtyDeletedProperties**](Event_pty_deleted_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventPtyDeletedProperties.md b/crates/opencode-client/generated/docs/EventPtyDeletedProperties.md new file mode 100644 index 0000000..975e3db --- /dev/null +++ b/crates/opencode-client/generated/docs/EventPtyDeletedProperties.md @@ -0,0 +1,11 @@ +# EventPtyDeletedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventPtyExited.md b/crates/opencode-client/generated/docs/EventPtyExited.md new file mode 100644 index 0000000..2d120f7 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventPtyExited.md @@ -0,0 +1,12 @@ +# EventPtyExited + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventPtyExitedProperties**](Event_pty_exited_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventPtyExitedProperties.md b/crates/opencode-client/generated/docs/EventPtyExitedProperties.md new file mode 100644 index 0000000..b5e9866 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventPtyExitedProperties.md @@ -0,0 +1,12 @@ +# EventPtyExitedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**exit_code** | **f64** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventPtyUpdated.md b/crates/opencode-client/generated/docs/EventPtyUpdated.md new file mode 100644 index 0000000..9311031 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventPtyUpdated.md @@ -0,0 +1,12 @@ +# EventPtyUpdated + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventPtyCreatedProperties**](Event_pty_created_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventServerConnected.md b/crates/opencode-client/generated/docs/EventServerConnected.md new file mode 100644 index 0000000..cb4db56 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventServerConnected.md @@ -0,0 +1,12 @@ +# EventServerConnected + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**serde_json::Value**](.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventServerInstanceDisposed.md b/crates/opencode-client/generated/docs/EventServerInstanceDisposed.md new file mode 100644 index 0000000..fa082a0 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventServerInstanceDisposed.md @@ -0,0 +1,12 @@ +# EventServerInstanceDisposed + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventServerInstanceDisposedProperties**](Event_server_instance_disposed_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventServerInstanceDisposedProperties.md b/crates/opencode-client/generated/docs/EventServerInstanceDisposedProperties.md new file mode 100644 index 0000000..16b096e --- /dev/null +++ b/crates/opencode-client/generated/docs/EventServerInstanceDisposedProperties.md @@ -0,0 +1,11 @@ +# EventServerInstanceDisposedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**directory** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventSessionCompacted.md b/crates/opencode-client/generated/docs/EventSessionCompacted.md new file mode 100644 index 0000000..7126f3a --- /dev/null +++ b/crates/opencode-client/generated/docs/EventSessionCompacted.md @@ -0,0 +1,12 @@ +# EventSessionCompacted + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventSessionIdleProperties**](Event_session_idle_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventSessionCreated.md b/crates/opencode-client/generated/docs/EventSessionCreated.md new file mode 100644 index 0000000..85410fb --- /dev/null +++ b/crates/opencode-client/generated/docs/EventSessionCreated.md @@ -0,0 +1,12 @@ +# EventSessionCreated + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventSessionCreatedProperties**](Event_session_created_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventSessionCreatedProperties.md b/crates/opencode-client/generated/docs/EventSessionCreatedProperties.md new file mode 100644 index 0000000..35fab66 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventSessionCreatedProperties.md @@ -0,0 +1,11 @@ +# EventSessionCreatedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**info** | [**models::Session**](Session.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventSessionDeleted.md b/crates/opencode-client/generated/docs/EventSessionDeleted.md new file mode 100644 index 0000000..103c457 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventSessionDeleted.md @@ -0,0 +1,12 @@ +# EventSessionDeleted + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventSessionCreatedProperties**](Event_session_created_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventSessionDiff.md b/crates/opencode-client/generated/docs/EventSessionDiff.md new file mode 100644 index 0000000..f7557b0 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventSessionDiff.md @@ -0,0 +1,12 @@ +# EventSessionDiff + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventSessionDiffProperties**](Event_session_diff_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventSessionDiffProperties.md b/crates/opencode-client/generated/docs/EventSessionDiffProperties.md new file mode 100644 index 0000000..f12a2cd --- /dev/null +++ b/crates/opencode-client/generated/docs/EventSessionDiffProperties.md @@ -0,0 +1,12 @@ +# EventSessionDiffProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**session_id** | **String** | | +**diff** | [**Vec**](FileDiff.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventSessionError.md b/crates/opencode-client/generated/docs/EventSessionError.md new file mode 100644 index 0000000..b95d84a --- /dev/null +++ b/crates/opencode-client/generated/docs/EventSessionError.md @@ -0,0 +1,12 @@ +# EventSessionError + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventSessionErrorProperties**](Event_session_error_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventSessionErrorProperties.md b/crates/opencode-client/generated/docs/EventSessionErrorProperties.md new file mode 100644 index 0000000..27047b3 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventSessionErrorProperties.md @@ -0,0 +1,12 @@ +# EventSessionErrorProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**session_id** | Option<**String**> | | [optional] +**error** | Option<[**models::AssistantMessageError**](AssistantMessage_error.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventSessionIdle.md b/crates/opencode-client/generated/docs/EventSessionIdle.md new file mode 100644 index 0000000..5a7f7f8 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventSessionIdle.md @@ -0,0 +1,12 @@ +# EventSessionIdle + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventSessionIdleProperties**](Event_session_idle_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventSessionIdleProperties.md b/crates/opencode-client/generated/docs/EventSessionIdleProperties.md new file mode 100644 index 0000000..42618a4 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventSessionIdleProperties.md @@ -0,0 +1,11 @@ +# EventSessionIdleProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**session_id** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventSessionStatus.md b/crates/opencode-client/generated/docs/EventSessionStatus.md new file mode 100644 index 0000000..a90e36e --- /dev/null +++ b/crates/opencode-client/generated/docs/EventSessionStatus.md @@ -0,0 +1,12 @@ +# EventSessionStatus + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventSessionStatusProperties**](Event_session_status_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventSessionStatusProperties.md b/crates/opencode-client/generated/docs/EventSessionStatusProperties.md new file mode 100644 index 0000000..f23abc9 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventSessionStatusProperties.md @@ -0,0 +1,12 @@ +# EventSessionStatusProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**session_id** | **String** | | +**status** | [**models::SessionStatus**](SessionStatus.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventSessionUpdated.md b/crates/opencode-client/generated/docs/EventSessionUpdated.md new file mode 100644 index 0000000..53ee731 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventSessionUpdated.md @@ -0,0 +1,12 @@ +# EventSessionUpdated + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventSessionCreatedProperties**](Event_session_created_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventTodoUpdated.md b/crates/opencode-client/generated/docs/EventTodoUpdated.md new file mode 100644 index 0000000..7cb3900 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventTodoUpdated.md @@ -0,0 +1,12 @@ +# EventTodoUpdated + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventTodoUpdatedProperties**](Event_todo_updated_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventTodoUpdatedProperties.md b/crates/opencode-client/generated/docs/EventTodoUpdatedProperties.md new file mode 100644 index 0000000..a06acdd --- /dev/null +++ b/crates/opencode-client/generated/docs/EventTodoUpdatedProperties.md @@ -0,0 +1,12 @@ +# EventTodoUpdatedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**session_id** | **String** | | +**todos** | [**Vec**](Todo.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventTuiCommandExecute.md b/crates/opencode-client/generated/docs/EventTuiCommandExecute.md new file mode 100644 index 0000000..f0e4eab --- /dev/null +++ b/crates/opencode-client/generated/docs/EventTuiCommandExecute.md @@ -0,0 +1,12 @@ +# EventTuiCommandExecute + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventTuiCommandExecuteProperties**](Event_tui_command_execute_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventTuiCommandExecuteProperties.md b/crates/opencode-client/generated/docs/EventTuiCommandExecuteProperties.md new file mode 100644 index 0000000..0d9211e --- /dev/null +++ b/crates/opencode-client/generated/docs/EventTuiCommandExecuteProperties.md @@ -0,0 +1,11 @@ +# EventTuiCommandExecuteProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**command** | [**models::EventTuiCommandExecutePropertiesCommand**](Event_tui_command_execute_properties_command.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventTuiCommandExecutePropertiesCommand.md b/crates/opencode-client/generated/docs/EventTuiCommandExecutePropertiesCommand.md new file mode 100644 index 0000000..3f39671 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventTuiCommandExecutePropertiesCommand.md @@ -0,0 +1,10 @@ +# EventTuiCommandExecutePropertiesCommand + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventTuiPromptAppend.md b/crates/opencode-client/generated/docs/EventTuiPromptAppend.md new file mode 100644 index 0000000..5737af9 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventTuiPromptAppend.md @@ -0,0 +1,12 @@ +# EventTuiPromptAppend + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::FindText200ResponseInnerPath**](find_text_200_response_inner_path.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventTuiToastShow.md b/crates/opencode-client/generated/docs/EventTuiToastShow.md new file mode 100644 index 0000000..fc90f11 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventTuiToastShow.md @@ -0,0 +1,12 @@ +# EventTuiToastShow + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::TuiShowToastRequest**](tui_showToast_request.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventVcsBranchUpdated.md b/crates/opencode-client/generated/docs/EventVcsBranchUpdated.md new file mode 100644 index 0000000..49fb255 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventVcsBranchUpdated.md @@ -0,0 +1,12 @@ +# EventVcsBranchUpdated + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::EventVcsBranchUpdatedProperties**](Event_vcs_branch_updated_properties.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/EventVcsBranchUpdatedProperties.md b/crates/opencode-client/generated/docs/EventVcsBranchUpdatedProperties.md new file mode 100644 index 0000000..c9dae13 --- /dev/null +++ b/crates/opencode-client/generated/docs/EventVcsBranchUpdatedProperties.md @@ -0,0 +1,11 @@ +# EventVcsBranchUpdatedProperties + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**branch** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/File.md b/crates/opencode-client/generated/docs/File.md new file mode 100644 index 0000000..f7bd428 --- /dev/null +++ b/crates/opencode-client/generated/docs/File.md @@ -0,0 +1,14 @@ +# File + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**path** | **String** | | +**added** | **i32** | | +**removed** | **i32** | | +**status** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/FileContent.md b/crates/opencode-client/generated/docs/FileContent.md new file mode 100644 index 0000000..9e7eb7b --- /dev/null +++ b/crates/opencode-client/generated/docs/FileContent.md @@ -0,0 +1,16 @@ +# FileContent + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**content** | **String** | | +**diff** | Option<**String**> | | [optional] +**patch** | Option<[**models::FileContentPatch**](FileContent_patch.md)> | | [optional] +**encoding** | Option<**String**> | | [optional] +**mime_type** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/FileContentPatch.md b/crates/opencode-client/generated/docs/FileContentPatch.md new file mode 100644 index 0000000..6d64b52 --- /dev/null +++ b/crates/opencode-client/generated/docs/FileContentPatch.md @@ -0,0 +1,16 @@ +# FileContentPatch + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**old_file_name** | **String** | | +**new_file_name** | **String** | | +**old_header** | Option<**String**> | | [optional] +**new_header** | Option<**String**> | | [optional] +**hunks** | [**Vec**](FileContent_patch_hunks_inner.md) | | +**index** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/FileContentPatchHunksInner.md b/crates/opencode-client/generated/docs/FileContentPatchHunksInner.md new file mode 100644 index 0000000..e3f9dda --- /dev/null +++ b/crates/opencode-client/generated/docs/FileContentPatchHunksInner.md @@ -0,0 +1,15 @@ +# FileContentPatchHunksInner + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**old_start** | **f64** | | +**old_lines** | **f64** | | +**new_start** | **f64** | | +**new_lines** | **f64** | | +**lines** | **Vec** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/FileDiff.md b/crates/opencode-client/generated/docs/FileDiff.md new file mode 100644 index 0000000..4b99ff1 --- /dev/null +++ b/crates/opencode-client/generated/docs/FileDiff.md @@ -0,0 +1,15 @@ +# FileDiff + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**file** | **String** | | +**before** | **String** | | +**after** | **String** | | +**additions** | **f64** | | +**deletions** | **f64** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/FileNode.md b/crates/opencode-client/generated/docs/FileNode.md new file mode 100644 index 0000000..2f55fe1 --- /dev/null +++ b/crates/opencode-client/generated/docs/FileNode.md @@ -0,0 +1,15 @@ +# FileNode + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**name** | **String** | | +**path** | **String** | | +**absolute** | **String** | | +**r#type** | **String** | | +**ignored** | **bool** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/FilePart.md b/crates/opencode-client/generated/docs/FilePart.md new file mode 100644 index 0000000..082bec1 --- /dev/null +++ b/crates/opencode-client/generated/docs/FilePart.md @@ -0,0 +1,18 @@ +# FilePart + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**session_id** | **String** | | +**message_id** | **String** | | +**r#type** | **String** | | +**mime** | **String** | | +**filename** | Option<**String**> | | [optional] +**url** | **String** | | +**source** | Option<[**models::FilePartSource**](FilePartSource.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/FilePartInput.md b/crates/opencode-client/generated/docs/FilePartInput.md new file mode 100644 index 0000000..04dca4f --- /dev/null +++ b/crates/opencode-client/generated/docs/FilePartInput.md @@ -0,0 +1,16 @@ +# FilePartInput + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | Option<**String**> | | [optional] +**r#type** | **String** | | +**mime** | **String** | | +**filename** | Option<**String**> | | [optional] +**url** | **String** | | +**source** | Option<[**models::FilePartSource**](FilePartSource.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/FilePartSource.md b/crates/opencode-client/generated/docs/FilePartSource.md new file mode 100644 index 0000000..5132744 --- /dev/null +++ b/crates/opencode-client/generated/docs/FilePartSource.md @@ -0,0 +1,16 @@ +# FilePartSource + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**text** | [**models::FilePartSourceText**](FilePartSourceText.md) | | +**r#type** | **String** | | +**path** | **String** | | +**range** | [**models::Range**](Range.md) | | +**name** | **String** | | +**kind** | **i32** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/FilePartSourceText.md b/crates/opencode-client/generated/docs/FilePartSourceText.md new file mode 100644 index 0000000..ced4460 --- /dev/null +++ b/crates/opencode-client/generated/docs/FilePartSourceText.md @@ -0,0 +1,13 @@ +# FilePartSourceText + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**value** | **String** | | +**start** | **i32** | | +**end** | **i32** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/FileSource.md b/crates/opencode-client/generated/docs/FileSource.md new file mode 100644 index 0000000..1bb3b8d --- /dev/null +++ b/crates/opencode-client/generated/docs/FileSource.md @@ -0,0 +1,13 @@ +# FileSource + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**text** | [**models::FilePartSourceText**](FilePartSourceText.md) | | +**r#type** | **String** | | +**path** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/FindText200ResponseInner.md b/crates/opencode-client/generated/docs/FindText200ResponseInner.md new file mode 100644 index 0000000..7b14b60 --- /dev/null +++ b/crates/opencode-client/generated/docs/FindText200ResponseInner.md @@ -0,0 +1,15 @@ +# FindText200ResponseInner + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**path** | [**models::FindText200ResponseInnerPath**](find_text_200_response_inner_path.md) | | +**lines** | [**models::FindText200ResponseInnerPath**](find_text_200_response_inner_path.md) | | +**line_number** | **f64** | | +**absolute_offset** | **f64** | | +**submatches** | [**Vec**](find_text_200_response_inner_submatches_inner.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/FindText200ResponseInnerPath.md b/crates/opencode-client/generated/docs/FindText200ResponseInnerPath.md new file mode 100644 index 0000000..e598e78 --- /dev/null +++ b/crates/opencode-client/generated/docs/FindText200ResponseInnerPath.md @@ -0,0 +1,11 @@ +# FindText200ResponseInnerPath + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**text** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/FindText200ResponseInnerSubmatchesInner.md b/crates/opencode-client/generated/docs/FindText200ResponseInnerSubmatchesInner.md new file mode 100644 index 0000000..d510cef --- /dev/null +++ b/crates/opencode-client/generated/docs/FindText200ResponseInnerSubmatchesInner.md @@ -0,0 +1,13 @@ +# FindText200ResponseInnerSubmatchesInner + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#match** | [**models::FindText200ResponseInnerPath**](find_text_200_response_inner_path.md) | | +**start** | **f64** | | +**end** | **f64** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/FormatterStatus.md b/crates/opencode-client/generated/docs/FormatterStatus.md new file mode 100644 index 0000000..d8e7861 --- /dev/null +++ b/crates/opencode-client/generated/docs/FormatterStatus.md @@ -0,0 +1,13 @@ +# FormatterStatus + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**name** | **String** | | +**extensions** | **Vec** | | +**enabled** | **bool** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/GlobalEvent.md b/crates/opencode-client/generated/docs/GlobalEvent.md new file mode 100644 index 0000000..d4ea35c --- /dev/null +++ b/crates/opencode-client/generated/docs/GlobalEvent.md @@ -0,0 +1,12 @@ +# GlobalEvent + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**directory** | **String** | | +**payload** | [**models::Event**](Event.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/GlobalHealth200Response.md b/crates/opencode-client/generated/docs/GlobalHealth200Response.md new file mode 100644 index 0000000..a33088c --- /dev/null +++ b/crates/opencode-client/generated/docs/GlobalHealth200Response.md @@ -0,0 +1,12 @@ +# GlobalHealth200Response + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**healthy** | **bool** | | +**version** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/KeybindsConfig.md b/crates/opencode-client/generated/docs/KeybindsConfig.md new file mode 100644 index 0000000..e737158 --- /dev/null +++ b/crates/opencode-client/generated/docs/KeybindsConfig.md @@ -0,0 +1,97 @@ +# KeybindsConfig + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**leader** | Option<**String**> | Leader key for keybind combinations | [optional][default to ctrl+x] +**app_exit** | Option<**String**> | Exit the application | [optional][default to ctrl+c,ctrl+d,q] +**editor_open** | Option<**String**> | Open external editor | [optional][default to e] +**theme_list** | Option<**String**> | List available themes | [optional][default to t] +**sidebar_toggle** | Option<**String**> | Toggle sidebar | [optional][default to b] +**scrollbar_toggle** | Option<**String**> | Toggle session scrollbar | [optional][default to none] +**username_toggle** | Option<**String**> | Toggle username visibility | [optional][default to none] +**status_view** | Option<**String**> | View status | [optional][default to s] +**session_export** | Option<**String**> | Export session to editor | [optional][default to x] +**session_new** | Option<**String**> | Create a new session | [optional][default to n] +**session_list** | Option<**String**> | List all sessions | [optional][default to l] +**session_timeline** | Option<**String**> | Show session timeline | [optional][default to g] +**session_fork** | Option<**String**> | Fork session from message | [optional][default to none] +**session_rename** | Option<**String**> | Rename session | [optional][default to none] +**session_share** | Option<**String**> | Share current session | [optional][default to none] +**session_unshare** | Option<**String**> | Unshare current session | [optional][default to none] +**session_interrupt** | Option<**String**> | Interrupt current session | [optional][default to escape] +**session_compact** | Option<**String**> | Compact the session | [optional][default to c] +**messages_page_up** | Option<**String**> | Scroll messages up by one page | [optional][default to pageup] +**messages_page_down** | Option<**String**> | Scroll messages down by one page | [optional][default to pagedown] +**messages_half_page_up** | Option<**String**> | Scroll messages up by half page | [optional][default to ctrl+alt+u] +**messages_half_page_down** | Option<**String**> | Scroll messages down by half page | [optional][default to ctrl+alt+d] +**messages_first** | Option<**String**> | Navigate to first message | [optional][default to ctrl+g,home] +**messages_last** | Option<**String**> | Navigate to last message | [optional][default to ctrl+alt+g,end] +**messages_next** | Option<**String**> | Navigate to next message | [optional][default to none] +**messages_previous** | Option<**String**> | Navigate to previous message | [optional][default to none] +**messages_last_user** | Option<**String**> | Navigate to last user message | [optional][default to none] +**messages_copy** | Option<**String**> | Copy message | [optional][default to y] +**messages_undo** | Option<**String**> | Undo message | [optional][default to u] +**messages_redo** | Option<**String**> | Redo message | [optional][default to r] +**messages_toggle_conceal** | Option<**String**> | Toggle code block concealment in messages | [optional][default to h] +**tool_details** | Option<**String**> | Toggle tool details visibility | [optional][default to none] +**model_list** | Option<**String**> | List available models | [optional][default to m] +**model_cycle_recent** | Option<**String**> | Next recently used model | [optional][default to f2] +**model_cycle_recent_reverse** | Option<**String**> | Previous recently used model | [optional][default to shift+f2] +**model_cycle_favorite** | Option<**String**> | Next favorite model | [optional][default to none] +**model_cycle_favorite_reverse** | Option<**String**> | Previous favorite model | [optional][default to none] +**command_list** | Option<**String**> | List available commands | [optional][default to ctrl+p] +**agent_list** | Option<**String**> | List agents | [optional][default to a] +**agent_cycle** | Option<**String**> | Next agent | [optional][default to tab] +**agent_cycle_reverse** | Option<**String**> | Previous agent | [optional][default to shift+tab] +**variant_cycle** | Option<**String**> | Cycle model variants | [optional][default to ctrl+t] +**input_clear** | Option<**String**> | Clear input field | [optional][default to ctrl+c] +**input_paste** | Option<**String**> | Paste from clipboard | [optional][default to ctrl+v] +**input_submit** | Option<**String**> | Submit input | [optional][default to return] +**input_newline** | Option<**String**> | Insert newline in input | [optional][default to shift+return,ctrl+return,alt+return,ctrl+j] +**input_move_left** | Option<**String**> | Move cursor left in input | [optional][default to left,ctrl+b] +**input_move_right** | Option<**String**> | Move cursor right in input | [optional][default to right,ctrl+f] +**input_move_up** | Option<**String**> | Move cursor up in input | [optional][default to up] +**input_move_down** | Option<**String**> | Move cursor down in input | [optional][default to down] +**input_select_left** | Option<**String**> | Select left in input | [optional][default to shift+left] +**input_select_right** | Option<**String**> | Select right in input | [optional][default to shift+right] +**input_select_up** | Option<**String**> | Select up in input | [optional][default to shift+up] +**input_select_down** | Option<**String**> | Select down in input | [optional][default to shift+down] +**input_line_home** | Option<**String**> | Move to start of line in input | [optional][default to ctrl+a] +**input_line_end** | Option<**String**> | Move to end of line in input | [optional][default to ctrl+e] +**input_select_line_home** | Option<**String**> | Select to start of line in input | [optional][default to ctrl+shift+a] +**input_select_line_end** | Option<**String**> | Select to end of line in input | [optional][default to ctrl+shift+e] +**input_visual_line_home** | Option<**String**> | Move to start of visual line in input | [optional][default to alt+a] +**input_visual_line_end** | Option<**String**> | Move to end of visual line in input | [optional][default to alt+e] +**input_select_visual_line_home** | Option<**String**> | Select to start of visual line in input | [optional][default to alt+shift+a] +**input_select_visual_line_end** | Option<**String**> | Select to end of visual line in input | [optional][default to alt+shift+e] +**input_buffer_home** | Option<**String**> | Move to start of buffer in input | [optional][default to home] +**input_buffer_end** | Option<**String**> | Move to end of buffer in input | [optional][default to end] +**input_select_buffer_home** | Option<**String**> | Select to start of buffer in input | [optional][default to shift+home] +**input_select_buffer_end** | Option<**String**> | Select to end of buffer in input | [optional][default to shift+end] +**input_delete_line** | Option<**String**> | Delete line in input | [optional][default to ctrl+shift+d] +**input_delete_to_line_end** | Option<**String**> | Delete to end of line in input | [optional][default to ctrl+k] +**input_delete_to_line_start** | Option<**String**> | Delete to start of line in input | [optional][default to ctrl+u] +**input_backspace** | Option<**String**> | Backspace in input | [optional][default to backspace,shift+backspace] +**input_delete** | Option<**String**> | Delete character in input | [optional][default to ctrl+d,delete,shift+delete] +**input_undo** | Option<**String**> | Undo in input | [optional][default to ctrl+-,super+z] +**input_redo** | Option<**String**> | Redo in input | [optional][default to ctrl+.,super+shift+z] +**input_word_forward** | Option<**String**> | Move word forward in input | [optional][default to alt+f,alt+right,ctrl+right] +**input_word_backward** | Option<**String**> | Move word backward in input | [optional][default to alt+b,alt+left,ctrl+left] +**input_select_word_forward** | Option<**String**> | Select word forward in input | [optional][default to alt+shift+f,alt+shift+right] +**input_select_word_backward** | Option<**String**> | Select word backward in input | [optional][default to alt+shift+b,alt+shift+left] +**input_delete_word_forward** | Option<**String**> | Delete word forward in input | [optional][default to alt+d,alt+delete,ctrl+delete] +**input_delete_word_backward** | Option<**String**> | Delete word backward in input | [optional][default to ctrl+w,ctrl+backspace,alt+backspace] +**history_previous** | Option<**String**> | Previous history item | [optional][default to up] +**history_next** | Option<**String**> | Next history item | [optional][default to down] +**session_child_cycle** | Option<**String**> | Next child session | [optional][default to right] +**session_child_cycle_reverse** | Option<**String**> | Previous child session | [optional][default to left] +**session_parent** | Option<**String**> | Go to parent session | [optional][default to up] +**terminal_suspend** | Option<**String**> | Suspend terminal | [optional][default to ctrl+z] +**terminal_title_toggle** | Option<**String**> | Toggle terminal title | [optional][default to none] +**tips_toggle** | Option<**String**> | Toggle tips on home screen | [optional][default to h] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/LayoutConfig.md b/crates/opencode-client/generated/docs/LayoutConfig.md new file mode 100644 index 0000000..988c5a1 --- /dev/null +++ b/crates/opencode-client/generated/docs/LayoutConfig.md @@ -0,0 +1,13 @@ +# LayoutConfig + +## Enum Variants + +| Name | Value | +|---- | -----| +| Auto | auto | +| Stretch | stretch | + + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/LogLevel.md b/crates/opencode-client/generated/docs/LogLevel.md new file mode 100644 index 0000000..33708e0 --- /dev/null +++ b/crates/opencode-client/generated/docs/LogLevel.md @@ -0,0 +1,15 @@ +# LogLevel + +## Enum Variants + +| Name | Value | +|---- | -----| +| Debug | DEBUG | +| Info | INFO | +| Warn | WARN | +| Error | ERROR | + + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/LspStatus.md b/crates/opencode-client/generated/docs/LspStatus.md new file mode 100644 index 0000000..3bbd4c5 --- /dev/null +++ b/crates/opencode-client/generated/docs/LspStatus.md @@ -0,0 +1,14 @@ +# LspStatus + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**name** | **String** | | +**root** | **String** | | +**status** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/McpAddRequest.md b/crates/opencode-client/generated/docs/McpAddRequest.md new file mode 100644 index 0000000..2a76b8d --- /dev/null +++ b/crates/opencode-client/generated/docs/McpAddRequest.md @@ -0,0 +1,12 @@ +# McpAddRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**name** | **String** | | +**config** | [**models::McpAddRequestConfig**](mcp_add_request_config.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/McpAddRequestConfig.md b/crates/opencode-client/generated/docs/McpAddRequestConfig.md new file mode 100644 index 0000000..9f6d974 --- /dev/null +++ b/crates/opencode-client/generated/docs/McpAddRequestConfig.md @@ -0,0 +1,18 @@ +# McpAddRequestConfig + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | Type of MCP server connection | +**command** | **Vec** | Command and arguments to run the MCP server | +**environment** | Option<**std::collections::HashMap**> | Environment variables to set when running the MCP server | [optional] +**enabled** | Option<**bool**> | Enable or disable the MCP server on startup | [optional] +**timeout** | Option<**i32**> | Timeout in ms for fetching tools from the MCP server. Defaults to 5000 (5 seconds) if not specified. | [optional] +**url** | **String** | URL of the remote MCP server | +**headers** | Option<**std::collections::HashMap**> | Headers to send with the request | [optional] +**oauth** | Option<[**models::McpRemoteConfigOauth**](McpRemoteConfig_oauth.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/McpAuthCallbackRequest.md b/crates/opencode-client/generated/docs/McpAuthCallbackRequest.md new file mode 100644 index 0000000..60efb25 --- /dev/null +++ b/crates/opencode-client/generated/docs/McpAuthCallbackRequest.md @@ -0,0 +1,11 @@ +# McpAuthCallbackRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**code** | **String** | Authorization code from OAuth callback | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/McpAuthRemove200Response.md b/crates/opencode-client/generated/docs/McpAuthRemove200Response.md new file mode 100644 index 0000000..da5e492 --- /dev/null +++ b/crates/opencode-client/generated/docs/McpAuthRemove200Response.md @@ -0,0 +1,11 @@ +# McpAuthRemove200Response + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**success** | **bool** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/McpAuthStart200Response.md b/crates/opencode-client/generated/docs/McpAuthStart200Response.md new file mode 100644 index 0000000..b032912 --- /dev/null +++ b/crates/opencode-client/generated/docs/McpAuthStart200Response.md @@ -0,0 +1,11 @@ +# McpAuthStart200Response + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**authorization_url** | **String** | URL to open in browser for authorization | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/McpLocalConfig.md b/crates/opencode-client/generated/docs/McpLocalConfig.md new file mode 100644 index 0000000..56392bb --- /dev/null +++ b/crates/opencode-client/generated/docs/McpLocalConfig.md @@ -0,0 +1,15 @@ +# McpLocalConfig + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | Type of MCP server connection | +**command** | **Vec** | Command and arguments to run the MCP server | +**environment** | Option<**std::collections::HashMap**> | Environment variables to set when running the MCP server | [optional] +**enabled** | Option<**bool**> | Enable or disable the MCP server on startup | [optional] +**timeout** | Option<**i32**> | Timeout in ms for fetching tools from the MCP server. Defaults to 5000 (5 seconds) if not specified. | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/McpOAuthConfig.md b/crates/opencode-client/generated/docs/McpOAuthConfig.md new file mode 100644 index 0000000..326e208 --- /dev/null +++ b/crates/opencode-client/generated/docs/McpOAuthConfig.md @@ -0,0 +1,13 @@ +# McpOAuthConfig + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**client_id** | Option<**String**> | OAuth client ID. If not provided, dynamic client registration (RFC 7591) will be attempted. | [optional] +**client_secret** | Option<**String**> | OAuth client secret (if required by the authorization server) | [optional] +**scope** | Option<**String**> | OAuth scopes to request during authorization | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/McpRemoteConfig.md b/crates/opencode-client/generated/docs/McpRemoteConfig.md new file mode 100644 index 0000000..86667ae --- /dev/null +++ b/crates/opencode-client/generated/docs/McpRemoteConfig.md @@ -0,0 +1,16 @@ +# McpRemoteConfig + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | Type of MCP server connection | +**url** | **String** | URL of the remote MCP server | +**enabled** | Option<**bool**> | Enable or disable the MCP server on startup | [optional] +**headers** | Option<**std::collections::HashMap**> | Headers to send with the request | [optional] +**oauth** | Option<[**models::McpRemoteConfigOauth**](McpRemoteConfig_oauth.md)> | | [optional] +**timeout** | Option<**i32**> | Timeout in ms for fetching tools from the MCP server. Defaults to 5000 (5 seconds) if not specified. | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/McpRemoteConfigOauth.md b/crates/opencode-client/generated/docs/McpRemoteConfigOauth.md new file mode 100644 index 0000000..80a218c --- /dev/null +++ b/crates/opencode-client/generated/docs/McpRemoteConfigOauth.md @@ -0,0 +1,13 @@ +# McpRemoteConfigOauth + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**client_id** | Option<**String**> | OAuth client ID. If not provided, dynamic client registration (RFC 7591) will be attempted. | [optional] +**client_secret** | Option<**String**> | OAuth client secret (if required by the authorization server) | [optional] +**scope** | Option<**String**> | OAuth scopes to request during authorization | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/McpStatus.md b/crates/opencode-client/generated/docs/McpStatus.md new file mode 100644 index 0000000..fda4082 --- /dev/null +++ b/crates/opencode-client/generated/docs/McpStatus.md @@ -0,0 +1,12 @@ +# McpStatus + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**status** | **String** | | +**error** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/McpStatusConnected.md b/crates/opencode-client/generated/docs/McpStatusConnected.md new file mode 100644 index 0000000..8944623 --- /dev/null +++ b/crates/opencode-client/generated/docs/McpStatusConnected.md @@ -0,0 +1,11 @@ +# McpStatusConnected + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**status** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/McpStatusDisabled.md b/crates/opencode-client/generated/docs/McpStatusDisabled.md new file mode 100644 index 0000000..72fb549 --- /dev/null +++ b/crates/opencode-client/generated/docs/McpStatusDisabled.md @@ -0,0 +1,11 @@ +# McpStatusDisabled + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**status** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/McpStatusFailed.md b/crates/opencode-client/generated/docs/McpStatusFailed.md new file mode 100644 index 0000000..1d8245e --- /dev/null +++ b/crates/opencode-client/generated/docs/McpStatusFailed.md @@ -0,0 +1,12 @@ +# McpStatusFailed + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**status** | **String** | | +**error** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/McpStatusNeedsAuth.md b/crates/opencode-client/generated/docs/McpStatusNeedsAuth.md new file mode 100644 index 0000000..04b12e2 --- /dev/null +++ b/crates/opencode-client/generated/docs/McpStatusNeedsAuth.md @@ -0,0 +1,11 @@ +# McpStatusNeedsAuth + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**status** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/McpStatusNeedsClientRegistration.md b/crates/opencode-client/generated/docs/McpStatusNeedsClientRegistration.md new file mode 100644 index 0000000..637a2e9 --- /dev/null +++ b/crates/opencode-client/generated/docs/McpStatusNeedsClientRegistration.md @@ -0,0 +1,12 @@ +# McpStatusNeedsClientRegistration + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**status** | **String** | | +**error** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/Message.md b/crates/opencode-client/generated/docs/Message.md new file mode 100644 index 0000000..157dce2 --- /dev/null +++ b/crates/opencode-client/generated/docs/Message.md @@ -0,0 +1,29 @@ +# Message + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**session_id** | **String** | | +**role** | **String** | | +**time** | [**models::AssistantMessageTime**](AssistantMessage_time.md) | | +**summary** | Option<**bool**> | | [optional] +**agent** | **String** | | +**model** | [**models::SessionPromptRequestModel**](session_prompt_request_model.md) | | +**system** | Option<**String**> | | [optional] +**tools** | Option<**std::collections::HashMap**> | | [optional] +**variant** | Option<**String**> | | [optional] +**error** | Option<[**models::AssistantMessageError**](AssistantMessage_error.md)> | | [optional] +**parent_id** | **String** | | +**model_id** | **String** | | +**provider_id** | **String** | | +**mode** | **String** | | +**path** | [**models::AssistantMessagePath**](AssistantMessage_path.md) | | +**cost** | **f64** | | +**tokens** | [**models::AssistantMessageTokens**](AssistantMessage_tokens.md) | | +**finish** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/MessageAbortedError.md b/crates/opencode-client/generated/docs/MessageAbortedError.md new file mode 100644 index 0000000..3b4c395 --- /dev/null +++ b/crates/opencode-client/generated/docs/MessageAbortedError.md @@ -0,0 +1,12 @@ +# MessageAbortedError + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**name** | **String** | | +**data** | [**models::UnknownErrorData**](UnknownError_data.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/MessageOutputLengthError.md b/crates/opencode-client/generated/docs/MessageOutputLengthError.md new file mode 100644 index 0000000..13e3219 --- /dev/null +++ b/crates/opencode-client/generated/docs/MessageOutputLengthError.md @@ -0,0 +1,12 @@ +# MessageOutputLengthError + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**name** | **String** | | +**data** | [**serde_json::Value**](.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/Model.md b/crates/opencode-client/generated/docs/Model.md new file mode 100644 index 0000000..12b4ec0 --- /dev/null +++ b/crates/opencode-client/generated/docs/Model.md @@ -0,0 +1,23 @@ +# Model + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**provider_id** | **String** | | +**api** | [**models::ModelApi**](Model_api.md) | | +**name** | **String** | | +**family** | Option<**String**> | | [optional] +**capabilities** | [**models::ModelCapabilities**](Model_capabilities.md) | | +**cost** | [**models::ModelCost**](Model_cost.md) | | +**limit** | [**models::ProviderList200ResponseAllInnerModelsValueLimit**](provider_list_200_response_all_inner_models_value_limit.md) | | +**status** | **String** | | +**options** | [**std::collections::HashMap**](serde_json::Value.md) | | +**headers** | **std::collections::HashMap** | | +**release_date** | **String** | | +**variants** | Option<[**std::collections::HashMap>**](std::collections::HashMap.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ModelApi.md b/crates/opencode-client/generated/docs/ModelApi.md new file mode 100644 index 0000000..dcc2355 --- /dev/null +++ b/crates/opencode-client/generated/docs/ModelApi.md @@ -0,0 +1,13 @@ +# ModelApi + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**url** | **String** | | +**npm** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ModelCapabilities.md b/crates/opencode-client/generated/docs/ModelCapabilities.md new file mode 100644 index 0000000..efd707e --- /dev/null +++ b/crates/opencode-client/generated/docs/ModelCapabilities.md @@ -0,0 +1,17 @@ +# ModelCapabilities + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**temperature** | **bool** | | +**reasoning** | **bool** | | +**attachment** | **bool** | | +**toolcall** | **bool** | | +**input** | [**models::ModelCapabilitiesInput**](Model_capabilities_input.md) | | +**output** | [**models::ModelCapabilitiesInput**](Model_capabilities_input.md) | | +**interleaved** | [**models::ModelCapabilitiesInterleaved**](Model_capabilities_interleaved.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ModelCapabilitiesInput.md b/crates/opencode-client/generated/docs/ModelCapabilitiesInput.md new file mode 100644 index 0000000..c7beee2 --- /dev/null +++ b/crates/opencode-client/generated/docs/ModelCapabilitiesInput.md @@ -0,0 +1,15 @@ +# ModelCapabilitiesInput + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**text** | **bool** | | +**audio** | **bool** | | +**image** | **bool** | | +**video** | **bool** | | +**pdf** | **bool** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ModelCapabilitiesInterleaved.md b/crates/opencode-client/generated/docs/ModelCapabilitiesInterleaved.md new file mode 100644 index 0000000..7d0f1a0 --- /dev/null +++ b/crates/opencode-client/generated/docs/ModelCapabilitiesInterleaved.md @@ -0,0 +1,11 @@ +# ModelCapabilitiesInterleaved + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**field** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ModelCapabilitiesInterleavedAnyOf.md b/crates/opencode-client/generated/docs/ModelCapabilitiesInterleavedAnyOf.md new file mode 100644 index 0000000..91c9c6c --- /dev/null +++ b/crates/opencode-client/generated/docs/ModelCapabilitiesInterleavedAnyOf.md @@ -0,0 +1,11 @@ +# ModelCapabilitiesInterleavedAnyOf + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**field** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ModelCost.md b/crates/opencode-client/generated/docs/ModelCost.md new file mode 100644 index 0000000..2007a8f --- /dev/null +++ b/crates/opencode-client/generated/docs/ModelCost.md @@ -0,0 +1,14 @@ +# ModelCost + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**input** | **f64** | | +**output** | **f64** | | +**cache** | [**models::AssistantMessageTokensCache**](AssistantMessage_tokens_cache.md) | | +**experimental_over200_k** | Option<[**models::ModelCostExperimentalOver200K**](Model_cost_experimentalOver200K.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ModelCostExperimentalOver200K.md b/crates/opencode-client/generated/docs/ModelCostExperimentalOver200K.md new file mode 100644 index 0000000..7fa2806 --- /dev/null +++ b/crates/opencode-client/generated/docs/ModelCostExperimentalOver200K.md @@ -0,0 +1,13 @@ +# ModelCostExperimentalOver200K + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**input** | **f64** | | +**output** | **f64** | | +**cache** | [**models::AssistantMessageTokensCache**](AssistantMessage_tokens_cache.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/NotFoundError.md b/crates/opencode-client/generated/docs/NotFoundError.md new file mode 100644 index 0000000..394ae64 --- /dev/null +++ b/crates/opencode-client/generated/docs/NotFoundError.md @@ -0,0 +1,12 @@ +# NotFoundError + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**name** | **String** | | +**data** | [**models::UnknownErrorData**](UnknownError_data.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/OAuth.md b/crates/opencode-client/generated/docs/OAuth.md new file mode 100644 index 0000000..30ca901 --- /dev/null +++ b/crates/opencode-client/generated/docs/OAuth.md @@ -0,0 +1,15 @@ +# OAuth + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**refresh** | **String** | | +**access** | **String** | | +**expires** | **f64** | | +**enterprise_url** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/Part.md b/crates/opencode-client/generated/docs/Part.md new file mode 100644 index 0000000..b0189a7 --- /dev/null +++ b/crates/opencode-client/generated/docs/Part.md @@ -0,0 +1,40 @@ +# Part + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**session_id** | **String** | | +**message_id** | **String** | | +**r#type** | **String** | | +**text** | **String** | | +**synthetic** | Option<**bool**> | | [optional] +**ignored** | Option<**bool**> | | [optional] +**time** | [**models::UserMessageTime**](UserMessage_time.md) | | +**metadata** | Option<[**std::collections::HashMap**](serde_json::Value.md)> | | [optional] +**prompt** | **String** | | +**description** | **String** | | +**agent** | **String** | | +**command** | Option<**String**> | | [optional] +**mime** | **String** | | +**filename** | Option<**String**> | | [optional] +**url** | **String** | | +**source** | Option<[**models::AgentPartSource**](AgentPart_source.md)> | | [optional] +**call_id** | **String** | | +**tool** | **String** | | +**state** | [**models::ToolState**](ToolState.md) | | +**snapshot** | **String** | | +**reason** | **String** | | +**cost** | **f64** | | +**tokens** | [**models::AssistantMessageTokens**](AssistantMessage_tokens.md) | | +**hash** | **String** | | +**files** | **Vec** | | +**name** | **String** | | +**attempt** | **f64** | | +**error** | [**models::ApiError**](APIError.md) | | +**auto** | **bool** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/PartAnyOf.md b/crates/opencode-client/generated/docs/PartAnyOf.md new file mode 100644 index 0000000..f7bbd80 --- /dev/null +++ b/crates/opencode-client/generated/docs/PartAnyOf.md @@ -0,0 +1,18 @@ +# PartAnyOf + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**session_id** | **String** | | +**message_id** | **String** | | +**r#type** | **String** | | +**prompt** | **String** | | +**description** | **String** | | +**agent** | **String** | | +**command** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/PatchPart.md b/crates/opencode-client/generated/docs/PatchPart.md new file mode 100644 index 0000000..fa33fce --- /dev/null +++ b/crates/opencode-client/generated/docs/PatchPart.md @@ -0,0 +1,16 @@ +# PatchPart + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**session_id** | **String** | | +**message_id** | **String** | | +**r#type** | **String** | | +**hash** | **String** | | +**files** | **Vec** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/Path.md b/crates/opencode-client/generated/docs/Path.md new file mode 100644 index 0000000..2ca75a3 --- /dev/null +++ b/crates/opencode-client/generated/docs/Path.md @@ -0,0 +1,15 @@ +# Path + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**home** | **String** | | +**state** | **String** | | +**config** | **String** | | +**worktree** | **String** | | +**directory** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/Permission.md b/crates/opencode-client/generated/docs/Permission.md new file mode 100644 index 0000000..8551dfa --- /dev/null +++ b/crates/opencode-client/generated/docs/Permission.md @@ -0,0 +1,19 @@ +# Permission + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**r#type** | **String** | | +**pattern** | Option<[**models::PermissionPattern**](Permission_pattern.md)> | | [optional] +**session_id** | **String** | | +**message_id** | **String** | | +**call_id** | Option<**String**> | | [optional] +**title** | **String** | | +**metadata** | [**std::collections::HashMap**](serde_json::Value.md) | | +**time** | [**models::UserMessageTime**](UserMessage_time.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/PermissionPattern.md b/crates/opencode-client/generated/docs/PermissionPattern.md new file mode 100644 index 0000000..88d1537 --- /dev/null +++ b/crates/opencode-client/generated/docs/PermissionPattern.md @@ -0,0 +1,10 @@ +# PermissionPattern + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/PermissionRespondRequest.md b/crates/opencode-client/generated/docs/PermissionRespondRequest.md new file mode 100644 index 0000000..e0b05d1 --- /dev/null +++ b/crates/opencode-client/generated/docs/PermissionRespondRequest.md @@ -0,0 +1,11 @@ +# PermissionRespondRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**response** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/Project.md b/crates/opencode-client/generated/docs/Project.md new file mode 100644 index 0000000..7884480 --- /dev/null +++ b/crates/opencode-client/generated/docs/Project.md @@ -0,0 +1,16 @@ +# Project + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**worktree** | **String** | | +**vcs** | Option<**String**> | | [optional] +**name** | Option<**String**> | | [optional] +**icon** | Option<[**models::ProjectUpdateRequestIcon**](project_update_request_icon.md)> | | [optional] +**time** | [**models::ProjectTime**](Project_time.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProjectTime.md b/crates/opencode-client/generated/docs/ProjectTime.md new file mode 100644 index 0000000..0ba0f73 --- /dev/null +++ b/crates/opencode-client/generated/docs/ProjectTime.md @@ -0,0 +1,13 @@ +# ProjectTime + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**created** | **f64** | | +**updated** | **f64** | | +**initialized** | Option<**f64**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProjectUpdateRequest.md b/crates/opencode-client/generated/docs/ProjectUpdateRequest.md new file mode 100644 index 0000000..855b293 --- /dev/null +++ b/crates/opencode-client/generated/docs/ProjectUpdateRequest.md @@ -0,0 +1,12 @@ +# ProjectUpdateRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**name** | Option<**String**> | | [optional] +**icon** | Option<[**models::ProjectUpdateRequestIcon**](project_update_request_icon.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProjectUpdateRequestIcon.md b/crates/opencode-client/generated/docs/ProjectUpdateRequestIcon.md new file mode 100644 index 0000000..68394bc --- /dev/null +++ b/crates/opencode-client/generated/docs/ProjectUpdateRequestIcon.md @@ -0,0 +1,12 @@ +# ProjectUpdateRequestIcon + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**url** | Option<**String**> | | [optional] +**color** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/Provider.md b/crates/opencode-client/generated/docs/Provider.md new file mode 100644 index 0000000..3469cc6 --- /dev/null +++ b/crates/opencode-client/generated/docs/Provider.md @@ -0,0 +1,17 @@ +# Provider + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**name** | **String** | | +**source** | **String** | | +**env** | **Vec** | | +**key** | Option<**String**> | | [optional] +**options** | [**std::collections::HashMap**](serde_json::Value.md) | | +**models** | [**std::collections::HashMap**](Model.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderAuthAuthorization.md b/crates/opencode-client/generated/docs/ProviderAuthAuthorization.md new file mode 100644 index 0000000..ec2a991 --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderAuthAuthorization.md @@ -0,0 +1,13 @@ +# ProviderAuthAuthorization + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**url** | **String** | | +**method** | **String** | | +**instructions** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderAuthError.md b/crates/opencode-client/generated/docs/ProviderAuthError.md new file mode 100644 index 0000000..294e5f2 --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderAuthError.md @@ -0,0 +1,12 @@ +# ProviderAuthError + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**name** | **String** | | +**data** | [**models::ProviderAuthErrorData**](ProviderAuthError_data.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderAuthErrorData.md b/crates/opencode-client/generated/docs/ProviderAuthErrorData.md new file mode 100644 index 0000000..538e7a3 --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderAuthErrorData.md @@ -0,0 +1,12 @@ +# ProviderAuthErrorData + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**provider_id** | **String** | | +**message** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderAuthMethod.md b/crates/opencode-client/generated/docs/ProviderAuthMethod.md new file mode 100644 index 0000000..a279963 --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderAuthMethod.md @@ -0,0 +1,12 @@ +# ProviderAuthMethod + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**label** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderConfig.md b/crates/opencode-client/generated/docs/ProviderConfig.md new file mode 100644 index 0000000..0f45a5a --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderConfig.md @@ -0,0 +1,19 @@ +# ProviderConfig + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**api** | Option<**String**> | | [optional] +**name** | Option<**String**> | | [optional] +**env** | Option<**Vec**> | | [optional] +**id** | Option<**String**> | | [optional] +**npm** | Option<**String**> | | [optional] +**models** | Option<[**std::collections::HashMap**](ProviderConfig_models_value.md)> | | [optional] +**whitelist** | Option<**Vec**> | | [optional] +**blacklist** | Option<**Vec**> | | [optional] +**options** | Option<[**models::ProviderConfigOptions**](ProviderConfig_options.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderConfigModelsValue.md b/crates/opencode-client/generated/docs/ProviderConfigModelsValue.md new file mode 100644 index 0000000..5230273 --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderConfigModelsValue.md @@ -0,0 +1,28 @@ +# ProviderConfigModelsValue + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | Option<**String**> | | [optional] +**name** | Option<**String**> | | [optional] +**family** | Option<**String**> | | [optional] +**release_date** | Option<**String**> | | [optional] +**attachment** | Option<**bool**> | | [optional] +**reasoning** | Option<**bool**> | | [optional] +**temperature** | Option<**bool**> | | [optional] +**tool_call** | Option<**bool**> | | [optional] +**interleaved** | Option<[**models::ProviderConfigModelsValueInterleaved**](ProviderConfig_models_value_interleaved.md)> | | [optional] +**cost** | Option<[**models::ProviderList200ResponseAllInnerModelsValueCost**](provider_list_200_response_all_inner_models_value_cost.md)> | | [optional] +**limit** | Option<[**models::ProviderList200ResponseAllInnerModelsValueLimit**](provider_list_200_response_all_inner_models_value_limit.md)> | | [optional] +**modalities** | Option<[**models::ProviderList200ResponseAllInnerModelsValueModalities**](provider_list_200_response_all_inner_models_value_modalities.md)> | | [optional] +**experimental** | Option<**bool**> | | [optional] +**status** | Option<**String**> | | [optional] +**options** | Option<[**std::collections::HashMap**](serde_json::Value.md)> | | [optional] +**headers** | Option<**std::collections::HashMap**> | | [optional] +**provider** | Option<[**models::ProviderList200ResponseAllInnerModelsValueProvider**](provider_list_200_response_all_inner_models_value_provider.md)> | | [optional] +**variants** | Option<[**std::collections::HashMap**](ProviderConfig_models_value_variants_value.md)> | Variant-specific configuration | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderConfigModelsValueInterleaved.md b/crates/opencode-client/generated/docs/ProviderConfigModelsValueInterleaved.md new file mode 100644 index 0000000..c489b95 --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderConfigModelsValueInterleaved.md @@ -0,0 +1,11 @@ +# ProviderConfigModelsValueInterleaved + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**field** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderConfigModelsValueInterleavedAnyOf.md b/crates/opencode-client/generated/docs/ProviderConfigModelsValueInterleavedAnyOf.md new file mode 100644 index 0000000..4ca92d0 --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderConfigModelsValueInterleavedAnyOf.md @@ -0,0 +1,11 @@ +# ProviderConfigModelsValueInterleavedAnyOf + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**field** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderConfigModelsValueVariantsValue.md b/crates/opencode-client/generated/docs/ProviderConfigModelsValueVariantsValue.md new file mode 100644 index 0000000..425dd4c --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderConfigModelsValueVariantsValue.md @@ -0,0 +1,11 @@ +# ProviderConfigModelsValueVariantsValue + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**disabled** | Option<**bool**> | Disable this variant for the model | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderConfigOptions.md b/crates/opencode-client/generated/docs/ProviderConfigOptions.md new file mode 100644 index 0000000..92a0f5d --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderConfigOptions.md @@ -0,0 +1,15 @@ +# ProviderConfigOptions + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**api_key** | Option<**String**> | | [optional] +**base_url** | Option<**String**> | | [optional] +**enterprise_url** | Option<**String**> | GitHub Enterprise URL for copilot authentication | [optional] +**set_cache_key** | Option<**bool**> | Enable promptCacheKey for this provider (default false) | [optional] +**timeout** | Option<[**models::ProviderConfigOptionsTimeout**](ProviderConfig_options_timeout.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderConfigOptionsTimeout.md b/crates/opencode-client/generated/docs/ProviderConfigOptionsTimeout.md new file mode 100644 index 0000000..6aa2cbb --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderConfigOptionsTimeout.md @@ -0,0 +1,10 @@ +# ProviderConfigOptionsTimeout + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderList200Response.md b/crates/opencode-client/generated/docs/ProviderList200Response.md new file mode 100644 index 0000000..828ef8b --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderList200Response.md @@ -0,0 +1,13 @@ +# ProviderList200Response + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**all** | [**Vec**](provider_list_200_response_all_inner.md) | | +**default** | **std::collections::HashMap** | | +**connected** | **Vec** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderList200ResponseAllInner.md b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInner.md new file mode 100644 index 0000000..d8c9696 --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInner.md @@ -0,0 +1,16 @@ +# ProviderList200ResponseAllInner + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**api** | Option<**String**> | | [optional] +**name** | **String** | | +**env** | **Vec** | | +**id** | **String** | | +**npm** | Option<**String**> | | [optional] +**models** | [**std::collections::HashMap**](provider_list_200_response_all_inner_models_value.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValue.md b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValue.md new file mode 100644 index 0000000..67b7f43 --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValue.md @@ -0,0 +1,28 @@ +# ProviderList200ResponseAllInnerModelsValue + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**name** | **String** | | +**family** | Option<**String**> | | [optional] +**release_date** | **String** | | +**attachment** | **bool** | | +**reasoning** | **bool** | | +**temperature** | **bool** | | +**tool_call** | **bool** | | +**interleaved** | Option<[**models::ProviderList200ResponseAllInnerModelsValueInterleaved**](provider_list_200_response_all_inner_models_value_interleaved.md)> | | [optional] +**cost** | Option<[**models::ProviderList200ResponseAllInnerModelsValueCost**](provider_list_200_response_all_inner_models_value_cost.md)> | | [optional] +**limit** | [**models::ProviderList200ResponseAllInnerModelsValueLimit**](provider_list_200_response_all_inner_models_value_limit.md) | | +**modalities** | Option<[**models::ProviderList200ResponseAllInnerModelsValueModalities**](provider_list_200_response_all_inner_models_value_modalities.md)> | | [optional] +**experimental** | Option<**bool**> | | [optional] +**status** | Option<**String**> | | [optional] +**options** | [**std::collections::HashMap**](serde_json::Value.md) | | +**headers** | Option<**std::collections::HashMap**> | | [optional] +**provider** | Option<[**models::ProviderList200ResponseAllInnerModelsValueProvider**](provider_list_200_response_all_inner_models_value_provider.md)> | | [optional] +**variants** | Option<[**std::collections::HashMap>**](std::collections::HashMap.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueCost.md b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueCost.md new file mode 100644 index 0000000..4fd1b23 --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueCost.md @@ -0,0 +1,15 @@ +# ProviderList200ResponseAllInnerModelsValueCost + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**input** | **f64** | | +**output** | **f64** | | +**cache_read** | Option<**f64**> | | [optional] +**cache_write** | Option<**f64**> | | [optional] +**context_over_200k** | Option<[**models::ProviderList200ResponseAllInnerModelsValueCostContextOver200k**](provider_list_200_response_all_inner_models_value_cost_context_over_200k.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueCostContextOver200k.md b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueCostContextOver200k.md new file mode 100644 index 0000000..f3675bb --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueCostContextOver200k.md @@ -0,0 +1,14 @@ +# ProviderList200ResponseAllInnerModelsValueCostContextOver200k + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**input** | **f64** | | +**output** | **f64** | | +**cache_read** | Option<**f64**> | | [optional] +**cache_write** | Option<**f64**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueInterleaved.md b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueInterleaved.md new file mode 100644 index 0000000..a806f7d --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueInterleaved.md @@ -0,0 +1,11 @@ +# ProviderList200ResponseAllInnerModelsValueInterleaved + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**field** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf.md b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf.md new file mode 100644 index 0000000..cc87bfb --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf.md @@ -0,0 +1,11 @@ +# ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**field** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueLimit.md b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueLimit.md new file mode 100644 index 0000000..a6cea17 --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueLimit.md @@ -0,0 +1,12 @@ +# ProviderList200ResponseAllInnerModelsValueLimit + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**context** | **f64** | | +**output** | **f64** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueModalities.md b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueModalities.md new file mode 100644 index 0000000..7007155 --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueModalities.md @@ -0,0 +1,12 @@ +# ProviderList200ResponseAllInnerModelsValueModalities + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**input** | **Vec** | | +**output** | **Vec** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueProvider.md b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueProvider.md new file mode 100644 index 0000000..87145ee --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderList200ResponseAllInnerModelsValueProvider.md @@ -0,0 +1,11 @@ +# ProviderList200ResponseAllInnerModelsValueProvider + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**npm** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderOauthAuthorizeRequest.md b/crates/opencode-client/generated/docs/ProviderOauthAuthorizeRequest.md new file mode 100644 index 0000000..db9195c --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderOauthAuthorizeRequest.md @@ -0,0 +1,11 @@ +# ProviderOauthAuthorizeRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**method** | **f64** | Auth method index | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ProviderOauthCallbackRequest.md b/crates/opencode-client/generated/docs/ProviderOauthCallbackRequest.md new file mode 100644 index 0000000..c5a3fad --- /dev/null +++ b/crates/opencode-client/generated/docs/ProviderOauthCallbackRequest.md @@ -0,0 +1,12 @@ +# ProviderOauthCallbackRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**method** | **f64** | Auth method index | +**code** | Option<**String**> | OAuth authorization code | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/Pty.md b/crates/opencode-client/generated/docs/Pty.md new file mode 100644 index 0000000..3deb891 --- /dev/null +++ b/crates/opencode-client/generated/docs/Pty.md @@ -0,0 +1,17 @@ +# Pty + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**title** | **String** | | +**command** | **String** | | +**args** | **Vec** | | +**cwd** | **String** | | +**status** | **String** | | +**pid** | **f64** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/PtyCreateRequest.md b/crates/opencode-client/generated/docs/PtyCreateRequest.md new file mode 100644 index 0000000..e571d26 --- /dev/null +++ b/crates/opencode-client/generated/docs/PtyCreateRequest.md @@ -0,0 +1,15 @@ +# PtyCreateRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**command** | Option<**String**> | | [optional] +**args** | Option<**Vec**> | | [optional] +**cwd** | Option<**String**> | | [optional] +**title** | Option<**String**> | | [optional] +**env** | Option<**std::collections::HashMap**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/PtyUpdateRequest.md b/crates/opencode-client/generated/docs/PtyUpdateRequest.md new file mode 100644 index 0000000..f25beec --- /dev/null +++ b/crates/opencode-client/generated/docs/PtyUpdateRequest.md @@ -0,0 +1,12 @@ +# PtyUpdateRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**title** | Option<**String**> | | [optional] +**size** | Option<[**models::PtyUpdateRequestSize**](pty_update_request_size.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/PtyUpdateRequestSize.md b/crates/opencode-client/generated/docs/PtyUpdateRequestSize.md new file mode 100644 index 0000000..6f2bfb9 --- /dev/null +++ b/crates/opencode-client/generated/docs/PtyUpdateRequestSize.md @@ -0,0 +1,12 @@ +# PtyUpdateRequestSize + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**rows** | **f64** | | +**cols** | **f64** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/Range.md b/crates/opencode-client/generated/docs/Range.md new file mode 100644 index 0000000..9a45e4b --- /dev/null +++ b/crates/opencode-client/generated/docs/Range.md @@ -0,0 +1,12 @@ +# Range + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**start** | [**models::RangeStart**](Range_start.md) | | +**end** | [**models::RangeStart**](Range_start.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/RangeStart.md b/crates/opencode-client/generated/docs/RangeStart.md new file mode 100644 index 0000000..366a441 --- /dev/null +++ b/crates/opencode-client/generated/docs/RangeStart.md @@ -0,0 +1,12 @@ +# RangeStart + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**line** | **f64** | | +**character** | **f64** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ReasoningPart.md b/crates/opencode-client/generated/docs/ReasoningPart.md new file mode 100644 index 0000000..708ac48 --- /dev/null +++ b/crates/opencode-client/generated/docs/ReasoningPart.md @@ -0,0 +1,17 @@ +# ReasoningPart + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**session_id** | **String** | | +**message_id** | **String** | | +**r#type** | **String** | | +**text** | **String** | | +**metadata** | Option<[**std::collections::HashMap**](serde_json::Value.md)> | | [optional] +**time** | [**models::TextPartTime**](TextPart_time.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/RetryPart.md b/crates/opencode-client/generated/docs/RetryPart.md new file mode 100644 index 0000000..1df87db --- /dev/null +++ b/crates/opencode-client/generated/docs/RetryPart.md @@ -0,0 +1,17 @@ +# RetryPart + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**session_id** | **String** | | +**message_id** | **String** | | +**r#type** | **String** | | +**attempt** | **f64** | | +**error** | [**models::ApiError**](APIError.md) | | +**time** | [**models::UserMessageTime**](UserMessage_time.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ServerConfig.md b/crates/opencode-client/generated/docs/ServerConfig.md new file mode 100644 index 0000000..bea7c7b --- /dev/null +++ b/crates/opencode-client/generated/docs/ServerConfig.md @@ -0,0 +1,14 @@ +# ServerConfig + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**port** | Option<**i32**> | Port to listen on | [optional] +**hostname** | Option<**String**> | Hostname to listen on | [optional] +**mdns** | Option<**bool**> | Enable mDNS service discovery | [optional] +**cors** | Option<**Vec**> | Additional domains to allow for CORS | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/Session.md b/crates/opencode-client/generated/docs/Session.md new file mode 100644 index 0000000..6b923f8 --- /dev/null +++ b/crates/opencode-client/generated/docs/Session.md @@ -0,0 +1,20 @@ +# Session + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**project_id** | **String** | | +**directory** | **String** | | +**parent_id** | Option<**String**> | | [optional] +**summary** | Option<[**models::SessionSummary**](Session_summary.md)> | | [optional] +**share** | Option<[**models::SessionShare**](Session_share.md)> | | [optional] +**title** | **String** | | +**version** | **String** | | +**time** | [**models::SessionTime**](Session_time.md) | | +**revert** | Option<[**models::SessionRevert**](Session_revert.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionApi.md b/crates/opencode-client/generated/docs/SessionApi.md new file mode 100644 index 0000000..abdde31 --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionApi.md @@ -0,0 +1,72 @@ +# \SessionApi + +All URIs are relative to *http://localhost* + +Method | HTTP request | Description +------------- | ------------- | ------------- +[**session_children**](SessionApi.md#session_children) | **GET** /session/{sessionID}/children | Get session children +[**session_get**](SessionApi.md#session_get) | **GET** /session/{sessionID} | Get session + + + +## session_children + +> Vec session_children(session_id, directory) +Get session children + +Retrieve all child sessions that were forked from the specified parent session. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +[**Vec**](Session.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + + +## session_get + +> models::Session session_get(session_id, directory) +Get session + +Retrieve detailed information about a specific OpenCode session. + +### Parameters + + +Name | Type | Description | Required | Notes +------------- | ------------- | ------------- | ------------- | ------------- +**session_id** | **String** | | [required] | +**directory** | Option<**String**> | | | + +### Return type + +[**models::Session**](Session.md) + +### Authorization + +No authorization required + +### HTTP request headers + +- **Content-Type**: Not defined +- **Accept**: application/json + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + diff --git a/crates/opencode-client/generated/docs/SessionCommandRequest.md b/crates/opencode-client/generated/docs/SessionCommandRequest.md new file mode 100644 index 0000000..38a8a13 --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionCommandRequest.md @@ -0,0 +1,16 @@ +# SessionCommandRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**message_id** | Option<**String**> | | [optional] +**agent** | Option<**String**> | | [optional] +**model** | Option<**String**> | | [optional] +**arguments** | **String** | | +**command** | **String** | | +**variant** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionCreateRequest.md b/crates/opencode-client/generated/docs/SessionCreateRequest.md new file mode 100644 index 0000000..f874ff1 --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionCreateRequest.md @@ -0,0 +1,12 @@ +# SessionCreateRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**parent_id** | Option<**String**> | | [optional] +**title** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionForkRequest.md b/crates/opencode-client/generated/docs/SessionForkRequest.md new file mode 100644 index 0000000..e91dded --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionForkRequest.md @@ -0,0 +1,11 @@ +# SessionForkRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**message_id** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionInitRequest.md b/crates/opencode-client/generated/docs/SessionInitRequest.md new file mode 100644 index 0000000..553637b --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionInitRequest.md @@ -0,0 +1,13 @@ +# SessionInitRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**model_id** | **String** | | +**provider_id** | **String** | | +**message_id** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionMessages200ResponseInner.md b/crates/opencode-client/generated/docs/SessionMessages200ResponseInner.md new file mode 100644 index 0000000..99d7911 --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionMessages200ResponseInner.md @@ -0,0 +1,12 @@ +# SessionMessages200ResponseInner + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**info** | [**models::Message**](Message.md) | | +**parts** | [**Vec**](Part.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionPrompt200Response.md b/crates/opencode-client/generated/docs/SessionPrompt200Response.md new file mode 100644 index 0000000..184c964 --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionPrompt200Response.md @@ -0,0 +1,12 @@ +# SessionPrompt200Response + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**info** | [**models::AssistantMessage**](AssistantMessage.md) | | +**parts** | [**Vec**](Part.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionPromptRequest.md b/crates/opencode-client/generated/docs/SessionPromptRequest.md new file mode 100644 index 0000000..fea83c8 --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionPromptRequest.md @@ -0,0 +1,18 @@ +# SessionPromptRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**message_id** | Option<**String**> | | [optional] +**model** | Option<[**models::SessionPromptRequestModel**](session_prompt_request_model.md)> | | [optional] +**agent** | Option<**String**> | | [optional] +**no_reply** | Option<**bool**> | | [optional] +**tools** | Option<**std::collections::HashMap**> | | [optional] +**system** | Option<**String**> | | [optional] +**variant** | Option<**String**> | | [optional] +**parts** | [**Vec**](session_prompt_request_parts_inner.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionPromptRequestModel.md b/crates/opencode-client/generated/docs/SessionPromptRequestModel.md new file mode 100644 index 0000000..9cda7bb --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionPromptRequestModel.md @@ -0,0 +1,12 @@ +# SessionPromptRequestModel + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**provider_id** | **String** | | +**model_id** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionPromptRequestPartsInner.md b/crates/opencode-client/generated/docs/SessionPromptRequestPartsInner.md new file mode 100644 index 0000000..256d4f0 --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionPromptRequestPartsInner.md @@ -0,0 +1,26 @@ +# SessionPromptRequestPartsInner + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | Option<**String**> | | [optional] +**r#type** | **String** | | +**text** | **String** | | +**synthetic** | Option<**bool**> | | [optional] +**ignored** | Option<**bool**> | | [optional] +**time** | Option<[**models::TextPartTime**](TextPart_time.md)> | | [optional] +**metadata** | Option<[**std::collections::HashMap**](serde_json::Value.md)> | | [optional] +**mime** | **String** | | +**filename** | Option<**String**> | | [optional] +**url** | **String** | | +**source** | Option<[**models::AgentPartSource**](AgentPart_source.md)> | | [optional] +**name** | **String** | | +**prompt** | **String** | | +**description** | **String** | | +**agent** | **String** | | +**command** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionRevert.md b/crates/opencode-client/generated/docs/SessionRevert.md new file mode 100644 index 0000000..31b8fdd --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionRevert.md @@ -0,0 +1,14 @@ +# SessionRevert + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**message_id** | **String** | | +**part_id** | Option<**String**> | | [optional] +**snapshot** | Option<**String**> | | [optional] +**diff** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionRevertRequest.md b/crates/opencode-client/generated/docs/SessionRevertRequest.md new file mode 100644 index 0000000..faaa1ba --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionRevertRequest.md @@ -0,0 +1,12 @@ +# SessionRevertRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**message_id** | **String** | | +**part_id** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionShare.md b/crates/opencode-client/generated/docs/SessionShare.md new file mode 100644 index 0000000..74970ed --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionShare.md @@ -0,0 +1,11 @@ +# SessionShare + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**url** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionShellRequest.md b/crates/opencode-client/generated/docs/SessionShellRequest.md new file mode 100644 index 0000000..0be16f1 --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionShellRequest.md @@ -0,0 +1,13 @@ +# SessionShellRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**agent** | **String** | | +**model** | Option<[**models::SessionPromptRequestModel**](session_prompt_request_model.md)> | | [optional] +**command** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionStatus.md b/crates/opencode-client/generated/docs/SessionStatus.md new file mode 100644 index 0000000..0277661 --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionStatus.md @@ -0,0 +1,14 @@ +# SessionStatus + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**attempt** | **f64** | | +**message** | **String** | | +**next** | **f64** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionStatusAnyOf.md b/crates/opencode-client/generated/docs/SessionStatusAnyOf.md new file mode 100644 index 0000000..5059816 --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionStatusAnyOf.md @@ -0,0 +1,11 @@ +# SessionStatusAnyOf + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionStatusAnyOf1.md b/crates/opencode-client/generated/docs/SessionStatusAnyOf1.md new file mode 100644 index 0000000..ff2851d --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionStatusAnyOf1.md @@ -0,0 +1,14 @@ +# SessionStatusAnyOf1 + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**attempt** | **f64** | | +**message** | **String** | | +**next** | **f64** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionStatusAnyOf2.md b/crates/opencode-client/generated/docs/SessionStatusAnyOf2.md new file mode 100644 index 0000000..eb3c6e3 --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionStatusAnyOf2.md @@ -0,0 +1,11 @@ +# SessionStatusAnyOf2 + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionSummarizeRequest.md b/crates/opencode-client/generated/docs/SessionSummarizeRequest.md new file mode 100644 index 0000000..a8dd087 --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionSummarizeRequest.md @@ -0,0 +1,13 @@ +# SessionSummarizeRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**provider_id** | **String** | | +**model_id** | **String** | | +**auto** | Option<**bool**> | | [optional][default to false] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionSummary.md b/crates/opencode-client/generated/docs/SessionSummary.md new file mode 100644 index 0000000..c005e62 --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionSummary.md @@ -0,0 +1,14 @@ +# SessionSummary + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**additions** | **f64** | | +**deletions** | **f64** | | +**files** | **f64** | | +**diffs** | Option<[**Vec**](FileDiff.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionTime.md b/crates/opencode-client/generated/docs/SessionTime.md new file mode 100644 index 0000000..61697ab --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionTime.md @@ -0,0 +1,14 @@ +# SessionTime + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**created** | **f64** | | +**updated** | **f64** | | +**compacting** | Option<**f64**> | | [optional] +**archived** | Option<**f64**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionUpdateRequest.md b/crates/opencode-client/generated/docs/SessionUpdateRequest.md new file mode 100644 index 0000000..a202c3e --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionUpdateRequest.md @@ -0,0 +1,12 @@ +# SessionUpdateRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**title** | Option<**String**> | | [optional] +**time** | Option<[**models::SessionUpdateRequestTime**](session_update_request_time.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SessionUpdateRequestTime.md b/crates/opencode-client/generated/docs/SessionUpdateRequestTime.md new file mode 100644 index 0000000..99789b2 --- /dev/null +++ b/crates/opencode-client/generated/docs/SessionUpdateRequestTime.md @@ -0,0 +1,11 @@ +# SessionUpdateRequestTime + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**archived** | Option<**f64**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SnapshotPart.md b/crates/opencode-client/generated/docs/SnapshotPart.md new file mode 100644 index 0000000..5d32f13 --- /dev/null +++ b/crates/opencode-client/generated/docs/SnapshotPart.md @@ -0,0 +1,15 @@ +# SnapshotPart + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**session_id** | **String** | | +**message_id** | **String** | | +**r#type** | **String** | | +**snapshot** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/StepFinishPart.md b/crates/opencode-client/generated/docs/StepFinishPart.md new file mode 100644 index 0000000..0ec677c --- /dev/null +++ b/crates/opencode-client/generated/docs/StepFinishPart.md @@ -0,0 +1,18 @@ +# StepFinishPart + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**session_id** | **String** | | +**message_id** | **String** | | +**r#type** | **String** | | +**reason** | **String** | | +**snapshot** | Option<**String**> | | [optional] +**cost** | **f64** | | +**tokens** | [**models::AssistantMessageTokens**](AssistantMessage_tokens.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/StepStartPart.md b/crates/opencode-client/generated/docs/StepStartPart.md new file mode 100644 index 0000000..3b9c1f2 --- /dev/null +++ b/crates/opencode-client/generated/docs/StepStartPart.md @@ -0,0 +1,15 @@ +# StepStartPart + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**session_id** | **String** | | +**message_id** | **String** | | +**r#type** | **String** | | +**snapshot** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SubtaskPartInput.md b/crates/opencode-client/generated/docs/SubtaskPartInput.md new file mode 100644 index 0000000..14ae7b2 --- /dev/null +++ b/crates/opencode-client/generated/docs/SubtaskPartInput.md @@ -0,0 +1,16 @@ +# SubtaskPartInput + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | Option<**String**> | | [optional] +**r#type** | **String** | | +**prompt** | **String** | | +**description** | **String** | | +**agent** | **String** | | +**command** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/Symbol.md b/crates/opencode-client/generated/docs/Symbol.md new file mode 100644 index 0000000..8e031e5 --- /dev/null +++ b/crates/opencode-client/generated/docs/Symbol.md @@ -0,0 +1,13 @@ +# Symbol + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**name** | **String** | | +**kind** | **f64** | | +**location** | [**models::SymbolLocation**](Symbol_location.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SymbolLocation.md b/crates/opencode-client/generated/docs/SymbolLocation.md new file mode 100644 index 0000000..f55f71e --- /dev/null +++ b/crates/opencode-client/generated/docs/SymbolLocation.md @@ -0,0 +1,12 @@ +# SymbolLocation + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**uri** | **String** | | +**range** | [**models::Range**](Range.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/SymbolSource.md b/crates/opencode-client/generated/docs/SymbolSource.md new file mode 100644 index 0000000..a12828b --- /dev/null +++ b/crates/opencode-client/generated/docs/SymbolSource.md @@ -0,0 +1,16 @@ +# SymbolSource + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**text** | [**models::FilePartSourceText**](FilePartSourceText.md) | | +**r#type** | **String** | | +**path** | **String** | | +**range** | [**models::Range**](Range.md) | | +**name** | **String** | | +**kind** | **i32** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/TextPart.md b/crates/opencode-client/generated/docs/TextPart.md new file mode 100644 index 0000000..f561477 --- /dev/null +++ b/crates/opencode-client/generated/docs/TextPart.md @@ -0,0 +1,19 @@ +# TextPart + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**session_id** | **String** | | +**message_id** | **String** | | +**r#type** | **String** | | +**text** | **String** | | +**synthetic** | Option<**bool**> | | [optional] +**ignored** | Option<**bool**> | | [optional] +**time** | Option<[**models::TextPartTime**](TextPart_time.md)> | | [optional] +**metadata** | Option<[**std::collections::HashMap**](serde_json::Value.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/TextPartInput.md b/crates/opencode-client/generated/docs/TextPartInput.md new file mode 100644 index 0000000..bdc832d --- /dev/null +++ b/crates/opencode-client/generated/docs/TextPartInput.md @@ -0,0 +1,17 @@ +# TextPartInput + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | Option<**String**> | | [optional] +**r#type** | **String** | | +**text** | **String** | | +**synthetic** | Option<**bool**> | | [optional] +**ignored** | Option<**bool**> | | [optional] +**time** | Option<[**models::TextPartTime**](TextPart_time.md)> | | [optional] +**metadata** | Option<[**std::collections::HashMap**](serde_json::Value.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/TextPartTime.md b/crates/opencode-client/generated/docs/TextPartTime.md new file mode 100644 index 0000000..f5a37b0 --- /dev/null +++ b/crates/opencode-client/generated/docs/TextPartTime.md @@ -0,0 +1,12 @@ +# TextPartTime + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**start** | **f64** | | +**end** | Option<**f64**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/Todo.md b/crates/opencode-client/generated/docs/Todo.md new file mode 100644 index 0000000..1a091c3 --- /dev/null +++ b/crates/opencode-client/generated/docs/Todo.md @@ -0,0 +1,14 @@ +# Todo + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**content** | **String** | Brief description of the task | +**status** | **String** | Current status of the task: pending, in_progress, completed, cancelled | +**priority** | **String** | Priority level of the task: high, medium, low | +**id** | **String** | Unique identifier for the todo item | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ToolListItem.md b/crates/opencode-client/generated/docs/ToolListItem.md new file mode 100644 index 0000000..a83f06b --- /dev/null +++ b/crates/opencode-client/generated/docs/ToolListItem.md @@ -0,0 +1,13 @@ +# ToolListItem + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**description** | **String** | | +**parameters** | Option<[**serde_json::Value**](.md)> | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ToolPart.md b/crates/opencode-client/generated/docs/ToolPart.md new file mode 100644 index 0000000..e8808ea --- /dev/null +++ b/crates/opencode-client/generated/docs/ToolPart.md @@ -0,0 +1,18 @@ +# ToolPart + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**session_id** | **String** | | +**message_id** | **String** | | +**r#type** | **String** | | +**call_id** | **String** | | +**tool** | **String** | | +**state** | [**models::ToolState**](ToolState.md) | | +**metadata** | Option<[**std::collections::HashMap**](serde_json::Value.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ToolState.md b/crates/opencode-client/generated/docs/ToolState.md new file mode 100644 index 0000000..9275f97 --- /dev/null +++ b/crates/opencode-client/generated/docs/ToolState.md @@ -0,0 +1,19 @@ +# ToolState + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**status** | **String** | | +**input** | [**std::collections::HashMap**](serde_json::Value.md) | | +**raw** | **String** | | +**title** | **String** | | +**metadata** | [**std::collections::HashMap**](serde_json::Value.md) | | +**time** | [**models::ToolStateErrorTime**](ToolStateError_time.md) | | +**output** | **String** | | +**attachments** | Option<[**Vec**](FilePart.md)> | | [optional] +**error** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ToolStateCompleted.md b/crates/opencode-client/generated/docs/ToolStateCompleted.md new file mode 100644 index 0000000..1886a22 --- /dev/null +++ b/crates/opencode-client/generated/docs/ToolStateCompleted.md @@ -0,0 +1,17 @@ +# ToolStateCompleted + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**status** | **String** | | +**input** | [**std::collections::HashMap**](serde_json::Value.md) | | +**output** | **String** | | +**title** | **String** | | +**metadata** | [**std::collections::HashMap**](serde_json::Value.md) | | +**time** | [**models::ToolStateCompletedTime**](ToolStateCompleted_time.md) | | +**attachments** | Option<[**Vec**](FilePart.md)> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ToolStateCompletedTime.md b/crates/opencode-client/generated/docs/ToolStateCompletedTime.md new file mode 100644 index 0000000..e1ea778 --- /dev/null +++ b/crates/opencode-client/generated/docs/ToolStateCompletedTime.md @@ -0,0 +1,13 @@ +# ToolStateCompletedTime + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**start** | **f64** | | +**end** | **f64** | | +**compacted** | Option<**f64**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ToolStateError.md b/crates/opencode-client/generated/docs/ToolStateError.md new file mode 100644 index 0000000..9b2c0f1 --- /dev/null +++ b/crates/opencode-client/generated/docs/ToolStateError.md @@ -0,0 +1,15 @@ +# ToolStateError + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**status** | **String** | | +**input** | [**std::collections::HashMap**](serde_json::Value.md) | | +**error** | **String** | | +**metadata** | Option<[**std::collections::HashMap**](serde_json::Value.md)> | | [optional] +**time** | [**models::ToolStateErrorTime**](ToolStateError_time.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ToolStateErrorTime.md b/crates/opencode-client/generated/docs/ToolStateErrorTime.md new file mode 100644 index 0000000..9306bde --- /dev/null +++ b/crates/opencode-client/generated/docs/ToolStateErrorTime.md @@ -0,0 +1,12 @@ +# ToolStateErrorTime + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**start** | **f64** | | +**end** | **f64** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ToolStatePending.md b/crates/opencode-client/generated/docs/ToolStatePending.md new file mode 100644 index 0000000..795aefc --- /dev/null +++ b/crates/opencode-client/generated/docs/ToolStatePending.md @@ -0,0 +1,13 @@ +# ToolStatePending + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**status** | **String** | | +**input** | [**std::collections::HashMap**](serde_json::Value.md) | | +**raw** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ToolStateRunning.md b/crates/opencode-client/generated/docs/ToolStateRunning.md new file mode 100644 index 0000000..f13954b --- /dev/null +++ b/crates/opencode-client/generated/docs/ToolStateRunning.md @@ -0,0 +1,15 @@ +# ToolStateRunning + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**status** | **String** | | +**input** | [**std::collections::HashMap**](serde_json::Value.md) | | +**title** | Option<**String**> | | [optional] +**metadata** | Option<[**std::collections::HashMap**](serde_json::Value.md)> | | [optional] +**time** | [**models::ToolStateRunningTime**](ToolStateRunning_time.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/ToolStateRunningTime.md b/crates/opencode-client/generated/docs/ToolStateRunningTime.md new file mode 100644 index 0000000..82fddd1 --- /dev/null +++ b/crates/opencode-client/generated/docs/ToolStateRunningTime.md @@ -0,0 +1,11 @@ +# ToolStateRunningTime + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**start** | **f64** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/TuiControlNext200Response.md b/crates/opencode-client/generated/docs/TuiControlNext200Response.md new file mode 100644 index 0000000..8a9f9bf --- /dev/null +++ b/crates/opencode-client/generated/docs/TuiControlNext200Response.md @@ -0,0 +1,12 @@ +# TuiControlNext200Response + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**path** | **String** | | +**body** | Option<[**serde_json::Value**](.md)> | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/TuiExecuteCommandRequest.md b/crates/opencode-client/generated/docs/TuiExecuteCommandRequest.md new file mode 100644 index 0000000..fae579b --- /dev/null +++ b/crates/opencode-client/generated/docs/TuiExecuteCommandRequest.md @@ -0,0 +1,11 @@ +# TuiExecuteCommandRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**command** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/TuiPublishRequest.md b/crates/opencode-client/generated/docs/TuiPublishRequest.md new file mode 100644 index 0000000..141bb6d --- /dev/null +++ b/crates/opencode-client/generated/docs/TuiPublishRequest.md @@ -0,0 +1,12 @@ +# TuiPublishRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**properties** | [**models::TuiShowToastRequest**](tui_showToast_request.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/TuiShowToastRequest.md b/crates/opencode-client/generated/docs/TuiShowToastRequest.md new file mode 100644 index 0000000..88e9d93 --- /dev/null +++ b/crates/opencode-client/generated/docs/TuiShowToastRequest.md @@ -0,0 +1,14 @@ +# TuiShowToastRequest + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**title** | Option<**String**> | | [optional] +**message** | **String** | | +**variant** | **String** | | +**duration** | Option<**f64**> | Duration in milliseconds | [optional][default to 5000] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/UnknownError.md b/crates/opencode-client/generated/docs/UnknownError.md new file mode 100644 index 0000000..bd36d8d --- /dev/null +++ b/crates/opencode-client/generated/docs/UnknownError.md @@ -0,0 +1,12 @@ +# UnknownError + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**name** | **String** | | +**data** | [**models::UnknownErrorData**](UnknownError_data.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/UnknownErrorData.md b/crates/opencode-client/generated/docs/UnknownErrorData.md new file mode 100644 index 0000000..164b09d --- /dev/null +++ b/crates/opencode-client/generated/docs/UnknownErrorData.md @@ -0,0 +1,11 @@ +# UnknownErrorData + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**message** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/UserMessage.md b/crates/opencode-client/generated/docs/UserMessage.md new file mode 100644 index 0000000..fa0790d --- /dev/null +++ b/crates/opencode-client/generated/docs/UserMessage.md @@ -0,0 +1,20 @@ +# UserMessage + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**id** | **String** | | +**session_id** | **String** | | +**role** | **String** | | +**time** | [**models::UserMessageTime**](UserMessage_time.md) | | +**summary** | Option<[**models::UserMessageSummary**](UserMessage_summary.md)> | | [optional] +**agent** | **String** | | +**model** | [**models::SessionPromptRequestModel**](session_prompt_request_model.md) | | +**system** | Option<**String**> | | [optional] +**tools** | Option<**std::collections::HashMap**> | | [optional] +**variant** | Option<**String**> | | [optional] + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/UserMessageSummary.md b/crates/opencode-client/generated/docs/UserMessageSummary.md new file mode 100644 index 0000000..b8a4495 --- /dev/null +++ b/crates/opencode-client/generated/docs/UserMessageSummary.md @@ -0,0 +1,13 @@ +# UserMessageSummary + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**title** | Option<**String**> | | [optional] +**body** | Option<**String**> | | [optional] +**diffs** | [**Vec**](FileDiff.md) | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/UserMessageTime.md b/crates/opencode-client/generated/docs/UserMessageTime.md new file mode 100644 index 0000000..d8c6cea --- /dev/null +++ b/crates/opencode-client/generated/docs/UserMessageTime.md @@ -0,0 +1,11 @@ +# UserMessageTime + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**created** | **f64** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/VcsInfo.md b/crates/opencode-client/generated/docs/VcsInfo.md new file mode 100644 index 0000000..f10baec --- /dev/null +++ b/crates/opencode-client/generated/docs/VcsInfo.md @@ -0,0 +1,11 @@ +# VcsInfo + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**branch** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/docs/WellKnownAuth.md b/crates/opencode-client/generated/docs/WellKnownAuth.md new file mode 100644 index 0000000..9ddb79f --- /dev/null +++ b/crates/opencode-client/generated/docs/WellKnownAuth.md @@ -0,0 +1,13 @@ +# WellKnownAuth + +## Properties + +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**r#type** | **String** | | +**key** | **String** | | +**token** | **String** | | + +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/crates/opencode-client/generated/git_push.sh b/crates/opencode-client/generated/git_push.sh new file mode 100644 index 0000000..f53a75d --- /dev/null +++ b/crates/opencode-client/generated/git_push.sh @@ -0,0 +1,57 @@ +#!/bin/sh +# ref: https://help.github.com/articles/adding-an-existing-project-to-github-using-the-command-line/ +# +# Usage example: /bin/sh ./git_push.sh wing328 openapi-petstore-perl "minor update" "gitlab.com" + +git_user_id=$1 +git_repo_id=$2 +release_note=$3 +git_host=$4 + +if [ "$git_host" = "" ]; then + git_host="github.com" + echo "[INFO] No command line input provided. Set \$git_host to $git_host" +fi + +if [ "$git_user_id" = "" ]; then + git_user_id="GIT_USER_ID" + echo "[INFO] No command line input provided. Set \$git_user_id to $git_user_id" +fi + +if [ "$git_repo_id" = "" ]; then + git_repo_id="GIT_REPO_ID" + echo "[INFO] No command line input provided. Set \$git_repo_id to $git_repo_id" +fi + +if [ "$release_note" = "" ]; then + release_note="Minor update" + echo "[INFO] No command line input provided. Set \$release_note to $release_note" +fi + +# Initialize the local directory as a Git repository +git init + +# Adds the files in the local repository and stages them for commit. +git add . + +# Commits the tracked changes and prepares them to be pushed to a remote repository. +git commit -m "$release_note" + +# Sets the new remote +git_remote=$(git remote) +if [ "$git_remote" = "" ]; then # git remote not defined + + if [ "$GIT_TOKEN" = "" ]; then + echo "[INFO] \$GIT_TOKEN (environment variable) is not set. Using the git credential in your environment." + git remote add origin https://${git_host}/${git_user_id}/${git_repo_id}.git + else + git remote add origin https://${git_user_id}:"${GIT_TOKEN}"@${git_host}/${git_user_id}/${git_repo_id}.git + fi + +fi + +git pull origin master + +# Pushes (Forces) the changes in the local repository up to the remote repository +echo "Git pushing to https://${git_host}/${git_user_id}/${git_repo_id}.git" +git push origin master 2>&1 | grep -v 'To https' diff --git a/crates/opencode-client/generated/src/apis/configuration.rs b/crates/opencode-client/generated/src/apis/configuration.rs new file mode 100644 index 0000000..9b7e71b --- /dev/null +++ b/crates/opencode-client/generated/src/apis/configuration.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + + + +#[derive(Debug, Clone)] +pub struct Configuration { + pub base_path: String, + pub user_agent: Option, + pub client: reqwest::Client, + pub basic_auth: Option, + pub oauth_access_token: Option, + pub bearer_access_token: Option, + pub api_key: Option, +} + +pub type BasicAuth = (String, Option); + +#[derive(Debug, Clone)] +pub struct ApiKey { + pub prefix: Option, + pub key: String, +} + + +impl Configuration { + pub fn new() -> Configuration { + Configuration::default() + } +} + +impl Default for Configuration { + fn default() -> Self { + Configuration { + base_path: "http://localhost".to_owned(), + user_agent: Some("OpenAPI-Generator/0.0.3/rust".to_owned()), + client: reqwest::Client::new(), + basic_auth: None, + oauth_access_token: None, + bearer_access_token: None, + api_key: None, + } + } +} diff --git a/crates/opencode-client/generated/src/apis/default_api.rs b/crates/opencode-client/generated/src/apis/default_api.rs new file mode 100644 index 0000000..a1b1297 --- /dev/null +++ b/crates/opencode-client/generated/src/apis/default_api.rs @@ -0,0 +1,4042 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + + +use reqwest; +use serde::{Deserialize, Serialize, de::Error as _}; +use crate::{apis::ResponseContent, models}; +use super::{Error, configuration, ContentType}; + + +/// struct for typed errors of method [`app_agents`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum AppAgentsError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`app_log`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum AppLogError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`auth_set`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum AuthSetError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`command_list`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum CommandListError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`config_get`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ConfigGetError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`config_providers`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ConfigProvidersError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`config_update`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ConfigUpdateError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`event_subscribe`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum EventSubscribeError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`file_list`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum FileListError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`file_read`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum FileReadError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`file_status`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum FileStatusError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`find_files`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum FindFilesError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`find_symbols`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum FindSymbolsError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`find_text`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum FindTextError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`formatter_status`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum FormatterStatusError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`global_dispose`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum GlobalDisposeError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`global_event`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum GlobalEventError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`global_health`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum GlobalHealthError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`instance_dispose`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum InstanceDisposeError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`lsp_status`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum LspStatusError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`mcp_add`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpAddError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`mcp_auth_authenticate`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpAuthAuthenticateError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`mcp_auth_callback`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpAuthCallbackError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`mcp_auth_remove`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpAuthRemoveError { + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`mcp_auth_start`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpAuthStartError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`mcp_connect`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpConnectError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`mcp_disconnect`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpDisconnectError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`mcp_status`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpStatusError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`part_delete`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PartDeleteError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`part_update`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PartUpdateError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`path_get`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PathGetError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`permission_list`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PermissionListError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`permission_respond`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PermissionRespondError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`project_current`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ProjectCurrentError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`project_list`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ProjectListError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`project_update`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ProjectUpdateError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`provider_auth`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ProviderAuthError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`provider_list`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ProviderListError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`provider_oauth_authorize`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ProviderOauthAuthorizeError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`provider_oauth_callback`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ProviderOauthCallbackError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`pty_connect`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PtyConnectError { + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`pty_create`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PtyCreateError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`pty_get`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PtyGetError { + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`pty_list`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PtyListError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`pty_remove`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PtyRemoveError { + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`pty_update`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PtyUpdateError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_abort`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionAbortError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_command`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionCommandError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_create`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionCreateError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_delete`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionDeleteError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_diff`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionDiffError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_fork`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionForkError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_init`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionInitError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_list`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionListError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_message`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionMessageError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_messages`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionMessagesError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_prompt`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionPromptError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_prompt_async`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionPromptAsyncError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_revert`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionRevertError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_share`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionShareError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_shell`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionShellError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_status`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionStatusError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_summarize`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionSummarizeError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_todo`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionTodoError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_unrevert`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionUnrevertError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_unshare`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionUnshareError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_update`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionUpdateError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tool_ids`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ToolIdsError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tool_list`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ToolListError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_append_prompt`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiAppendPromptError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_clear_prompt`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiClearPromptError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_control_next`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiControlNextError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_control_response`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiControlResponseError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_execute_command`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiExecuteCommandError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_open_help`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiOpenHelpError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_open_models`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiOpenModelsError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_open_sessions`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiOpenSessionsError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_open_themes`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiOpenThemesError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_publish`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiPublishError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_show_toast`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiShowToastError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_submit_prompt`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiSubmitPromptError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`vcs_get`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum VcsGetError { + UnknownValue(serde_json::Value), +} + + +/// Get a list of all available AI agents in the OpenCode system. +pub async fn app_agents(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/agent", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Agent>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Agent>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Write a log entry to the server logs with specified level and metadata. +pub async fn app_log(configuration: &configuration::Configuration, directory: Option<&str>, app_log_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_app_log_request = app_log_request; + + let uri_str = format!("{}/log", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_app_log_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Set authentication credentials +pub async fn auth_set(configuration: &configuration::Configuration, provider_id: &str, directory: Option<&str>, auth: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_provider_id = provider_id; + let p_query_directory = directory; + let p_body_auth = auth; + + let uri_str = format!("{}/auth/{providerID}", configuration.base_path, providerID=crate::apis::urlencode(p_path_provider_id)); + let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_auth); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get a list of all available commands in the OpenCode system. +pub async fn command_list(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/command", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Command>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Command>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve the current OpenCode configuration settings and preferences. +pub async fn config_get(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/config", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Config`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Config`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get a list of all configured AI providers and their default models. +pub async fn config_providers(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/config/providers", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ConfigProviders200Response`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ConfigProviders200Response`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Update OpenCode configuration settings and preferences. +pub async fn config_update(configuration: &configuration::Configuration, directory: Option<&str>, config: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_config = config; + + let uri_str = format!("{}/config", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_config); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Config`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Config`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get events +pub async fn event_subscribe(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/event", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Event`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Event`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// List files and directories in a specified path. +pub async fn file_list(configuration: &configuration::Configuration, path: &str, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_path = path; + let p_query_directory = directory; + + let uri_str = format!("{}/file", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + req_builder = req_builder.query(&[("path", &p_query_path.to_string())]); + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::FileNode>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::FileNode>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Read the content of a specified file. +pub async fn file_read(configuration: &configuration::Configuration, path: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_path = path; + let p_query_directory = directory; + + let uri_str = format!("{}/file/content", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + req_builder = req_builder.query(&[("path", &p_query_path.to_string())]); + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::FileContent`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::FileContent`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get the git status of all files in the project. +pub async fn file_status(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/file/status", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::File>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::File>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Search for files or directories by name or pattern in the project directory. +pub async fn find_files(configuration: &configuration::Configuration, query: &str, directory: Option<&str>, dirs: Option<&str>, r#type: Option<&str>, limit: Option) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_query = query; + let p_query_directory = directory; + let p_query_dirs = dirs; + let p_query_type = r#type; + let p_query_limit = limit; + + let uri_str = format!("{}/find/file", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + req_builder = req_builder.query(&[("query", &p_query_query.to_string())]); + if let Some(ref param_value) = p_query_dirs { + req_builder = req_builder.query(&[("dirs", &serde_json::to_string(param_value)?)]); + } + if let Some(ref param_value) = p_query_type { + req_builder = req_builder.query(&[("type", &serde_json::to_string(param_value)?)]); + } + if let Some(ref param_value) = p_query_limit { + req_builder = req_builder.query(&[("limit", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<String>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<String>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Search for workspace symbols like functions, classes, and variables using LSP. +pub async fn find_symbols(configuration: &configuration::Configuration, query: &str, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_query = query; + let p_query_directory = directory; + + let uri_str = format!("{}/find/symbol", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + req_builder = req_builder.query(&[("query", &p_query_query.to_string())]); + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Symbol>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Symbol>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Search for text patterns across files in the project using ripgrep. +pub async fn find_text(configuration: &configuration::Configuration, pattern: &str, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_pattern = pattern; + let p_query_directory = directory; + + let uri_str = format!("{}/find", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + req_builder = req_builder.query(&[("pattern", &p_query_pattern.to_string())]); + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::FindText200ResponseInner>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::FindText200ResponseInner>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get formatter status +pub async fn formatter_status(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/formatter", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::FormatterStatus>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::FormatterStatus>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Clean up and dispose all OpenCode instances, releasing all resources. +pub async fn global_dispose(configuration: &configuration::Configuration, ) -> Result> { + + let uri_str = format!("{}/global/dispose", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Subscribe to global events from the OpenCode system using server-sent events. +pub async fn global_event(configuration: &configuration::Configuration, ) -> Result> { + + let uri_str = format!("{}/global/event", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GlobalEvent`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GlobalEvent`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get health information about the OpenCode server. +pub async fn global_health(configuration: &configuration::Configuration, ) -> Result> { + + let uri_str = format!("{}/global/health", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GlobalHealth200Response`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GlobalHealth200Response`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Clean up and dispose the current OpenCode instance, releasing all resources. +pub async fn instance_dispose(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/instance/dispose", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get LSP server status +pub async fn lsp_status(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/lsp", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::LspStatus>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::LspStatus>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Dynamically add a new Model Context Protocol (MCP) server to the system. +pub async fn mcp_add(configuration: &configuration::Configuration, directory: Option<&str>, mcp_add_request: Option) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_mcp_add_request = mcp_add_request; + + let uri_str = format!("{}/mcp", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_mcp_add_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `std::collections::HashMap<String, models::McpStatus>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap<String, models::McpStatus>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Start OAuth flow and wait for callback (opens browser) +pub async fn mcp_auth_authenticate(configuration: &configuration::Configuration, name: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_name = name; + let p_query_directory = directory; + + let uri_str = format!("{}/mcp/{name}/auth/authenticate", configuration.base_path, name=crate::apis::urlencode(p_path_name)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::McpStatus`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::McpStatus`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Complete OAuth authentication for a Model Context Protocol (MCP) server using the authorization code. +pub async fn mcp_auth_callback(configuration: &configuration::Configuration, name: &str, directory: Option<&str>, mcp_auth_callback_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_name = name; + let p_query_directory = directory; + let p_body_mcp_auth_callback_request = mcp_auth_callback_request; + + let uri_str = format!("{}/mcp/{name}/auth/callback", configuration.base_path, name=crate::apis::urlencode(p_path_name)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_mcp_auth_callback_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::McpStatus`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::McpStatus`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Remove OAuth credentials for an MCP server +pub async fn mcp_auth_remove(configuration: &configuration::Configuration, name: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_name = name; + let p_query_directory = directory; + + let uri_str = format!("{}/mcp/{name}/auth", configuration.base_path, name=crate::apis::urlencode(p_path_name)); + let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::McpAuthRemove200Response`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::McpAuthRemove200Response`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Start OAuth authentication flow for a Model Context Protocol (MCP) server. +pub async fn mcp_auth_start(configuration: &configuration::Configuration, name: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_name = name; + let p_query_directory = directory; + + let uri_str = format!("{}/mcp/{name}/auth", configuration.base_path, name=crate::apis::urlencode(p_path_name)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::McpAuthStart200Response`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::McpAuthStart200Response`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Connect an MCP server +pub async fn mcp_connect(configuration: &configuration::Configuration, name: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_name = name; + let p_query_directory = directory; + + let uri_str = format!("{}/mcp/{name}/connect", configuration.base_path, name=crate::apis::urlencode(p_path_name)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Disconnect an MCP server +pub async fn mcp_disconnect(configuration: &configuration::Configuration, name: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_name = name; + let p_query_directory = directory; + + let uri_str = format!("{}/mcp/{name}/disconnect", configuration.base_path, name=crate::apis::urlencode(p_path_name)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get the status of all Model Context Protocol (MCP) servers. +pub async fn mcp_status(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/mcp", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `std::collections::HashMap<String, models::McpStatus>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap<String, models::McpStatus>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Delete a part from a message +pub async fn part_delete(configuration: &configuration::Configuration, session_id: &str, message_id: &str, part_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_path_message_id = message_id; + let p_path_part_id = part_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}/message/{messageID}/part/{partID}", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id), messageID=crate::apis::urlencode(p_path_message_id), partID=crate::apis::urlencode(p_path_part_id)); + let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Update a part in a message +pub async fn part_update(configuration: &configuration::Configuration, session_id: &str, message_id: &str, part_id: &str, directory: Option<&str>, part: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_path_message_id = message_id; + let p_path_part_id = part_id; + let p_query_directory = directory; + let p_body_part = part; + + let uri_str = format!("{}/session/{sessionID}/message/{messageID}/part/{partID}", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id), messageID=crate::apis::urlencode(p_path_message_id), partID=crate::apis::urlencode(p_path_part_id)); + let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_part); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Part`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Part`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve the current working directory and related path information for the OpenCode instance. +pub async fn path_get(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/path", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Path`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Path`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get all pending permission requests across all sessions. +pub async fn permission_list(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/permission", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Permission>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Permission>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Approve or deny a permission request from the AI assistant. +pub async fn permission_respond(configuration: &configuration::Configuration, session_id: &str, permission_id: &str, directory: Option<&str>, permission_respond_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_path_permission_id = permission_id; + let p_query_directory = directory; + let p_body_permission_respond_request = permission_respond_request; + + let uri_str = format!("{}/session/{sessionID}/permissions/{permissionID}", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id), permissionID=crate::apis::urlencode(p_path_permission_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_permission_respond_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve the currently active project that OpenCode is working with. +pub async fn project_current(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/project/current", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Project`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Project`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get a list of projects that have been opened with OpenCode. +pub async fn project_list(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/project", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Project>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Project>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Update project properties such as name, icon and color. +pub async fn project_update(configuration: &configuration::Configuration, project_id: &str, directory: Option<&str>, project_update_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_project_id = project_id; + let p_query_directory = directory; + let p_body_project_update_request = project_update_request; + + let uri_str = format!("{}/project/{projectID}", configuration.base_path, projectID=crate::apis::urlencode(p_path_project_id)); + let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_project_update_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Project`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Project`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve available authentication methods for all AI providers. +pub async fn provider_auth(configuration: &configuration::Configuration, directory: Option<&str>) -> Result>, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/provider/auth", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `std::collections::HashMap<String, Vec<models::ProviderAuthMethod>>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap<String, Vec<models::ProviderAuthMethod>>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get a list of all available AI providers, including both available and connected ones. +pub async fn provider_list(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/provider", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProviderList200Response`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProviderList200Response`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Initiate OAuth authorization for a specific AI provider to get an authorization URL. +pub async fn provider_oauth_authorize(configuration: &configuration::Configuration, provider_id: &str, directory: Option<&str>, provider_oauth_authorize_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_provider_id = provider_id; + let p_query_directory = directory; + let p_body_provider_oauth_authorize_request = provider_oauth_authorize_request; + + let uri_str = format!("{}/provider/{providerID}/oauth/authorize", configuration.base_path, providerID=crate::apis::urlencode(p_path_provider_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_provider_oauth_authorize_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProviderAuthAuthorization`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProviderAuthAuthorization`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Handle the OAuth callback from a provider after user authorization. +pub async fn provider_oauth_callback(configuration: &configuration::Configuration, provider_id: &str, directory: Option<&str>, provider_oauth_callback_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_provider_id = provider_id; + let p_query_directory = directory; + let p_body_provider_oauth_callback_request = provider_oauth_callback_request; + + let uri_str = format!("{}/provider/{providerID}/oauth/callback", configuration.base_path, providerID=crate::apis::urlencode(p_path_provider_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_provider_oauth_callback_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Establish a WebSocket connection to interact with a pseudo-terminal (PTY) session in real-time. +pub async fn pty_connect(configuration: &configuration::Configuration, pty_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_pty_id = pty_id; + let p_query_directory = directory; + + let uri_str = format!("{}/pty/{ptyID}/connect", configuration.base_path, ptyID=crate::apis::urlencode(p_path_pty_id)); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Create a new pseudo-terminal (PTY) session for running shell commands and processes. +pub async fn pty_create(configuration: &configuration::Configuration, directory: Option<&str>, pty_create_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_pty_create_request = pty_create_request; + + let uri_str = format!("{}/pty", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_pty_create_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Pty`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Pty`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve detailed information about a specific pseudo-terminal (PTY) session. +pub async fn pty_get(configuration: &configuration::Configuration, pty_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_pty_id = pty_id; + let p_query_directory = directory; + + let uri_str = format!("{}/pty/{ptyID}", configuration.base_path, ptyID=crate::apis::urlencode(p_path_pty_id)); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Pty`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Pty`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get a list of all active pseudo-terminal (PTY) sessions managed by OpenCode. +pub async fn pty_list(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/pty", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Pty>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Pty>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Remove and terminate a specific pseudo-terminal (PTY) session. +pub async fn pty_remove(configuration: &configuration::Configuration, pty_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_pty_id = pty_id; + let p_query_directory = directory; + + let uri_str = format!("{}/pty/{ptyID}", configuration.base_path, ptyID=crate::apis::urlencode(p_path_pty_id)); + let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Update properties of an existing pseudo-terminal (PTY) session. +pub async fn pty_update(configuration: &configuration::Configuration, pty_id: &str, directory: Option<&str>, pty_update_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_pty_id = pty_id; + let p_query_directory = directory; + let p_body_pty_update_request = pty_update_request; + + let uri_str = format!("{}/pty/{ptyID}", configuration.base_path, ptyID=crate::apis::urlencode(p_path_pty_id)); + let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_pty_update_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Pty`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Pty`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Abort an active session and stop any ongoing AI processing or command execution. +pub async fn session_abort(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}/abort", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Send a new command to a session for execution by the AI assistant. +pub async fn session_command(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_command_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_command_request = session_command_request; + + let uri_str = format!("{}/session/{sessionID}/command", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_command_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SessionPrompt200Response`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SessionPrompt200Response`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Create a new OpenCode session for interacting with AI assistants and managing conversations. +pub async fn session_create(configuration: &configuration::Configuration, directory: Option<&str>, session_create_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_session_create_request = session_create_request; + + let uri_str = format!("{}/session", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_create_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Session`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Session`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Delete a session and permanently remove all associated data, including messages and history. +pub async fn session_delete(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get all file changes (diffs) made during this session. +pub async fn session_diff(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, message_id: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_query_message_id = message_id; + + let uri_str = format!("{}/session/{sessionID}/diff", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref param_value) = p_query_message_id { + req_builder = req_builder.query(&[("messageID", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::FileDiff>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::FileDiff>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Create a new session by forking an existing session at a specific message point. +pub async fn session_fork(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_fork_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_fork_request = session_fork_request; + + let uri_str = format!("{}/session/{sessionID}/fork", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_fork_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Session`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Session`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Analyze the current application and create an AGENTS.md file with project-specific agent configurations. +pub async fn session_init(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_init_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_init_request = session_init_request; + + let uri_str = format!("{}/session/{sessionID}/init", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_init_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get a list of all OpenCode sessions, sorted by most recently updated. +pub async fn session_list(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/session", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Session>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Session>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve a specific message from a session by its message ID. +pub async fn session_message(configuration: &configuration::Configuration, session_id: &str, message_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_path_message_id = message_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}/message/{messageID}", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id), messageID=crate::apis::urlencode(p_path_message_id)); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SessionMessages200ResponseInner`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SessionMessages200ResponseInner`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve all messages in a session, including user prompts and AI responses. +pub async fn session_messages(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, limit: Option) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_query_limit = limit; + + let uri_str = format!("{}/session/{sessionID}/message", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref param_value) = p_query_limit { + req_builder = req_builder.query(&[("limit", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::SessionMessages200ResponseInner>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::SessionMessages200ResponseInner>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Create and send a new message to a session, streaming the AI response. +pub async fn session_prompt(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_prompt_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_prompt_request = session_prompt_request; + + let uri_str = format!("{}/session/{sessionID}/message", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_prompt_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SessionPrompt200Response`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SessionPrompt200Response`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Create and send a new message to a session asynchronously, starting the session if needed and returning immediately. +pub async fn session_prompt_async(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_prompt_request: Option) -> Result<(), Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_prompt_request = session_prompt_request; + + let uri_str = format!("{}/session/{sessionID}/prompt_async", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_prompt_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + + if !status.is_client_error() && !status.is_server_error() { + Ok(()) + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Revert a specific message in a session, undoing its effects and restoring the previous state. +pub async fn session_revert(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_revert_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_revert_request = session_revert_request; + + let uri_str = format!("{}/session/{sessionID}/revert", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_revert_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Session`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Session`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Create a shareable link for a session, allowing others to view the conversation. +pub async fn session_share(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}/share", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Session`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Session`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Execute a shell command within the session context and return the AI's response. +pub async fn session_shell(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_shell_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_shell_request = session_shell_request; + + let uri_str = format!("{}/session/{sessionID}/shell", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_shell_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AssistantMessage`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AssistantMessage`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve the current status of all sessions, including active, idle, and completed states. +pub async fn session_status(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/session/status", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `std::collections::HashMap<String, models::SessionStatus>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap<String, models::SessionStatus>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Generate a concise summary of the session using AI compaction to preserve key information. +pub async fn session_summarize(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_summarize_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_summarize_request = session_summarize_request; + + let uri_str = format!("{}/session/{sessionID}/summarize", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_summarize_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve the todo list associated with a specific session, showing tasks and action items. +pub async fn session_todo(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}/todo", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Todo>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Todo>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Restore all previously reverted messages in a session. +pub async fn session_unrevert(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}/unrevert", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Session`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Session`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Remove the shareable link for a session, making it private again. +pub async fn session_unshare(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}/share", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Session`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Session`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Update properties of an existing session, such as title or other metadata. +pub async fn session_update(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_update_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_update_request = session_update_request; + + let uri_str = format!("{}/session/{sessionID}", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_update_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Session`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Session`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get a list of all available tool IDs, including both built-in tools and dynamically registered tools. +pub async fn tool_ids(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/experimental/tool/ids", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<String>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<String>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get a list of available tools with their JSON schema parameters for a specific provider and model combination. +pub async fn tool_list(configuration: &configuration::Configuration, provider: &str, model: &str, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_provider = provider; + let p_query_model = model; + let p_query_directory = directory; + + let uri_str = format!("{}/experimental/tool", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + req_builder = req_builder.query(&[("provider", &p_query_provider.to_string())]); + req_builder = req_builder.query(&[("model", &p_query_model.to_string())]); + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::ToolListItem>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::ToolListItem>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Append prompt to the TUI +pub async fn tui_append_prompt(configuration: &configuration::Configuration, directory: Option<&str>, find_text200_response_inner_path: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_find_text200_response_inner_path = find_text200_response_inner_path; + + let uri_str = format!("{}/tui/append-prompt", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_find_text200_response_inner_path); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Clear the prompt +pub async fn tui_clear_prompt(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/tui/clear-prompt", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve the next TUI (Terminal User Interface) request from the queue for processing. +pub async fn tui_control_next(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/tui/control/next", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TuiControlNext200Response`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TuiControlNext200Response`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Submit a response to the TUI request queue to complete a pending request. +pub async fn tui_control_response(configuration: &configuration::Configuration, directory: Option<&str>, body: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_body = body; + + let uri_str = format!("{}/tui/control/response", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_body); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Execute a TUI command (e.g. agent_cycle) +pub async fn tui_execute_command(configuration: &configuration::Configuration, directory: Option<&str>, tui_execute_command_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_tui_execute_command_request = tui_execute_command_request; + + let uri_str = format!("{}/tui/execute-command", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_tui_execute_command_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Open the help dialog in the TUI to display user assistance information. +pub async fn tui_open_help(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/tui/open-help", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Open the model dialog +pub async fn tui_open_models(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/tui/open-models", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Open the session dialog +pub async fn tui_open_sessions(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/tui/open-sessions", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Open the theme dialog +pub async fn tui_open_themes(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/tui/open-themes", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Publish a TUI event +pub async fn tui_publish(configuration: &configuration::Configuration, directory: Option<&str>, tui_publish_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_tui_publish_request = tui_publish_request; + + let uri_str = format!("{}/tui/publish", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_tui_publish_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Show a toast notification in the TUI +pub async fn tui_show_toast(configuration: &configuration::Configuration, directory: Option<&str>, tui_show_toast_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_tui_show_toast_request = tui_show_toast_request; + + let uri_str = format!("{}/tui/show-toast", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_tui_show_toast_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Submit the prompt +pub async fn tui_submit_prompt(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/tui/submit-prompt", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve version control system (VCS) information for the current project, such as git branch. +pub async fn vcs_get(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/vcs", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::VcsInfo`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::VcsInfo`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + diff --git a/crates/opencode-client/generated/src/apis/mod.rs b/crates/opencode-client/generated/src/apis/mod.rs new file mode 100644 index 0000000..f213bf7 --- /dev/null +++ b/crates/opencode-client/generated/src/apis/mod.rs @@ -0,0 +1,117 @@ +use std::error; +use std::fmt; + +#[derive(Debug, Clone)] +pub struct ResponseContent { + pub status: reqwest::StatusCode, + pub content: String, + pub entity: Option, +} + +#[derive(Debug)] +pub enum Error { + Reqwest(reqwest::Error), + Serde(serde_json::Error), + Io(std::io::Error), + ResponseError(ResponseContent), +} + +impl fmt::Display for Error { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let (module, e) = match self { + Error::Reqwest(e) => ("reqwest", e.to_string()), + Error::Serde(e) => ("serde", e.to_string()), + Error::Io(e) => ("IO", e.to_string()), + Error::ResponseError(e) => ("response", format!("status code {}", e.status)), + }; + write!(f, "error in {}: {}", module, e) + } +} + +impl error::Error for Error { + fn source(&self) -> Option<&(dyn error::Error + 'static)> { + Some(match self { + Error::Reqwest(e) => e, + Error::Serde(e) => e, + Error::Io(e) => e, + Error::ResponseError(_) => return None, + }) + } +} + +impl From for Error { + fn from(e: reqwest::Error) -> Self { + Error::Reqwest(e) + } +} + +impl From for Error { + fn from(e: serde_json::Error) -> Self { + Error::Serde(e) + } +} + +impl From for Error { + fn from(e: std::io::Error) -> Self { + Error::Io(e) + } +} + +pub fn urlencode>(s: T) -> String { + ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect() +} + +pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String, String)> { + if let serde_json::Value::Object(object) = value { + let mut params = vec![]; + + for (key, value) in object { + match value { + serde_json::Value::Object(_) => params.append(&mut parse_deep_object( + &format!("{}[{}]", prefix, key), + value, + )), + serde_json::Value::Array(array) => { + for (i, value) in array.iter().enumerate() { + params.append(&mut parse_deep_object( + &format!("{}[{}][{}]", prefix, key, i), + value, + )); + } + }, + serde_json::Value::String(s) => params.push((format!("{}[{}]", prefix, key), s.clone())), + _ => params.push((format!("{}[{}]", prefix, key), value.to_string())), + } + } + + return params; + } + + unimplemented!("Only objects are supported with style=deepObject") +} + +/// Internal use only +/// A content type supported by this client. +#[allow(dead_code)] +enum ContentType { + Json, + Text, + Unsupported(String) +} + +impl From<&str> for ContentType { + fn from(content_type: &str) -> Self { + if content_type.starts_with("application") && content_type.contains("json") { + return Self::Json; + } else if content_type.starts_with("text/plain") { + return Self::Text; + } else { + return Self::Unsupported(content_type.to_string()); + } + } +} + +pub mod default_api; +pub mod session_api; + +pub mod configuration; diff --git a/crates/opencode-client/generated/src/apis/session_api.rs b/crates/opencode-client/generated/src/apis/session_api.rs new file mode 100644 index 0000000..8e21b51 --- /dev/null +++ b/crates/opencode-client/generated/src/apis/session_api.rs @@ -0,0 +1,118 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + + +use reqwest; +use serde::{Deserialize, Serialize, de::Error as _}; +use crate::{apis::ResponseContent, models}; +use super::{Error, configuration, ContentType}; + + +/// struct for typed errors of method [`session_children`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionChildrenError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_get`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionGetError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + + +/// Retrieve all child sessions that were forked from the specified parent session. +pub async fn session_children(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}/children", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Session>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Session>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve detailed information about a specific OpenCode session. +pub async fn session_get(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Session`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Session`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + diff --git a/crates/opencode-client/generated/src/lib.rs b/crates/opencode-client/generated/src/lib.rs new file mode 100644 index 0000000..e152062 --- /dev/null +++ b/crates/opencode-client/generated/src/lib.rs @@ -0,0 +1,11 @@ +#![allow(unused_imports)] +#![allow(clippy::too_many_arguments)] + +extern crate serde_repr; +extern crate serde; +extern crate serde_json; +extern crate url; +extern crate reqwest; + +pub mod apis; +pub mod models; diff --git a/crates/opencode-client/generated/src/models/agent.rs b/crates/opencode-client/generated/src/models/agent.rs new file mode 100644 index 0000000..e02c00e --- /dev/null +++ b/crates/opencode-client/generated/src/models/agent.rs @@ -0,0 +1,85 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Agent { + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(rename = "mode")] + pub mode: Mode, + #[serde(rename = "native", skip_serializing_if = "Option::is_none")] + pub native: Option, + #[serde(rename = "hidden", skip_serializing_if = "Option::is_none")] + pub hidden: Option, + #[serde(rename = "default", skip_serializing_if = "Option::is_none")] + pub default: Option, + #[serde(rename = "topP", skip_serializing_if = "Option::is_none")] + pub top_p: Option, + #[serde(rename = "temperature", skip_serializing_if = "Option::is_none")] + pub temperature: Option, + #[serde(rename = "color", skip_serializing_if = "Option::is_none")] + pub color: Option, + #[serde(rename = "permission")] + pub permission: Box, + #[serde(rename = "model", skip_serializing_if = "Option::is_none")] + pub model: Option>, + #[serde(rename = "prompt", skip_serializing_if = "Option::is_none")] + pub prompt: Option, + #[serde(rename = "tools")] + pub tools: std::collections::HashMap, + #[serde(rename = "options")] + pub options: std::collections::HashMap, + #[serde(rename = "maxSteps", skip_serializing_if = "Option::is_none")] + pub max_steps: Option, +} + +impl Agent { + pub fn new(name: String, mode: Mode, permission: models::AgentPermission, tools: std::collections::HashMap, options: std::collections::HashMap) -> Agent { + Agent { + name, + description: None, + mode, + native: None, + hidden: None, + default: None, + top_p: None, + temperature: None, + color: None, + permission: Box::new(permission), + model: None, + prompt: None, + tools, + options, + max_steps: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Mode { + #[serde(rename = "subagent")] + Subagent, + #[serde(rename = "primary")] + Primary, + #[serde(rename = "all")] + All, +} + +impl Default for Mode { + fn default() -> Mode { + Self::Subagent + } +} + diff --git a/crates/opencode-client/generated/src/models/agent_config.rs b/crates/opencode-client/generated/src/models/agent_config.rs new file mode 100644 index 0000000..0423a38 --- /dev/null +++ b/crates/opencode-client/generated/src/models/agent_config.rs @@ -0,0 +1,76 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AgentConfig { + #[serde(rename = "model", skip_serializing_if = "Option::is_none")] + pub model: Option, + #[serde(rename = "temperature", skip_serializing_if = "Option::is_none")] + pub temperature: Option, + #[serde(rename = "top_p", skip_serializing_if = "Option::is_none")] + pub top_p: Option, + #[serde(rename = "prompt", skip_serializing_if = "Option::is_none")] + pub prompt: Option, + #[serde(rename = "tools", skip_serializing_if = "Option::is_none")] + pub tools: Option>, + #[serde(rename = "disable", skip_serializing_if = "Option::is_none")] + pub disable: Option, + /// Description of when to use the agent + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(rename = "mode", skip_serializing_if = "Option::is_none")] + pub mode: Option, + /// Hex color code for the agent (e.g., #FF5733) + #[serde(rename = "color", skip_serializing_if = "Option::is_none")] + pub color: Option, + /// Maximum number of agentic iterations before forcing text-only response + #[serde(rename = "maxSteps", skip_serializing_if = "Option::is_none")] + pub max_steps: Option, + #[serde(rename = "permission", skip_serializing_if = "Option::is_none")] + pub permission: Option>, +} + +impl AgentConfig { + pub fn new() -> AgentConfig { + AgentConfig { + model: None, + temperature: None, + top_p: None, + prompt: None, + tools: None, + disable: None, + description: None, + mode: None, + color: None, + max_steps: None, + permission: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Mode { + #[serde(rename = "subagent")] + Subagent, + #[serde(rename = "primary")] + Primary, + #[serde(rename = "all")] + All, +} + +impl Default for Mode { + fn default() -> Mode { + Self::Subagent + } +} + diff --git a/crates/opencode-client/generated/src/models/agent_config_permission.rs b/crates/opencode-client/generated/src/models/agent_config_permission.rs new file mode 100644 index 0000000..76e86d3 --- /dev/null +++ b/crates/opencode-client/generated/src/models/agent_config_permission.rs @@ -0,0 +1,106 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AgentConfigPermission { + #[serde(rename = "edit", skip_serializing_if = "Option::is_none")] + pub edit: Option, + #[serde(rename = "bash", skip_serializing_if = "Option::is_none")] + pub bash: Option>, + #[serde(rename = "skill", skip_serializing_if = "Option::is_none")] + pub skill: Option>, + #[serde(rename = "webfetch", skip_serializing_if = "Option::is_none")] + pub webfetch: Option, + #[serde(rename = "doom_loop", skip_serializing_if = "Option::is_none")] + pub doom_loop: Option, + #[serde(rename = "external_directory", skip_serializing_if = "Option::is_none")] + pub external_directory: Option, +} + +impl AgentConfigPermission { + pub fn new() -> AgentConfigPermission { + AgentConfigPermission { + edit: None, + bash: None, + skill: None, + webfetch: None, + doom_loop: None, + external_directory: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Edit { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for Edit { + fn default() -> Edit { + Self::Ask + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Webfetch { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for Webfetch { + fn default() -> Webfetch { + Self::Ask + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum DoomLoop { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for DoomLoop { + fn default() -> DoomLoop { + Self::Ask + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum ExternalDirectory { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for ExternalDirectory { + fn default() -> ExternalDirectory { + Self::Ask + } +} + diff --git a/crates/opencode-client/generated/src/models/agent_config_permission_bash.rs b/crates/opencode-client/generated/src/models/agent_config_permission_bash.rs new file mode 100644 index 0000000..bdcf3ec --- /dev/null +++ b/crates/opencode-client/generated/src/models/agent_config_permission_bash.rs @@ -0,0 +1,24 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AgentConfigPermissionBash { +} + +impl AgentConfigPermissionBash { + pub fn new() -> AgentConfigPermissionBash { + AgentConfigPermissionBash { + } + } +} + diff --git a/crates/opencode-client/generated/src/models/agent_part.rs b/crates/opencode-client/generated/src/models/agent_part.rs new file mode 100644 index 0000000..e658c84 --- /dev/null +++ b/crates/opencode-client/generated/src/models/agent_part.rs @@ -0,0 +1,54 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AgentPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "source", skip_serializing_if = "Option::is_none")] + pub source: Option>, +} + +impl AgentPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, name: String) -> AgentPart { + AgentPart { + id, + session_id, + message_id, + r#type, + name, + source: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "agent")] + Agent, +} + +impl Default for Type { + fn default() -> Type { + Self::Agent + } +} + diff --git a/crates/opencode-client/generated/src/models/agent_part_input.rs b/crates/opencode-client/generated/src/models/agent_part_input.rs new file mode 100644 index 0000000..1c48c38 --- /dev/null +++ b/crates/opencode-client/generated/src/models/agent_part_input.rs @@ -0,0 +1,48 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AgentPartInput { + #[serde(rename = "id", skip_serializing_if = "Option::is_none")] + pub id: Option, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "source", skip_serializing_if = "Option::is_none")] + pub source: Option>, +} + +impl AgentPartInput { + pub fn new(r#type: Type, name: String) -> AgentPartInput { + AgentPartInput { + id: None, + r#type, + name, + source: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "agent")] + Agent, +} + +impl Default for Type { + fn default() -> Type { + Self::Agent + } +} + diff --git a/crates/opencode-client/generated/src/models/agent_part_source.rs b/crates/opencode-client/generated/src/models/agent_part_source.rs new file mode 100644 index 0000000..20dbcc9 --- /dev/null +++ b/crates/opencode-client/generated/src/models/agent_part_source.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AgentPartSource { + #[serde(rename = "value")] + pub value: String, + #[serde(rename = "start")] + pub start: i32, + #[serde(rename = "end")] + pub end: i32, +} + +impl AgentPartSource { + pub fn new(value: String, start: i32, end: i32) -> AgentPartSource { + AgentPartSource { + value, + start, + end, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/agent_permission.rs b/crates/opencode-client/generated/src/models/agent_permission.rs new file mode 100644 index 0000000..4a006d5 --- /dev/null +++ b/crates/opencode-client/generated/src/models/agent_permission.rs @@ -0,0 +1,138 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AgentPermission { + #[serde(rename = "edit")] + pub edit: Edit, + #[serde(rename = "bash")] + pub bash: Bash, + #[serde(rename = "skill")] + pub skill: Skill, + #[serde(rename = "webfetch", skip_serializing_if = "Option::is_none")] + pub webfetch: Option, + #[serde(rename = "doom_loop", skip_serializing_if = "Option::is_none")] + pub doom_loop: Option, + #[serde(rename = "external_directory", skip_serializing_if = "Option::is_none")] + pub external_directory: Option, +} + +impl AgentPermission { + pub fn new(edit: Edit, bash: Bash, skill: Skill) -> AgentPermission { + AgentPermission { + edit, + bash, + skill, + webfetch: None, + doom_loop: None, + external_directory: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Edit { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for Edit { + fn default() -> Edit { + Self::Ask + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Bash { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for Bash { + fn default() -> Bash { + Self::Ask + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Skill { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for Skill { + fn default() -> Skill { + Self::Ask + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Webfetch { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for Webfetch { + fn default() -> Webfetch { + Self::Ask + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum DoomLoop { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for DoomLoop { + fn default() -> DoomLoop { + Self::Ask + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum ExternalDirectory { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for ExternalDirectory { + fn default() -> ExternalDirectory { + Self::Ask + } +} + diff --git a/crates/opencode-client/generated/src/models/api_auth.rs b/crates/opencode-client/generated/src/models/api_auth.rs new file mode 100644 index 0000000..ab03341 --- /dev/null +++ b/crates/opencode-client/generated/src/models/api_auth.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ApiAuth { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "key")] + pub key: String, +} + +impl ApiAuth { + pub fn new(r#type: Type, key: String) -> ApiAuth { + ApiAuth { + r#type, + key, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "api")] + Api, +} + +impl Default for Type { + fn default() -> Type { + Self::Api + } +} + diff --git a/crates/opencode-client/generated/src/models/api_error.rs b/crates/opencode-client/generated/src/models/api_error.rs new file mode 100644 index 0000000..fcbe3df --- /dev/null +++ b/crates/opencode-client/generated/src/models/api_error.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ApiError { + #[serde(rename = "name")] + pub name: Name, + #[serde(rename = "data")] + pub data: Box, +} + +impl ApiError { + pub fn new(name: Name, data: models::ApiErrorData) -> ApiError { + ApiError { + name, + data: Box::new(data), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Name { + #[serde(rename = "APIError")] + ApiError, +} + +impl Default for Name { + fn default() -> Name { + Self::ApiError + } +} + diff --git a/crates/opencode-client/generated/src/models/api_error_data.rs b/crates/opencode-client/generated/src/models/api_error_data.rs new file mode 100644 index 0000000..45f796e --- /dev/null +++ b/crates/opencode-client/generated/src/models/api_error_data.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ApiErrorData { + #[serde(rename = "message")] + pub message: String, + #[serde(rename = "statusCode", skip_serializing_if = "Option::is_none")] + pub status_code: Option, + #[serde(rename = "isRetryable")] + pub is_retryable: bool, + #[serde(rename = "responseHeaders", skip_serializing_if = "Option::is_none")] + pub response_headers: Option>, + #[serde(rename = "responseBody", skip_serializing_if = "Option::is_none")] + pub response_body: Option, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, +} + +impl ApiErrorData { + pub fn new(message: String, is_retryable: bool) -> ApiErrorData { + ApiErrorData { + message, + status_code: None, + is_retryable, + response_headers: None, + response_body: None, + metadata: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/app_log_request.rs b/crates/opencode-client/generated/src/models/app_log_request.rs new file mode 100644 index 0000000..3ff249a --- /dev/null +++ b/crates/opencode-client/generated/src/models/app_log_request.rs @@ -0,0 +1,58 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AppLogRequest { + /// Service name for the log entry + #[serde(rename = "service")] + pub service: String, + /// Log level + #[serde(rename = "level")] + pub level: Level, + /// Log message + #[serde(rename = "message")] + pub message: String, + /// Additional metadata for the log entry + #[serde(rename = "extra", skip_serializing_if = "Option::is_none")] + pub extra: Option>, +} + +impl AppLogRequest { + pub fn new(service: String, level: Level, message: String) -> AppLogRequest { + AppLogRequest { + service, + level, + message, + extra: None, + } + } +} +/// Log level +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Level { + #[serde(rename = "debug")] + Debug, + #[serde(rename = "info")] + Info, + #[serde(rename = "error")] + Error, + #[serde(rename = "warn")] + Warn, +} + +impl Default for Level { + fn default() -> Level { + Self::Debug + } +} + diff --git a/crates/opencode-client/generated/src/models/assistant_message.rs b/crates/opencode-client/generated/src/models/assistant_message.rs new file mode 100644 index 0000000..7b2c776 --- /dev/null +++ b/crates/opencode-client/generated/src/models/assistant_message.rs @@ -0,0 +1,81 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AssistantMessage { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "role")] + pub role: Role, + #[serde(rename = "time")] + pub time: Box, + #[serde(rename = "error", skip_serializing_if = "Option::is_none")] + pub error: Option>, + #[serde(rename = "parentID")] + pub parent_id: String, + #[serde(rename = "modelID")] + pub model_id: String, + #[serde(rename = "providerID")] + pub provider_id: String, + #[serde(rename = "mode")] + pub mode: String, + #[serde(rename = "agent")] + pub agent: String, + #[serde(rename = "path")] + pub path: Box, + #[serde(rename = "summary", skip_serializing_if = "Option::is_none")] + pub summary: Option, + #[serde(rename = "cost")] + pub cost: f64, + #[serde(rename = "tokens")] + pub tokens: Box, + #[serde(rename = "finish", skip_serializing_if = "Option::is_none")] + pub finish: Option, +} + +impl AssistantMessage { + pub fn new(id: String, session_id: String, role: Role, time: models::AssistantMessageTime, parent_id: String, model_id: String, provider_id: String, mode: String, agent: String, path: models::AssistantMessagePath, cost: f64, tokens: models::AssistantMessageTokens) -> AssistantMessage { + AssistantMessage { + id, + session_id, + role, + time: Box::new(time), + error: None, + parent_id, + model_id, + provider_id, + mode, + agent, + path: Box::new(path), + summary: None, + cost, + tokens: Box::new(tokens), + finish: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Role { + #[serde(rename = "assistant")] + Assistant, +} + +impl Default for Role { + fn default() -> Role { + Self::Assistant + } +} + diff --git a/crates/opencode-client/generated/src/models/assistant_message_error.rs b/crates/opencode-client/generated/src/models/assistant_message_error.rs new file mode 100644 index 0000000..d924467 --- /dev/null +++ b/crates/opencode-client/generated/src/models/assistant_message_error.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AssistantMessageError { + #[serde(rename = "name")] + pub name: Name, + #[serde(rename = "data")] + pub data: Box, +} + +impl AssistantMessageError { + pub fn new(name: Name, data: models::ApiErrorData) -> AssistantMessageError { + AssistantMessageError { + name, + data: Box::new(data), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Name { + #[serde(rename = "APIError")] + ApiError, +} + +impl Default for Name { + fn default() -> Name { + Self::ApiError + } +} + diff --git a/crates/opencode-client/generated/src/models/assistant_message_path.rs b/crates/opencode-client/generated/src/models/assistant_message_path.rs new file mode 100644 index 0000000..250e2af --- /dev/null +++ b/crates/opencode-client/generated/src/models/assistant_message_path.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AssistantMessagePath { + #[serde(rename = "cwd")] + pub cwd: String, + #[serde(rename = "root")] + pub root: String, +} + +impl AssistantMessagePath { + pub fn new(cwd: String, root: String) -> AssistantMessagePath { + AssistantMessagePath { + cwd, + root, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/assistant_message_time.rs b/crates/opencode-client/generated/src/models/assistant_message_time.rs new file mode 100644 index 0000000..d572b83 --- /dev/null +++ b/crates/opencode-client/generated/src/models/assistant_message_time.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AssistantMessageTime { + #[serde(rename = "created")] + pub created: f64, + #[serde(rename = "completed", skip_serializing_if = "Option::is_none")] + pub completed: Option, +} + +impl AssistantMessageTime { + pub fn new(created: f64) -> AssistantMessageTime { + AssistantMessageTime { + created, + completed: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/assistant_message_tokens.rs b/crates/opencode-client/generated/src/models/assistant_message_tokens.rs new file mode 100644 index 0000000..4ff9185 --- /dev/null +++ b/crates/opencode-client/generated/src/models/assistant_message_tokens.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AssistantMessageTokens { + #[serde(rename = "input")] + pub input: f64, + #[serde(rename = "output")] + pub output: f64, + #[serde(rename = "reasoning")] + pub reasoning: f64, + #[serde(rename = "cache")] + pub cache: Box, +} + +impl AssistantMessageTokens { + pub fn new(input: f64, output: f64, reasoning: f64, cache: models::AssistantMessageTokensCache) -> AssistantMessageTokens { + AssistantMessageTokens { + input, + output, + reasoning, + cache: Box::new(cache), + } + } +} + diff --git a/crates/opencode-client/generated/src/models/assistant_message_tokens_cache.rs b/crates/opencode-client/generated/src/models/assistant_message_tokens_cache.rs new file mode 100644 index 0000000..f470527 --- /dev/null +++ b/crates/opencode-client/generated/src/models/assistant_message_tokens_cache.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AssistantMessageTokensCache { + #[serde(rename = "read")] + pub read: f64, + #[serde(rename = "write")] + pub write: f64, +} + +impl AssistantMessageTokensCache { + pub fn new(read: f64, write: f64) -> AssistantMessageTokensCache { + AssistantMessageTokensCache { + read, + write, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/auth.rs b/crates/opencode-client/generated/src/models/auth.rs new file mode 100644 index 0000000..3c94cd9 --- /dev/null +++ b/crates/opencode-client/generated/src/models/auth.rs @@ -0,0 +1,61 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Auth { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "refresh")] + pub refresh: String, + #[serde(rename = "access")] + pub access: String, + #[serde(rename = "expires")] + pub expires: f64, + #[serde(rename = "enterpriseUrl", skip_serializing_if = "Option::is_none")] + pub enterprise_url: Option, + #[serde(rename = "key")] + pub key: String, + #[serde(rename = "token")] + pub token: String, +} + +impl Auth { + pub fn new(r#type: Type, refresh: String, access: String, expires: f64, key: String, token: String) -> Auth { + Auth { + r#type, + refresh, + access, + expires, + enterprise_url: None, + key, + token, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "oauth")] + Oauth, + #[serde(rename = "api")] + Api, + #[serde(rename = "wellknown")] + Wellknown, +} + +impl Default for Type { + fn default() -> Type { + Self::Oauth + } +} + diff --git a/crates/opencode-client/generated/src/models/bad_request_error.rs b/crates/opencode-client/generated/src/models/bad_request_error.rs new file mode 100644 index 0000000..7dfc848 --- /dev/null +++ b/crates/opencode-client/generated/src/models/bad_request_error.rs @@ -0,0 +1,45 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct BadRequestError { + #[serde(rename = "data", deserialize_with = "Option::deserialize")] + pub data: Option, + #[serde(rename = "errors")] + pub errors: Vec>, + #[serde(rename = "success")] + pub success: Success, +} + +impl BadRequestError { + pub fn new(data: Option, errors: Vec>, success: Success) -> BadRequestError { + BadRequestError { + data, + errors, + success, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Success { + #[serde(rename = "false")] + False, +} + +impl Default for Success { + fn default() -> Success { + Self::False + } +} + diff --git a/crates/opencode-client/generated/src/models/command.rs b/crates/opencode-client/generated/src/models/command.rs new file mode 100644 index 0000000..c7ac19a --- /dev/null +++ b/crates/opencode-client/generated/src/models/command.rs @@ -0,0 +1,45 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Command { + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(rename = "agent", skip_serializing_if = "Option::is_none")] + pub agent: Option, + #[serde(rename = "model", skip_serializing_if = "Option::is_none")] + pub model: Option, + #[serde(rename = "template")] + pub template: Box, + #[serde(rename = "subtask", skip_serializing_if = "Option::is_none")] + pub subtask: Option, + #[serde(rename = "hints")] + pub hints: Vec, +} + +impl Command { + pub fn new(name: String, template: models::CommandTemplate, hints: Vec) -> Command { + Command { + name, + description: None, + agent: None, + model: None, + template: Box::new(template), + subtask: None, + hints, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/command_template.rs b/crates/opencode-client/generated/src/models/command_template.rs new file mode 100644 index 0000000..174ade6 --- /dev/null +++ b/crates/opencode-client/generated/src/models/command_template.rs @@ -0,0 +1,24 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct CommandTemplate { +} + +impl CommandTemplate { + pub fn new() -> CommandTemplate { + CommandTemplate { + } + } +} + diff --git a/crates/opencode-client/generated/src/models/compaction_part.rs b/crates/opencode-client/generated/src/models/compaction_part.rs new file mode 100644 index 0000000..0bc3fb0 --- /dev/null +++ b/crates/opencode-client/generated/src/models/compaction_part.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct CompactionPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "auto")] + pub auto: bool, +} + +impl CompactionPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, auto: bool) -> CompactionPart { + CompactionPart { + id, + session_id, + message_id, + r#type, + auto, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "compaction")] + Compaction, +} + +impl Default for Type { + fn default() -> Type { + Self::Compaction + } +} + diff --git a/crates/opencode-client/generated/src/models/config.rs b/crates/opencode-client/generated/src/models/config.rs new file mode 100644 index 0000000..876fbc9 --- /dev/null +++ b/crates/opencode-client/generated/src/models/config.rs @@ -0,0 +1,150 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Config { + /// JSON schema reference for configuration validation + #[serde(rename = "$schema", skip_serializing_if = "Option::is_none")] + pub dollar_schema: Option, + /// Theme name to use for the interface + #[serde(rename = "theme", skip_serializing_if = "Option::is_none")] + pub theme: Option, + #[serde(rename = "keybinds", skip_serializing_if = "Option::is_none")] + pub keybinds: Option>, + #[serde(rename = "logLevel", skip_serializing_if = "Option::is_none")] + pub log_level: Option, + #[serde(rename = "tui", skip_serializing_if = "Option::is_none")] + pub tui: Option>, + #[serde(rename = "server", skip_serializing_if = "Option::is_none")] + pub server: Option>, + /// Command configuration, see https://opencode.ai/docs/commands + #[serde(rename = "command", skip_serializing_if = "Option::is_none")] + pub command: Option>, + #[serde(rename = "watcher", skip_serializing_if = "Option::is_none")] + pub watcher: Option>, + #[serde(rename = "plugin", skip_serializing_if = "Option::is_none")] + pub plugin: Option>, + #[serde(rename = "snapshot", skip_serializing_if = "Option::is_none")] + pub snapshot: Option, + /// Control sharing behavior:'manual' allows manual sharing via commands, 'auto' enables automatic sharing, 'disabled' disables all sharing + #[serde(rename = "share", skip_serializing_if = "Option::is_none")] + pub share: Option, + /// @deprecated Use 'share' field instead. Share newly created sessions automatically + #[serde(rename = "autoshare", skip_serializing_if = "Option::is_none")] + pub autoshare: Option, + #[serde(rename = "autoupdate", skip_serializing_if = "Option::is_none")] + pub autoupdate: Option>, + /// Disable providers that are loaded automatically + #[serde(rename = "disabled_providers", skip_serializing_if = "Option::is_none")] + pub disabled_providers: Option>, + /// When set, ONLY these providers will be enabled. All other providers will be ignored + #[serde(rename = "enabled_providers", skip_serializing_if = "Option::is_none")] + pub enabled_providers: Option>, + /// Model to use in the format of provider/model, eg anthropic/claude-2 + #[serde(rename = "model", skip_serializing_if = "Option::is_none")] + pub model: Option, + /// Small model to use for tasks like title generation in the format of provider/model + #[serde(rename = "small_model", skip_serializing_if = "Option::is_none")] + pub small_model: Option, + /// Default agent to use when none is specified. Must be a primary agent. Falls back to 'build' if not set or if the specified agent is invalid. + #[serde(rename = "default_agent", skip_serializing_if = "Option::is_none")] + pub default_agent: Option, + /// Custom username to display in conversations instead of system username + #[serde(rename = "username", skip_serializing_if = "Option::is_none")] + pub username: Option, + #[serde(rename = "mode", skip_serializing_if = "Option::is_none")] + pub mode: Option, + #[serde(rename = "agent", skip_serializing_if = "Option::is_none")] + pub agent: Option, + /// Custom provider configurations and model overrides + #[serde(rename = "provider", skip_serializing_if = "Option::is_none")] + pub provider: Option>, + /// MCP (Model Context Protocol) server configurations + #[serde(rename = "mcp", skip_serializing_if = "Option::is_none")] + pub mcp: Option>, + #[serde(rename = "formatter", skip_serializing_if = "Option::is_none")] + pub formatter: Option>, + #[serde(rename = "lsp", skip_serializing_if = "Option::is_none")] + pub lsp: Option>, + /// Additional instruction files or patterns to include + #[serde(rename = "instructions", skip_serializing_if = "Option::is_none")] + pub instructions: Option>, + #[serde(rename = "layout", skip_serializing_if = "Option::is_none")] + pub layout: Option, + #[serde(rename = "permission", skip_serializing_if = "Option::is_none")] + pub permission: Option>, + #[serde(rename = "tools", skip_serializing_if = "Option::is_none")] + pub tools: Option>, + #[serde(rename = "enterprise", skip_serializing_if = "Option::is_none")] + pub enterprise: Option>, + #[serde(rename = "compaction", skip_serializing_if = "Option::is_none")] + pub compaction: Option>, + #[serde(rename = "experimental", skip_serializing_if = "Option::is_none")] + pub experimental: Option>, +} + +impl Config { + pub fn new() -> Config { + Config { + dollar_schema: None, + theme: None, + keybinds: None, + log_level: None, + tui: None, + server: None, + command: None, + watcher: None, + plugin: None, + snapshot: None, + share: None, + autoshare: None, + autoupdate: None, + disabled_providers: None, + enabled_providers: None, + model: None, + small_model: None, + default_agent: None, + username: None, + mode: None, + agent: None, + provider: None, + mcp: None, + formatter: None, + lsp: None, + instructions: None, + layout: None, + permission: None, + tools: None, + enterprise: None, + compaction: None, + experimental: None, + } + } +} +/// Control sharing behavior:'manual' allows manual sharing via commands, 'auto' enables automatic sharing, 'disabled' disables all sharing +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Share { + #[serde(rename = "manual")] + Manual, + #[serde(rename = "auto")] + Auto, + #[serde(rename = "disabled")] + Disabled, +} + +impl Default for Share { + fn default() -> Share { + Self::Manual + } +} + diff --git a/crates/opencode-client/generated/src/models/config_agent.rs b/crates/opencode-client/generated/src/models/config_agent.rs new file mode 100644 index 0000000..16321e2 --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_agent.rs @@ -0,0 +1,47 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// ConfigAgent : Agent configuration, see https://opencode.ai/docs/agent +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigAgent { + #[serde(rename = "plan", skip_serializing_if = "Option::is_none")] + pub plan: Option, + #[serde(rename = "build", skip_serializing_if = "Option::is_none")] + pub build: Option, + #[serde(rename = "general", skip_serializing_if = "Option::is_none")] + pub general: Option, + #[serde(rename = "explore", skip_serializing_if = "Option::is_none")] + pub explore: Option, + #[serde(rename = "title", skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(rename = "summary", skip_serializing_if = "Option::is_none")] + pub summary: Option, + #[serde(rename = "compaction", skip_serializing_if = "Option::is_none")] + pub compaction: Option, +} + +impl ConfigAgent { + /// Agent configuration, see https://opencode.ai/docs/agent + pub fn new() -> ConfigAgent { + ConfigAgent { + plan: None, + build: None, + general: None, + explore: None, + title: None, + summary: None, + compaction: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/config_autoupdate.rs b/crates/opencode-client/generated/src/models/config_autoupdate.rs new file mode 100644 index 0000000..0024f1b --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_autoupdate.rs @@ -0,0 +1,26 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// ConfigAutoupdate : Automatically update to the latest version. Set to true to auto-update, false to disable, or 'notify' to show update notifications +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigAutoupdate { +} + +impl ConfigAutoupdate { + /// Automatically update to the latest version. Set to true to auto-update, false to disable, or 'notify' to show update notifications + pub fn new() -> ConfigAutoupdate { + ConfigAutoupdate { + } + } +} + diff --git a/crates/opencode-client/generated/src/models/config_command_value.rs b/crates/opencode-client/generated/src/models/config_command_value.rs new file mode 100644 index 0000000..4d4a40f --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_command_value.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigCommandValue { + #[serde(rename = "template")] + pub template: String, + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(rename = "agent", skip_serializing_if = "Option::is_none")] + pub agent: Option, + #[serde(rename = "model", skip_serializing_if = "Option::is_none")] + pub model: Option, + #[serde(rename = "subtask", skip_serializing_if = "Option::is_none")] + pub subtask: Option, +} + +impl ConfigCommandValue { + pub fn new(template: String) -> ConfigCommandValue { + ConfigCommandValue { + template, + description: None, + agent: None, + model: None, + subtask: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/config_compaction.rs b/crates/opencode-client/generated/src/models/config_compaction.rs new file mode 100644 index 0000000..9051b03 --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_compaction.rs @@ -0,0 +1,32 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigCompaction { + /// Enable automatic compaction when context is full (default: true) + #[serde(rename = "auto", skip_serializing_if = "Option::is_none")] + pub auto: Option, + /// Enable pruning of old tool outputs (default: true) + #[serde(rename = "prune", skip_serializing_if = "Option::is_none")] + pub prune: Option, +} + +impl ConfigCompaction { + pub fn new() -> ConfigCompaction { + ConfigCompaction { + auto: None, + prune: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/config_enterprise.rs b/crates/opencode-client/generated/src/models/config_enterprise.rs new file mode 100644 index 0000000..192b3a6 --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_enterprise.rs @@ -0,0 +1,28 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigEnterprise { + /// Enterprise URL + #[serde(rename = "url", skip_serializing_if = "Option::is_none")] + pub url: Option, +} + +impl ConfigEnterprise { + pub fn new() -> ConfigEnterprise { + ConfigEnterprise { + url: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/config_experimental.rs b/crates/opencode-client/generated/src/models/config_experimental.rs new file mode 100644 index 0000000..2fb2baf --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_experimental.rs @@ -0,0 +1,54 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigExperimental { + #[serde(rename = "hook", skip_serializing_if = "Option::is_none")] + pub hook: Option>, + /// Number of retries for chat completions on failure + #[serde(rename = "chatMaxRetries", skip_serializing_if = "Option::is_none")] + pub chat_max_retries: Option, + #[serde(rename = "disable_paste_summary", skip_serializing_if = "Option::is_none")] + pub disable_paste_summary: Option, + /// Enable the batch tool + #[serde(rename = "batch_tool", skip_serializing_if = "Option::is_none")] + pub batch_tool: Option, + /// Enable OpenTelemetry spans for AI SDK calls (using the 'experimental_telemetry' flag) + #[serde(rename = "openTelemetry", skip_serializing_if = "Option::is_none")] + pub open_telemetry: Option, + /// Tools that should only be available to primary agents. + #[serde(rename = "primary_tools", skip_serializing_if = "Option::is_none")] + pub primary_tools: Option>, + /// Continue the agent loop when a tool call is denied + #[serde(rename = "continue_loop_on_deny", skip_serializing_if = "Option::is_none")] + pub continue_loop_on_deny: Option, + /// Timeout in milliseconds for model context protocol (MCP) requests + #[serde(rename = "mcp_timeout", skip_serializing_if = "Option::is_none")] + pub mcp_timeout: Option, +} + +impl ConfigExperimental { + pub fn new() -> ConfigExperimental { + ConfigExperimental { + hook: None, + chat_max_retries: None, + disable_paste_summary: None, + batch_tool: None, + open_telemetry: None, + primary_tools: None, + continue_loop_on_deny: None, + mcp_timeout: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/config_experimental_hook.rs b/crates/opencode-client/generated/src/models/config_experimental_hook.rs new file mode 100644 index 0000000..69861fd --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_experimental_hook.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigExperimentalHook { + #[serde(rename = "file_edited", skip_serializing_if = "Option::is_none")] + pub file_edited: Option>>, + #[serde(rename = "session_completed", skip_serializing_if = "Option::is_none")] + pub session_completed: Option>, +} + +impl ConfigExperimentalHook { + pub fn new() -> ConfigExperimentalHook { + ConfigExperimentalHook { + file_edited: None, + session_completed: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/config_experimental_hook_file_edited_value_inner.rs b/crates/opencode-client/generated/src/models/config_experimental_hook_file_edited_value_inner.rs new file mode 100644 index 0000000..cf39444 --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_experimental_hook_file_edited_value_inner.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigExperimentalHookFileEditedValueInner { + #[serde(rename = "command")] + pub command: Vec, + #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] + pub environment: Option>, +} + +impl ConfigExperimentalHookFileEditedValueInner { + pub fn new(command: Vec) -> ConfigExperimentalHookFileEditedValueInner { + ConfigExperimentalHookFileEditedValueInner { + command, + environment: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/config_formatter.rs b/crates/opencode-client/generated/src/models/config_formatter.rs new file mode 100644 index 0000000..5b4a031 --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_formatter.rs @@ -0,0 +1,24 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigFormatter { +} + +impl ConfigFormatter { + pub fn new() -> ConfigFormatter { + ConfigFormatter { + } + } +} + diff --git a/crates/opencode-client/generated/src/models/config_formatter_any_of_value.rs b/crates/opencode-client/generated/src/models/config_formatter_any_of_value.rs new file mode 100644 index 0000000..267fc81 --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_formatter_any_of_value.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigFormatterAnyOfValue { + #[serde(rename = "disabled", skip_serializing_if = "Option::is_none")] + pub disabled: Option, + #[serde(rename = "command", skip_serializing_if = "Option::is_none")] + pub command: Option>, + #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] + pub environment: Option>, + #[serde(rename = "extensions", skip_serializing_if = "Option::is_none")] + pub extensions: Option>, +} + +impl ConfigFormatterAnyOfValue { + pub fn new() -> ConfigFormatterAnyOfValue { + ConfigFormatterAnyOfValue { + disabled: None, + command: None, + environment: None, + extensions: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/config_lsp.rs b/crates/opencode-client/generated/src/models/config_lsp.rs new file mode 100644 index 0000000..33fee06 --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_lsp.rs @@ -0,0 +1,24 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigLsp { +} + +impl ConfigLsp { + pub fn new() -> ConfigLsp { + ConfigLsp { + } + } +} + diff --git a/crates/opencode-client/generated/src/models/config_lsp_any_of_value.rs b/crates/opencode-client/generated/src/models/config_lsp_any_of_value.rs new file mode 100644 index 0000000..d006a1b --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_lsp_any_of_value.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigLspAnyOfValue { + #[serde(rename = "disabled")] + pub disabled: bool, + #[serde(rename = "command")] + pub command: Vec, + #[serde(rename = "extensions", skip_serializing_if = "Option::is_none")] + pub extensions: Option>, + #[serde(rename = "env", skip_serializing_if = "Option::is_none")] + pub env: Option>, + #[serde(rename = "initialization", skip_serializing_if = "Option::is_none")] + pub initialization: Option>, +} + +impl ConfigLspAnyOfValue { + pub fn new(disabled: bool, command: Vec) -> ConfigLspAnyOfValue { + ConfigLspAnyOfValue { + disabled, + command, + extensions: None, + env: None, + initialization: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/config_lsp_any_of_value_any_of.rs b/crates/opencode-client/generated/src/models/config_lsp_any_of_value_any_of.rs new file mode 100644 index 0000000..f822eca --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_lsp_any_of_value_any_of.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigLspAnyOfValueAnyOf { + #[serde(rename = "disabled")] + pub disabled: Disabled, +} + +impl ConfigLspAnyOfValueAnyOf { + pub fn new(disabled: Disabled) -> ConfigLspAnyOfValueAnyOf { + ConfigLspAnyOfValueAnyOf { + disabled, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Disabled { + #[serde(rename = "true")] + True, +} + +impl Default for Disabled { + fn default() -> Disabled { + Self::True + } +} + diff --git a/crates/opencode-client/generated/src/models/config_lsp_any_of_value_any_of_1.rs b/crates/opencode-client/generated/src/models/config_lsp_any_of_value_any_of_1.rs new file mode 100644 index 0000000..ef46d47 --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_lsp_any_of_value_any_of_1.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigLspAnyOfValueAnyOf1 { + #[serde(rename = "command")] + pub command: Vec, + #[serde(rename = "extensions", skip_serializing_if = "Option::is_none")] + pub extensions: Option>, + #[serde(rename = "disabled", skip_serializing_if = "Option::is_none")] + pub disabled: Option, + #[serde(rename = "env", skip_serializing_if = "Option::is_none")] + pub env: Option>, + #[serde(rename = "initialization", skip_serializing_if = "Option::is_none")] + pub initialization: Option>, +} + +impl ConfigLspAnyOfValueAnyOf1 { + pub fn new(command: Vec) -> ConfigLspAnyOfValueAnyOf1 { + ConfigLspAnyOfValueAnyOf1 { + command, + extensions: None, + disabled: None, + env: None, + initialization: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/config_mode.rs b/crates/opencode-client/generated/src/models/config_mode.rs new file mode 100644 index 0000000..603836f --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_mode.rs @@ -0,0 +1,32 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// ConfigMode : @deprecated Use `agent` field instead. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigMode { + #[serde(rename = "build", skip_serializing_if = "Option::is_none")] + pub build: Option, + #[serde(rename = "plan", skip_serializing_if = "Option::is_none")] + pub plan: Option, +} + +impl ConfigMode { + /// @deprecated Use `agent` field instead. + pub fn new() -> ConfigMode { + ConfigMode { + build: None, + plan: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/config_providers_200_response.rs b/crates/opencode-client/generated/src/models/config_providers_200_response.rs new file mode 100644 index 0000000..9a1048e --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_providers_200_response.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigProviders200Response { + #[serde(rename = "providers")] + pub providers: Vec, + #[serde(rename = "default")] + pub default: std::collections::HashMap, +} + +impl ConfigProviders200Response { + pub fn new(providers: Vec, default: std::collections::HashMap) -> ConfigProviders200Response { + ConfigProviders200Response { + providers, + default, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/config_tui.rs b/crates/opencode-client/generated/src/models/config_tui.rs new file mode 100644 index 0000000..607fd21 --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_tui.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// ConfigTui : TUI specific settings +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigTui { + /// TUI scroll speed + #[serde(rename = "scroll_speed", skip_serializing_if = "Option::is_none")] + pub scroll_speed: Option, + #[serde(rename = "scroll_acceleration", skip_serializing_if = "Option::is_none")] + pub scroll_acceleration: Option>, + /// Control diff rendering style: 'auto' adapts to terminal width, 'stacked' always shows single column + #[serde(rename = "diff_style", skip_serializing_if = "Option::is_none")] + pub diff_style: Option, +} + +impl ConfigTui { + /// TUI specific settings + pub fn new() -> ConfigTui { + ConfigTui { + scroll_speed: None, + scroll_acceleration: None, + diff_style: None, + } + } +} +/// Control diff rendering style: 'auto' adapts to terminal width, 'stacked' always shows single column +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum DiffStyle { + #[serde(rename = "auto")] + Auto, + #[serde(rename = "stacked")] + Stacked, +} + +impl Default for DiffStyle { + fn default() -> DiffStyle { + Self::Auto + } +} + diff --git a/crates/opencode-client/generated/src/models/config_tui_scroll_acceleration.rs b/crates/opencode-client/generated/src/models/config_tui_scroll_acceleration.rs new file mode 100644 index 0000000..5a88bd0 --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_tui_scroll_acceleration.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// ConfigTuiScrollAcceleration : Scroll acceleration settings +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigTuiScrollAcceleration { + /// Enable scroll acceleration + #[serde(rename = "enabled")] + pub enabled: bool, +} + +impl ConfigTuiScrollAcceleration { + /// Scroll acceleration settings + pub fn new(enabled: bool) -> ConfigTuiScrollAcceleration { + ConfigTuiScrollAcceleration { + enabled, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/config_watcher.rs b/crates/opencode-client/generated/src/models/config_watcher.rs new file mode 100644 index 0000000..22f60c3 --- /dev/null +++ b/crates/opencode-client/generated/src/models/config_watcher.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigWatcher { + #[serde(rename = "ignore", skip_serializing_if = "Option::is_none")] + pub ignore: Option>, +} + +impl ConfigWatcher { + pub fn new() -> ConfigWatcher { + ConfigWatcher { + ignore: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event.rs b/crates/opencode-client/generated/src/models/event.rs new file mode 100644 index 0000000..90ea08b --- /dev/null +++ b/crates/opencode-client/generated/src/models/event.rs @@ -0,0 +1,110 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Event { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: serde_json::Value, +} + +impl Event { + pub fn new(r#type: Type, properties: serde_json::Value) -> Event { + Event { + r#type, + properties, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "tui.prompt.append")] + TuiPromptAppend, + #[serde(rename = "tui.command.execute")] + TuiCommandExecute, + #[serde(rename = "tui.toast.show")] + TuiToastShow, + #[serde(rename = "installation.updated")] + InstallationUpdated, + #[serde(rename = "installation.update-available")] + InstallationUpdateAvailable, + #[serde(rename = "project.updated")] + ProjectUpdated, + #[serde(rename = "server.instance.disposed")] + ServerInstanceDisposed, + #[serde(rename = "file.edited")] + FileEdited, + #[serde(rename = "lsp.client.diagnostics")] + LspClientDiagnostics, + #[serde(rename = "todo.updated")] + TodoUpdated, + #[serde(rename = "session.status")] + SessionStatus, + #[serde(rename = "session.idle")] + SessionIdle, + #[serde(rename = "pty.created")] + PtyCreated, + #[serde(rename = "pty.updated")] + PtyUpdated, + #[serde(rename = "pty.exited")] + PtyExited, + #[serde(rename = "pty.deleted")] + PtyDeleted, + #[serde(rename = "lsp.updated")] + LspUpdated, + #[serde(rename = "mcp.tools.changed")] + McpToolsChanged, + #[serde(rename = "file.watcher.updated")] + FileWatcherUpdated, + #[serde(rename = "message.updated")] + MessageUpdated, + #[serde(rename = "message.removed")] + MessageRemoved, + #[serde(rename = "message.part.updated")] + MessagePartUpdated, + #[serde(rename = "message.part.removed")] + MessagePartRemoved, + #[serde(rename = "permission.updated")] + PermissionUpdated, + #[serde(rename = "permission.replied")] + PermissionReplied, + #[serde(rename = "command.executed")] + CommandExecuted, + #[serde(rename = "vcs.branch.updated")] + VcsBranchUpdated, + #[serde(rename = "session.compacted")] + SessionCompacted, + #[serde(rename = "session.created")] + SessionCreated, + #[serde(rename = "session.updated")] + SessionUpdated, + #[serde(rename = "session.deleted")] + SessionDeleted, + #[serde(rename = "session.diff")] + SessionDiff, + #[serde(rename = "session.error")] + SessionError, + #[serde(rename = "server.connected")] + ServerConnected, + #[serde(rename = "global.disposed")] + GlobalDisposed, +} + +impl Default for Type { + fn default() -> Type { + Self::TuiPromptAppend + } +} + diff --git a/crates/opencode-client/generated/src/models/event_command_executed.rs b/crates/opencode-client/generated/src/models/event_command_executed.rs new file mode 100644 index 0000000..18f1b7f --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_command_executed.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventCommandExecuted { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventCommandExecuted { + pub fn new(r#type: Type, properties: models::EventCommandExecutedProperties) -> EventCommandExecuted { + EventCommandExecuted { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "command.executed")] + CommandExecuted, +} + +impl Default for Type { + fn default() -> Type { + Self::CommandExecuted + } +} + diff --git a/crates/opencode-client/generated/src/models/event_command_executed_properties.rs b/crates/opencode-client/generated/src/models/event_command_executed_properties.rs new file mode 100644 index 0000000..72458f2 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_command_executed_properties.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventCommandExecutedProperties { + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "arguments")] + pub arguments: String, + #[serde(rename = "messageID")] + pub message_id: String, +} + +impl EventCommandExecutedProperties { + pub fn new(name: String, session_id: String, arguments: String, message_id: String) -> EventCommandExecutedProperties { + EventCommandExecutedProperties { + name, + session_id, + arguments, + message_id, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_file_edited.rs b/crates/opencode-client/generated/src/models/event_file_edited.rs new file mode 100644 index 0000000..edbfecc --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_file_edited.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventFileEdited { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventFileEdited { + pub fn new(r#type: Type, properties: models::EventFileEditedProperties) -> EventFileEdited { + EventFileEdited { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "file.edited")] + FileEdited, +} + +impl Default for Type { + fn default() -> Type { + Self::FileEdited + } +} + diff --git a/crates/opencode-client/generated/src/models/event_file_edited_properties.rs b/crates/opencode-client/generated/src/models/event_file_edited_properties.rs new file mode 100644 index 0000000..89c2910 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_file_edited_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventFileEditedProperties { + #[serde(rename = "file")] + pub file: String, +} + +impl EventFileEditedProperties { + pub fn new(file: String) -> EventFileEditedProperties { + EventFileEditedProperties { + file, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_file_watcher_updated.rs b/crates/opencode-client/generated/src/models/event_file_watcher_updated.rs new file mode 100644 index 0000000..09768ac --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_file_watcher_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventFileWatcherUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventFileWatcherUpdated { + pub fn new(r#type: Type, properties: models::EventFileWatcherUpdatedProperties) -> EventFileWatcherUpdated { + EventFileWatcherUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "file.watcher.updated")] + FileWatcherUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::FileWatcherUpdated + } +} + diff --git a/crates/opencode-client/generated/src/models/event_file_watcher_updated_properties.rs b/crates/opencode-client/generated/src/models/event_file_watcher_updated_properties.rs new file mode 100644 index 0000000..9c9f6bb --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_file_watcher_updated_properties.rs @@ -0,0 +1,46 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventFileWatcherUpdatedProperties { + #[serde(rename = "file")] + pub file: String, + #[serde(rename = "event")] + pub event: Event, +} + +impl EventFileWatcherUpdatedProperties { + pub fn new(file: String, event: Event) -> EventFileWatcherUpdatedProperties { + EventFileWatcherUpdatedProperties { + file, + event, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Event { + #[serde(rename = "add")] + Add, + #[serde(rename = "change")] + Change, + #[serde(rename = "unlink")] + Unlink, +} + +impl Default for Event { + fn default() -> Event { + Self::Add + } +} + diff --git a/crates/opencode-client/generated/src/models/event_global_disposed.rs b/crates/opencode-client/generated/src/models/event_global_disposed.rs new file mode 100644 index 0000000..9f3b711 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_global_disposed.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventGlobalDisposed { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: serde_json::Value, +} + +impl EventGlobalDisposed { + pub fn new(r#type: Type, properties: serde_json::Value) -> EventGlobalDisposed { + EventGlobalDisposed { + r#type, + properties, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "global.disposed")] + GlobalDisposed, +} + +impl Default for Type { + fn default() -> Type { + Self::GlobalDisposed + } +} + diff --git a/crates/opencode-client/generated/src/models/event_installation_update_available.rs b/crates/opencode-client/generated/src/models/event_installation_update_available.rs new file mode 100644 index 0000000..f017bbb --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_installation_update_available.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventInstallationUpdateAvailable { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventInstallationUpdateAvailable { + pub fn new(r#type: Type, properties: models::EventInstallationUpdatedProperties) -> EventInstallationUpdateAvailable { + EventInstallationUpdateAvailable { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "installation.update-available")] + InstallationUpdateAvailable, +} + +impl Default for Type { + fn default() -> Type { + Self::InstallationUpdateAvailable + } +} + diff --git a/crates/opencode-client/generated/src/models/event_installation_updated.rs b/crates/opencode-client/generated/src/models/event_installation_updated.rs new file mode 100644 index 0000000..ecce206 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_installation_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventInstallationUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventInstallationUpdated { + pub fn new(r#type: Type, properties: models::EventInstallationUpdatedProperties) -> EventInstallationUpdated { + EventInstallationUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "installation.updated")] + InstallationUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::InstallationUpdated + } +} + diff --git a/crates/opencode-client/generated/src/models/event_installation_updated_properties.rs b/crates/opencode-client/generated/src/models/event_installation_updated_properties.rs new file mode 100644 index 0000000..a02c0a3 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_installation_updated_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventInstallationUpdatedProperties { + #[serde(rename = "version")] + pub version: String, +} + +impl EventInstallationUpdatedProperties { + pub fn new(version: String) -> EventInstallationUpdatedProperties { + EventInstallationUpdatedProperties { + version, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_lsp_client_diagnostics.rs b/crates/opencode-client/generated/src/models/event_lsp_client_diagnostics.rs new file mode 100644 index 0000000..57ab0e1 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_lsp_client_diagnostics.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventLspClientDiagnostics { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventLspClientDiagnostics { + pub fn new(r#type: Type, properties: models::EventLspClientDiagnosticsProperties) -> EventLspClientDiagnostics { + EventLspClientDiagnostics { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "lsp.client.diagnostics")] + LspClientDiagnostics, +} + +impl Default for Type { + fn default() -> Type { + Self::LspClientDiagnostics + } +} + diff --git a/crates/opencode-client/generated/src/models/event_lsp_client_diagnostics_properties.rs b/crates/opencode-client/generated/src/models/event_lsp_client_diagnostics_properties.rs new file mode 100644 index 0000000..f11030d --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_lsp_client_diagnostics_properties.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventLspClientDiagnosticsProperties { + #[serde(rename = "serverID")] + pub server_id: String, + #[serde(rename = "path")] + pub path: String, +} + +impl EventLspClientDiagnosticsProperties { + pub fn new(server_id: String, path: String) -> EventLspClientDiagnosticsProperties { + EventLspClientDiagnosticsProperties { + server_id, + path, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_lsp_updated.rs b/crates/opencode-client/generated/src/models/event_lsp_updated.rs new file mode 100644 index 0000000..3b0d123 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_lsp_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventLspUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: serde_json::Value, +} + +impl EventLspUpdated { + pub fn new(r#type: Type, properties: serde_json::Value) -> EventLspUpdated { + EventLspUpdated { + r#type, + properties, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "lsp.updated")] + LspUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::LspUpdated + } +} + diff --git a/crates/opencode-client/generated/src/models/event_mcp_tools_changed.rs b/crates/opencode-client/generated/src/models/event_mcp_tools_changed.rs new file mode 100644 index 0000000..11d546c --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_mcp_tools_changed.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMcpToolsChanged { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventMcpToolsChanged { + pub fn new(r#type: Type, properties: models::EventMcpToolsChangedProperties) -> EventMcpToolsChanged { + EventMcpToolsChanged { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "mcp.tools.changed")] + McpToolsChanged, +} + +impl Default for Type { + fn default() -> Type { + Self::McpToolsChanged + } +} + diff --git a/crates/opencode-client/generated/src/models/event_mcp_tools_changed_properties.rs b/crates/opencode-client/generated/src/models/event_mcp_tools_changed_properties.rs new file mode 100644 index 0000000..6215f32 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_mcp_tools_changed_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMcpToolsChangedProperties { + #[serde(rename = "server")] + pub server: String, +} + +impl EventMcpToolsChangedProperties { + pub fn new(server: String) -> EventMcpToolsChangedProperties { + EventMcpToolsChangedProperties { + server, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_message_part_removed.rs b/crates/opencode-client/generated/src/models/event_message_part_removed.rs new file mode 100644 index 0000000..04013b2 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_message_part_removed.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMessagePartRemoved { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventMessagePartRemoved { + pub fn new(r#type: Type, properties: models::EventMessagePartRemovedProperties) -> EventMessagePartRemoved { + EventMessagePartRemoved { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "message.part.removed")] + MessagePartRemoved, +} + +impl Default for Type { + fn default() -> Type { + Self::MessagePartRemoved + } +} + diff --git a/crates/opencode-client/generated/src/models/event_message_part_removed_properties.rs b/crates/opencode-client/generated/src/models/event_message_part_removed_properties.rs new file mode 100644 index 0000000..4914b84 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_message_part_removed_properties.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMessagePartRemovedProperties { + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "partID")] + pub part_id: String, +} + +impl EventMessagePartRemovedProperties { + pub fn new(session_id: String, message_id: String, part_id: String) -> EventMessagePartRemovedProperties { + EventMessagePartRemovedProperties { + session_id, + message_id, + part_id, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_message_part_updated.rs b/crates/opencode-client/generated/src/models/event_message_part_updated.rs new file mode 100644 index 0000000..e9d89c3 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_message_part_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMessagePartUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventMessagePartUpdated { + pub fn new(r#type: Type, properties: models::EventMessagePartUpdatedProperties) -> EventMessagePartUpdated { + EventMessagePartUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "message.part.updated")] + MessagePartUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::MessagePartUpdated + } +} + diff --git a/crates/opencode-client/generated/src/models/event_message_part_updated_properties.rs b/crates/opencode-client/generated/src/models/event_message_part_updated_properties.rs new file mode 100644 index 0000000..a7ecdb9 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_message_part_updated_properties.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMessagePartUpdatedProperties { + #[serde(rename = "part")] + pub part: Box, + #[serde(rename = "delta", skip_serializing_if = "Option::is_none")] + pub delta: Option, +} + +impl EventMessagePartUpdatedProperties { + pub fn new(part: models::Part) -> EventMessagePartUpdatedProperties { + EventMessagePartUpdatedProperties { + part: Box::new(part), + delta: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_message_removed.rs b/crates/opencode-client/generated/src/models/event_message_removed.rs new file mode 100644 index 0000000..b00ce5f --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_message_removed.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMessageRemoved { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventMessageRemoved { + pub fn new(r#type: Type, properties: models::EventMessageRemovedProperties) -> EventMessageRemoved { + EventMessageRemoved { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "message.removed")] + MessageRemoved, +} + +impl Default for Type { + fn default() -> Type { + Self::MessageRemoved + } +} + diff --git a/crates/opencode-client/generated/src/models/event_message_removed_properties.rs b/crates/opencode-client/generated/src/models/event_message_removed_properties.rs new file mode 100644 index 0000000..c0e34ae --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_message_removed_properties.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMessageRemovedProperties { + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, +} + +impl EventMessageRemovedProperties { + pub fn new(session_id: String, message_id: String) -> EventMessageRemovedProperties { + EventMessageRemovedProperties { + session_id, + message_id, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_message_updated.rs b/crates/opencode-client/generated/src/models/event_message_updated.rs new file mode 100644 index 0000000..abdd3ca --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_message_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMessageUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventMessageUpdated { + pub fn new(r#type: Type, properties: models::EventMessageUpdatedProperties) -> EventMessageUpdated { + EventMessageUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "message.updated")] + MessageUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::MessageUpdated + } +} + diff --git a/crates/opencode-client/generated/src/models/event_message_updated_properties.rs b/crates/opencode-client/generated/src/models/event_message_updated_properties.rs new file mode 100644 index 0000000..a216ff3 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_message_updated_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMessageUpdatedProperties { + #[serde(rename = "info")] + pub info: Box, +} + +impl EventMessageUpdatedProperties { + pub fn new(info: models::Message) -> EventMessageUpdatedProperties { + EventMessageUpdatedProperties { + info: Box::new(info), + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_permission_replied.rs b/crates/opencode-client/generated/src/models/event_permission_replied.rs new file mode 100644 index 0000000..2930219 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_permission_replied.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPermissionReplied { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventPermissionReplied { + pub fn new(r#type: Type, properties: models::EventPermissionRepliedProperties) -> EventPermissionReplied { + EventPermissionReplied { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "permission.replied")] + PermissionReplied, +} + +impl Default for Type { + fn default() -> Type { + Self::PermissionReplied + } +} + diff --git a/crates/opencode-client/generated/src/models/event_permission_replied_properties.rs b/crates/opencode-client/generated/src/models/event_permission_replied_properties.rs new file mode 100644 index 0000000..ee4e714 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_permission_replied_properties.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPermissionRepliedProperties { + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "permissionID")] + pub permission_id: String, + #[serde(rename = "response")] + pub response: String, +} + +impl EventPermissionRepliedProperties { + pub fn new(session_id: String, permission_id: String, response: String) -> EventPermissionRepliedProperties { + EventPermissionRepliedProperties { + session_id, + permission_id, + response, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_permission_updated.rs b/crates/opencode-client/generated/src/models/event_permission_updated.rs new file mode 100644 index 0000000..c0d7f3b --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_permission_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPermissionUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventPermissionUpdated { + pub fn new(r#type: Type, properties: models::Permission) -> EventPermissionUpdated { + EventPermissionUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "permission.updated")] + PermissionUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::PermissionUpdated + } +} + diff --git a/crates/opencode-client/generated/src/models/event_project_updated.rs b/crates/opencode-client/generated/src/models/event_project_updated.rs new file mode 100644 index 0000000..bcc8244 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_project_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventProjectUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventProjectUpdated { + pub fn new(r#type: Type, properties: models::Project) -> EventProjectUpdated { + EventProjectUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "project.updated")] + ProjectUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::ProjectUpdated + } +} + diff --git a/crates/opencode-client/generated/src/models/event_pty_created.rs b/crates/opencode-client/generated/src/models/event_pty_created.rs new file mode 100644 index 0000000..05dc8fe --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_pty_created.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPtyCreated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventPtyCreated { + pub fn new(r#type: Type, properties: models::EventPtyCreatedProperties) -> EventPtyCreated { + EventPtyCreated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "pty.created")] + PtyCreated, +} + +impl Default for Type { + fn default() -> Type { + Self::PtyCreated + } +} + diff --git a/crates/opencode-client/generated/src/models/event_pty_created_properties.rs b/crates/opencode-client/generated/src/models/event_pty_created_properties.rs new file mode 100644 index 0000000..5586d1d --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_pty_created_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPtyCreatedProperties { + #[serde(rename = "info")] + pub info: Box, +} + +impl EventPtyCreatedProperties { + pub fn new(info: models::Pty) -> EventPtyCreatedProperties { + EventPtyCreatedProperties { + info: Box::new(info), + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_pty_deleted.rs b/crates/opencode-client/generated/src/models/event_pty_deleted.rs new file mode 100644 index 0000000..22e2c84 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_pty_deleted.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPtyDeleted { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventPtyDeleted { + pub fn new(r#type: Type, properties: models::EventPtyDeletedProperties) -> EventPtyDeleted { + EventPtyDeleted { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "pty.deleted")] + PtyDeleted, +} + +impl Default for Type { + fn default() -> Type { + Self::PtyDeleted + } +} + diff --git a/crates/opencode-client/generated/src/models/event_pty_deleted_properties.rs b/crates/opencode-client/generated/src/models/event_pty_deleted_properties.rs new file mode 100644 index 0000000..c68d879 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_pty_deleted_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPtyDeletedProperties { + #[serde(rename = "id")] + pub id: String, +} + +impl EventPtyDeletedProperties { + pub fn new(id: String) -> EventPtyDeletedProperties { + EventPtyDeletedProperties { + id, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_pty_exited.rs b/crates/opencode-client/generated/src/models/event_pty_exited.rs new file mode 100644 index 0000000..5171c89 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_pty_exited.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPtyExited { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventPtyExited { + pub fn new(r#type: Type, properties: models::EventPtyExitedProperties) -> EventPtyExited { + EventPtyExited { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "pty.exited")] + PtyExited, +} + +impl Default for Type { + fn default() -> Type { + Self::PtyExited + } +} + diff --git a/crates/opencode-client/generated/src/models/event_pty_exited_properties.rs b/crates/opencode-client/generated/src/models/event_pty_exited_properties.rs new file mode 100644 index 0000000..2d80d3a --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_pty_exited_properties.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPtyExitedProperties { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "exitCode")] + pub exit_code: f64, +} + +impl EventPtyExitedProperties { + pub fn new(id: String, exit_code: f64) -> EventPtyExitedProperties { + EventPtyExitedProperties { + id, + exit_code, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_pty_updated.rs b/crates/opencode-client/generated/src/models/event_pty_updated.rs new file mode 100644 index 0000000..b0ebbef --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_pty_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPtyUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventPtyUpdated { + pub fn new(r#type: Type, properties: models::EventPtyCreatedProperties) -> EventPtyUpdated { + EventPtyUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "pty.updated")] + PtyUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::PtyUpdated + } +} + diff --git a/crates/opencode-client/generated/src/models/event_server_connected.rs b/crates/opencode-client/generated/src/models/event_server_connected.rs new file mode 100644 index 0000000..ea8f5ec --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_server_connected.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventServerConnected { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: serde_json::Value, +} + +impl EventServerConnected { + pub fn new(r#type: Type, properties: serde_json::Value) -> EventServerConnected { + EventServerConnected { + r#type, + properties, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "server.connected")] + ServerConnected, +} + +impl Default for Type { + fn default() -> Type { + Self::ServerConnected + } +} + diff --git a/crates/opencode-client/generated/src/models/event_server_instance_disposed.rs b/crates/opencode-client/generated/src/models/event_server_instance_disposed.rs new file mode 100644 index 0000000..b8dc74a --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_server_instance_disposed.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventServerInstanceDisposed { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventServerInstanceDisposed { + pub fn new(r#type: Type, properties: models::EventServerInstanceDisposedProperties) -> EventServerInstanceDisposed { + EventServerInstanceDisposed { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "server.instance.disposed")] + ServerInstanceDisposed, +} + +impl Default for Type { + fn default() -> Type { + Self::ServerInstanceDisposed + } +} + diff --git a/crates/opencode-client/generated/src/models/event_server_instance_disposed_properties.rs b/crates/opencode-client/generated/src/models/event_server_instance_disposed_properties.rs new file mode 100644 index 0000000..d298e41 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_server_instance_disposed_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventServerInstanceDisposedProperties { + #[serde(rename = "directory")] + pub directory: String, +} + +impl EventServerInstanceDisposedProperties { + pub fn new(directory: String) -> EventServerInstanceDisposedProperties { + EventServerInstanceDisposedProperties { + directory, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_session_compacted.rs b/crates/opencode-client/generated/src/models/event_session_compacted.rs new file mode 100644 index 0000000..3ce59e4 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_session_compacted.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionCompacted { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventSessionCompacted { + pub fn new(r#type: Type, properties: models::EventSessionIdleProperties) -> EventSessionCompacted { + EventSessionCompacted { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "session.compacted")] + SessionCompacted, +} + +impl Default for Type { + fn default() -> Type { + Self::SessionCompacted + } +} + diff --git a/crates/opencode-client/generated/src/models/event_session_created.rs b/crates/opencode-client/generated/src/models/event_session_created.rs new file mode 100644 index 0000000..cef8242 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_session_created.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionCreated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventSessionCreated { + pub fn new(r#type: Type, properties: models::EventSessionCreatedProperties) -> EventSessionCreated { + EventSessionCreated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "session.created")] + SessionCreated, +} + +impl Default for Type { + fn default() -> Type { + Self::SessionCreated + } +} + diff --git a/crates/opencode-client/generated/src/models/event_session_created_properties.rs b/crates/opencode-client/generated/src/models/event_session_created_properties.rs new file mode 100644 index 0000000..673d010 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_session_created_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionCreatedProperties { + #[serde(rename = "info")] + pub info: Box, +} + +impl EventSessionCreatedProperties { + pub fn new(info: models::Session) -> EventSessionCreatedProperties { + EventSessionCreatedProperties { + info: Box::new(info), + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_session_deleted.rs b/crates/opencode-client/generated/src/models/event_session_deleted.rs new file mode 100644 index 0000000..098dfaf --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_session_deleted.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionDeleted { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventSessionDeleted { + pub fn new(r#type: Type, properties: models::EventSessionCreatedProperties) -> EventSessionDeleted { + EventSessionDeleted { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "session.deleted")] + SessionDeleted, +} + +impl Default for Type { + fn default() -> Type { + Self::SessionDeleted + } +} + diff --git a/crates/opencode-client/generated/src/models/event_session_diff.rs b/crates/opencode-client/generated/src/models/event_session_diff.rs new file mode 100644 index 0000000..6895b1e --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_session_diff.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionDiff { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventSessionDiff { + pub fn new(r#type: Type, properties: models::EventSessionDiffProperties) -> EventSessionDiff { + EventSessionDiff { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "session.diff")] + SessionDiff, +} + +impl Default for Type { + fn default() -> Type { + Self::SessionDiff + } +} + diff --git a/crates/opencode-client/generated/src/models/event_session_diff_properties.rs b/crates/opencode-client/generated/src/models/event_session_diff_properties.rs new file mode 100644 index 0000000..b414c46 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_session_diff_properties.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionDiffProperties { + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "diff")] + pub diff: Vec, +} + +impl EventSessionDiffProperties { + pub fn new(session_id: String, diff: Vec) -> EventSessionDiffProperties { + EventSessionDiffProperties { + session_id, + diff, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_session_error.rs b/crates/opencode-client/generated/src/models/event_session_error.rs new file mode 100644 index 0000000..17c8592 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_session_error.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionError { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventSessionError { + pub fn new(r#type: Type, properties: models::EventSessionErrorProperties) -> EventSessionError { + EventSessionError { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "session.error")] + SessionError, +} + +impl Default for Type { + fn default() -> Type { + Self::SessionError + } +} + diff --git a/crates/opencode-client/generated/src/models/event_session_error_properties.rs b/crates/opencode-client/generated/src/models/event_session_error_properties.rs new file mode 100644 index 0000000..1cf209a --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_session_error_properties.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionErrorProperties { + #[serde(rename = "sessionID", skip_serializing_if = "Option::is_none")] + pub session_id: Option, + #[serde(rename = "error", skip_serializing_if = "Option::is_none")] + pub error: Option>, +} + +impl EventSessionErrorProperties { + pub fn new() -> EventSessionErrorProperties { + EventSessionErrorProperties { + session_id: None, + error: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_session_idle.rs b/crates/opencode-client/generated/src/models/event_session_idle.rs new file mode 100644 index 0000000..bf87813 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_session_idle.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionIdle { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventSessionIdle { + pub fn new(r#type: Type, properties: models::EventSessionIdleProperties) -> EventSessionIdle { + EventSessionIdle { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "session.idle")] + SessionIdle, +} + +impl Default for Type { + fn default() -> Type { + Self::SessionIdle + } +} + diff --git a/crates/opencode-client/generated/src/models/event_session_idle_properties.rs b/crates/opencode-client/generated/src/models/event_session_idle_properties.rs new file mode 100644 index 0000000..e3ea8c5 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_session_idle_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionIdleProperties { + #[serde(rename = "sessionID")] + pub session_id: String, +} + +impl EventSessionIdleProperties { + pub fn new(session_id: String) -> EventSessionIdleProperties { + EventSessionIdleProperties { + session_id, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_session_status.rs b/crates/opencode-client/generated/src/models/event_session_status.rs new file mode 100644 index 0000000..5bc59f6 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_session_status.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionStatus { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventSessionStatus { + pub fn new(r#type: Type, properties: models::EventSessionStatusProperties) -> EventSessionStatus { + EventSessionStatus { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "session.status")] + SessionStatus, +} + +impl Default for Type { + fn default() -> Type { + Self::SessionStatus + } +} + diff --git a/crates/opencode-client/generated/src/models/event_session_status_properties.rs b/crates/opencode-client/generated/src/models/event_session_status_properties.rs new file mode 100644 index 0000000..de9eeef --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_session_status_properties.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionStatusProperties { + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "status")] + pub status: Box, +} + +impl EventSessionStatusProperties { + pub fn new(session_id: String, status: models::SessionStatus) -> EventSessionStatusProperties { + EventSessionStatusProperties { + session_id, + status: Box::new(status), + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_session_updated.rs b/crates/opencode-client/generated/src/models/event_session_updated.rs new file mode 100644 index 0000000..95cadb7 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_session_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventSessionUpdated { + pub fn new(r#type: Type, properties: models::EventSessionCreatedProperties) -> EventSessionUpdated { + EventSessionUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "session.updated")] + SessionUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::SessionUpdated + } +} + diff --git a/crates/opencode-client/generated/src/models/event_todo_updated.rs b/crates/opencode-client/generated/src/models/event_todo_updated.rs new file mode 100644 index 0000000..8dc99f4 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_todo_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventTodoUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventTodoUpdated { + pub fn new(r#type: Type, properties: models::EventTodoUpdatedProperties) -> EventTodoUpdated { + EventTodoUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "todo.updated")] + TodoUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::TodoUpdated + } +} + diff --git a/crates/opencode-client/generated/src/models/event_todo_updated_properties.rs b/crates/opencode-client/generated/src/models/event_todo_updated_properties.rs new file mode 100644 index 0000000..41d4799 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_todo_updated_properties.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventTodoUpdatedProperties { + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "todos")] + pub todos: Vec, +} + +impl EventTodoUpdatedProperties { + pub fn new(session_id: String, todos: Vec) -> EventTodoUpdatedProperties { + EventTodoUpdatedProperties { + session_id, + todos, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_tui_command_execute.rs b/crates/opencode-client/generated/src/models/event_tui_command_execute.rs new file mode 100644 index 0000000..a904f11 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_tui_command_execute.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventTuiCommandExecute { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventTuiCommandExecute { + pub fn new(r#type: Type, properties: models::EventTuiCommandExecuteProperties) -> EventTuiCommandExecute { + EventTuiCommandExecute { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "tui.command.execute")] + TuiCommandExecute, +} + +impl Default for Type { + fn default() -> Type { + Self::TuiCommandExecute + } +} + diff --git a/crates/opencode-client/generated/src/models/event_tui_command_execute_properties.rs b/crates/opencode-client/generated/src/models/event_tui_command_execute_properties.rs new file mode 100644 index 0000000..eea3d29 --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_tui_command_execute_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventTuiCommandExecuteProperties { + #[serde(rename = "command")] + pub command: Box, +} + +impl EventTuiCommandExecuteProperties { + pub fn new(command: models::EventTuiCommandExecutePropertiesCommand) -> EventTuiCommandExecuteProperties { + EventTuiCommandExecuteProperties { + command: Box::new(command), + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_tui_command_execute_properties_command.rs b/crates/opencode-client/generated/src/models/event_tui_command_execute_properties_command.rs new file mode 100644 index 0000000..19e86be --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_tui_command_execute_properties_command.rs @@ -0,0 +1,24 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventTuiCommandExecutePropertiesCommand { +} + +impl EventTuiCommandExecutePropertiesCommand { + pub fn new() -> EventTuiCommandExecutePropertiesCommand { + EventTuiCommandExecutePropertiesCommand { + } + } +} + diff --git a/crates/opencode-client/generated/src/models/event_tui_prompt_append.rs b/crates/opencode-client/generated/src/models/event_tui_prompt_append.rs new file mode 100644 index 0000000..a880b9e --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_tui_prompt_append.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventTuiPromptAppend { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventTuiPromptAppend { + pub fn new(r#type: Type, properties: models::FindText200ResponseInnerPath) -> EventTuiPromptAppend { + EventTuiPromptAppend { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "tui.prompt.append")] + TuiPromptAppend, +} + +impl Default for Type { + fn default() -> Type { + Self::TuiPromptAppend + } +} + diff --git a/crates/opencode-client/generated/src/models/event_tui_toast_show.rs b/crates/opencode-client/generated/src/models/event_tui_toast_show.rs new file mode 100644 index 0000000..999ab7c --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_tui_toast_show.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventTuiToastShow { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventTuiToastShow { + pub fn new(r#type: Type, properties: models::TuiShowToastRequest) -> EventTuiToastShow { + EventTuiToastShow { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "tui.toast.show")] + TuiToastShow, +} + +impl Default for Type { + fn default() -> Type { + Self::TuiToastShow + } +} + diff --git a/crates/opencode-client/generated/src/models/event_vcs_branch_updated.rs b/crates/opencode-client/generated/src/models/event_vcs_branch_updated.rs new file mode 100644 index 0000000..4d1fcba --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_vcs_branch_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventVcsBranchUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventVcsBranchUpdated { + pub fn new(r#type: Type, properties: models::EventVcsBranchUpdatedProperties) -> EventVcsBranchUpdated { + EventVcsBranchUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "vcs.branch.updated")] + VcsBranchUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::VcsBranchUpdated + } +} + diff --git a/crates/opencode-client/generated/src/models/event_vcs_branch_updated_properties.rs b/crates/opencode-client/generated/src/models/event_vcs_branch_updated_properties.rs new file mode 100644 index 0000000..e33ec4a --- /dev/null +++ b/crates/opencode-client/generated/src/models/event_vcs_branch_updated_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventVcsBranchUpdatedProperties { + #[serde(rename = "branch", skip_serializing_if = "Option::is_none")] + pub branch: Option, +} + +impl EventVcsBranchUpdatedProperties { + pub fn new() -> EventVcsBranchUpdatedProperties { + EventVcsBranchUpdatedProperties { + branch: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/file.rs b/crates/opencode-client/generated/src/models/file.rs new file mode 100644 index 0000000..06c002c --- /dev/null +++ b/crates/opencode-client/generated/src/models/file.rs @@ -0,0 +1,52 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct File { + #[serde(rename = "path")] + pub path: String, + #[serde(rename = "added")] + pub added: i32, + #[serde(rename = "removed")] + pub removed: i32, + #[serde(rename = "status")] + pub status: Status, +} + +impl File { + pub fn new(path: String, added: i32, removed: i32, status: Status) -> File { + File { + path, + added, + removed, + status, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "added")] + Added, + #[serde(rename = "deleted")] + Deleted, + #[serde(rename = "modified")] + Modified, +} + +impl Default for Status { + fn default() -> Status { + Self::Added + } +} + diff --git a/crates/opencode-client/generated/src/models/file_content.rs b/crates/opencode-client/generated/src/models/file_content.rs new file mode 100644 index 0000000..7938f8c --- /dev/null +++ b/crates/opencode-client/generated/src/models/file_content.rs @@ -0,0 +1,66 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FileContent { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "content")] + pub content: String, + #[serde(rename = "diff", skip_serializing_if = "Option::is_none")] + pub diff: Option, + #[serde(rename = "patch", skip_serializing_if = "Option::is_none")] + pub patch: Option>, + #[serde(rename = "encoding", skip_serializing_if = "Option::is_none")] + pub encoding: Option, + #[serde(rename = "mimeType", skip_serializing_if = "Option::is_none")] + pub mime_type: Option, +} + +impl FileContent { + pub fn new(r#type: Type, content: String) -> FileContent { + FileContent { + r#type, + content, + diff: None, + patch: None, + encoding: None, + mime_type: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "text")] + Text, +} + +impl Default for Type { + fn default() -> Type { + Self::Text + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Encoding { + #[serde(rename = "base64")] + Base64, +} + +impl Default for Encoding { + fn default() -> Encoding { + Self::Base64 + } +} + diff --git a/crates/opencode-client/generated/src/models/file_content_patch.rs b/crates/opencode-client/generated/src/models/file_content_patch.rs new file mode 100644 index 0000000..cfc5a1b --- /dev/null +++ b/crates/opencode-client/generated/src/models/file_content_patch.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FileContentPatch { + #[serde(rename = "oldFileName")] + pub old_file_name: String, + #[serde(rename = "newFileName")] + pub new_file_name: String, + #[serde(rename = "oldHeader", skip_serializing_if = "Option::is_none")] + pub old_header: Option, + #[serde(rename = "newHeader", skip_serializing_if = "Option::is_none")] + pub new_header: Option, + #[serde(rename = "hunks")] + pub hunks: Vec, + #[serde(rename = "index", skip_serializing_if = "Option::is_none")] + pub index: Option, +} + +impl FileContentPatch { + pub fn new(old_file_name: String, new_file_name: String, hunks: Vec) -> FileContentPatch { + FileContentPatch { + old_file_name, + new_file_name, + old_header: None, + new_header: None, + hunks, + index: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/file_content_patch_hunks_inner.rs b/crates/opencode-client/generated/src/models/file_content_patch_hunks_inner.rs new file mode 100644 index 0000000..68dd648 --- /dev/null +++ b/crates/opencode-client/generated/src/models/file_content_patch_hunks_inner.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FileContentPatchHunksInner { + #[serde(rename = "oldStart")] + pub old_start: f64, + #[serde(rename = "oldLines")] + pub old_lines: f64, + #[serde(rename = "newStart")] + pub new_start: f64, + #[serde(rename = "newLines")] + pub new_lines: f64, + #[serde(rename = "lines")] + pub lines: Vec, +} + +impl FileContentPatchHunksInner { + pub fn new(old_start: f64, old_lines: f64, new_start: f64, new_lines: f64, lines: Vec) -> FileContentPatchHunksInner { + FileContentPatchHunksInner { + old_start, + old_lines, + new_start, + new_lines, + lines, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/file_diff.rs b/crates/opencode-client/generated/src/models/file_diff.rs new file mode 100644 index 0000000..3d8fe13 --- /dev/null +++ b/crates/opencode-client/generated/src/models/file_diff.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FileDiff { + #[serde(rename = "file")] + pub file: String, + #[serde(rename = "before")] + pub before: String, + #[serde(rename = "after")] + pub after: String, + #[serde(rename = "additions")] + pub additions: f64, + #[serde(rename = "deletions")] + pub deletions: f64, +} + +impl FileDiff { + pub fn new(file: String, before: String, after: String, additions: f64, deletions: f64) -> FileDiff { + FileDiff { + file, + before, + after, + additions, + deletions, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/file_node.rs b/crates/opencode-client/generated/src/models/file_node.rs new file mode 100644 index 0000000..941f558 --- /dev/null +++ b/crates/opencode-client/generated/src/models/file_node.rs @@ -0,0 +1,53 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FileNode { + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "path")] + pub path: String, + #[serde(rename = "absolute")] + pub absolute: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "ignored")] + pub ignored: bool, +} + +impl FileNode { + pub fn new(name: String, path: String, absolute: String, r#type: Type, ignored: bool) -> FileNode { + FileNode { + name, + path, + absolute, + r#type, + ignored, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "file")] + File, + #[serde(rename = "directory")] + Directory, +} + +impl Default for Type { + fn default() -> Type { + Self::File + } +} + diff --git a/crates/opencode-client/generated/src/models/file_part.rs b/crates/opencode-client/generated/src/models/file_part.rs new file mode 100644 index 0000000..a290a15 --- /dev/null +++ b/crates/opencode-client/generated/src/models/file_part.rs @@ -0,0 +1,60 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FilePart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "mime")] + pub mime: String, + #[serde(rename = "filename", skip_serializing_if = "Option::is_none")] + pub filename: Option, + #[serde(rename = "url")] + pub url: String, + #[serde(rename = "source", skip_serializing_if = "Option::is_none")] + pub source: Option>, +} + +impl FilePart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, mime: String, url: String) -> FilePart { + FilePart { + id, + session_id, + message_id, + r#type, + mime, + filename: None, + url, + source: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "file")] + File, +} + +impl Default for Type { + fn default() -> Type { + Self::File + } +} + diff --git a/crates/opencode-client/generated/src/models/file_part_input.rs b/crates/opencode-client/generated/src/models/file_part_input.rs new file mode 100644 index 0000000..a9952ef --- /dev/null +++ b/crates/opencode-client/generated/src/models/file_part_input.rs @@ -0,0 +1,54 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FilePartInput { + #[serde(rename = "id", skip_serializing_if = "Option::is_none")] + pub id: Option, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "mime")] + pub mime: String, + #[serde(rename = "filename", skip_serializing_if = "Option::is_none")] + pub filename: Option, + #[serde(rename = "url")] + pub url: String, + #[serde(rename = "source", skip_serializing_if = "Option::is_none")] + pub source: Option>, +} + +impl FilePartInput { + pub fn new(r#type: Type, mime: String, url: String) -> FilePartInput { + FilePartInput { + id: None, + r#type, + mime, + filename: None, + url, + source: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "file")] + File, +} + +impl Default for Type { + fn default() -> Type { + Self::File + } +} + diff --git a/crates/opencode-client/generated/src/models/file_part_source.rs b/crates/opencode-client/generated/src/models/file_part_source.rs new file mode 100644 index 0000000..fcfacbd --- /dev/null +++ b/crates/opencode-client/generated/src/models/file_part_source.rs @@ -0,0 +1,56 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FilePartSource { + #[serde(rename = "text")] + pub text: Box, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "path")] + pub path: String, + #[serde(rename = "range")] + pub range: Box, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "kind")] + pub kind: i32, +} + +impl FilePartSource { + pub fn new(text: models::FilePartSourceText, r#type: Type, path: String, range: models::Range, name: String, kind: i32) -> FilePartSource { + FilePartSource { + text: Box::new(text), + r#type, + path, + range: Box::new(range), + name, + kind, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "file")] + File, + #[serde(rename = "symbol")] + Symbol, +} + +impl Default for Type { + fn default() -> Type { + Self::File + } +} + diff --git a/crates/opencode-client/generated/src/models/file_part_source_text.rs b/crates/opencode-client/generated/src/models/file_part_source_text.rs new file mode 100644 index 0000000..1c1cc6e --- /dev/null +++ b/crates/opencode-client/generated/src/models/file_part_source_text.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FilePartSourceText { + #[serde(rename = "value")] + pub value: String, + #[serde(rename = "start")] + pub start: i32, + #[serde(rename = "end")] + pub end: i32, +} + +impl FilePartSourceText { + pub fn new(value: String, start: i32, end: i32) -> FilePartSourceText { + FilePartSourceText { + value, + start, + end, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/file_source.rs b/crates/opencode-client/generated/src/models/file_source.rs new file mode 100644 index 0000000..6eb96f7 --- /dev/null +++ b/crates/opencode-client/generated/src/models/file_source.rs @@ -0,0 +1,45 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FileSource { + #[serde(rename = "text")] + pub text: Box, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "path")] + pub path: String, +} + +impl FileSource { + pub fn new(text: models::FilePartSourceText, r#type: Type, path: String) -> FileSource { + FileSource { + text: Box::new(text), + r#type, + path, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "file")] + File, +} + +impl Default for Type { + fn default() -> Type { + Self::File + } +} + diff --git a/crates/opencode-client/generated/src/models/find_text_200_response_inner.rs b/crates/opencode-client/generated/src/models/find_text_200_response_inner.rs new file mode 100644 index 0000000..6ad2586 --- /dev/null +++ b/crates/opencode-client/generated/src/models/find_text_200_response_inner.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FindText200ResponseInner { + #[serde(rename = "path")] + pub path: Box, + #[serde(rename = "lines")] + pub lines: Box, + #[serde(rename = "line_number")] + pub line_number: f64, + #[serde(rename = "absolute_offset")] + pub absolute_offset: f64, + #[serde(rename = "submatches")] + pub submatches: Vec, +} + +impl FindText200ResponseInner { + pub fn new(path: models::FindText200ResponseInnerPath, lines: models::FindText200ResponseInnerPath, line_number: f64, absolute_offset: f64, submatches: Vec) -> FindText200ResponseInner { + FindText200ResponseInner { + path: Box::new(path), + lines: Box::new(lines), + line_number, + absolute_offset, + submatches, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/find_text_200_response_inner_path.rs b/crates/opencode-client/generated/src/models/find_text_200_response_inner_path.rs new file mode 100644 index 0000000..df33e19 --- /dev/null +++ b/crates/opencode-client/generated/src/models/find_text_200_response_inner_path.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FindText200ResponseInnerPath { + #[serde(rename = "text")] + pub text: String, +} + +impl FindText200ResponseInnerPath { + pub fn new(text: String) -> FindText200ResponseInnerPath { + FindText200ResponseInnerPath { + text, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/find_text_200_response_inner_submatches_inner.rs b/crates/opencode-client/generated/src/models/find_text_200_response_inner_submatches_inner.rs new file mode 100644 index 0000000..f7a9680 --- /dev/null +++ b/crates/opencode-client/generated/src/models/find_text_200_response_inner_submatches_inner.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FindText200ResponseInnerSubmatchesInner { + #[serde(rename = "match")] + pub r#match: Box, + #[serde(rename = "start")] + pub start: f64, + #[serde(rename = "end")] + pub end: f64, +} + +impl FindText200ResponseInnerSubmatchesInner { + pub fn new(r#match: models::FindText200ResponseInnerPath, start: f64, end: f64) -> FindText200ResponseInnerSubmatchesInner { + FindText200ResponseInnerSubmatchesInner { + r#match: Box::new(r#match), + start, + end, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/formatter_status.rs b/crates/opencode-client/generated/src/models/formatter_status.rs new file mode 100644 index 0000000..59d0808 --- /dev/null +++ b/crates/opencode-client/generated/src/models/formatter_status.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FormatterStatus { + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "extensions")] + pub extensions: Vec, + #[serde(rename = "enabled")] + pub enabled: bool, +} + +impl FormatterStatus { + pub fn new(name: String, extensions: Vec, enabled: bool) -> FormatterStatus { + FormatterStatus { + name, + extensions, + enabled, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/global_event.rs b/crates/opencode-client/generated/src/models/global_event.rs new file mode 100644 index 0000000..aa9d564 --- /dev/null +++ b/crates/opencode-client/generated/src/models/global_event.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct GlobalEvent { + #[serde(rename = "directory")] + pub directory: String, + #[serde(rename = "payload")] + pub payload: Box, +} + +impl GlobalEvent { + pub fn new(directory: String, payload: models::Event) -> GlobalEvent { + GlobalEvent { + directory, + payload: Box::new(payload), + } + } +} + diff --git a/crates/opencode-client/generated/src/models/global_health_200_response.rs b/crates/opencode-client/generated/src/models/global_health_200_response.rs new file mode 100644 index 0000000..85811f1 --- /dev/null +++ b/crates/opencode-client/generated/src/models/global_health_200_response.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct GlobalHealth200Response { + #[serde(rename = "healthy")] + pub healthy: Healthy, + #[serde(rename = "version")] + pub version: String, +} + +impl GlobalHealth200Response { + pub fn new(healthy: Healthy, version: String) -> GlobalHealth200Response { + GlobalHealth200Response { + healthy, + version, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Healthy { + #[serde(rename = "true")] + True, +} + +impl Default for Healthy { + fn default() -> Healthy { + Self::True + } +} + diff --git a/crates/opencode-client/generated/src/models/keybinds_config.rs b/crates/opencode-client/generated/src/models/keybinds_config.rs new file mode 100644 index 0000000..711b45c --- /dev/null +++ b/crates/opencode-client/generated/src/models/keybinds_config.rs @@ -0,0 +1,374 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// KeybindsConfig : Custom keybind configurations +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct KeybindsConfig { + /// Leader key for keybind combinations + #[serde(rename = "leader", skip_serializing_if = "Option::is_none")] + pub leader: Option, + /// Exit the application + #[serde(rename = "app_exit", skip_serializing_if = "Option::is_none")] + pub app_exit: Option, + /// Open external editor + #[serde(rename = "editor_open", skip_serializing_if = "Option::is_none")] + pub editor_open: Option, + /// List available themes + #[serde(rename = "theme_list", skip_serializing_if = "Option::is_none")] + pub theme_list: Option, + /// Toggle sidebar + #[serde(rename = "sidebar_toggle", skip_serializing_if = "Option::is_none")] + pub sidebar_toggle: Option, + /// Toggle session scrollbar + #[serde(rename = "scrollbar_toggle", skip_serializing_if = "Option::is_none")] + pub scrollbar_toggle: Option, + /// Toggle username visibility + #[serde(rename = "username_toggle", skip_serializing_if = "Option::is_none")] + pub username_toggle: Option, + /// View status + #[serde(rename = "status_view", skip_serializing_if = "Option::is_none")] + pub status_view: Option, + /// Export session to editor + #[serde(rename = "session_export", skip_serializing_if = "Option::is_none")] + pub session_export: Option, + /// Create a new session + #[serde(rename = "session_new", skip_serializing_if = "Option::is_none")] + pub session_new: Option, + /// List all sessions + #[serde(rename = "session_list", skip_serializing_if = "Option::is_none")] + pub session_list: Option, + /// Show session timeline + #[serde(rename = "session_timeline", skip_serializing_if = "Option::is_none")] + pub session_timeline: Option, + /// Fork session from message + #[serde(rename = "session_fork", skip_serializing_if = "Option::is_none")] + pub session_fork: Option, + /// Rename session + #[serde(rename = "session_rename", skip_serializing_if = "Option::is_none")] + pub session_rename: Option, + /// Share current session + #[serde(rename = "session_share", skip_serializing_if = "Option::is_none")] + pub session_share: Option, + /// Unshare current session + #[serde(rename = "session_unshare", skip_serializing_if = "Option::is_none")] + pub session_unshare: Option, + /// Interrupt current session + #[serde(rename = "session_interrupt", skip_serializing_if = "Option::is_none")] + pub session_interrupt: Option, + /// Compact the session + #[serde(rename = "session_compact", skip_serializing_if = "Option::is_none")] + pub session_compact: Option, + /// Scroll messages up by one page + #[serde(rename = "messages_page_up", skip_serializing_if = "Option::is_none")] + pub messages_page_up: Option, + /// Scroll messages down by one page + #[serde(rename = "messages_page_down", skip_serializing_if = "Option::is_none")] + pub messages_page_down: Option, + /// Scroll messages up by half page + #[serde(rename = "messages_half_page_up", skip_serializing_if = "Option::is_none")] + pub messages_half_page_up: Option, + /// Scroll messages down by half page + #[serde(rename = "messages_half_page_down", skip_serializing_if = "Option::is_none")] + pub messages_half_page_down: Option, + /// Navigate to first message + #[serde(rename = "messages_first", skip_serializing_if = "Option::is_none")] + pub messages_first: Option, + /// Navigate to last message + #[serde(rename = "messages_last", skip_serializing_if = "Option::is_none")] + pub messages_last: Option, + /// Navigate to next message + #[serde(rename = "messages_next", skip_serializing_if = "Option::is_none")] + pub messages_next: Option, + /// Navigate to previous message + #[serde(rename = "messages_previous", skip_serializing_if = "Option::is_none")] + pub messages_previous: Option, + /// Navigate to last user message + #[serde(rename = "messages_last_user", skip_serializing_if = "Option::is_none")] + pub messages_last_user: Option, + /// Copy message + #[serde(rename = "messages_copy", skip_serializing_if = "Option::is_none")] + pub messages_copy: Option, + /// Undo message + #[serde(rename = "messages_undo", skip_serializing_if = "Option::is_none")] + pub messages_undo: Option, + /// Redo message + #[serde(rename = "messages_redo", skip_serializing_if = "Option::is_none")] + pub messages_redo: Option, + /// Toggle code block concealment in messages + #[serde(rename = "messages_toggle_conceal", skip_serializing_if = "Option::is_none")] + pub messages_toggle_conceal: Option, + /// Toggle tool details visibility + #[serde(rename = "tool_details", skip_serializing_if = "Option::is_none")] + pub tool_details: Option, + /// List available models + #[serde(rename = "model_list", skip_serializing_if = "Option::is_none")] + pub model_list: Option, + /// Next recently used model + #[serde(rename = "model_cycle_recent", skip_serializing_if = "Option::is_none")] + pub model_cycle_recent: Option, + /// Previous recently used model + #[serde(rename = "model_cycle_recent_reverse", skip_serializing_if = "Option::is_none")] + pub model_cycle_recent_reverse: Option, + /// Next favorite model + #[serde(rename = "model_cycle_favorite", skip_serializing_if = "Option::is_none")] + pub model_cycle_favorite: Option, + /// Previous favorite model + #[serde(rename = "model_cycle_favorite_reverse", skip_serializing_if = "Option::is_none")] + pub model_cycle_favorite_reverse: Option, + /// List available commands + #[serde(rename = "command_list", skip_serializing_if = "Option::is_none")] + pub command_list: Option, + /// List agents + #[serde(rename = "agent_list", skip_serializing_if = "Option::is_none")] + pub agent_list: Option, + /// Next agent + #[serde(rename = "agent_cycle", skip_serializing_if = "Option::is_none")] + pub agent_cycle: Option, + /// Previous agent + #[serde(rename = "agent_cycle_reverse", skip_serializing_if = "Option::is_none")] + pub agent_cycle_reverse: Option, + /// Cycle model variants + #[serde(rename = "variant_cycle", skip_serializing_if = "Option::is_none")] + pub variant_cycle: Option, + /// Clear input field + #[serde(rename = "input_clear", skip_serializing_if = "Option::is_none")] + pub input_clear: Option, + /// Paste from clipboard + #[serde(rename = "input_paste", skip_serializing_if = "Option::is_none")] + pub input_paste: Option, + /// Submit input + #[serde(rename = "input_submit", skip_serializing_if = "Option::is_none")] + pub input_submit: Option, + /// Insert newline in input + #[serde(rename = "input_newline", skip_serializing_if = "Option::is_none")] + pub input_newline: Option, + /// Move cursor left in input + #[serde(rename = "input_move_left", skip_serializing_if = "Option::is_none")] + pub input_move_left: Option, + /// Move cursor right in input + #[serde(rename = "input_move_right", skip_serializing_if = "Option::is_none")] + pub input_move_right: Option, + /// Move cursor up in input + #[serde(rename = "input_move_up", skip_serializing_if = "Option::is_none")] + pub input_move_up: Option, + /// Move cursor down in input + #[serde(rename = "input_move_down", skip_serializing_if = "Option::is_none")] + pub input_move_down: Option, + /// Select left in input + #[serde(rename = "input_select_left", skip_serializing_if = "Option::is_none")] + pub input_select_left: Option, + /// Select right in input + #[serde(rename = "input_select_right", skip_serializing_if = "Option::is_none")] + pub input_select_right: Option, + /// Select up in input + #[serde(rename = "input_select_up", skip_serializing_if = "Option::is_none")] + pub input_select_up: Option, + /// Select down in input + #[serde(rename = "input_select_down", skip_serializing_if = "Option::is_none")] + pub input_select_down: Option, + /// Move to start of line in input + #[serde(rename = "input_line_home", skip_serializing_if = "Option::is_none")] + pub input_line_home: Option, + /// Move to end of line in input + #[serde(rename = "input_line_end", skip_serializing_if = "Option::is_none")] + pub input_line_end: Option, + /// Select to start of line in input + #[serde(rename = "input_select_line_home", skip_serializing_if = "Option::is_none")] + pub input_select_line_home: Option, + /// Select to end of line in input + #[serde(rename = "input_select_line_end", skip_serializing_if = "Option::is_none")] + pub input_select_line_end: Option, + /// Move to start of visual line in input + #[serde(rename = "input_visual_line_home", skip_serializing_if = "Option::is_none")] + pub input_visual_line_home: Option, + /// Move to end of visual line in input + #[serde(rename = "input_visual_line_end", skip_serializing_if = "Option::is_none")] + pub input_visual_line_end: Option, + /// Select to start of visual line in input + #[serde(rename = "input_select_visual_line_home", skip_serializing_if = "Option::is_none")] + pub input_select_visual_line_home: Option, + /// Select to end of visual line in input + #[serde(rename = "input_select_visual_line_end", skip_serializing_if = "Option::is_none")] + pub input_select_visual_line_end: Option, + /// Move to start of buffer in input + #[serde(rename = "input_buffer_home", skip_serializing_if = "Option::is_none")] + pub input_buffer_home: Option, + /// Move to end of buffer in input + #[serde(rename = "input_buffer_end", skip_serializing_if = "Option::is_none")] + pub input_buffer_end: Option, + /// Select to start of buffer in input + #[serde(rename = "input_select_buffer_home", skip_serializing_if = "Option::is_none")] + pub input_select_buffer_home: Option, + /// Select to end of buffer in input + #[serde(rename = "input_select_buffer_end", skip_serializing_if = "Option::is_none")] + pub input_select_buffer_end: Option, + /// Delete line in input + #[serde(rename = "input_delete_line", skip_serializing_if = "Option::is_none")] + pub input_delete_line: Option, + /// Delete to end of line in input + #[serde(rename = "input_delete_to_line_end", skip_serializing_if = "Option::is_none")] + pub input_delete_to_line_end: Option, + /// Delete to start of line in input + #[serde(rename = "input_delete_to_line_start", skip_serializing_if = "Option::is_none")] + pub input_delete_to_line_start: Option, + /// Backspace in input + #[serde(rename = "input_backspace", skip_serializing_if = "Option::is_none")] + pub input_backspace: Option, + /// Delete character in input + #[serde(rename = "input_delete", skip_serializing_if = "Option::is_none")] + pub input_delete: Option, + /// Undo in input + #[serde(rename = "input_undo", skip_serializing_if = "Option::is_none")] + pub input_undo: Option, + /// Redo in input + #[serde(rename = "input_redo", skip_serializing_if = "Option::is_none")] + pub input_redo: Option, + /// Move word forward in input + #[serde(rename = "input_word_forward", skip_serializing_if = "Option::is_none")] + pub input_word_forward: Option, + /// Move word backward in input + #[serde(rename = "input_word_backward", skip_serializing_if = "Option::is_none")] + pub input_word_backward: Option, + /// Select word forward in input + #[serde(rename = "input_select_word_forward", skip_serializing_if = "Option::is_none")] + pub input_select_word_forward: Option, + /// Select word backward in input + #[serde(rename = "input_select_word_backward", skip_serializing_if = "Option::is_none")] + pub input_select_word_backward: Option, + /// Delete word forward in input + #[serde(rename = "input_delete_word_forward", skip_serializing_if = "Option::is_none")] + pub input_delete_word_forward: Option, + /// Delete word backward in input + #[serde(rename = "input_delete_word_backward", skip_serializing_if = "Option::is_none")] + pub input_delete_word_backward: Option, + /// Previous history item + #[serde(rename = "history_previous", skip_serializing_if = "Option::is_none")] + pub history_previous: Option, + /// Next history item + #[serde(rename = "history_next", skip_serializing_if = "Option::is_none")] + pub history_next: Option, + /// Next child session + #[serde(rename = "session_child_cycle", skip_serializing_if = "Option::is_none")] + pub session_child_cycle: Option, + /// Previous child session + #[serde(rename = "session_child_cycle_reverse", skip_serializing_if = "Option::is_none")] + pub session_child_cycle_reverse: Option, + /// Go to parent session + #[serde(rename = "session_parent", skip_serializing_if = "Option::is_none")] + pub session_parent: Option, + /// Suspend terminal + #[serde(rename = "terminal_suspend", skip_serializing_if = "Option::is_none")] + pub terminal_suspend: Option, + /// Toggle terminal title + #[serde(rename = "terminal_title_toggle", skip_serializing_if = "Option::is_none")] + pub terminal_title_toggle: Option, + /// Toggle tips on home screen + #[serde(rename = "tips_toggle", skip_serializing_if = "Option::is_none")] + pub tips_toggle: Option, +} + +impl KeybindsConfig { + /// Custom keybind configurations + pub fn new() -> KeybindsConfig { + KeybindsConfig { + leader: None, + app_exit: None, + editor_open: None, + theme_list: None, + sidebar_toggle: None, + scrollbar_toggle: None, + username_toggle: None, + status_view: None, + session_export: None, + session_new: None, + session_list: None, + session_timeline: None, + session_fork: None, + session_rename: None, + session_share: None, + session_unshare: None, + session_interrupt: None, + session_compact: None, + messages_page_up: None, + messages_page_down: None, + messages_half_page_up: None, + messages_half_page_down: None, + messages_first: None, + messages_last: None, + messages_next: None, + messages_previous: None, + messages_last_user: None, + messages_copy: None, + messages_undo: None, + messages_redo: None, + messages_toggle_conceal: None, + tool_details: None, + model_list: None, + model_cycle_recent: None, + model_cycle_recent_reverse: None, + model_cycle_favorite: None, + model_cycle_favorite_reverse: None, + command_list: None, + agent_list: None, + agent_cycle: None, + agent_cycle_reverse: None, + variant_cycle: None, + input_clear: None, + input_paste: None, + input_submit: None, + input_newline: None, + input_move_left: None, + input_move_right: None, + input_move_up: None, + input_move_down: None, + input_select_left: None, + input_select_right: None, + input_select_up: None, + input_select_down: None, + input_line_home: None, + input_line_end: None, + input_select_line_home: None, + input_select_line_end: None, + input_visual_line_home: None, + input_visual_line_end: None, + input_select_visual_line_home: None, + input_select_visual_line_end: None, + input_buffer_home: None, + input_buffer_end: None, + input_select_buffer_home: None, + input_select_buffer_end: None, + input_delete_line: None, + input_delete_to_line_end: None, + input_delete_to_line_start: None, + input_backspace: None, + input_delete: None, + input_undo: None, + input_redo: None, + input_word_forward: None, + input_word_backward: None, + input_select_word_forward: None, + input_select_word_backward: None, + input_delete_word_forward: None, + input_delete_word_backward: None, + history_previous: None, + history_next: None, + session_child_cycle: None, + session_child_cycle_reverse: None, + session_parent: None, + terminal_suspend: None, + terminal_title_toggle: None, + tips_toggle: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/layout_config.rs b/crates/opencode-client/generated/src/models/layout_config.rs new file mode 100644 index 0000000..eb80109 --- /dev/null +++ b/crates/opencode-client/generated/src/models/layout_config.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// LayoutConfig : @deprecated Always uses stretch layout. +/// @deprecated Always uses stretch layout. +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum LayoutConfig { + #[serde(rename = "auto")] + Auto, + #[serde(rename = "stretch")] + Stretch, + +} + +impl std::fmt::Display for LayoutConfig { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + match self { + Self::Auto => write!(f, "auto"), + Self::Stretch => write!(f, "stretch"), + } + } +} + +impl Default for LayoutConfig { + fn default() -> LayoutConfig { + Self::Auto + } +} + diff --git a/crates/opencode-client/generated/src/models/log_level.rs b/crates/opencode-client/generated/src/models/log_level.rs new file mode 100644 index 0000000..77d7129 --- /dev/null +++ b/crates/opencode-client/generated/src/models/log_level.rs @@ -0,0 +1,45 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// LogLevel : Log level +/// Log level +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum LogLevel { + #[serde(rename = "DEBUG")] + Debug, + #[serde(rename = "INFO")] + Info, + #[serde(rename = "WARN")] + Warn, + #[serde(rename = "ERROR")] + Error, + +} + +impl std::fmt::Display for LogLevel { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + match self { + Self::Debug => write!(f, "DEBUG"), + Self::Info => write!(f, "INFO"), + Self::Warn => write!(f, "WARN"), + Self::Error => write!(f, "ERROR"), + } + } +} + +impl Default for LogLevel { + fn default() -> LogLevel { + Self::Debug + } +} + diff --git a/crates/opencode-client/generated/src/models/lsp_status.rs b/crates/opencode-client/generated/src/models/lsp_status.rs new file mode 100644 index 0000000..e940227 --- /dev/null +++ b/crates/opencode-client/generated/src/models/lsp_status.rs @@ -0,0 +1,50 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct LspStatus { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "root")] + pub root: String, + #[serde(rename = "status")] + pub status: Status, +} + +impl LspStatus { + pub fn new(id: String, name: String, root: String, status: Status) -> LspStatus { + LspStatus { + id, + name, + root, + status, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "connected")] + Connected, + #[serde(rename = "error")] + Error, +} + +impl Default for Status { + fn default() -> Status { + Self::Connected + } +} + diff --git a/crates/opencode-client/generated/src/models/mcp_add_request.rs b/crates/opencode-client/generated/src/models/mcp_add_request.rs new file mode 100644 index 0000000..832c79a --- /dev/null +++ b/crates/opencode-client/generated/src/models/mcp_add_request.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpAddRequest { + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "config")] + pub config: Box, +} + +impl McpAddRequest { + pub fn new(name: String, config: models::McpAddRequestConfig) -> McpAddRequest { + McpAddRequest { + name, + config: Box::new(config), + } + } +} + diff --git a/crates/opencode-client/generated/src/models/mcp_add_request_config.rs b/crates/opencode-client/generated/src/models/mcp_add_request_config.rs new file mode 100644 index 0000000..b7257ff --- /dev/null +++ b/crates/opencode-client/generated/src/models/mcp_add_request_config.rs @@ -0,0 +1,69 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpAddRequestConfig { + /// Type of MCP server connection + #[serde(rename = "type")] + pub r#type: Type, + /// Command and arguments to run the MCP server + #[serde(rename = "command")] + pub command: Vec, + /// Environment variables to set when running the MCP server + #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] + pub environment: Option>, + /// Enable or disable the MCP server on startup + #[serde(rename = "enabled", skip_serializing_if = "Option::is_none")] + pub enabled: Option, + /// Timeout in ms for fetching tools from the MCP server. Defaults to 5000 (5 seconds) if not specified. + #[serde(rename = "timeout", skip_serializing_if = "Option::is_none")] + pub timeout: Option, + /// URL of the remote MCP server + #[serde(rename = "url")] + pub url: String, + /// Headers to send with the request + #[serde(rename = "headers", skip_serializing_if = "Option::is_none")] + pub headers: Option>, + #[serde(rename = "oauth", skip_serializing_if = "Option::is_none")] + pub oauth: Option>, +} + +impl McpAddRequestConfig { + pub fn new(r#type: Type, command: Vec, url: String) -> McpAddRequestConfig { + McpAddRequestConfig { + r#type, + command, + environment: None, + enabled: None, + timeout: None, + url, + headers: None, + oauth: None, + } + } +} +/// Type of MCP server connection +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "local")] + Local, + #[serde(rename = "remote")] + Remote, +} + +impl Default for Type { + fn default() -> Type { + Self::Local + } +} + diff --git a/crates/opencode-client/generated/src/models/mcp_auth_callback_request.rs b/crates/opencode-client/generated/src/models/mcp_auth_callback_request.rs new file mode 100644 index 0000000..694cad1 --- /dev/null +++ b/crates/opencode-client/generated/src/models/mcp_auth_callback_request.rs @@ -0,0 +1,28 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpAuthCallbackRequest { + /// Authorization code from OAuth callback + #[serde(rename = "code")] + pub code: String, +} + +impl McpAuthCallbackRequest { + pub fn new(code: String) -> McpAuthCallbackRequest { + McpAuthCallbackRequest { + code, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/mcp_auth_remove_200_response.rs b/crates/opencode-client/generated/src/models/mcp_auth_remove_200_response.rs new file mode 100644 index 0000000..6b902ce --- /dev/null +++ b/crates/opencode-client/generated/src/models/mcp_auth_remove_200_response.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpAuthRemove200Response { + #[serde(rename = "success")] + pub success: Success, +} + +impl McpAuthRemove200Response { + pub fn new(success: Success) -> McpAuthRemove200Response { + McpAuthRemove200Response { + success, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Success { + #[serde(rename = "true")] + True, +} + +impl Default for Success { + fn default() -> Success { + Self::True + } +} + diff --git a/crates/opencode-client/generated/src/models/mcp_auth_start_200_response.rs b/crates/opencode-client/generated/src/models/mcp_auth_start_200_response.rs new file mode 100644 index 0000000..d2360d2 --- /dev/null +++ b/crates/opencode-client/generated/src/models/mcp_auth_start_200_response.rs @@ -0,0 +1,28 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpAuthStart200Response { + /// URL to open in browser for authorization + #[serde(rename = "authorizationUrl")] + pub authorization_url: String, +} + +impl McpAuthStart200Response { + pub fn new(authorization_url: String) -> McpAuthStart200Response { + McpAuthStart200Response { + authorization_url, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/mcp_local_config.rs b/crates/opencode-client/generated/src/models/mcp_local_config.rs new file mode 100644 index 0000000..2315283 --- /dev/null +++ b/crates/opencode-client/generated/src/models/mcp_local_config.rs @@ -0,0 +1,56 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpLocalConfig { + /// Type of MCP server connection + #[serde(rename = "type")] + pub r#type: Type, + /// Command and arguments to run the MCP server + #[serde(rename = "command")] + pub command: Vec, + /// Environment variables to set when running the MCP server + #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] + pub environment: Option>, + /// Enable or disable the MCP server on startup + #[serde(rename = "enabled", skip_serializing_if = "Option::is_none")] + pub enabled: Option, + /// Timeout in ms for fetching tools from the MCP server. Defaults to 5000 (5 seconds) if not specified. + #[serde(rename = "timeout", skip_serializing_if = "Option::is_none")] + pub timeout: Option, +} + +impl McpLocalConfig { + pub fn new(r#type: Type, command: Vec) -> McpLocalConfig { + McpLocalConfig { + r#type, + command, + environment: None, + enabled: None, + timeout: None, + } + } +} +/// Type of MCP server connection +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "local")] + Local, +} + +impl Default for Type { + fn default() -> Type { + Self::Local + } +} + diff --git a/crates/opencode-client/generated/src/models/mcp_o_auth_config.rs b/crates/opencode-client/generated/src/models/mcp_o_auth_config.rs new file mode 100644 index 0000000..fdb139a --- /dev/null +++ b/crates/opencode-client/generated/src/models/mcp_o_auth_config.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpOAuthConfig { + /// OAuth client ID. If not provided, dynamic client registration (RFC 7591) will be attempted. + #[serde(rename = "clientId", skip_serializing_if = "Option::is_none")] + pub client_id: Option, + /// OAuth client secret (if required by the authorization server) + #[serde(rename = "clientSecret", skip_serializing_if = "Option::is_none")] + pub client_secret: Option, + /// OAuth scopes to request during authorization + #[serde(rename = "scope", skip_serializing_if = "Option::is_none")] + pub scope: Option, +} + +impl McpOAuthConfig { + pub fn new() -> McpOAuthConfig { + McpOAuthConfig { + client_id: None, + client_secret: None, + scope: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/mcp_remote_config.rs b/crates/opencode-client/generated/src/models/mcp_remote_config.rs new file mode 100644 index 0000000..8c01b8a --- /dev/null +++ b/crates/opencode-client/generated/src/models/mcp_remote_config.rs @@ -0,0 +1,59 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpRemoteConfig { + /// Type of MCP server connection + #[serde(rename = "type")] + pub r#type: Type, + /// URL of the remote MCP server + #[serde(rename = "url")] + pub url: String, + /// Enable or disable the MCP server on startup + #[serde(rename = "enabled", skip_serializing_if = "Option::is_none")] + pub enabled: Option, + /// Headers to send with the request + #[serde(rename = "headers", skip_serializing_if = "Option::is_none")] + pub headers: Option>, + #[serde(rename = "oauth", skip_serializing_if = "Option::is_none")] + pub oauth: Option>, + /// Timeout in ms for fetching tools from the MCP server. Defaults to 5000 (5 seconds) if not specified. + #[serde(rename = "timeout", skip_serializing_if = "Option::is_none")] + pub timeout: Option, +} + +impl McpRemoteConfig { + pub fn new(r#type: Type, url: String) -> McpRemoteConfig { + McpRemoteConfig { + r#type, + url, + enabled: None, + headers: None, + oauth: None, + timeout: None, + } + } +} +/// Type of MCP server connection +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "remote")] + Remote, +} + +impl Default for Type { + fn default() -> Type { + Self::Remote + } +} + diff --git a/crates/opencode-client/generated/src/models/mcp_remote_config_oauth.rs b/crates/opencode-client/generated/src/models/mcp_remote_config_oauth.rs new file mode 100644 index 0000000..46bcae2 --- /dev/null +++ b/crates/opencode-client/generated/src/models/mcp_remote_config_oauth.rs @@ -0,0 +1,38 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// McpRemoteConfigOauth : OAuth authentication configuration for the MCP server. Set to false to disable OAuth auto-detection. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpRemoteConfigOauth { + /// OAuth client ID. If not provided, dynamic client registration (RFC 7591) will be attempted. + #[serde(rename = "clientId", skip_serializing_if = "Option::is_none")] + pub client_id: Option, + /// OAuth client secret (if required by the authorization server) + #[serde(rename = "clientSecret", skip_serializing_if = "Option::is_none")] + pub client_secret: Option, + /// OAuth scopes to request during authorization + #[serde(rename = "scope", skip_serializing_if = "Option::is_none")] + pub scope: Option, +} + +impl McpRemoteConfigOauth { + /// OAuth authentication configuration for the MCP server. Set to false to disable OAuth auto-detection. + pub fn new() -> McpRemoteConfigOauth { + McpRemoteConfigOauth { + client_id: None, + client_secret: None, + scope: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/mcp_status.rs b/crates/opencode-client/generated/src/models/mcp_status.rs new file mode 100644 index 0000000..c4d78a6 --- /dev/null +++ b/crates/opencode-client/generated/src/models/mcp_status.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpStatus { + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "error")] + pub error: String, +} + +impl McpStatus { + pub fn new(status: Status, error: String) -> McpStatus { + McpStatus { + status, + error, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "needs_client_registration")] + NeedsClientRegistration, +} + +impl Default for Status { + fn default() -> Status { + Self::NeedsClientRegistration + } +} + diff --git a/crates/opencode-client/generated/src/models/mcp_status_connected.rs b/crates/opencode-client/generated/src/models/mcp_status_connected.rs new file mode 100644 index 0000000..15b1003 --- /dev/null +++ b/crates/opencode-client/generated/src/models/mcp_status_connected.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpStatusConnected { + #[serde(rename = "status")] + pub status: Status, +} + +impl McpStatusConnected { + pub fn new(status: Status) -> McpStatusConnected { + McpStatusConnected { + status, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "connected")] + Connected, +} + +impl Default for Status { + fn default() -> Status { + Self::Connected + } +} + diff --git a/crates/opencode-client/generated/src/models/mcp_status_disabled.rs b/crates/opencode-client/generated/src/models/mcp_status_disabled.rs new file mode 100644 index 0000000..404ca91 --- /dev/null +++ b/crates/opencode-client/generated/src/models/mcp_status_disabled.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpStatusDisabled { + #[serde(rename = "status")] + pub status: Status, +} + +impl McpStatusDisabled { + pub fn new(status: Status) -> McpStatusDisabled { + McpStatusDisabled { + status, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "disabled")] + Disabled, +} + +impl Default for Status { + fn default() -> Status { + Self::Disabled + } +} + diff --git a/crates/opencode-client/generated/src/models/mcp_status_failed.rs b/crates/opencode-client/generated/src/models/mcp_status_failed.rs new file mode 100644 index 0000000..b177d5f --- /dev/null +++ b/crates/opencode-client/generated/src/models/mcp_status_failed.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpStatusFailed { + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "error")] + pub error: String, +} + +impl McpStatusFailed { + pub fn new(status: Status, error: String) -> McpStatusFailed { + McpStatusFailed { + status, + error, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "failed")] + Failed, +} + +impl Default for Status { + fn default() -> Status { + Self::Failed + } +} + diff --git a/crates/opencode-client/generated/src/models/mcp_status_needs_auth.rs b/crates/opencode-client/generated/src/models/mcp_status_needs_auth.rs new file mode 100644 index 0000000..422b91a --- /dev/null +++ b/crates/opencode-client/generated/src/models/mcp_status_needs_auth.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpStatusNeedsAuth { + #[serde(rename = "status")] + pub status: Status, +} + +impl McpStatusNeedsAuth { + pub fn new(status: Status) -> McpStatusNeedsAuth { + McpStatusNeedsAuth { + status, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "needs_auth")] + NeedsAuth, +} + +impl Default for Status { + fn default() -> Status { + Self::NeedsAuth + } +} + diff --git a/crates/opencode-client/generated/src/models/mcp_status_needs_client_registration.rs b/crates/opencode-client/generated/src/models/mcp_status_needs_client_registration.rs new file mode 100644 index 0000000..7de56b9 --- /dev/null +++ b/crates/opencode-client/generated/src/models/mcp_status_needs_client_registration.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpStatusNeedsClientRegistration { + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "error")] + pub error: String, +} + +impl McpStatusNeedsClientRegistration { + pub fn new(status: Status, error: String) -> McpStatusNeedsClientRegistration { + McpStatusNeedsClientRegistration { + status, + error, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "needs_client_registration")] + NeedsClientRegistration, +} + +impl Default for Status { + fn default() -> Status { + Self::NeedsClientRegistration + } +} + diff --git a/crates/opencode-client/generated/src/models/message.rs b/crates/opencode-client/generated/src/models/message.rs new file mode 100644 index 0000000..9a2d3cb --- /dev/null +++ b/crates/opencode-client/generated/src/models/message.rs @@ -0,0 +1,93 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Message { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "role")] + pub role: Role, + #[serde(rename = "time")] + pub time: Box, + #[serde(rename = "summary", skip_serializing_if = "Option::is_none")] + pub summary: Option, + #[serde(rename = "agent")] + pub agent: String, + #[serde(rename = "model")] + pub model: Box, + #[serde(rename = "system", skip_serializing_if = "Option::is_none")] + pub system: Option, + #[serde(rename = "tools", skip_serializing_if = "Option::is_none")] + pub tools: Option>, + #[serde(rename = "variant", skip_serializing_if = "Option::is_none")] + pub variant: Option, + #[serde(rename = "error", skip_serializing_if = "Option::is_none")] + pub error: Option>, + #[serde(rename = "parentID")] + pub parent_id: String, + #[serde(rename = "modelID")] + pub model_id: String, + #[serde(rename = "providerID")] + pub provider_id: String, + #[serde(rename = "mode")] + pub mode: String, + #[serde(rename = "path")] + pub path: Box, + #[serde(rename = "cost")] + pub cost: f64, + #[serde(rename = "tokens")] + pub tokens: Box, + #[serde(rename = "finish", skip_serializing_if = "Option::is_none")] + pub finish: Option, +} + +impl Message { + pub fn new(id: String, session_id: String, role: Role, time: models::AssistantMessageTime, agent: String, model: models::SessionPromptRequestModel, parent_id: String, model_id: String, provider_id: String, mode: String, path: models::AssistantMessagePath, cost: f64, tokens: models::AssistantMessageTokens) -> Message { + Message { + id, + session_id, + role, + time: Box::new(time), + summary: None, + agent, + model: Box::new(model), + system: None, + tools: None, + variant: None, + error: None, + parent_id, + model_id, + provider_id, + mode, + path: Box::new(path), + cost, + tokens: Box::new(tokens), + finish: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Role { + #[serde(rename = "assistant")] + Assistant, +} + +impl Default for Role { + fn default() -> Role { + Self::Assistant + } +} + diff --git a/crates/opencode-client/generated/src/models/message_aborted_error.rs b/crates/opencode-client/generated/src/models/message_aborted_error.rs new file mode 100644 index 0000000..20d1b72 --- /dev/null +++ b/crates/opencode-client/generated/src/models/message_aborted_error.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct MessageAbortedError { + #[serde(rename = "name")] + pub name: Name, + #[serde(rename = "data")] + pub data: Box, +} + +impl MessageAbortedError { + pub fn new(name: Name, data: models::UnknownErrorData) -> MessageAbortedError { + MessageAbortedError { + name, + data: Box::new(data), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Name { + #[serde(rename = "MessageAbortedError")] + MessageAbortedError, +} + +impl Default for Name { + fn default() -> Name { + Self::MessageAbortedError + } +} + diff --git a/crates/opencode-client/generated/src/models/message_output_length_error.rs b/crates/opencode-client/generated/src/models/message_output_length_error.rs new file mode 100644 index 0000000..82ea07a --- /dev/null +++ b/crates/opencode-client/generated/src/models/message_output_length_error.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct MessageOutputLengthError { + #[serde(rename = "name")] + pub name: Name, + #[serde(rename = "data")] + pub data: serde_json::Value, +} + +impl MessageOutputLengthError { + pub fn new(name: Name, data: serde_json::Value) -> MessageOutputLengthError { + MessageOutputLengthError { + name, + data, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Name { + #[serde(rename = "MessageOutputLengthError")] + MessageOutputLengthError, +} + +impl Default for Name { + fn default() -> Name { + Self::MessageOutputLengthError + } +} + diff --git a/crates/opencode-client/generated/src/models/mod.rs b/crates/opencode-client/generated/src/models/mod.rs new file mode 100644 index 0000000..8297184 --- /dev/null +++ b/crates/opencode-client/generated/src/models/mod.rs @@ -0,0 +1,502 @@ +pub mod agent; +pub use self::agent::Agent; +pub mod agent_config; +pub use self::agent_config::AgentConfig; +pub mod agent_config_permission; +pub use self::agent_config_permission::AgentConfigPermission; +pub mod agent_config_permission_bash; +pub use self::agent_config_permission_bash::AgentConfigPermissionBash; +pub mod agent_part; +pub use self::agent_part::AgentPart; +pub mod agent_part_input; +pub use self::agent_part_input::AgentPartInput; +pub mod agent_part_source; +pub use self::agent_part_source::AgentPartSource; +pub mod agent_permission; +pub use self::agent_permission::AgentPermission; +pub mod api_auth; +pub use self::api_auth::ApiAuth; +pub mod api_error; +pub use self::api_error::ApiError; +pub mod api_error_data; +pub use self::api_error_data::ApiErrorData; +pub mod app_log_request; +pub use self::app_log_request::AppLogRequest; +pub mod assistant_message; +pub use self::assistant_message::AssistantMessage; +pub mod assistant_message_error; +pub use self::assistant_message_error::AssistantMessageError; +pub mod assistant_message_path; +pub use self::assistant_message_path::AssistantMessagePath; +pub mod assistant_message_time; +pub use self::assistant_message_time::AssistantMessageTime; +pub mod assistant_message_tokens; +pub use self::assistant_message_tokens::AssistantMessageTokens; +pub mod assistant_message_tokens_cache; +pub use self::assistant_message_tokens_cache::AssistantMessageTokensCache; +pub mod auth; +pub use self::auth::Auth; +pub mod bad_request_error; +pub use self::bad_request_error::BadRequestError; +pub mod command; +pub use self::command::Command; +pub mod command_template; +pub use self::command_template::CommandTemplate; +pub mod compaction_part; +pub use self::compaction_part::CompactionPart; +pub mod config; +pub use self::config::Config; +pub mod config_agent; +pub use self::config_agent::ConfigAgent; +pub mod config_autoupdate; +pub use self::config_autoupdate::ConfigAutoupdate; +pub mod config_command_value; +pub use self::config_command_value::ConfigCommandValue; +pub mod config_compaction; +pub use self::config_compaction::ConfigCompaction; +pub mod config_enterprise; +pub use self::config_enterprise::ConfigEnterprise; +pub mod config_experimental; +pub use self::config_experimental::ConfigExperimental; +pub mod config_experimental_hook; +pub use self::config_experimental_hook::ConfigExperimentalHook; +pub mod config_experimental_hook_file_edited_value_inner; +pub use self::config_experimental_hook_file_edited_value_inner::ConfigExperimentalHookFileEditedValueInner; +pub mod config_formatter; +pub use self::config_formatter::ConfigFormatter; +pub mod config_formatter_any_of_value; +pub use self::config_formatter_any_of_value::ConfigFormatterAnyOfValue; +pub mod config_lsp; +pub use self::config_lsp::ConfigLsp; +pub mod config_lsp_any_of_value; +pub use self::config_lsp_any_of_value::ConfigLspAnyOfValue; +pub mod config_lsp_any_of_value_any_of; +pub use self::config_lsp_any_of_value_any_of::ConfigLspAnyOfValueAnyOf; +pub mod config_lsp_any_of_value_any_of_1; +pub use self::config_lsp_any_of_value_any_of_1::ConfigLspAnyOfValueAnyOf1; +pub mod config_mode; +pub use self::config_mode::ConfigMode; +pub mod config_providers_200_response; +pub use self::config_providers_200_response::ConfigProviders200Response; +pub mod config_tui; +pub use self::config_tui::ConfigTui; +pub mod config_tui_scroll_acceleration; +pub use self::config_tui_scroll_acceleration::ConfigTuiScrollAcceleration; +pub mod config_watcher; +pub use self::config_watcher::ConfigWatcher; +pub mod event; +pub use self::event::Event; +pub mod event_command_executed; +pub use self::event_command_executed::EventCommandExecuted; +pub mod event_command_executed_properties; +pub use self::event_command_executed_properties::EventCommandExecutedProperties; +pub mod event_file_edited; +pub use self::event_file_edited::EventFileEdited; +pub mod event_file_edited_properties; +pub use self::event_file_edited_properties::EventFileEditedProperties; +pub mod event_file_watcher_updated; +pub use self::event_file_watcher_updated::EventFileWatcherUpdated; +pub mod event_file_watcher_updated_properties; +pub use self::event_file_watcher_updated_properties::EventFileWatcherUpdatedProperties; +pub mod event_global_disposed; +pub use self::event_global_disposed::EventGlobalDisposed; +pub mod event_installation_update_available; +pub use self::event_installation_update_available::EventInstallationUpdateAvailable; +pub mod event_installation_updated; +pub use self::event_installation_updated::EventInstallationUpdated; +pub mod event_installation_updated_properties; +pub use self::event_installation_updated_properties::EventInstallationUpdatedProperties; +pub mod event_lsp_client_diagnostics; +pub use self::event_lsp_client_diagnostics::EventLspClientDiagnostics; +pub mod event_lsp_client_diagnostics_properties; +pub use self::event_lsp_client_diagnostics_properties::EventLspClientDiagnosticsProperties; +pub mod event_lsp_updated; +pub use self::event_lsp_updated::EventLspUpdated; +pub mod event_mcp_tools_changed; +pub use self::event_mcp_tools_changed::EventMcpToolsChanged; +pub mod event_mcp_tools_changed_properties; +pub use self::event_mcp_tools_changed_properties::EventMcpToolsChangedProperties; +pub mod event_message_part_removed; +pub use self::event_message_part_removed::EventMessagePartRemoved; +pub mod event_message_part_removed_properties; +pub use self::event_message_part_removed_properties::EventMessagePartRemovedProperties; +pub mod event_message_part_updated; +pub use self::event_message_part_updated::EventMessagePartUpdated; +pub mod event_message_part_updated_properties; +pub use self::event_message_part_updated_properties::EventMessagePartUpdatedProperties; +pub mod event_message_removed; +pub use self::event_message_removed::EventMessageRemoved; +pub mod event_message_removed_properties; +pub use self::event_message_removed_properties::EventMessageRemovedProperties; +pub mod event_message_updated; +pub use self::event_message_updated::EventMessageUpdated; +pub mod event_message_updated_properties; +pub use self::event_message_updated_properties::EventMessageUpdatedProperties; +pub mod event_permission_replied; +pub use self::event_permission_replied::EventPermissionReplied; +pub mod event_permission_replied_properties; +pub use self::event_permission_replied_properties::EventPermissionRepliedProperties; +pub mod event_permission_updated; +pub use self::event_permission_updated::EventPermissionUpdated; +pub mod event_project_updated; +pub use self::event_project_updated::EventProjectUpdated; +pub mod event_pty_created; +pub use self::event_pty_created::EventPtyCreated; +pub mod event_pty_created_properties; +pub use self::event_pty_created_properties::EventPtyCreatedProperties; +pub mod event_pty_deleted; +pub use self::event_pty_deleted::EventPtyDeleted; +pub mod event_pty_deleted_properties; +pub use self::event_pty_deleted_properties::EventPtyDeletedProperties; +pub mod event_pty_exited; +pub use self::event_pty_exited::EventPtyExited; +pub mod event_pty_exited_properties; +pub use self::event_pty_exited_properties::EventPtyExitedProperties; +pub mod event_pty_updated; +pub use self::event_pty_updated::EventPtyUpdated; +pub mod event_server_connected; +pub use self::event_server_connected::EventServerConnected; +pub mod event_server_instance_disposed; +pub use self::event_server_instance_disposed::EventServerInstanceDisposed; +pub mod event_server_instance_disposed_properties; +pub use self::event_server_instance_disposed_properties::EventServerInstanceDisposedProperties; +pub mod event_session_compacted; +pub use self::event_session_compacted::EventSessionCompacted; +pub mod event_session_created; +pub use self::event_session_created::EventSessionCreated; +pub mod event_session_created_properties; +pub use self::event_session_created_properties::EventSessionCreatedProperties; +pub mod event_session_deleted; +pub use self::event_session_deleted::EventSessionDeleted; +pub mod event_session_diff; +pub use self::event_session_diff::EventSessionDiff; +pub mod event_session_diff_properties; +pub use self::event_session_diff_properties::EventSessionDiffProperties; +pub mod event_session_error; +pub use self::event_session_error::EventSessionError; +pub mod event_session_error_properties; +pub use self::event_session_error_properties::EventSessionErrorProperties; +pub mod event_session_idle; +pub use self::event_session_idle::EventSessionIdle; +pub mod event_session_idle_properties; +pub use self::event_session_idle_properties::EventSessionIdleProperties; +pub mod event_session_status; +pub use self::event_session_status::EventSessionStatus; +pub mod event_session_status_properties; +pub use self::event_session_status_properties::EventSessionStatusProperties; +pub mod event_session_updated; +pub use self::event_session_updated::EventSessionUpdated; +pub mod event_todo_updated; +pub use self::event_todo_updated::EventTodoUpdated; +pub mod event_todo_updated_properties; +pub use self::event_todo_updated_properties::EventTodoUpdatedProperties; +pub mod event_tui_command_execute; +pub use self::event_tui_command_execute::EventTuiCommandExecute; +pub mod event_tui_command_execute_properties; +pub use self::event_tui_command_execute_properties::EventTuiCommandExecuteProperties; +pub mod event_tui_command_execute_properties_command; +pub use self::event_tui_command_execute_properties_command::EventTuiCommandExecutePropertiesCommand; +pub mod event_tui_prompt_append; +pub use self::event_tui_prompt_append::EventTuiPromptAppend; +pub mod event_tui_toast_show; +pub use self::event_tui_toast_show::EventTuiToastShow; +pub mod event_vcs_branch_updated; +pub use self::event_vcs_branch_updated::EventVcsBranchUpdated; +pub mod event_vcs_branch_updated_properties; +pub use self::event_vcs_branch_updated_properties::EventVcsBranchUpdatedProperties; +pub mod file; +pub use self::file::File; +pub mod file_content; +pub use self::file_content::FileContent; +pub mod file_content_patch; +pub use self::file_content_patch::FileContentPatch; +pub mod file_content_patch_hunks_inner; +pub use self::file_content_patch_hunks_inner::FileContentPatchHunksInner; +pub mod file_diff; +pub use self::file_diff::FileDiff; +pub mod file_node; +pub use self::file_node::FileNode; +pub mod file_part; +pub use self::file_part::FilePart; +pub mod file_part_input; +pub use self::file_part_input::FilePartInput; +pub mod file_part_source; +pub use self::file_part_source::FilePartSource; +pub mod file_part_source_text; +pub use self::file_part_source_text::FilePartSourceText; +pub mod file_source; +pub use self::file_source::FileSource; +pub mod find_text_200_response_inner; +pub use self::find_text_200_response_inner::FindText200ResponseInner; +pub mod find_text_200_response_inner_path; +pub use self::find_text_200_response_inner_path::FindText200ResponseInnerPath; +pub mod find_text_200_response_inner_submatches_inner; +pub use self::find_text_200_response_inner_submatches_inner::FindText200ResponseInnerSubmatchesInner; +pub mod formatter_status; +pub use self::formatter_status::FormatterStatus; +pub mod global_event; +pub use self::global_event::GlobalEvent; +pub mod global_health_200_response; +pub use self::global_health_200_response::GlobalHealth200Response; +pub mod keybinds_config; +pub use self::keybinds_config::KeybindsConfig; +pub mod layout_config; +pub use self::layout_config::LayoutConfig; +pub mod log_level; +pub use self::log_level::LogLevel; +pub mod lsp_status; +pub use self::lsp_status::LspStatus; +pub mod mcp_add_request; +pub use self::mcp_add_request::McpAddRequest; +pub mod mcp_add_request_config; +pub use self::mcp_add_request_config::McpAddRequestConfig; +pub mod mcp_auth_callback_request; +pub use self::mcp_auth_callback_request::McpAuthCallbackRequest; +pub mod mcp_auth_remove_200_response; +pub use self::mcp_auth_remove_200_response::McpAuthRemove200Response; +pub mod mcp_auth_start_200_response; +pub use self::mcp_auth_start_200_response::McpAuthStart200Response; +pub mod mcp_local_config; +pub use self::mcp_local_config::McpLocalConfig; +pub mod mcp_o_auth_config; +pub use self::mcp_o_auth_config::McpOAuthConfig; +pub mod mcp_remote_config; +pub use self::mcp_remote_config::McpRemoteConfig; +pub mod mcp_remote_config_oauth; +pub use self::mcp_remote_config_oauth::McpRemoteConfigOauth; +pub mod mcp_status; +pub use self::mcp_status::McpStatus; +pub mod mcp_status_connected; +pub use self::mcp_status_connected::McpStatusConnected; +pub mod mcp_status_disabled; +pub use self::mcp_status_disabled::McpStatusDisabled; +pub mod mcp_status_failed; +pub use self::mcp_status_failed::McpStatusFailed; +pub mod mcp_status_needs_auth; +pub use self::mcp_status_needs_auth::McpStatusNeedsAuth; +pub mod mcp_status_needs_client_registration; +pub use self::mcp_status_needs_client_registration::McpStatusNeedsClientRegistration; +pub mod message; +pub use self::message::Message; +pub mod message_aborted_error; +pub use self::message_aborted_error::MessageAbortedError; +pub mod message_output_length_error; +pub use self::message_output_length_error::MessageOutputLengthError; +pub mod model; +pub use self::model::Model; +pub mod model_api; +pub use self::model_api::ModelApi; +pub mod model_capabilities; +pub use self::model_capabilities::ModelCapabilities; +pub mod model_capabilities_input; +pub use self::model_capabilities_input::ModelCapabilitiesInput; +pub mod model_capabilities_interleaved; +pub use self::model_capabilities_interleaved::ModelCapabilitiesInterleaved; +pub mod model_capabilities_interleaved_any_of; +pub use self::model_capabilities_interleaved_any_of::ModelCapabilitiesInterleavedAnyOf; +pub mod model_cost; +pub use self::model_cost::ModelCost; +pub mod model_cost_experimental_over200_k; +pub use self::model_cost_experimental_over200_k::ModelCostExperimentalOver200K; +pub mod not_found_error; +pub use self::not_found_error::NotFoundError; +pub mod o_auth; +pub use self::o_auth::OAuth; +pub mod part; +pub use self::part::Part; +pub mod part_any_of; +pub use self::part_any_of::PartAnyOf; +pub mod patch_part; +pub use self::patch_part::PatchPart; +pub mod path; +pub use self::path::Path; +pub mod permission; +pub use self::permission::Permission; +pub mod permission_pattern; +pub use self::permission_pattern::PermissionPattern; +pub mod permission_respond_request; +pub use self::permission_respond_request::PermissionRespondRequest; +pub mod project; +pub use self::project::Project; +pub mod project_time; +pub use self::project_time::ProjectTime; +pub mod project_update_request; +pub use self::project_update_request::ProjectUpdateRequest; +pub mod project_update_request_icon; +pub use self::project_update_request_icon::ProjectUpdateRequestIcon; +pub mod provider; +pub use self::provider::Provider; +pub mod provider_auth_authorization; +pub use self::provider_auth_authorization::ProviderAuthAuthorization; +pub mod provider_auth_error; +pub use self::provider_auth_error::ProviderAuthError; +pub mod provider_auth_error_data; +pub use self::provider_auth_error_data::ProviderAuthErrorData; +pub mod provider_auth_method; +pub use self::provider_auth_method::ProviderAuthMethod; +pub mod provider_config; +pub use self::provider_config::ProviderConfig; +pub mod provider_config_models_value; +pub use self::provider_config_models_value::ProviderConfigModelsValue; +pub mod provider_config_models_value_interleaved; +pub use self::provider_config_models_value_interleaved::ProviderConfigModelsValueInterleaved; +pub mod provider_config_models_value_interleaved_any_of; +pub use self::provider_config_models_value_interleaved_any_of::ProviderConfigModelsValueInterleavedAnyOf; +pub mod provider_config_models_value_variants_value; +pub use self::provider_config_models_value_variants_value::ProviderConfigModelsValueVariantsValue; +pub mod provider_config_options; +pub use self::provider_config_options::ProviderConfigOptions; +pub mod provider_config_options_timeout; +pub use self::provider_config_options_timeout::ProviderConfigOptionsTimeout; +pub mod provider_list_200_response; +pub use self::provider_list_200_response::ProviderList200Response; +pub mod provider_list_200_response_all_inner; +pub use self::provider_list_200_response_all_inner::ProviderList200ResponseAllInner; +pub mod provider_list_200_response_all_inner_models_value; +pub use self::provider_list_200_response_all_inner_models_value::ProviderList200ResponseAllInnerModelsValue; +pub mod provider_list_200_response_all_inner_models_value_cost; +pub use self::provider_list_200_response_all_inner_models_value_cost::ProviderList200ResponseAllInnerModelsValueCost; +pub mod provider_list_200_response_all_inner_models_value_cost_context_over_200k; +pub use self::provider_list_200_response_all_inner_models_value_cost_context_over_200k::ProviderList200ResponseAllInnerModelsValueCostContextOver200k; +pub mod provider_list_200_response_all_inner_models_value_interleaved; +pub use self::provider_list_200_response_all_inner_models_value_interleaved::ProviderList200ResponseAllInnerModelsValueInterleaved; +pub mod provider_list_200_response_all_inner_models_value_interleaved_any_of; +pub use self::provider_list_200_response_all_inner_models_value_interleaved_any_of::ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf; +pub mod provider_list_200_response_all_inner_models_value_limit; +pub use self::provider_list_200_response_all_inner_models_value_limit::ProviderList200ResponseAllInnerModelsValueLimit; +pub mod provider_list_200_response_all_inner_models_value_modalities; +pub use self::provider_list_200_response_all_inner_models_value_modalities::ProviderList200ResponseAllInnerModelsValueModalities; +pub mod provider_list_200_response_all_inner_models_value_provider; +pub use self::provider_list_200_response_all_inner_models_value_provider::ProviderList200ResponseAllInnerModelsValueProvider; +pub mod provider_oauth_authorize_request; +pub use self::provider_oauth_authorize_request::ProviderOauthAuthorizeRequest; +pub mod provider_oauth_callback_request; +pub use self::provider_oauth_callback_request::ProviderOauthCallbackRequest; +pub mod pty; +pub use self::pty::Pty; +pub mod pty_create_request; +pub use self::pty_create_request::PtyCreateRequest; +pub mod pty_update_request; +pub use self::pty_update_request::PtyUpdateRequest; +pub mod pty_update_request_size; +pub use self::pty_update_request_size::PtyUpdateRequestSize; +pub mod range; +pub use self::range::Range; +pub mod range_start; +pub use self::range_start::RangeStart; +pub mod reasoning_part; +pub use self::reasoning_part::ReasoningPart; +pub mod retry_part; +pub use self::retry_part::RetryPart; +pub mod server_config; +pub use self::server_config::ServerConfig; +pub mod session; +pub use self::session::Session; +pub mod session_command_request; +pub use self::session_command_request::SessionCommandRequest; +pub mod session_create_request; +pub use self::session_create_request::SessionCreateRequest; +pub mod session_fork_request; +pub use self::session_fork_request::SessionForkRequest; +pub mod session_init_request; +pub use self::session_init_request::SessionInitRequest; +pub mod session_messages_200_response_inner; +pub use self::session_messages_200_response_inner::SessionMessages200ResponseInner; +pub mod session_prompt_200_response; +pub use self::session_prompt_200_response::SessionPrompt200Response; +pub mod session_prompt_request; +pub use self::session_prompt_request::SessionPromptRequest; +pub mod session_prompt_request_model; +pub use self::session_prompt_request_model::SessionPromptRequestModel; +pub mod session_prompt_request_parts_inner; +pub use self::session_prompt_request_parts_inner::SessionPromptRequestPartsInner; +pub mod session_revert; +pub use self::session_revert::SessionRevert; +pub mod session_revert_request; +pub use self::session_revert_request::SessionRevertRequest; +pub mod session_share; +pub use self::session_share::SessionShare; +pub mod session_shell_request; +pub use self::session_shell_request::SessionShellRequest; +pub mod session_status; +pub use self::session_status::SessionStatus; +pub mod session_status_any_of; +pub use self::session_status_any_of::SessionStatusAnyOf; +pub mod session_status_any_of_1; +pub use self::session_status_any_of_1::SessionStatusAnyOf1; +pub mod session_status_any_of_2; +pub use self::session_status_any_of_2::SessionStatusAnyOf2; +pub mod session_summarize_request; +pub use self::session_summarize_request::SessionSummarizeRequest; +pub mod session_summary; +pub use self::session_summary::SessionSummary; +pub mod session_time; +pub use self::session_time::SessionTime; +pub mod session_update_request; +pub use self::session_update_request::SessionUpdateRequest; +pub mod session_update_request_time; +pub use self::session_update_request_time::SessionUpdateRequestTime; +pub mod snapshot_part; +pub use self::snapshot_part::SnapshotPart; +pub mod step_finish_part; +pub use self::step_finish_part::StepFinishPart; +pub mod step_start_part; +pub use self::step_start_part::StepStartPart; +pub mod subtask_part_input; +pub use self::subtask_part_input::SubtaskPartInput; +pub mod symbol; +pub use self::symbol::Symbol; +pub mod symbol_location; +pub use self::symbol_location::SymbolLocation; +pub mod symbol_source; +pub use self::symbol_source::SymbolSource; +pub mod text_part; +pub use self::text_part::TextPart; +pub mod text_part_input; +pub use self::text_part_input::TextPartInput; +pub mod text_part_time; +pub use self::text_part_time::TextPartTime; +pub mod todo; +pub use self::todo::Todo; +pub mod tool_list_item; +pub use self::tool_list_item::ToolListItem; +pub mod tool_part; +pub use self::tool_part::ToolPart; +pub mod tool_state; +pub use self::tool_state::ToolState; +pub mod tool_state_completed; +pub use self::tool_state_completed::ToolStateCompleted; +pub mod tool_state_completed_time; +pub use self::tool_state_completed_time::ToolStateCompletedTime; +pub mod tool_state_error; +pub use self::tool_state_error::ToolStateError; +pub mod tool_state_error_time; +pub use self::tool_state_error_time::ToolStateErrorTime; +pub mod tool_state_pending; +pub use self::tool_state_pending::ToolStatePending; +pub mod tool_state_running; +pub use self::tool_state_running::ToolStateRunning; +pub mod tool_state_running_time; +pub use self::tool_state_running_time::ToolStateRunningTime; +pub mod tui_control_next_200_response; +pub use self::tui_control_next_200_response::TuiControlNext200Response; +pub mod tui_execute_command_request; +pub use self::tui_execute_command_request::TuiExecuteCommandRequest; +pub mod tui_publish_request; +pub use self::tui_publish_request::TuiPublishRequest; +pub mod tui_show_toast_request; +pub use self::tui_show_toast_request::TuiShowToastRequest; +pub mod unknown_error; +pub use self::unknown_error::UnknownError; +pub mod unknown_error_data; +pub use self::unknown_error_data::UnknownErrorData; +pub mod user_message; +pub use self::user_message::UserMessage; +pub mod user_message_summary; +pub use self::user_message_summary::UserMessageSummary; +pub mod user_message_time; +pub use self::user_message_time::UserMessageTime; +pub mod vcs_info; +pub use self::vcs_info::VcsInfo; +pub mod well_known_auth; +pub use self::well_known_auth::WellKnownAuth; diff --git a/crates/opencode-client/generated/src/models/model.rs b/crates/opencode-client/generated/src/models/model.rs new file mode 100644 index 0000000..45f5b50 --- /dev/null +++ b/crates/opencode-client/generated/src/models/model.rs @@ -0,0 +1,81 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Model { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "providerID")] + pub provider_id: String, + #[serde(rename = "api")] + pub api: Box, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "family", skip_serializing_if = "Option::is_none")] + pub family: Option, + #[serde(rename = "capabilities")] + pub capabilities: Box, + #[serde(rename = "cost")] + pub cost: Box, + #[serde(rename = "limit")] + pub limit: Box, + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "options")] + pub options: std::collections::HashMap, + #[serde(rename = "headers")] + pub headers: std::collections::HashMap, + #[serde(rename = "release_date")] + pub release_date: String, + #[serde(rename = "variants", skip_serializing_if = "Option::is_none")] + pub variants: Option>>, +} + +impl Model { + pub fn new(id: String, provider_id: String, api: models::ModelApi, name: String, capabilities: models::ModelCapabilities, cost: models::ModelCost, limit: models::ProviderList200ResponseAllInnerModelsValueLimit, status: Status, options: std::collections::HashMap, headers: std::collections::HashMap, release_date: String) -> Model { + Model { + id, + provider_id, + api: Box::new(api), + name, + family: None, + capabilities: Box::new(capabilities), + cost: Box::new(cost), + limit: Box::new(limit), + status, + options, + headers, + release_date, + variants: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "alpha")] + Alpha, + #[serde(rename = "beta")] + Beta, + #[serde(rename = "deprecated")] + Deprecated, + #[serde(rename = "active")] + Active, +} + +impl Default for Status { + fn default() -> Status { + Self::Alpha + } +} + diff --git a/crates/opencode-client/generated/src/models/model_api.rs b/crates/opencode-client/generated/src/models/model_api.rs new file mode 100644 index 0000000..cca01fa --- /dev/null +++ b/crates/opencode-client/generated/src/models/model_api.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ModelApi { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "url")] + pub url: String, + #[serde(rename = "npm")] + pub npm: String, +} + +impl ModelApi { + pub fn new(id: String, url: String, npm: String) -> ModelApi { + ModelApi { + id, + url, + npm, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/model_capabilities.rs b/crates/opencode-client/generated/src/models/model_capabilities.rs new file mode 100644 index 0000000..9193cb2 --- /dev/null +++ b/crates/opencode-client/generated/src/models/model_capabilities.rs @@ -0,0 +1,45 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ModelCapabilities { + #[serde(rename = "temperature")] + pub temperature: bool, + #[serde(rename = "reasoning")] + pub reasoning: bool, + #[serde(rename = "attachment")] + pub attachment: bool, + #[serde(rename = "toolcall")] + pub toolcall: bool, + #[serde(rename = "input")] + pub input: Box, + #[serde(rename = "output")] + pub output: Box, + #[serde(rename = "interleaved")] + pub interleaved: Box, +} + +impl ModelCapabilities { + pub fn new(temperature: bool, reasoning: bool, attachment: bool, toolcall: bool, input: models::ModelCapabilitiesInput, output: models::ModelCapabilitiesInput, interleaved: models::ModelCapabilitiesInterleaved) -> ModelCapabilities { + ModelCapabilities { + temperature, + reasoning, + attachment, + toolcall, + input: Box::new(input), + output: Box::new(output), + interleaved: Box::new(interleaved), + } + } +} + diff --git a/crates/opencode-client/generated/src/models/model_capabilities_input.rs b/crates/opencode-client/generated/src/models/model_capabilities_input.rs new file mode 100644 index 0000000..40f2800 --- /dev/null +++ b/crates/opencode-client/generated/src/models/model_capabilities_input.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ModelCapabilitiesInput { + #[serde(rename = "text")] + pub text: bool, + #[serde(rename = "audio")] + pub audio: bool, + #[serde(rename = "image")] + pub image: bool, + #[serde(rename = "video")] + pub video: bool, + #[serde(rename = "pdf")] + pub pdf: bool, +} + +impl ModelCapabilitiesInput { + pub fn new(text: bool, audio: bool, image: bool, video: bool, pdf: bool) -> ModelCapabilitiesInput { + ModelCapabilitiesInput { + text, + audio, + image, + video, + pdf, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/model_capabilities_interleaved.rs b/crates/opencode-client/generated/src/models/model_capabilities_interleaved.rs new file mode 100644 index 0000000..ddc8bd8 --- /dev/null +++ b/crates/opencode-client/generated/src/models/model_capabilities_interleaved.rs @@ -0,0 +1,41 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ModelCapabilitiesInterleaved { + #[serde(rename = "field")] + pub field: Field, +} + +impl ModelCapabilitiesInterleaved { + pub fn new(field: Field) -> ModelCapabilitiesInterleaved { + ModelCapabilitiesInterleaved { + field, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Field { + #[serde(rename = "reasoning_content")] + ReasoningContent, + #[serde(rename = "reasoning_details")] + ReasoningDetails, +} + +impl Default for Field { + fn default() -> Field { + Self::ReasoningContent + } +} + diff --git a/crates/opencode-client/generated/src/models/model_capabilities_interleaved_any_of.rs b/crates/opencode-client/generated/src/models/model_capabilities_interleaved_any_of.rs new file mode 100644 index 0000000..a180e61 --- /dev/null +++ b/crates/opencode-client/generated/src/models/model_capabilities_interleaved_any_of.rs @@ -0,0 +1,41 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ModelCapabilitiesInterleavedAnyOf { + #[serde(rename = "field")] + pub field: Field, +} + +impl ModelCapabilitiesInterleavedAnyOf { + pub fn new(field: Field) -> ModelCapabilitiesInterleavedAnyOf { + ModelCapabilitiesInterleavedAnyOf { + field, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Field { + #[serde(rename = "reasoning_content")] + ReasoningContent, + #[serde(rename = "reasoning_details")] + ReasoningDetails, +} + +impl Default for Field { + fn default() -> Field { + Self::ReasoningContent + } +} + diff --git a/crates/opencode-client/generated/src/models/model_cost.rs b/crates/opencode-client/generated/src/models/model_cost.rs new file mode 100644 index 0000000..dbeb9db --- /dev/null +++ b/crates/opencode-client/generated/src/models/model_cost.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ModelCost { + #[serde(rename = "input")] + pub input: f64, + #[serde(rename = "output")] + pub output: f64, + #[serde(rename = "cache")] + pub cache: Box, + #[serde(rename = "experimentalOver200K", skip_serializing_if = "Option::is_none")] + pub experimental_over200_k: Option>, +} + +impl ModelCost { + pub fn new(input: f64, output: f64, cache: models::AssistantMessageTokensCache) -> ModelCost { + ModelCost { + input, + output, + cache: Box::new(cache), + experimental_over200_k: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/model_cost_experimental_over200_k.rs b/crates/opencode-client/generated/src/models/model_cost_experimental_over200_k.rs new file mode 100644 index 0000000..3215715 --- /dev/null +++ b/crates/opencode-client/generated/src/models/model_cost_experimental_over200_k.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ModelCostExperimentalOver200K { + #[serde(rename = "input")] + pub input: f64, + #[serde(rename = "output")] + pub output: f64, + #[serde(rename = "cache")] + pub cache: Box, +} + +impl ModelCostExperimentalOver200K { + pub fn new(input: f64, output: f64, cache: models::AssistantMessageTokensCache) -> ModelCostExperimentalOver200K { + ModelCostExperimentalOver200K { + input, + output, + cache: Box::new(cache), + } + } +} + diff --git a/crates/opencode-client/generated/src/models/not_found_error.rs b/crates/opencode-client/generated/src/models/not_found_error.rs new file mode 100644 index 0000000..3a3f4e5 --- /dev/null +++ b/crates/opencode-client/generated/src/models/not_found_error.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct NotFoundError { + #[serde(rename = "name")] + pub name: Name, + #[serde(rename = "data")] + pub data: Box, +} + +impl NotFoundError { + pub fn new(name: Name, data: models::UnknownErrorData) -> NotFoundError { + NotFoundError { + name, + data: Box::new(data), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Name { + #[serde(rename = "NotFoundError")] + NotFoundError, +} + +impl Default for Name { + fn default() -> Name { + Self::NotFoundError + } +} + diff --git a/crates/opencode-client/generated/src/models/o_auth.rs b/crates/opencode-client/generated/src/models/o_auth.rs new file mode 100644 index 0000000..c1d4929 --- /dev/null +++ b/crates/opencode-client/generated/src/models/o_auth.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct OAuth { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "refresh")] + pub refresh: String, + #[serde(rename = "access")] + pub access: String, + #[serde(rename = "expires")] + pub expires: f64, + #[serde(rename = "enterpriseUrl", skip_serializing_if = "Option::is_none")] + pub enterprise_url: Option, +} + +impl OAuth { + pub fn new(r#type: Type, refresh: String, access: String, expires: f64) -> OAuth { + OAuth { + r#type, + refresh, + access, + expires, + enterprise_url: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "oauth")] + Oauth, +} + +impl Default for Type { + fn default() -> Type { + Self::Oauth + } +} + diff --git a/crates/opencode-client/generated/src/models/part.rs b/crates/opencode-client/generated/src/models/part.rs new file mode 100644 index 0000000..f0e1237 --- /dev/null +++ b/crates/opencode-client/generated/src/models/part.rs @@ -0,0 +1,148 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Part { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "text")] + pub text: String, + #[serde(rename = "synthetic", skip_serializing_if = "Option::is_none")] + pub synthetic: Option, + #[serde(rename = "ignored", skip_serializing_if = "Option::is_none")] + pub ignored: Option, + #[serde(rename = "time")] + pub time: Box, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, + #[serde(rename = "prompt")] + pub prompt: String, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "agent")] + pub agent: String, + #[serde(rename = "command", skip_serializing_if = "Option::is_none")] + pub command: Option, + #[serde(rename = "mime")] + pub mime: String, + #[serde(rename = "filename", skip_serializing_if = "Option::is_none")] + pub filename: Option, + #[serde(rename = "url")] + pub url: String, + #[serde(rename = "source", skip_serializing_if = "Option::is_none")] + pub source: Option>, + #[serde(rename = "callID")] + pub call_id: String, + #[serde(rename = "tool")] + pub tool: String, + #[serde(rename = "state")] + pub state: Box, + #[serde(rename = "snapshot")] + pub snapshot: String, + #[serde(rename = "reason")] + pub reason: String, + #[serde(rename = "cost")] + pub cost: f64, + #[serde(rename = "tokens")] + pub tokens: Box, + #[serde(rename = "hash")] + pub hash: String, + #[serde(rename = "files")] + pub files: Vec, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "attempt")] + pub attempt: f64, + #[serde(rename = "error")] + pub error: Box, + #[serde(rename = "auto")] + pub auto: bool, +} + +impl Part { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, text: String, time: models::UserMessageTime, prompt: String, description: String, agent: String, mime: String, url: String, call_id: String, tool: String, state: models::ToolState, snapshot: String, reason: String, cost: f64, tokens: models::AssistantMessageTokens, hash: String, files: Vec, name: String, attempt: f64, error: models::ApiError, auto: bool) -> Part { + Part { + id, + session_id, + message_id, + r#type, + text, + synthetic: None, + ignored: None, + time: Box::new(time), + metadata: None, + prompt, + description, + agent, + command: None, + mime, + filename: None, + url, + source: None, + call_id, + tool, + state: Box::new(state), + snapshot, + reason, + cost, + tokens: Box::new(tokens), + hash, + files, + name, + attempt, + error: Box::new(error), + auto, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "text")] + Text, + #[serde(rename = "subtask")] + Subtask, + #[serde(rename = "reasoning")] + Reasoning, + #[serde(rename = "file")] + File, + #[serde(rename = "tool")] + Tool, + #[serde(rename = "step-start")] + StepStart, + #[serde(rename = "step-finish")] + StepFinish, + #[serde(rename = "snapshot")] + Snapshot, + #[serde(rename = "patch")] + Patch, + #[serde(rename = "agent")] + Agent, + #[serde(rename = "retry")] + Retry, + #[serde(rename = "compaction")] + Compaction, +} + +impl Default for Type { + fn default() -> Type { + Self::Text + } +} + diff --git a/crates/opencode-client/generated/src/models/part_any_of.rs b/crates/opencode-client/generated/src/models/part_any_of.rs new file mode 100644 index 0000000..f1537fa --- /dev/null +++ b/crates/opencode-client/generated/src/models/part_any_of.rs @@ -0,0 +1,60 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct PartAnyOf { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "prompt")] + pub prompt: String, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "agent")] + pub agent: String, + #[serde(rename = "command", skip_serializing_if = "Option::is_none")] + pub command: Option, +} + +impl PartAnyOf { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, prompt: String, description: String, agent: String) -> PartAnyOf { + PartAnyOf { + id, + session_id, + message_id, + r#type, + prompt, + description, + agent, + command: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "subtask")] + Subtask, +} + +impl Default for Type { + fn default() -> Type { + Self::Subtask + } +} + diff --git a/crates/opencode-client/generated/src/models/patch_part.rs b/crates/opencode-client/generated/src/models/patch_part.rs new file mode 100644 index 0000000..22db0a8 --- /dev/null +++ b/crates/opencode-client/generated/src/models/patch_part.rs @@ -0,0 +1,54 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct PatchPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "hash")] + pub hash: String, + #[serde(rename = "files")] + pub files: Vec, +} + +impl PatchPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, hash: String, files: Vec) -> PatchPart { + PatchPart { + id, + session_id, + message_id, + r#type, + hash, + files, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "patch")] + Patch, +} + +impl Default for Type { + fn default() -> Type { + Self::Patch + } +} + diff --git a/crates/opencode-client/generated/src/models/path.rs b/crates/opencode-client/generated/src/models/path.rs new file mode 100644 index 0000000..6c67ebb --- /dev/null +++ b/crates/opencode-client/generated/src/models/path.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Path { + #[serde(rename = "home")] + pub home: String, + #[serde(rename = "state")] + pub state: String, + #[serde(rename = "config")] + pub config: String, + #[serde(rename = "worktree")] + pub worktree: String, + #[serde(rename = "directory")] + pub directory: String, +} + +impl Path { + pub fn new(home: String, state: String, config: String, worktree: String, directory: String) -> Path { + Path { + home, + state, + config, + worktree, + directory, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/permission.rs b/crates/opencode-client/generated/src/models/permission.rs new file mode 100644 index 0000000..55523bc --- /dev/null +++ b/crates/opencode-client/generated/src/models/permission.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Permission { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "type")] + pub r#type: String, + #[serde(rename = "pattern", skip_serializing_if = "Option::is_none")] + pub pattern: Option>, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "callID", skip_serializing_if = "Option::is_none")] + pub call_id: Option, + #[serde(rename = "title")] + pub title: String, + #[serde(rename = "metadata")] + pub metadata: std::collections::HashMap, + #[serde(rename = "time")] + pub time: Box, +} + +impl Permission { + pub fn new(id: String, r#type: String, session_id: String, message_id: String, title: String, metadata: std::collections::HashMap, time: models::UserMessageTime) -> Permission { + Permission { + id, + r#type, + pattern: None, + session_id, + message_id, + call_id: None, + title, + metadata, + time: Box::new(time), + } + } +} + diff --git a/crates/opencode-client/generated/src/models/permission_pattern.rs b/crates/opencode-client/generated/src/models/permission_pattern.rs new file mode 100644 index 0000000..e5adcdd --- /dev/null +++ b/crates/opencode-client/generated/src/models/permission_pattern.rs @@ -0,0 +1,24 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct PermissionPattern { +} + +impl PermissionPattern { + pub fn new() -> PermissionPattern { + PermissionPattern { + } + } +} + diff --git a/crates/opencode-client/generated/src/models/permission_respond_request.rs b/crates/opencode-client/generated/src/models/permission_respond_request.rs new file mode 100644 index 0000000..e2f9767 --- /dev/null +++ b/crates/opencode-client/generated/src/models/permission_respond_request.rs @@ -0,0 +1,43 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct PermissionRespondRequest { + #[serde(rename = "response")] + pub response: Response, +} + +impl PermissionRespondRequest { + pub fn new(response: Response) -> PermissionRespondRequest { + PermissionRespondRequest { + response, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Response { + #[serde(rename = "once")] + Once, + #[serde(rename = "always")] + Always, + #[serde(rename = "reject")] + Reject, +} + +impl Default for Response { + fn default() -> Response { + Self::Once + } +} + diff --git a/crates/opencode-client/generated/src/models/project.rs b/crates/opencode-client/generated/src/models/project.rs new file mode 100644 index 0000000..0566b61 --- /dev/null +++ b/crates/opencode-client/generated/src/models/project.rs @@ -0,0 +1,54 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Project { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "worktree")] + pub worktree: String, + #[serde(rename = "vcs", skip_serializing_if = "Option::is_none")] + pub vcs: Option, + #[serde(rename = "name", skip_serializing_if = "Option::is_none")] + pub name: Option, + #[serde(rename = "icon", skip_serializing_if = "Option::is_none")] + pub icon: Option>, + #[serde(rename = "time")] + pub time: Box, +} + +impl Project { + pub fn new(id: String, worktree: String, time: models::ProjectTime) -> Project { + Project { + id, + worktree, + vcs: None, + name: None, + icon: None, + time: Box::new(time), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Vcs { + #[serde(rename = "git")] + Git, +} + +impl Default for Vcs { + fn default() -> Vcs { + Self::Git + } +} + diff --git a/crates/opencode-client/generated/src/models/project_time.rs b/crates/opencode-client/generated/src/models/project_time.rs new file mode 100644 index 0000000..e68e679 --- /dev/null +++ b/crates/opencode-client/generated/src/models/project_time.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProjectTime { + #[serde(rename = "created")] + pub created: f64, + #[serde(rename = "updated")] + pub updated: f64, + #[serde(rename = "initialized", skip_serializing_if = "Option::is_none")] + pub initialized: Option, +} + +impl ProjectTime { + pub fn new(created: f64, updated: f64) -> ProjectTime { + ProjectTime { + created, + updated, + initialized: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/project_update_request.rs b/crates/opencode-client/generated/src/models/project_update_request.rs new file mode 100644 index 0000000..745b335 --- /dev/null +++ b/crates/opencode-client/generated/src/models/project_update_request.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProjectUpdateRequest { + #[serde(rename = "name", skip_serializing_if = "Option::is_none")] + pub name: Option, + #[serde(rename = "icon", skip_serializing_if = "Option::is_none")] + pub icon: Option>, +} + +impl ProjectUpdateRequest { + pub fn new() -> ProjectUpdateRequest { + ProjectUpdateRequest { + name: None, + icon: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/project_update_request_icon.rs b/crates/opencode-client/generated/src/models/project_update_request_icon.rs new file mode 100644 index 0000000..f87c6cb --- /dev/null +++ b/crates/opencode-client/generated/src/models/project_update_request_icon.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProjectUpdateRequestIcon { + #[serde(rename = "url", skip_serializing_if = "Option::is_none")] + pub url: Option, + #[serde(rename = "color", skip_serializing_if = "Option::is_none")] + pub color: Option, +} + +impl ProjectUpdateRequestIcon { + pub fn new() -> ProjectUpdateRequestIcon { + ProjectUpdateRequestIcon { + url: None, + color: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/provider.rs b/crates/opencode-client/generated/src/models/provider.rs new file mode 100644 index 0000000..1546013 --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider.rs @@ -0,0 +1,63 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Provider { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "source")] + pub source: Source, + #[serde(rename = "env")] + pub env: Vec, + #[serde(rename = "key", skip_serializing_if = "Option::is_none")] + pub key: Option, + #[serde(rename = "options")] + pub options: std::collections::HashMap, + #[serde(rename = "models")] + pub models: std::collections::HashMap, +} + +impl Provider { + pub fn new(id: String, name: String, source: Source, env: Vec, options: std::collections::HashMap, models: std::collections::HashMap) -> Provider { + Provider { + id, + name, + source, + env, + key: None, + options, + models, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Source { + #[serde(rename = "env")] + Env, + #[serde(rename = "config")] + Config, + #[serde(rename = "custom")] + Custom, + #[serde(rename = "api")] + Api, +} + +impl Default for Source { + fn default() -> Source { + Self::Env + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_auth_authorization.rs b/crates/opencode-client/generated/src/models/provider_auth_authorization.rs new file mode 100644 index 0000000..302a9f3 --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_auth_authorization.rs @@ -0,0 +1,47 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderAuthAuthorization { + #[serde(rename = "url")] + pub url: String, + #[serde(rename = "method")] + pub method: Method, + #[serde(rename = "instructions")] + pub instructions: String, +} + +impl ProviderAuthAuthorization { + pub fn new(url: String, method: Method, instructions: String) -> ProviderAuthAuthorization { + ProviderAuthAuthorization { + url, + method, + instructions, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Method { + #[serde(rename = "auto")] + Auto, + #[serde(rename = "code")] + Code, +} + +impl Default for Method { + fn default() -> Method { + Self::Auto + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_auth_error.rs b/crates/opencode-client/generated/src/models/provider_auth_error.rs new file mode 100644 index 0000000..41d7272 --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_auth_error.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderAuthError { + #[serde(rename = "name")] + pub name: Name, + #[serde(rename = "data")] + pub data: Box, +} + +impl ProviderAuthError { + pub fn new(name: Name, data: models::ProviderAuthErrorData) -> ProviderAuthError { + ProviderAuthError { + name, + data: Box::new(data), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Name { + #[serde(rename = "ProviderAuthError")] + ProviderAuthError, +} + +impl Default for Name { + fn default() -> Name { + Self::ProviderAuthError + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_auth_error_data.rs b/crates/opencode-client/generated/src/models/provider_auth_error_data.rs new file mode 100644 index 0000000..b822752 --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_auth_error_data.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderAuthErrorData { + #[serde(rename = "providerID")] + pub provider_id: String, + #[serde(rename = "message")] + pub message: String, +} + +impl ProviderAuthErrorData { + pub fn new(provider_id: String, message: String) -> ProviderAuthErrorData { + ProviderAuthErrorData { + provider_id, + message, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_auth_method.rs b/crates/opencode-client/generated/src/models/provider_auth_method.rs new file mode 100644 index 0000000..90b333d --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_auth_method.rs @@ -0,0 +1,44 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderAuthMethod { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "label")] + pub label: String, +} + +impl ProviderAuthMethod { + pub fn new(r#type: Type, label: String) -> ProviderAuthMethod { + ProviderAuthMethod { + r#type, + label, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "oauth")] + Oauth, + #[serde(rename = "api")] + Api, +} + +impl Default for Type { + fn default() -> Type { + Self::Oauth + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_config.rs b/crates/opencode-client/generated/src/models/provider_config.rs new file mode 100644 index 0000000..c9801ef --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_config.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderConfig { + #[serde(rename = "api", skip_serializing_if = "Option::is_none")] + pub api: Option, + #[serde(rename = "name", skip_serializing_if = "Option::is_none")] + pub name: Option, + #[serde(rename = "env", skip_serializing_if = "Option::is_none")] + pub env: Option>, + #[serde(rename = "id", skip_serializing_if = "Option::is_none")] + pub id: Option, + #[serde(rename = "npm", skip_serializing_if = "Option::is_none")] + pub npm: Option, + #[serde(rename = "models", skip_serializing_if = "Option::is_none")] + pub models: Option>, + #[serde(rename = "whitelist", skip_serializing_if = "Option::is_none")] + pub whitelist: Option>, + #[serde(rename = "blacklist", skip_serializing_if = "Option::is_none")] + pub blacklist: Option>, + #[serde(rename = "options", skip_serializing_if = "Option::is_none")] + pub options: Option, +} + +impl ProviderConfig { + pub fn new() -> ProviderConfig { + ProviderConfig { + api: None, + name: None, + env: None, + id: None, + npm: None, + models: None, + whitelist: None, + blacklist: None, + options: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_config_models_value.rs b/crates/opencode-client/generated/src/models/provider_config_models_value.rs new file mode 100644 index 0000000..3dda5d0 --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_config_models_value.rs @@ -0,0 +1,95 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderConfigModelsValue { + #[serde(rename = "id", skip_serializing_if = "Option::is_none")] + pub id: Option, + #[serde(rename = "name", skip_serializing_if = "Option::is_none")] + pub name: Option, + #[serde(rename = "family", skip_serializing_if = "Option::is_none")] + pub family: Option, + #[serde(rename = "release_date", skip_serializing_if = "Option::is_none")] + pub release_date: Option, + #[serde(rename = "attachment", skip_serializing_if = "Option::is_none")] + pub attachment: Option, + #[serde(rename = "reasoning", skip_serializing_if = "Option::is_none")] + pub reasoning: Option, + #[serde(rename = "temperature", skip_serializing_if = "Option::is_none")] + pub temperature: Option, + #[serde(rename = "tool_call", skip_serializing_if = "Option::is_none")] + pub tool_call: Option, + #[serde(rename = "interleaved", skip_serializing_if = "Option::is_none")] + pub interleaved: Option>, + #[serde(rename = "cost", skip_serializing_if = "Option::is_none")] + pub cost: Option>, + #[serde(rename = "limit", skip_serializing_if = "Option::is_none")] + pub limit: Option>, + #[serde(rename = "modalities", skip_serializing_if = "Option::is_none")] + pub modalities: Option>, + #[serde(rename = "experimental", skip_serializing_if = "Option::is_none")] + pub experimental: Option, + #[serde(rename = "status", skip_serializing_if = "Option::is_none")] + pub status: Option, + #[serde(rename = "options", skip_serializing_if = "Option::is_none")] + pub options: Option>, + #[serde(rename = "headers", skip_serializing_if = "Option::is_none")] + pub headers: Option>, + #[serde(rename = "provider", skip_serializing_if = "Option::is_none")] + pub provider: Option>, + /// Variant-specific configuration + #[serde(rename = "variants", skip_serializing_if = "Option::is_none")] + pub variants: Option>, +} + +impl ProviderConfigModelsValue { + pub fn new() -> ProviderConfigModelsValue { + ProviderConfigModelsValue { + id: None, + name: None, + family: None, + release_date: None, + attachment: None, + reasoning: None, + temperature: None, + tool_call: None, + interleaved: None, + cost: None, + limit: None, + modalities: None, + experimental: None, + status: None, + options: None, + headers: None, + provider: None, + variants: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "alpha")] + Alpha, + #[serde(rename = "beta")] + Beta, + #[serde(rename = "deprecated")] + Deprecated, +} + +impl Default for Status { + fn default() -> Status { + Self::Alpha + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_config_models_value_interleaved.rs b/crates/opencode-client/generated/src/models/provider_config_models_value_interleaved.rs new file mode 100644 index 0000000..05b36a0 --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_config_models_value_interleaved.rs @@ -0,0 +1,41 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderConfigModelsValueInterleaved { + #[serde(rename = "field")] + pub field: Field, +} + +impl ProviderConfigModelsValueInterleaved { + pub fn new(field: Field) -> ProviderConfigModelsValueInterleaved { + ProviderConfigModelsValueInterleaved { + field, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Field { + #[serde(rename = "reasoning_content")] + ReasoningContent, + #[serde(rename = "reasoning_details")] + ReasoningDetails, +} + +impl Default for Field { + fn default() -> Field { + Self::ReasoningContent + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_config_models_value_interleaved_any_of.rs b/crates/opencode-client/generated/src/models/provider_config_models_value_interleaved_any_of.rs new file mode 100644 index 0000000..f66916b --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_config_models_value_interleaved_any_of.rs @@ -0,0 +1,41 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderConfigModelsValueInterleavedAnyOf { + #[serde(rename = "field")] + pub field: Field, +} + +impl ProviderConfigModelsValueInterleavedAnyOf { + pub fn new(field: Field) -> ProviderConfigModelsValueInterleavedAnyOf { + ProviderConfigModelsValueInterleavedAnyOf { + field, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Field { + #[serde(rename = "reasoning_content")] + ReasoningContent, + #[serde(rename = "reasoning_details")] + ReasoningDetails, +} + +impl Default for Field { + fn default() -> Field { + Self::ReasoningContent + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_config_models_value_variants_value.rs b/crates/opencode-client/generated/src/models/provider_config_models_value_variants_value.rs new file mode 100644 index 0000000..63949fa --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_config_models_value_variants_value.rs @@ -0,0 +1,28 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderConfigModelsValueVariantsValue { + /// Disable this variant for the model + #[serde(rename = "disabled", skip_serializing_if = "Option::is_none")] + pub disabled: Option, +} + +impl ProviderConfigModelsValueVariantsValue { + pub fn new() -> ProviderConfigModelsValueVariantsValue { + ProviderConfigModelsValueVariantsValue { + disabled: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_config_options.rs b/crates/opencode-client/generated/src/models/provider_config_options.rs new file mode 100644 index 0000000..69a9373 --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_config_options.rs @@ -0,0 +1,41 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderConfigOptions { + #[serde(rename = "apiKey", skip_serializing_if = "Option::is_none")] + pub api_key: Option, + #[serde(rename = "baseURL", skip_serializing_if = "Option::is_none")] + pub base_url: Option, + /// GitHub Enterprise URL for copilot authentication + #[serde(rename = "enterpriseUrl", skip_serializing_if = "Option::is_none")] + pub enterprise_url: Option, + /// Enable promptCacheKey for this provider (default false) + #[serde(rename = "setCacheKey", skip_serializing_if = "Option::is_none")] + pub set_cache_key: Option, + #[serde(rename = "timeout", skip_serializing_if = "Option::is_none")] + pub timeout: Option>, +} + +impl ProviderConfigOptions { + pub fn new() -> ProviderConfigOptions { + ProviderConfigOptions { + api_key: None, + base_url: None, + enterprise_url: None, + set_cache_key: None, + timeout: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_config_options_timeout.rs b/crates/opencode-client/generated/src/models/provider_config_options_timeout.rs new file mode 100644 index 0000000..ff527d3 --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_config_options_timeout.rs @@ -0,0 +1,26 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// ProviderConfigOptionsTimeout : Timeout in milliseconds for requests to this provider. Default is 300000 (5 minutes). Set to false to disable timeout. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderConfigOptionsTimeout { +} + +impl ProviderConfigOptionsTimeout { + /// Timeout in milliseconds for requests to this provider. Default is 300000 (5 minutes). Set to false to disable timeout. + pub fn new() -> ProviderConfigOptionsTimeout { + ProviderConfigOptionsTimeout { + } + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_list_200_response.rs b/crates/opencode-client/generated/src/models/provider_list_200_response.rs new file mode 100644 index 0000000..85bea36 --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_list_200_response.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200Response { + #[serde(rename = "all")] + pub all: Vec, + #[serde(rename = "default")] + pub default: std::collections::HashMap, + #[serde(rename = "connected")] + pub connected: Vec, +} + +impl ProviderList200Response { + pub fn new(all: Vec, default: std::collections::HashMap, connected: Vec) -> ProviderList200Response { + ProviderList200Response { + all, + default, + connected, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner.rs b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner.rs new file mode 100644 index 0000000..fea04b3 --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInner { + #[serde(rename = "api", skip_serializing_if = "Option::is_none")] + pub api: Option, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "env")] + pub env: Vec, + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "npm", skip_serializing_if = "Option::is_none")] + pub npm: Option, + #[serde(rename = "models")] + pub models: std::collections::HashMap, +} + +impl ProviderList200ResponseAllInner { + pub fn new(name: String, env: Vec, id: String, models: std::collections::HashMap) -> ProviderList200ResponseAllInner { + ProviderList200ResponseAllInner { + api: None, + name, + env, + id, + npm: None, + models, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value.rs b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value.rs new file mode 100644 index 0000000..b19389f --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value.rs @@ -0,0 +1,94 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInnerModelsValue { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "family", skip_serializing_if = "Option::is_none")] + pub family: Option, + #[serde(rename = "release_date")] + pub release_date: String, + #[serde(rename = "attachment")] + pub attachment: bool, + #[serde(rename = "reasoning")] + pub reasoning: bool, + #[serde(rename = "temperature")] + pub temperature: bool, + #[serde(rename = "tool_call")] + pub tool_call: bool, + #[serde(rename = "interleaved", skip_serializing_if = "Option::is_none")] + pub interleaved: Option>, + #[serde(rename = "cost", skip_serializing_if = "Option::is_none")] + pub cost: Option>, + #[serde(rename = "limit")] + pub limit: Box, + #[serde(rename = "modalities", skip_serializing_if = "Option::is_none")] + pub modalities: Option>, + #[serde(rename = "experimental", skip_serializing_if = "Option::is_none")] + pub experimental: Option, + #[serde(rename = "status", skip_serializing_if = "Option::is_none")] + pub status: Option, + #[serde(rename = "options")] + pub options: std::collections::HashMap, + #[serde(rename = "headers", skip_serializing_if = "Option::is_none")] + pub headers: Option>, + #[serde(rename = "provider", skip_serializing_if = "Option::is_none")] + pub provider: Option>, + #[serde(rename = "variants", skip_serializing_if = "Option::is_none")] + pub variants: Option>>, +} + +impl ProviderList200ResponseAllInnerModelsValue { + pub fn new(id: String, name: String, release_date: String, attachment: bool, reasoning: bool, temperature: bool, tool_call: bool, limit: models::ProviderList200ResponseAllInnerModelsValueLimit, options: std::collections::HashMap) -> ProviderList200ResponseAllInnerModelsValue { + ProviderList200ResponseAllInnerModelsValue { + id, + name, + family: None, + release_date, + attachment, + reasoning, + temperature, + tool_call, + interleaved: None, + cost: None, + limit: Box::new(limit), + modalities: None, + experimental: None, + status: None, + options, + headers: None, + provider: None, + variants: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "alpha")] + Alpha, + #[serde(rename = "beta")] + Beta, + #[serde(rename = "deprecated")] + Deprecated, +} + +impl Default for Status { + fn default() -> Status { + Self::Alpha + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_cost.rs b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_cost.rs new file mode 100644 index 0000000..59f2d12 --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_cost.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInnerModelsValueCost { + #[serde(rename = "input")] + pub input: f64, + #[serde(rename = "output")] + pub output: f64, + #[serde(rename = "cache_read", skip_serializing_if = "Option::is_none")] + pub cache_read: Option, + #[serde(rename = "cache_write", skip_serializing_if = "Option::is_none")] + pub cache_write: Option, + #[serde(rename = "context_over_200k", skip_serializing_if = "Option::is_none")] + pub context_over_200k: Option>, +} + +impl ProviderList200ResponseAllInnerModelsValueCost { + pub fn new(input: f64, output: f64) -> ProviderList200ResponseAllInnerModelsValueCost { + ProviderList200ResponseAllInnerModelsValueCost { + input, + output, + cache_read: None, + cache_write: None, + context_over_200k: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_cost_context_over_200k.rs b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_cost_context_over_200k.rs new file mode 100644 index 0000000..428d7af --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_cost_context_over_200k.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInnerModelsValueCostContextOver200k { + #[serde(rename = "input")] + pub input: f64, + #[serde(rename = "output")] + pub output: f64, + #[serde(rename = "cache_read", skip_serializing_if = "Option::is_none")] + pub cache_read: Option, + #[serde(rename = "cache_write", skip_serializing_if = "Option::is_none")] + pub cache_write: Option, +} + +impl ProviderList200ResponseAllInnerModelsValueCostContextOver200k { + pub fn new(input: f64, output: f64) -> ProviderList200ResponseAllInnerModelsValueCostContextOver200k { + ProviderList200ResponseAllInnerModelsValueCostContextOver200k { + input, + output, + cache_read: None, + cache_write: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_interleaved.rs b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_interleaved.rs new file mode 100644 index 0000000..a9cecfd --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_interleaved.rs @@ -0,0 +1,41 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInnerModelsValueInterleaved { + #[serde(rename = "field")] + pub field: Field, +} + +impl ProviderList200ResponseAllInnerModelsValueInterleaved { + pub fn new(field: Field) -> ProviderList200ResponseAllInnerModelsValueInterleaved { + ProviderList200ResponseAllInnerModelsValueInterleaved { + field, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Field { + #[serde(rename = "reasoning_content")] + ReasoningContent, + #[serde(rename = "reasoning_details")] + ReasoningDetails, +} + +impl Default for Field { + fn default() -> Field { + Self::ReasoningContent + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_interleaved_any_of.rs b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_interleaved_any_of.rs new file mode 100644 index 0000000..4c51ef5 --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_interleaved_any_of.rs @@ -0,0 +1,41 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf { + #[serde(rename = "field")] + pub field: Field, +} + +impl ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf { + pub fn new(field: Field) -> ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf { + ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf { + field, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Field { + #[serde(rename = "reasoning_content")] + ReasoningContent, + #[serde(rename = "reasoning_details")] + ReasoningDetails, +} + +impl Default for Field { + fn default() -> Field { + Self::ReasoningContent + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_limit.rs b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_limit.rs new file mode 100644 index 0000000..d45b35c --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_limit.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInnerModelsValueLimit { + #[serde(rename = "context")] + pub context: f64, + #[serde(rename = "output")] + pub output: f64, +} + +impl ProviderList200ResponseAllInnerModelsValueLimit { + pub fn new(context: f64, output: f64) -> ProviderList200ResponseAllInnerModelsValueLimit { + ProviderList200ResponseAllInnerModelsValueLimit { + context, + output, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_modalities.rs b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_modalities.rs new file mode 100644 index 0000000..767ca84 --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_modalities.rs @@ -0,0 +1,70 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInnerModelsValueModalities { + #[serde(rename = "input")] + pub input: Vec, + #[serde(rename = "output")] + pub output: Vec, +} + +impl ProviderList200ResponseAllInnerModelsValueModalities { + pub fn new(input: Vec, output: Vec) -> ProviderList200ResponseAllInnerModelsValueModalities { + ProviderList200ResponseAllInnerModelsValueModalities { + input, + output, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Input { + #[serde(rename = "text")] + Text, + #[serde(rename = "audio")] + Audio, + #[serde(rename = "image")] + Image, + #[serde(rename = "video")] + Video, + #[serde(rename = "pdf")] + Pdf, +} + +impl Default for Input { + fn default() -> Input { + Self::Text + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Output { + #[serde(rename = "text")] + Text, + #[serde(rename = "audio")] + Audio, + #[serde(rename = "image")] + Image, + #[serde(rename = "video")] + Video, + #[serde(rename = "pdf")] + Pdf, +} + +impl Default for Output { + fn default() -> Output { + Self::Text + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_provider.rs b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_provider.rs new file mode 100644 index 0000000..89f2768 --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_list_200_response_all_inner_models_value_provider.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInnerModelsValueProvider { + #[serde(rename = "npm")] + pub npm: String, +} + +impl ProviderList200ResponseAllInnerModelsValueProvider { + pub fn new(npm: String) -> ProviderList200ResponseAllInnerModelsValueProvider { + ProviderList200ResponseAllInnerModelsValueProvider { + npm, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_oauth_authorize_request.rs b/crates/opencode-client/generated/src/models/provider_oauth_authorize_request.rs new file mode 100644 index 0000000..d43cd3b --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_oauth_authorize_request.rs @@ -0,0 +1,28 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderOauthAuthorizeRequest { + /// Auth method index + #[serde(rename = "method")] + pub method: f64, +} + +impl ProviderOauthAuthorizeRequest { + pub fn new(method: f64) -> ProviderOauthAuthorizeRequest { + ProviderOauthAuthorizeRequest { + method, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/provider_oauth_callback_request.rs b/crates/opencode-client/generated/src/models/provider_oauth_callback_request.rs new file mode 100644 index 0000000..87c491f --- /dev/null +++ b/crates/opencode-client/generated/src/models/provider_oauth_callback_request.rs @@ -0,0 +1,32 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderOauthCallbackRequest { + /// Auth method index + #[serde(rename = "method")] + pub method: f64, + /// OAuth authorization code + #[serde(rename = "code", skip_serializing_if = "Option::is_none")] + pub code: Option, +} + +impl ProviderOauthCallbackRequest { + pub fn new(method: f64) -> ProviderOauthCallbackRequest { + ProviderOauthCallbackRequest { + method, + code: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/pty.rs b/crates/opencode-client/generated/src/models/pty.rs new file mode 100644 index 0000000..537068d --- /dev/null +++ b/crates/opencode-client/generated/src/models/pty.rs @@ -0,0 +1,59 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Pty { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "title")] + pub title: String, + #[serde(rename = "command")] + pub command: String, + #[serde(rename = "args")] + pub args: Vec, + #[serde(rename = "cwd")] + pub cwd: String, + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "pid")] + pub pid: f64, +} + +impl Pty { + pub fn new(id: String, title: String, command: String, args: Vec, cwd: String, status: Status, pid: f64) -> Pty { + Pty { + id, + title, + command, + args, + cwd, + status, + pid, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "running")] + Running, + #[serde(rename = "exited")] + Exited, +} + +impl Default for Status { + fn default() -> Status { + Self::Running + } +} + diff --git a/crates/opencode-client/generated/src/models/pty_create_request.rs b/crates/opencode-client/generated/src/models/pty_create_request.rs new file mode 100644 index 0000000..29b71c6 --- /dev/null +++ b/crates/opencode-client/generated/src/models/pty_create_request.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct PtyCreateRequest { + #[serde(rename = "command", skip_serializing_if = "Option::is_none")] + pub command: Option, + #[serde(rename = "args", skip_serializing_if = "Option::is_none")] + pub args: Option>, + #[serde(rename = "cwd", skip_serializing_if = "Option::is_none")] + pub cwd: Option, + #[serde(rename = "title", skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(rename = "env", skip_serializing_if = "Option::is_none")] + pub env: Option>, +} + +impl PtyCreateRequest { + pub fn new() -> PtyCreateRequest { + PtyCreateRequest { + command: None, + args: None, + cwd: None, + title: None, + env: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/pty_update_request.rs b/crates/opencode-client/generated/src/models/pty_update_request.rs new file mode 100644 index 0000000..081b6bd --- /dev/null +++ b/crates/opencode-client/generated/src/models/pty_update_request.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct PtyUpdateRequest { + #[serde(rename = "title", skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(rename = "size", skip_serializing_if = "Option::is_none")] + pub size: Option>, +} + +impl PtyUpdateRequest { + pub fn new() -> PtyUpdateRequest { + PtyUpdateRequest { + title: None, + size: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/pty_update_request_size.rs b/crates/opencode-client/generated/src/models/pty_update_request_size.rs new file mode 100644 index 0000000..5ce3849 --- /dev/null +++ b/crates/opencode-client/generated/src/models/pty_update_request_size.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct PtyUpdateRequestSize { + #[serde(rename = "rows")] + pub rows: f64, + #[serde(rename = "cols")] + pub cols: f64, +} + +impl PtyUpdateRequestSize { + pub fn new(rows: f64, cols: f64) -> PtyUpdateRequestSize { + PtyUpdateRequestSize { + rows, + cols, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/range.rs b/crates/opencode-client/generated/src/models/range.rs new file mode 100644 index 0000000..d07b982 --- /dev/null +++ b/crates/opencode-client/generated/src/models/range.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Range { + #[serde(rename = "start")] + pub start: Box, + #[serde(rename = "end")] + pub end: Box, +} + +impl Range { + pub fn new(start: models::RangeStart, end: models::RangeStart) -> Range { + Range { + start: Box::new(start), + end: Box::new(end), + } + } +} + diff --git a/crates/opencode-client/generated/src/models/range_start.rs b/crates/opencode-client/generated/src/models/range_start.rs new file mode 100644 index 0000000..3c22ccc --- /dev/null +++ b/crates/opencode-client/generated/src/models/range_start.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct RangeStart { + #[serde(rename = "line")] + pub line: f64, + #[serde(rename = "character")] + pub character: f64, +} + +impl RangeStart { + pub fn new(line: f64, character: f64) -> RangeStart { + RangeStart { + line, + character, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/reasoning_part.rs b/crates/opencode-client/generated/src/models/reasoning_part.rs new file mode 100644 index 0000000..aff14d5 --- /dev/null +++ b/crates/opencode-client/generated/src/models/reasoning_part.rs @@ -0,0 +1,57 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ReasoningPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "text")] + pub text: String, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, + #[serde(rename = "time")] + pub time: Box, +} + +impl ReasoningPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, text: String, time: models::TextPartTime) -> ReasoningPart { + ReasoningPart { + id, + session_id, + message_id, + r#type, + text, + metadata: None, + time: Box::new(time), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "reasoning")] + Reasoning, +} + +impl Default for Type { + fn default() -> Type { + Self::Reasoning + } +} + diff --git a/crates/opencode-client/generated/src/models/retry_part.rs b/crates/opencode-client/generated/src/models/retry_part.rs new file mode 100644 index 0000000..37174d2 --- /dev/null +++ b/crates/opencode-client/generated/src/models/retry_part.rs @@ -0,0 +1,57 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct RetryPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "attempt")] + pub attempt: f64, + #[serde(rename = "error")] + pub error: Box, + #[serde(rename = "time")] + pub time: Box, +} + +impl RetryPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, attempt: f64, error: models::ApiError, time: models::UserMessageTime) -> RetryPart { + RetryPart { + id, + session_id, + message_id, + r#type, + attempt, + error: Box::new(error), + time: Box::new(time), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "retry")] + Retry, +} + +impl Default for Type { + fn default() -> Type { + Self::Retry + } +} + diff --git a/crates/opencode-client/generated/src/models/server_config.rs b/crates/opencode-client/generated/src/models/server_config.rs new file mode 100644 index 0000000..5bdba7b --- /dev/null +++ b/crates/opencode-client/generated/src/models/server_config.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// ServerConfig : Server configuration for opencode serve and web commands +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ServerConfig { + /// Port to listen on + #[serde(rename = "port", skip_serializing_if = "Option::is_none")] + pub port: Option, + /// Hostname to listen on + #[serde(rename = "hostname", skip_serializing_if = "Option::is_none")] + pub hostname: Option, + /// Enable mDNS service discovery + #[serde(rename = "mdns", skip_serializing_if = "Option::is_none")] + pub mdns: Option, + /// Additional domains to allow for CORS + #[serde(rename = "cors", skip_serializing_if = "Option::is_none")] + pub cors: Option>, +} + +impl ServerConfig { + /// Server configuration for opencode serve and web commands + pub fn new() -> ServerConfig { + ServerConfig { + port: None, + hostname: None, + mdns: None, + cors: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session.rs b/crates/opencode-client/generated/src/models/session.rs new file mode 100644 index 0000000..9b80a66 --- /dev/null +++ b/crates/opencode-client/generated/src/models/session.rs @@ -0,0 +1,54 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Session { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "projectID")] + pub project_id: String, + #[serde(rename = "directory")] + pub directory: String, + #[serde(rename = "parentID", skip_serializing_if = "Option::is_none")] + pub parent_id: Option, + #[serde(rename = "summary", skip_serializing_if = "Option::is_none")] + pub summary: Option>, + #[serde(rename = "share", skip_serializing_if = "Option::is_none")] + pub share: Option>, + #[serde(rename = "title")] + pub title: String, + #[serde(rename = "version")] + pub version: String, + #[serde(rename = "time")] + pub time: Box, + #[serde(rename = "revert", skip_serializing_if = "Option::is_none")] + pub revert: Option>, +} + +impl Session { + pub fn new(id: String, project_id: String, directory: String, title: String, version: String, time: models::SessionTime) -> Session { + Session { + id, + project_id, + directory, + parent_id: None, + summary: None, + share: None, + title, + version, + time: Box::new(time), + revert: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_command_request.rs b/crates/opencode-client/generated/src/models/session_command_request.rs new file mode 100644 index 0000000..20b987d --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_command_request.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionCommandRequest { + #[serde(rename = "messageID", skip_serializing_if = "Option::is_none")] + pub message_id: Option, + #[serde(rename = "agent", skip_serializing_if = "Option::is_none")] + pub agent: Option, + #[serde(rename = "model", skip_serializing_if = "Option::is_none")] + pub model: Option, + #[serde(rename = "arguments")] + pub arguments: String, + #[serde(rename = "command")] + pub command: String, + #[serde(rename = "variant", skip_serializing_if = "Option::is_none")] + pub variant: Option, +} + +impl SessionCommandRequest { + pub fn new(arguments: String, command: String) -> SessionCommandRequest { + SessionCommandRequest { + message_id: None, + agent: None, + model: None, + arguments, + command, + variant: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_create_request.rs b/crates/opencode-client/generated/src/models/session_create_request.rs new file mode 100644 index 0000000..e06581c --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_create_request.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionCreateRequest { + #[serde(rename = "parentID", skip_serializing_if = "Option::is_none")] + pub parent_id: Option, + #[serde(rename = "title", skip_serializing_if = "Option::is_none")] + pub title: Option, +} + +impl SessionCreateRequest { + pub fn new() -> SessionCreateRequest { + SessionCreateRequest { + parent_id: None, + title: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_fork_request.rs b/crates/opencode-client/generated/src/models/session_fork_request.rs new file mode 100644 index 0000000..ae4ba6e --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_fork_request.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionForkRequest { + #[serde(rename = "messageID", skip_serializing_if = "Option::is_none")] + pub message_id: Option, +} + +impl SessionForkRequest { + pub fn new() -> SessionForkRequest { + SessionForkRequest { + message_id: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_init_request.rs b/crates/opencode-client/generated/src/models/session_init_request.rs new file mode 100644 index 0000000..aef8990 --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_init_request.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionInitRequest { + #[serde(rename = "modelID")] + pub model_id: String, + #[serde(rename = "providerID")] + pub provider_id: String, + #[serde(rename = "messageID")] + pub message_id: String, +} + +impl SessionInitRequest { + pub fn new(model_id: String, provider_id: String, message_id: String) -> SessionInitRequest { + SessionInitRequest { + model_id, + provider_id, + message_id, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_messages_200_response_inner.rs b/crates/opencode-client/generated/src/models/session_messages_200_response_inner.rs new file mode 100644 index 0000000..8dc9dc8 --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_messages_200_response_inner.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionMessages200ResponseInner { + #[serde(rename = "info")] + pub info: Box, + #[serde(rename = "parts")] + pub parts: Vec, +} + +impl SessionMessages200ResponseInner { + pub fn new(info: models::Message, parts: Vec) -> SessionMessages200ResponseInner { + SessionMessages200ResponseInner { + info: Box::new(info), + parts, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_prompt_200_response.rs b/crates/opencode-client/generated/src/models/session_prompt_200_response.rs new file mode 100644 index 0000000..29f7706 --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_prompt_200_response.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionPrompt200Response { + #[serde(rename = "info")] + pub info: Box, + #[serde(rename = "parts")] + pub parts: Vec, +} + +impl SessionPrompt200Response { + pub fn new(info: models::AssistantMessage, parts: Vec) -> SessionPrompt200Response { + SessionPrompt200Response { + info: Box::new(info), + parts, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_prompt_request.rs b/crates/opencode-client/generated/src/models/session_prompt_request.rs new file mode 100644 index 0000000..23d0e36 --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_prompt_request.rs @@ -0,0 +1,48 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionPromptRequest { + #[serde(rename = "messageID", skip_serializing_if = "Option::is_none")] + pub message_id: Option, + #[serde(rename = "model", skip_serializing_if = "Option::is_none")] + pub model: Option>, + #[serde(rename = "agent", skip_serializing_if = "Option::is_none")] + pub agent: Option, + #[serde(rename = "noReply", skip_serializing_if = "Option::is_none")] + pub no_reply: Option, + #[serde(rename = "tools", skip_serializing_if = "Option::is_none")] + pub tools: Option>, + #[serde(rename = "system", skip_serializing_if = "Option::is_none")] + pub system: Option, + #[serde(rename = "variant", skip_serializing_if = "Option::is_none")] + pub variant: Option, + #[serde(rename = "parts")] + pub parts: Vec, +} + +impl SessionPromptRequest { + pub fn new(parts: Vec) -> SessionPromptRequest { + SessionPromptRequest { + message_id: None, + model: None, + agent: None, + no_reply: None, + tools: None, + system: None, + variant: None, + parts, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_prompt_request_model.rs b/crates/opencode-client/generated/src/models/session_prompt_request_model.rs new file mode 100644 index 0000000..f7761fd --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_prompt_request_model.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionPromptRequestModel { + #[serde(rename = "providerID")] + pub provider_id: String, + #[serde(rename = "modelID")] + pub model_id: String, +} + +impl SessionPromptRequestModel { + pub fn new(provider_id: String, model_id: String) -> SessionPromptRequestModel { + SessionPromptRequestModel { + provider_id, + model_id, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_prompt_request_parts_inner.rs b/crates/opencode-client/generated/src/models/session_prompt_request_parts_inner.rs new file mode 100644 index 0000000..71c7a8e --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_prompt_request_parts_inner.rs @@ -0,0 +1,90 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionPromptRequestPartsInner { + #[serde(rename = "id", skip_serializing_if = "Option::is_none")] + pub id: Option, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "text")] + pub text: String, + #[serde(rename = "synthetic", skip_serializing_if = "Option::is_none")] + pub synthetic: Option, + #[serde(rename = "ignored", skip_serializing_if = "Option::is_none")] + pub ignored: Option, + #[serde(rename = "time", skip_serializing_if = "Option::is_none")] + pub time: Option>, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, + #[serde(rename = "mime")] + pub mime: String, + #[serde(rename = "filename", skip_serializing_if = "Option::is_none")] + pub filename: Option, + #[serde(rename = "url")] + pub url: String, + #[serde(rename = "source", skip_serializing_if = "Option::is_none")] + pub source: Option>, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "prompt")] + pub prompt: String, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "agent")] + pub agent: String, + #[serde(rename = "command", skip_serializing_if = "Option::is_none")] + pub command: Option, +} + +impl SessionPromptRequestPartsInner { + pub fn new(r#type: Type, text: String, mime: String, url: String, name: String, prompt: String, description: String, agent: String) -> SessionPromptRequestPartsInner { + SessionPromptRequestPartsInner { + id: None, + r#type, + text, + synthetic: None, + ignored: None, + time: None, + metadata: None, + mime, + filename: None, + url, + source: None, + name, + prompt, + description, + agent, + command: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "text")] + Text, + #[serde(rename = "file")] + File, + #[serde(rename = "agent")] + Agent, + #[serde(rename = "subtask")] + Subtask, +} + +impl Default for Type { + fn default() -> Type { + Self::Text + } +} + diff --git a/crates/opencode-client/generated/src/models/session_revert.rs b/crates/opencode-client/generated/src/models/session_revert.rs new file mode 100644 index 0000000..99639f9 --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_revert.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionRevert { + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "partID", skip_serializing_if = "Option::is_none")] + pub part_id: Option, + #[serde(rename = "snapshot", skip_serializing_if = "Option::is_none")] + pub snapshot: Option, + #[serde(rename = "diff", skip_serializing_if = "Option::is_none")] + pub diff: Option, +} + +impl SessionRevert { + pub fn new(message_id: String) -> SessionRevert { + SessionRevert { + message_id, + part_id: None, + snapshot: None, + diff: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_revert_request.rs b/crates/opencode-client/generated/src/models/session_revert_request.rs new file mode 100644 index 0000000..44144c1 --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_revert_request.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionRevertRequest { + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "partID", skip_serializing_if = "Option::is_none")] + pub part_id: Option, +} + +impl SessionRevertRequest { + pub fn new(message_id: String) -> SessionRevertRequest { + SessionRevertRequest { + message_id, + part_id: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_share.rs b/crates/opencode-client/generated/src/models/session_share.rs new file mode 100644 index 0000000..9724e75 --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_share.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionShare { + #[serde(rename = "url")] + pub url: String, +} + +impl SessionShare { + pub fn new(url: String) -> SessionShare { + SessionShare { + url, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_shell_request.rs b/crates/opencode-client/generated/src/models/session_shell_request.rs new file mode 100644 index 0000000..d2d2446 --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_shell_request.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionShellRequest { + #[serde(rename = "agent")] + pub agent: String, + #[serde(rename = "model", skip_serializing_if = "Option::is_none")] + pub model: Option>, + #[serde(rename = "command")] + pub command: String, +} + +impl SessionShellRequest { + pub fn new(agent: String, command: String) -> SessionShellRequest { + SessionShellRequest { + agent, + model: None, + command, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_status.rs b/crates/opencode-client/generated/src/models/session_status.rs new file mode 100644 index 0000000..123fd73 --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_status.rs @@ -0,0 +1,52 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionStatus { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "attempt")] + pub attempt: f64, + #[serde(rename = "message")] + pub message: String, + #[serde(rename = "next")] + pub next: f64, +} + +impl SessionStatus { + pub fn new(r#type: Type, attempt: f64, message: String, next: f64) -> SessionStatus { + SessionStatus { + r#type, + attempt, + message, + next, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "idle")] + Idle, + #[serde(rename = "retry")] + Retry, + #[serde(rename = "busy")] + Busy, +} + +impl Default for Type { + fn default() -> Type { + Self::Idle + } +} + diff --git a/crates/opencode-client/generated/src/models/session_status_any_of.rs b/crates/opencode-client/generated/src/models/session_status_any_of.rs new file mode 100644 index 0000000..e207e24 --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_status_any_of.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionStatusAnyOf { + #[serde(rename = "type")] + pub r#type: Type, +} + +impl SessionStatusAnyOf { + pub fn new(r#type: Type) -> SessionStatusAnyOf { + SessionStatusAnyOf { + r#type, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "idle")] + Idle, +} + +impl Default for Type { + fn default() -> Type { + Self::Idle + } +} + diff --git a/crates/opencode-client/generated/src/models/session_status_any_of_1.rs b/crates/opencode-client/generated/src/models/session_status_any_of_1.rs new file mode 100644 index 0000000..734f2bd --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_status_any_of_1.rs @@ -0,0 +1,48 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionStatusAnyOf1 { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "attempt")] + pub attempt: f64, + #[serde(rename = "message")] + pub message: String, + #[serde(rename = "next")] + pub next: f64, +} + +impl SessionStatusAnyOf1 { + pub fn new(r#type: Type, attempt: f64, message: String, next: f64) -> SessionStatusAnyOf1 { + SessionStatusAnyOf1 { + r#type, + attempt, + message, + next, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "retry")] + Retry, +} + +impl Default for Type { + fn default() -> Type { + Self::Retry + } +} + diff --git a/crates/opencode-client/generated/src/models/session_status_any_of_2.rs b/crates/opencode-client/generated/src/models/session_status_any_of_2.rs new file mode 100644 index 0000000..1b80b47 --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_status_any_of_2.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionStatusAnyOf2 { + #[serde(rename = "type")] + pub r#type: Type, +} + +impl SessionStatusAnyOf2 { + pub fn new(r#type: Type) -> SessionStatusAnyOf2 { + SessionStatusAnyOf2 { + r#type, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "busy")] + Busy, +} + +impl Default for Type { + fn default() -> Type { + Self::Busy + } +} + diff --git a/crates/opencode-client/generated/src/models/session_summarize_request.rs b/crates/opencode-client/generated/src/models/session_summarize_request.rs new file mode 100644 index 0000000..2233ef8 --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_summarize_request.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionSummarizeRequest { + #[serde(rename = "providerID")] + pub provider_id: String, + #[serde(rename = "modelID")] + pub model_id: String, + #[serde(rename = "auto", skip_serializing_if = "Option::is_none")] + pub auto: Option, +} + +impl SessionSummarizeRequest { + pub fn new(provider_id: String, model_id: String) -> SessionSummarizeRequest { + SessionSummarizeRequest { + provider_id, + model_id, + auto: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_summary.rs b/crates/opencode-client/generated/src/models/session_summary.rs new file mode 100644 index 0000000..44a6bd6 --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_summary.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionSummary { + #[serde(rename = "additions")] + pub additions: f64, + #[serde(rename = "deletions")] + pub deletions: f64, + #[serde(rename = "files")] + pub files: f64, + #[serde(rename = "diffs", skip_serializing_if = "Option::is_none")] + pub diffs: Option>, +} + +impl SessionSummary { + pub fn new(additions: f64, deletions: f64, files: f64) -> SessionSummary { + SessionSummary { + additions, + deletions, + files, + diffs: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_time.rs b/crates/opencode-client/generated/src/models/session_time.rs new file mode 100644 index 0000000..0b14d7a --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_time.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionTime { + #[serde(rename = "created")] + pub created: f64, + #[serde(rename = "updated")] + pub updated: f64, + #[serde(rename = "compacting", skip_serializing_if = "Option::is_none")] + pub compacting: Option, + #[serde(rename = "archived", skip_serializing_if = "Option::is_none")] + pub archived: Option, +} + +impl SessionTime { + pub fn new(created: f64, updated: f64) -> SessionTime { + SessionTime { + created, + updated, + compacting: None, + archived: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_update_request.rs b/crates/opencode-client/generated/src/models/session_update_request.rs new file mode 100644 index 0000000..3396a60 --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_update_request.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionUpdateRequest { + #[serde(rename = "title", skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(rename = "time", skip_serializing_if = "Option::is_none")] + pub time: Option>, +} + +impl SessionUpdateRequest { + pub fn new() -> SessionUpdateRequest { + SessionUpdateRequest { + title: None, + time: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/session_update_request_time.rs b/crates/opencode-client/generated/src/models/session_update_request_time.rs new file mode 100644 index 0000000..dde093e --- /dev/null +++ b/crates/opencode-client/generated/src/models/session_update_request_time.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionUpdateRequestTime { + #[serde(rename = "archived", skip_serializing_if = "Option::is_none")] + pub archived: Option, +} + +impl SessionUpdateRequestTime { + pub fn new() -> SessionUpdateRequestTime { + SessionUpdateRequestTime { + archived: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/snapshot_part.rs b/crates/opencode-client/generated/src/models/snapshot_part.rs new file mode 100644 index 0000000..b52618d --- /dev/null +++ b/crates/opencode-client/generated/src/models/snapshot_part.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SnapshotPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "snapshot")] + pub snapshot: String, +} + +impl SnapshotPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, snapshot: String) -> SnapshotPart { + SnapshotPart { + id, + session_id, + message_id, + r#type, + snapshot, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "snapshot")] + Snapshot, +} + +impl Default for Type { + fn default() -> Type { + Self::Snapshot + } +} + diff --git a/crates/opencode-client/generated/src/models/step_finish_part.rs b/crates/opencode-client/generated/src/models/step_finish_part.rs new file mode 100644 index 0000000..f6e1418 --- /dev/null +++ b/crates/opencode-client/generated/src/models/step_finish_part.rs @@ -0,0 +1,60 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct StepFinishPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "reason")] + pub reason: String, + #[serde(rename = "snapshot", skip_serializing_if = "Option::is_none")] + pub snapshot: Option, + #[serde(rename = "cost")] + pub cost: f64, + #[serde(rename = "tokens")] + pub tokens: Box, +} + +impl StepFinishPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, reason: String, cost: f64, tokens: models::AssistantMessageTokens) -> StepFinishPart { + StepFinishPart { + id, + session_id, + message_id, + r#type, + reason, + snapshot: None, + cost, + tokens: Box::new(tokens), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "step-finish")] + StepFinish, +} + +impl Default for Type { + fn default() -> Type { + Self::StepFinish + } +} + diff --git a/crates/opencode-client/generated/src/models/step_start_part.rs b/crates/opencode-client/generated/src/models/step_start_part.rs new file mode 100644 index 0000000..d55e1c6 --- /dev/null +++ b/crates/opencode-client/generated/src/models/step_start_part.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct StepStartPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "snapshot", skip_serializing_if = "Option::is_none")] + pub snapshot: Option, +} + +impl StepStartPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type) -> StepStartPart { + StepStartPart { + id, + session_id, + message_id, + r#type, + snapshot: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "step-start")] + StepStart, +} + +impl Default for Type { + fn default() -> Type { + Self::StepStart + } +} + diff --git a/crates/opencode-client/generated/src/models/subtask_part_input.rs b/crates/opencode-client/generated/src/models/subtask_part_input.rs new file mode 100644 index 0000000..a7e7ba6 --- /dev/null +++ b/crates/opencode-client/generated/src/models/subtask_part_input.rs @@ -0,0 +1,54 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SubtaskPartInput { + #[serde(rename = "id", skip_serializing_if = "Option::is_none")] + pub id: Option, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "prompt")] + pub prompt: String, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "agent")] + pub agent: String, + #[serde(rename = "command", skip_serializing_if = "Option::is_none")] + pub command: Option, +} + +impl SubtaskPartInput { + pub fn new(r#type: Type, prompt: String, description: String, agent: String) -> SubtaskPartInput { + SubtaskPartInput { + id: None, + r#type, + prompt, + description, + agent, + command: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "subtask")] + Subtask, +} + +impl Default for Type { + fn default() -> Type { + Self::Subtask + } +} + diff --git a/crates/opencode-client/generated/src/models/symbol.rs b/crates/opencode-client/generated/src/models/symbol.rs new file mode 100644 index 0000000..b472623 --- /dev/null +++ b/crates/opencode-client/generated/src/models/symbol.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Symbol { + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "kind")] + pub kind: f64, + #[serde(rename = "location")] + pub location: Box, +} + +impl Symbol { + pub fn new(name: String, kind: f64, location: models::SymbolLocation) -> Symbol { + Symbol { + name, + kind, + location: Box::new(location), + } + } +} + diff --git a/crates/opencode-client/generated/src/models/symbol_location.rs b/crates/opencode-client/generated/src/models/symbol_location.rs new file mode 100644 index 0000000..29515c6 --- /dev/null +++ b/crates/opencode-client/generated/src/models/symbol_location.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SymbolLocation { + #[serde(rename = "uri")] + pub uri: String, + #[serde(rename = "range")] + pub range: Box, +} + +impl SymbolLocation { + pub fn new(uri: String, range: models::Range) -> SymbolLocation { + SymbolLocation { + uri, + range: Box::new(range), + } + } +} + diff --git a/crates/opencode-client/generated/src/models/symbol_source.rs b/crates/opencode-client/generated/src/models/symbol_source.rs new file mode 100644 index 0000000..d0a7184 --- /dev/null +++ b/crates/opencode-client/generated/src/models/symbol_source.rs @@ -0,0 +1,54 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SymbolSource { + #[serde(rename = "text")] + pub text: Box, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "path")] + pub path: String, + #[serde(rename = "range")] + pub range: Box, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "kind")] + pub kind: i32, +} + +impl SymbolSource { + pub fn new(text: models::FilePartSourceText, r#type: Type, path: String, range: models::Range, name: String, kind: i32) -> SymbolSource { + SymbolSource { + text: Box::new(text), + r#type, + path, + range: Box::new(range), + name, + kind, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "symbol")] + Symbol, +} + +impl Default for Type { + fn default() -> Type { + Self::Symbol + } +} + diff --git a/crates/opencode-client/generated/src/models/text_part.rs b/crates/opencode-client/generated/src/models/text_part.rs new file mode 100644 index 0000000..3e1076f --- /dev/null +++ b/crates/opencode-client/generated/src/models/text_part.rs @@ -0,0 +1,63 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TextPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "text")] + pub text: String, + #[serde(rename = "synthetic", skip_serializing_if = "Option::is_none")] + pub synthetic: Option, + #[serde(rename = "ignored", skip_serializing_if = "Option::is_none")] + pub ignored: Option, + #[serde(rename = "time", skip_serializing_if = "Option::is_none")] + pub time: Option>, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, +} + +impl TextPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, text: String) -> TextPart { + TextPart { + id, + session_id, + message_id, + r#type, + text, + synthetic: None, + ignored: None, + time: None, + metadata: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "text")] + Text, +} + +impl Default for Type { + fn default() -> Type { + Self::Text + } +} + diff --git a/crates/opencode-client/generated/src/models/text_part_input.rs b/crates/opencode-client/generated/src/models/text_part_input.rs new file mode 100644 index 0000000..90dd80a --- /dev/null +++ b/crates/opencode-client/generated/src/models/text_part_input.rs @@ -0,0 +1,57 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TextPartInput { + #[serde(rename = "id", skip_serializing_if = "Option::is_none")] + pub id: Option, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "text")] + pub text: String, + #[serde(rename = "synthetic", skip_serializing_if = "Option::is_none")] + pub synthetic: Option, + #[serde(rename = "ignored", skip_serializing_if = "Option::is_none")] + pub ignored: Option, + #[serde(rename = "time", skip_serializing_if = "Option::is_none")] + pub time: Option>, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, +} + +impl TextPartInput { + pub fn new(r#type: Type, text: String) -> TextPartInput { + TextPartInput { + id: None, + r#type, + text, + synthetic: None, + ignored: None, + time: None, + metadata: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "text")] + Text, +} + +impl Default for Type { + fn default() -> Type { + Self::Text + } +} + diff --git a/crates/opencode-client/generated/src/models/text_part_time.rs b/crates/opencode-client/generated/src/models/text_part_time.rs new file mode 100644 index 0000000..189fd28 --- /dev/null +++ b/crates/opencode-client/generated/src/models/text_part_time.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TextPartTime { + #[serde(rename = "start")] + pub start: f64, + #[serde(rename = "end", skip_serializing_if = "Option::is_none")] + pub end: Option, +} + +impl TextPartTime { + pub fn new(start: f64) -> TextPartTime { + TextPartTime { + start, + end: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/todo.rs b/crates/opencode-client/generated/src/models/todo.rs new file mode 100644 index 0000000..10f861d --- /dev/null +++ b/crates/opencode-client/generated/src/models/todo.rs @@ -0,0 +1,40 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Todo { + /// Brief description of the task + #[serde(rename = "content")] + pub content: String, + /// Current status of the task: pending, in_progress, completed, cancelled + #[serde(rename = "status")] + pub status: String, + /// Priority level of the task: high, medium, low + #[serde(rename = "priority")] + pub priority: String, + /// Unique identifier for the todo item + #[serde(rename = "id")] + pub id: String, +} + +impl Todo { + pub fn new(content: String, status: String, priority: String, id: String) -> Todo { + Todo { + content, + status, + priority, + id, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/tool_list_item.rs b/crates/opencode-client/generated/src/models/tool_list_item.rs new file mode 100644 index 0000000..6ae9131 --- /dev/null +++ b/crates/opencode-client/generated/src/models/tool_list_item.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolListItem { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "parameters", deserialize_with = "Option::deserialize")] + pub parameters: Option, +} + +impl ToolListItem { + pub fn new(id: String, description: String, parameters: Option) -> ToolListItem { + ToolListItem { + id, + description, + parameters, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/tool_part.rs b/crates/opencode-client/generated/src/models/tool_part.rs new file mode 100644 index 0000000..7bafa59 --- /dev/null +++ b/crates/opencode-client/generated/src/models/tool_part.rs @@ -0,0 +1,60 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "callID")] + pub call_id: String, + #[serde(rename = "tool")] + pub tool: String, + #[serde(rename = "state")] + pub state: Box, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, +} + +impl ToolPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, call_id: String, tool: String, state: models::ToolState) -> ToolPart { + ToolPart { + id, + session_id, + message_id, + r#type, + call_id, + tool, + state: Box::new(state), + metadata: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "tool")] + Tool, +} + +impl Default for Type { + fn default() -> Type { + Self::Tool + } +} + diff --git a/crates/opencode-client/generated/src/models/tool_state.rs b/crates/opencode-client/generated/src/models/tool_state.rs new file mode 100644 index 0000000..1addf73 --- /dev/null +++ b/crates/opencode-client/generated/src/models/tool_state.rs @@ -0,0 +1,63 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolState { + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "input")] + pub input: std::collections::HashMap, + #[serde(rename = "raw")] + pub raw: String, + #[serde(rename = "title")] + pub title: String, + #[serde(rename = "metadata")] + pub metadata: std::collections::HashMap, + #[serde(rename = "time")] + pub time: Box, + #[serde(rename = "output")] + pub output: String, + #[serde(rename = "attachments", skip_serializing_if = "Option::is_none")] + pub attachments: Option>, + #[serde(rename = "error")] + pub error: String, +} + +impl ToolState { + pub fn new(status: Status, input: std::collections::HashMap, raw: String, title: String, metadata: std::collections::HashMap, time: models::ToolStateErrorTime, output: String, error: String) -> ToolState { + ToolState { + status, + input, + raw, + title, + metadata, + time: Box::new(time), + output, + attachments: None, + error, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "error")] + Error, +} + +impl Default for Status { + fn default() -> Status { + Self::Error + } +} + diff --git a/crates/opencode-client/generated/src/models/tool_state_completed.rs b/crates/opencode-client/generated/src/models/tool_state_completed.rs new file mode 100644 index 0000000..9573107 --- /dev/null +++ b/crates/opencode-client/generated/src/models/tool_state_completed.rs @@ -0,0 +1,57 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolStateCompleted { + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "input")] + pub input: std::collections::HashMap, + #[serde(rename = "output")] + pub output: String, + #[serde(rename = "title")] + pub title: String, + #[serde(rename = "metadata")] + pub metadata: std::collections::HashMap, + #[serde(rename = "time")] + pub time: Box, + #[serde(rename = "attachments", skip_serializing_if = "Option::is_none")] + pub attachments: Option>, +} + +impl ToolStateCompleted { + pub fn new(status: Status, input: std::collections::HashMap, output: String, title: String, metadata: std::collections::HashMap, time: models::ToolStateCompletedTime) -> ToolStateCompleted { + ToolStateCompleted { + status, + input, + output, + title, + metadata, + time: Box::new(time), + attachments: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "completed")] + Completed, +} + +impl Default for Status { + fn default() -> Status { + Self::Completed + } +} + diff --git a/crates/opencode-client/generated/src/models/tool_state_completed_time.rs b/crates/opencode-client/generated/src/models/tool_state_completed_time.rs new file mode 100644 index 0000000..af009e9 --- /dev/null +++ b/crates/opencode-client/generated/src/models/tool_state_completed_time.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolStateCompletedTime { + #[serde(rename = "start")] + pub start: f64, + #[serde(rename = "end")] + pub end: f64, + #[serde(rename = "compacted", skip_serializing_if = "Option::is_none")] + pub compacted: Option, +} + +impl ToolStateCompletedTime { + pub fn new(start: f64, end: f64) -> ToolStateCompletedTime { + ToolStateCompletedTime { + start, + end, + compacted: None, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/tool_state_error.rs b/crates/opencode-client/generated/src/models/tool_state_error.rs new file mode 100644 index 0000000..9fe286a --- /dev/null +++ b/crates/opencode-client/generated/src/models/tool_state_error.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolStateError { + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "input")] + pub input: std::collections::HashMap, + #[serde(rename = "error")] + pub error: String, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, + #[serde(rename = "time")] + pub time: Box, +} + +impl ToolStateError { + pub fn new(status: Status, input: std::collections::HashMap, error: String, time: models::ToolStateErrorTime) -> ToolStateError { + ToolStateError { + status, + input, + error, + metadata: None, + time: Box::new(time), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "error")] + Error, +} + +impl Default for Status { + fn default() -> Status { + Self::Error + } +} + diff --git a/crates/opencode-client/generated/src/models/tool_state_error_time.rs b/crates/opencode-client/generated/src/models/tool_state_error_time.rs new file mode 100644 index 0000000..a32917b --- /dev/null +++ b/crates/opencode-client/generated/src/models/tool_state_error_time.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolStateErrorTime { + #[serde(rename = "start")] + pub start: f64, + #[serde(rename = "end")] + pub end: f64, +} + +impl ToolStateErrorTime { + pub fn new(start: f64, end: f64) -> ToolStateErrorTime { + ToolStateErrorTime { + start, + end, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/tool_state_pending.rs b/crates/opencode-client/generated/src/models/tool_state_pending.rs new file mode 100644 index 0000000..5b0383e --- /dev/null +++ b/crates/opencode-client/generated/src/models/tool_state_pending.rs @@ -0,0 +1,45 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolStatePending { + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "input")] + pub input: std::collections::HashMap, + #[serde(rename = "raw")] + pub raw: String, +} + +impl ToolStatePending { + pub fn new(status: Status, input: std::collections::HashMap, raw: String) -> ToolStatePending { + ToolStatePending { + status, + input, + raw, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "pending")] + Pending, +} + +impl Default for Status { + fn default() -> Status { + Self::Pending + } +} + diff --git a/crates/opencode-client/generated/src/models/tool_state_running.rs b/crates/opencode-client/generated/src/models/tool_state_running.rs new file mode 100644 index 0000000..7e7c5aa --- /dev/null +++ b/crates/opencode-client/generated/src/models/tool_state_running.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolStateRunning { + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "input")] + pub input: std::collections::HashMap, + #[serde(rename = "title", skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, + #[serde(rename = "time")] + pub time: Box, +} + +impl ToolStateRunning { + pub fn new(status: Status, input: std::collections::HashMap, time: models::ToolStateRunningTime) -> ToolStateRunning { + ToolStateRunning { + status, + input, + title: None, + metadata: None, + time: Box::new(time), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "running")] + Running, +} + +impl Default for Status { + fn default() -> Status { + Self::Running + } +} + diff --git a/crates/opencode-client/generated/src/models/tool_state_running_time.rs b/crates/opencode-client/generated/src/models/tool_state_running_time.rs new file mode 100644 index 0000000..470a39b --- /dev/null +++ b/crates/opencode-client/generated/src/models/tool_state_running_time.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolStateRunningTime { + #[serde(rename = "start")] + pub start: f64, +} + +impl ToolStateRunningTime { + pub fn new(start: f64) -> ToolStateRunningTime { + ToolStateRunningTime { + start, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/tui_control_next_200_response.rs b/crates/opencode-client/generated/src/models/tui_control_next_200_response.rs new file mode 100644 index 0000000..48e08af --- /dev/null +++ b/crates/opencode-client/generated/src/models/tui_control_next_200_response.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TuiControlNext200Response { + #[serde(rename = "path")] + pub path: String, + #[serde(rename = "body", deserialize_with = "Option::deserialize")] + pub body: Option, +} + +impl TuiControlNext200Response { + pub fn new(path: String, body: Option) -> TuiControlNext200Response { + TuiControlNext200Response { + path, + body, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/tui_execute_command_request.rs b/crates/opencode-client/generated/src/models/tui_execute_command_request.rs new file mode 100644 index 0000000..b8e65e9 --- /dev/null +++ b/crates/opencode-client/generated/src/models/tui_execute_command_request.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TuiExecuteCommandRequest { + #[serde(rename = "command")] + pub command: String, +} + +impl TuiExecuteCommandRequest { + pub fn new(command: String) -> TuiExecuteCommandRequest { + TuiExecuteCommandRequest { + command, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/tui_publish_request.rs b/crates/opencode-client/generated/src/models/tui_publish_request.rs new file mode 100644 index 0000000..b47ab01 --- /dev/null +++ b/crates/opencode-client/generated/src/models/tui_publish_request.rs @@ -0,0 +1,46 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TuiPublishRequest { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl TuiPublishRequest { + pub fn new(r#type: Type, properties: models::TuiShowToastRequest) -> TuiPublishRequest { + TuiPublishRequest { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "tui.prompt.append")] + TuiPromptAppend, + #[serde(rename = "tui.command.execute")] + TuiCommandExecute, + #[serde(rename = "tui.toast.show")] + TuiToastShow, +} + +impl Default for Type { + fn default() -> Type { + Self::TuiPromptAppend + } +} + diff --git a/crates/opencode-client/generated/src/models/tui_show_toast_request.rs b/crates/opencode-client/generated/src/models/tui_show_toast_request.rs new file mode 100644 index 0000000..7a9a180 --- /dev/null +++ b/crates/opencode-client/generated/src/models/tui_show_toast_request.rs @@ -0,0 +1,55 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TuiShowToastRequest { + #[serde(rename = "title", skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(rename = "message")] + pub message: String, + #[serde(rename = "variant")] + pub variant: Variant, + /// Duration in milliseconds + #[serde(rename = "duration", skip_serializing_if = "Option::is_none")] + pub duration: Option, +} + +impl TuiShowToastRequest { + pub fn new(message: String, variant: Variant) -> TuiShowToastRequest { + TuiShowToastRequest { + title: None, + message, + variant, + duration: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Variant { + #[serde(rename = "info")] + Info, + #[serde(rename = "success")] + Success, + #[serde(rename = "warning")] + Warning, + #[serde(rename = "error")] + Error, +} + +impl Default for Variant { + fn default() -> Variant { + Self::Info + } +} + diff --git a/crates/opencode-client/generated/src/models/unknown_error.rs b/crates/opencode-client/generated/src/models/unknown_error.rs new file mode 100644 index 0000000..6169c93 --- /dev/null +++ b/crates/opencode-client/generated/src/models/unknown_error.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct UnknownError { + #[serde(rename = "name")] + pub name: Name, + #[serde(rename = "data")] + pub data: Box, +} + +impl UnknownError { + pub fn new(name: Name, data: models::UnknownErrorData) -> UnknownError { + UnknownError { + name, + data: Box::new(data), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Name { + #[serde(rename = "UnknownError")] + UnknownError, +} + +impl Default for Name { + fn default() -> Name { + Self::UnknownError + } +} + diff --git a/crates/opencode-client/generated/src/models/unknown_error_data.rs b/crates/opencode-client/generated/src/models/unknown_error_data.rs new file mode 100644 index 0000000..a69924f --- /dev/null +++ b/crates/opencode-client/generated/src/models/unknown_error_data.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct UnknownErrorData { + #[serde(rename = "message")] + pub message: String, +} + +impl UnknownErrorData { + pub fn new(message: String) -> UnknownErrorData { + UnknownErrorData { + message, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/user_message.rs b/crates/opencode-client/generated/src/models/user_message.rs new file mode 100644 index 0000000..386a99e --- /dev/null +++ b/crates/opencode-client/generated/src/models/user_message.rs @@ -0,0 +1,66 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct UserMessage { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "role")] + pub role: Role, + #[serde(rename = "time")] + pub time: Box, + #[serde(rename = "summary", skip_serializing_if = "Option::is_none")] + pub summary: Option>, + #[serde(rename = "agent")] + pub agent: String, + #[serde(rename = "model")] + pub model: Box, + #[serde(rename = "system", skip_serializing_if = "Option::is_none")] + pub system: Option, + #[serde(rename = "tools", skip_serializing_if = "Option::is_none")] + pub tools: Option>, + #[serde(rename = "variant", skip_serializing_if = "Option::is_none")] + pub variant: Option, +} + +impl UserMessage { + pub fn new(id: String, session_id: String, role: Role, time: models::UserMessageTime, agent: String, model: models::SessionPromptRequestModel) -> UserMessage { + UserMessage { + id, + session_id, + role, + time: Box::new(time), + summary: None, + agent, + model: Box::new(model), + system: None, + tools: None, + variant: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Role { + #[serde(rename = "user")] + User, +} + +impl Default for Role { + fn default() -> Role { + Self::User + } +} + diff --git a/crates/opencode-client/generated/src/models/user_message_summary.rs b/crates/opencode-client/generated/src/models/user_message_summary.rs new file mode 100644 index 0000000..fb52632 --- /dev/null +++ b/crates/opencode-client/generated/src/models/user_message_summary.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct UserMessageSummary { + #[serde(rename = "title", skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(rename = "body", skip_serializing_if = "Option::is_none")] + pub body: Option, + #[serde(rename = "diffs")] + pub diffs: Vec, +} + +impl UserMessageSummary { + pub fn new(diffs: Vec) -> UserMessageSummary { + UserMessageSummary { + title: None, + body: None, + diffs, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/user_message_time.rs b/crates/opencode-client/generated/src/models/user_message_time.rs new file mode 100644 index 0000000..0147aef --- /dev/null +++ b/crates/opencode-client/generated/src/models/user_message_time.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct UserMessageTime { + #[serde(rename = "created")] + pub created: f64, +} + +impl UserMessageTime { + pub fn new(created: f64) -> UserMessageTime { + UserMessageTime { + created, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/vcs_info.rs b/crates/opencode-client/generated/src/models/vcs_info.rs new file mode 100644 index 0000000..ade0eaf --- /dev/null +++ b/crates/opencode-client/generated/src/models/vcs_info.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct VcsInfo { + #[serde(rename = "branch")] + pub branch: String, +} + +impl VcsInfo { + pub fn new(branch: String) -> VcsInfo { + VcsInfo { + branch, + } + } +} + diff --git a/crates/opencode-client/generated/src/models/well_known_auth.rs b/crates/opencode-client/generated/src/models/well_known_auth.rs new file mode 100644 index 0000000..278c7ec --- /dev/null +++ b/crates/opencode-client/generated/src/models/well_known_auth.rs @@ -0,0 +1,45 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct WellKnownAuth { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "key")] + pub key: String, + #[serde(rename = "token")] + pub token: String, +} + +impl WellKnownAuth { + pub fn new(r#type: Type, key: String, token: String) -> WellKnownAuth { + WellKnownAuth { + r#type, + key, + token, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "wellknown")] + Wellknown, +} + +impl Default for Type { + fn default() -> Type { + Self::Wellknown + } +} + diff --git a/crates/opencode-client/src/apis/configuration.rs b/crates/opencode-client/src/apis/configuration.rs new file mode 100644 index 0000000..9b7e71b --- /dev/null +++ b/crates/opencode-client/src/apis/configuration.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + + + +#[derive(Debug, Clone)] +pub struct Configuration { + pub base_path: String, + pub user_agent: Option, + pub client: reqwest::Client, + pub basic_auth: Option, + pub oauth_access_token: Option, + pub bearer_access_token: Option, + pub api_key: Option, +} + +pub type BasicAuth = (String, Option); + +#[derive(Debug, Clone)] +pub struct ApiKey { + pub prefix: Option, + pub key: String, +} + + +impl Configuration { + pub fn new() -> Configuration { + Configuration::default() + } +} + +impl Default for Configuration { + fn default() -> Self { + Configuration { + base_path: "http://localhost".to_owned(), + user_agent: Some("OpenAPI-Generator/0.0.3/rust".to_owned()), + client: reqwest::Client::new(), + basic_auth: None, + oauth_access_token: None, + bearer_access_token: None, + api_key: None, + } + } +} diff --git a/crates/opencode-client/src/apis/default_api.rs b/crates/opencode-client/src/apis/default_api.rs new file mode 100644 index 0000000..a1b1297 --- /dev/null +++ b/crates/opencode-client/src/apis/default_api.rs @@ -0,0 +1,4042 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + + +use reqwest; +use serde::{Deserialize, Serialize, de::Error as _}; +use crate::{apis::ResponseContent, models}; +use super::{Error, configuration, ContentType}; + + +/// struct for typed errors of method [`app_agents`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum AppAgentsError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`app_log`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum AppLogError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`auth_set`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum AuthSetError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`command_list`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum CommandListError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`config_get`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ConfigGetError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`config_providers`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ConfigProvidersError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`config_update`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ConfigUpdateError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`event_subscribe`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum EventSubscribeError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`file_list`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum FileListError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`file_read`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum FileReadError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`file_status`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum FileStatusError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`find_files`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum FindFilesError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`find_symbols`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum FindSymbolsError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`find_text`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum FindTextError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`formatter_status`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum FormatterStatusError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`global_dispose`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum GlobalDisposeError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`global_event`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum GlobalEventError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`global_health`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum GlobalHealthError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`instance_dispose`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum InstanceDisposeError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`lsp_status`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum LspStatusError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`mcp_add`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpAddError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`mcp_auth_authenticate`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpAuthAuthenticateError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`mcp_auth_callback`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpAuthCallbackError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`mcp_auth_remove`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpAuthRemoveError { + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`mcp_auth_start`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpAuthStartError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`mcp_connect`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpConnectError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`mcp_disconnect`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpDisconnectError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`mcp_status`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpStatusError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`part_delete`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PartDeleteError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`part_update`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PartUpdateError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`path_get`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PathGetError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`permission_list`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PermissionListError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`permission_respond`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PermissionRespondError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`project_current`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ProjectCurrentError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`project_list`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ProjectListError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`project_update`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ProjectUpdateError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`provider_auth`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ProviderAuthError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`provider_list`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ProviderListError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`provider_oauth_authorize`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ProviderOauthAuthorizeError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`provider_oauth_callback`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ProviderOauthCallbackError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`pty_connect`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PtyConnectError { + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`pty_create`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PtyCreateError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`pty_get`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PtyGetError { + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`pty_list`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PtyListError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`pty_remove`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PtyRemoveError { + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`pty_update`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum PtyUpdateError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_abort`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionAbortError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_command`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionCommandError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_create`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionCreateError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_delete`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionDeleteError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_diff`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionDiffError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_fork`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionForkError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_init`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionInitError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_list`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionListError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_message`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionMessageError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_messages`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionMessagesError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_prompt`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionPromptError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_prompt_async`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionPromptAsyncError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_revert`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionRevertError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_share`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionShareError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_shell`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionShellError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_status`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionStatusError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_summarize`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionSummarizeError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_todo`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionTodoError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_unrevert`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionUnrevertError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_unshare`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionUnshareError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_update`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionUpdateError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tool_ids`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ToolIdsError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tool_list`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum ToolListError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_append_prompt`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiAppendPromptError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_clear_prompt`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiClearPromptError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_control_next`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiControlNextError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_control_response`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiControlResponseError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_execute_command`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiExecuteCommandError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_open_help`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiOpenHelpError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_open_models`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiOpenModelsError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_open_sessions`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiOpenSessionsError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_open_themes`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiOpenThemesError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_publish`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiPublishError { + Status400(models::BadRequestError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_show_toast`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiShowToastError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`tui_submit_prompt`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum TuiSubmitPromptError { + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`vcs_get`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum VcsGetError { + UnknownValue(serde_json::Value), +} + + +/// Get a list of all available AI agents in the OpenCode system. +pub async fn app_agents(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/agent", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Agent>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Agent>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Write a log entry to the server logs with specified level and metadata. +pub async fn app_log(configuration: &configuration::Configuration, directory: Option<&str>, app_log_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_app_log_request = app_log_request; + + let uri_str = format!("{}/log", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_app_log_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Set authentication credentials +pub async fn auth_set(configuration: &configuration::Configuration, provider_id: &str, directory: Option<&str>, auth: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_provider_id = provider_id; + let p_query_directory = directory; + let p_body_auth = auth; + + let uri_str = format!("{}/auth/{providerID}", configuration.base_path, providerID=crate::apis::urlencode(p_path_provider_id)); + let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_auth); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get a list of all available commands in the OpenCode system. +pub async fn command_list(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/command", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Command>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Command>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve the current OpenCode configuration settings and preferences. +pub async fn config_get(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/config", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Config`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Config`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get a list of all configured AI providers and their default models. +pub async fn config_providers(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/config/providers", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ConfigProviders200Response`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ConfigProviders200Response`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Update OpenCode configuration settings and preferences. +pub async fn config_update(configuration: &configuration::Configuration, directory: Option<&str>, config: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_config = config; + + let uri_str = format!("{}/config", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_config); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Config`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Config`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get events +pub async fn event_subscribe(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/event", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Event`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Event`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// List files and directories in a specified path. +pub async fn file_list(configuration: &configuration::Configuration, path: &str, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_path = path; + let p_query_directory = directory; + + let uri_str = format!("{}/file", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + req_builder = req_builder.query(&[("path", &p_query_path.to_string())]); + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::FileNode>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::FileNode>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Read the content of a specified file. +pub async fn file_read(configuration: &configuration::Configuration, path: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_path = path; + let p_query_directory = directory; + + let uri_str = format!("{}/file/content", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + req_builder = req_builder.query(&[("path", &p_query_path.to_string())]); + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::FileContent`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::FileContent`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get the git status of all files in the project. +pub async fn file_status(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/file/status", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::File>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::File>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Search for files or directories by name or pattern in the project directory. +pub async fn find_files(configuration: &configuration::Configuration, query: &str, directory: Option<&str>, dirs: Option<&str>, r#type: Option<&str>, limit: Option) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_query = query; + let p_query_directory = directory; + let p_query_dirs = dirs; + let p_query_type = r#type; + let p_query_limit = limit; + + let uri_str = format!("{}/find/file", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + req_builder = req_builder.query(&[("query", &p_query_query.to_string())]); + if let Some(ref param_value) = p_query_dirs { + req_builder = req_builder.query(&[("dirs", &serde_json::to_string(param_value)?)]); + } + if let Some(ref param_value) = p_query_type { + req_builder = req_builder.query(&[("type", &serde_json::to_string(param_value)?)]); + } + if let Some(ref param_value) = p_query_limit { + req_builder = req_builder.query(&[("limit", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<String>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<String>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Search for workspace symbols like functions, classes, and variables using LSP. +pub async fn find_symbols(configuration: &configuration::Configuration, query: &str, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_query = query; + let p_query_directory = directory; + + let uri_str = format!("{}/find/symbol", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + req_builder = req_builder.query(&[("query", &p_query_query.to_string())]); + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Symbol>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Symbol>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Search for text patterns across files in the project using ripgrep. +pub async fn find_text(configuration: &configuration::Configuration, pattern: &str, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_pattern = pattern; + let p_query_directory = directory; + + let uri_str = format!("{}/find", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + req_builder = req_builder.query(&[("pattern", &p_query_pattern.to_string())]); + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::FindText200ResponseInner>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::FindText200ResponseInner>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get formatter status +pub async fn formatter_status(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/formatter", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::FormatterStatus>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::FormatterStatus>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Clean up and dispose all OpenCode instances, releasing all resources. +pub async fn global_dispose(configuration: &configuration::Configuration, ) -> Result> { + + let uri_str = format!("{}/global/dispose", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Subscribe to global events from the OpenCode system using server-sent events. +pub async fn global_event(configuration: &configuration::Configuration, ) -> Result> { + + let uri_str = format!("{}/global/event", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GlobalEvent`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GlobalEvent`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get health information about the OpenCode server. +pub async fn global_health(configuration: &configuration::Configuration, ) -> Result> { + + let uri_str = format!("{}/global/health", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GlobalHealth200Response`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GlobalHealth200Response`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Clean up and dispose the current OpenCode instance, releasing all resources. +pub async fn instance_dispose(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/instance/dispose", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get LSP server status +pub async fn lsp_status(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/lsp", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::LspStatus>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::LspStatus>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Dynamically add a new Model Context Protocol (MCP) server to the system. +pub async fn mcp_add(configuration: &configuration::Configuration, directory: Option<&str>, mcp_add_request: Option) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_mcp_add_request = mcp_add_request; + + let uri_str = format!("{}/mcp", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_mcp_add_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `std::collections::HashMap<String, models::McpStatus>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap<String, models::McpStatus>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Start OAuth flow and wait for callback (opens browser) +pub async fn mcp_auth_authenticate(configuration: &configuration::Configuration, name: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_name = name; + let p_query_directory = directory; + + let uri_str = format!("{}/mcp/{name}/auth/authenticate", configuration.base_path, name=crate::apis::urlencode(p_path_name)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::McpStatus`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::McpStatus`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Complete OAuth authentication for a Model Context Protocol (MCP) server using the authorization code. +pub async fn mcp_auth_callback(configuration: &configuration::Configuration, name: &str, directory: Option<&str>, mcp_auth_callback_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_name = name; + let p_query_directory = directory; + let p_body_mcp_auth_callback_request = mcp_auth_callback_request; + + let uri_str = format!("{}/mcp/{name}/auth/callback", configuration.base_path, name=crate::apis::urlencode(p_path_name)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_mcp_auth_callback_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::McpStatus`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::McpStatus`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Remove OAuth credentials for an MCP server +pub async fn mcp_auth_remove(configuration: &configuration::Configuration, name: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_name = name; + let p_query_directory = directory; + + let uri_str = format!("{}/mcp/{name}/auth", configuration.base_path, name=crate::apis::urlencode(p_path_name)); + let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::McpAuthRemove200Response`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::McpAuthRemove200Response`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Start OAuth authentication flow for a Model Context Protocol (MCP) server. +pub async fn mcp_auth_start(configuration: &configuration::Configuration, name: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_name = name; + let p_query_directory = directory; + + let uri_str = format!("{}/mcp/{name}/auth", configuration.base_path, name=crate::apis::urlencode(p_path_name)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::McpAuthStart200Response`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::McpAuthStart200Response`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Connect an MCP server +pub async fn mcp_connect(configuration: &configuration::Configuration, name: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_name = name; + let p_query_directory = directory; + + let uri_str = format!("{}/mcp/{name}/connect", configuration.base_path, name=crate::apis::urlencode(p_path_name)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Disconnect an MCP server +pub async fn mcp_disconnect(configuration: &configuration::Configuration, name: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_name = name; + let p_query_directory = directory; + + let uri_str = format!("{}/mcp/{name}/disconnect", configuration.base_path, name=crate::apis::urlencode(p_path_name)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get the status of all Model Context Protocol (MCP) servers. +pub async fn mcp_status(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/mcp", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `std::collections::HashMap<String, models::McpStatus>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap<String, models::McpStatus>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Delete a part from a message +pub async fn part_delete(configuration: &configuration::Configuration, session_id: &str, message_id: &str, part_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_path_message_id = message_id; + let p_path_part_id = part_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}/message/{messageID}/part/{partID}", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id), messageID=crate::apis::urlencode(p_path_message_id), partID=crate::apis::urlencode(p_path_part_id)); + let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Update a part in a message +pub async fn part_update(configuration: &configuration::Configuration, session_id: &str, message_id: &str, part_id: &str, directory: Option<&str>, part: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_path_message_id = message_id; + let p_path_part_id = part_id; + let p_query_directory = directory; + let p_body_part = part; + + let uri_str = format!("{}/session/{sessionID}/message/{messageID}/part/{partID}", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id), messageID=crate::apis::urlencode(p_path_message_id), partID=crate::apis::urlencode(p_path_part_id)); + let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_part); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Part`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Part`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve the current working directory and related path information for the OpenCode instance. +pub async fn path_get(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/path", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Path`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Path`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get all pending permission requests across all sessions. +pub async fn permission_list(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/permission", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Permission>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Permission>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Approve or deny a permission request from the AI assistant. +pub async fn permission_respond(configuration: &configuration::Configuration, session_id: &str, permission_id: &str, directory: Option<&str>, permission_respond_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_path_permission_id = permission_id; + let p_query_directory = directory; + let p_body_permission_respond_request = permission_respond_request; + + let uri_str = format!("{}/session/{sessionID}/permissions/{permissionID}", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id), permissionID=crate::apis::urlencode(p_path_permission_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_permission_respond_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve the currently active project that OpenCode is working with. +pub async fn project_current(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/project/current", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Project`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Project`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get a list of projects that have been opened with OpenCode. +pub async fn project_list(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/project", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Project>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Project>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Update project properties such as name, icon and color. +pub async fn project_update(configuration: &configuration::Configuration, project_id: &str, directory: Option<&str>, project_update_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_project_id = project_id; + let p_query_directory = directory; + let p_body_project_update_request = project_update_request; + + let uri_str = format!("{}/project/{projectID}", configuration.base_path, projectID=crate::apis::urlencode(p_path_project_id)); + let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_project_update_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Project`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Project`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve available authentication methods for all AI providers. +pub async fn provider_auth(configuration: &configuration::Configuration, directory: Option<&str>) -> Result>, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/provider/auth", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `std::collections::HashMap<String, Vec<models::ProviderAuthMethod>>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap<String, Vec<models::ProviderAuthMethod>>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get a list of all available AI providers, including both available and connected ones. +pub async fn provider_list(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/provider", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProviderList200Response`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProviderList200Response`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Initiate OAuth authorization for a specific AI provider to get an authorization URL. +pub async fn provider_oauth_authorize(configuration: &configuration::Configuration, provider_id: &str, directory: Option<&str>, provider_oauth_authorize_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_provider_id = provider_id; + let p_query_directory = directory; + let p_body_provider_oauth_authorize_request = provider_oauth_authorize_request; + + let uri_str = format!("{}/provider/{providerID}/oauth/authorize", configuration.base_path, providerID=crate::apis::urlencode(p_path_provider_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_provider_oauth_authorize_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProviderAuthAuthorization`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProviderAuthAuthorization`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Handle the OAuth callback from a provider after user authorization. +pub async fn provider_oauth_callback(configuration: &configuration::Configuration, provider_id: &str, directory: Option<&str>, provider_oauth_callback_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_provider_id = provider_id; + let p_query_directory = directory; + let p_body_provider_oauth_callback_request = provider_oauth_callback_request; + + let uri_str = format!("{}/provider/{providerID}/oauth/callback", configuration.base_path, providerID=crate::apis::urlencode(p_path_provider_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_provider_oauth_callback_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Establish a WebSocket connection to interact with a pseudo-terminal (PTY) session in real-time. +pub async fn pty_connect(configuration: &configuration::Configuration, pty_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_pty_id = pty_id; + let p_query_directory = directory; + + let uri_str = format!("{}/pty/{ptyID}/connect", configuration.base_path, ptyID=crate::apis::urlencode(p_path_pty_id)); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Create a new pseudo-terminal (PTY) session for running shell commands and processes. +pub async fn pty_create(configuration: &configuration::Configuration, directory: Option<&str>, pty_create_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_pty_create_request = pty_create_request; + + let uri_str = format!("{}/pty", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_pty_create_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Pty`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Pty`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve detailed information about a specific pseudo-terminal (PTY) session. +pub async fn pty_get(configuration: &configuration::Configuration, pty_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_pty_id = pty_id; + let p_query_directory = directory; + + let uri_str = format!("{}/pty/{ptyID}", configuration.base_path, ptyID=crate::apis::urlencode(p_path_pty_id)); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Pty`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Pty`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get a list of all active pseudo-terminal (PTY) sessions managed by OpenCode. +pub async fn pty_list(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/pty", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Pty>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Pty>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Remove and terminate a specific pseudo-terminal (PTY) session. +pub async fn pty_remove(configuration: &configuration::Configuration, pty_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_pty_id = pty_id; + let p_query_directory = directory; + + let uri_str = format!("{}/pty/{ptyID}", configuration.base_path, ptyID=crate::apis::urlencode(p_path_pty_id)); + let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Update properties of an existing pseudo-terminal (PTY) session. +pub async fn pty_update(configuration: &configuration::Configuration, pty_id: &str, directory: Option<&str>, pty_update_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_pty_id = pty_id; + let p_query_directory = directory; + let p_body_pty_update_request = pty_update_request; + + let uri_str = format!("{}/pty/{ptyID}", configuration.base_path, ptyID=crate::apis::urlencode(p_path_pty_id)); + let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_pty_update_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Pty`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Pty`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Abort an active session and stop any ongoing AI processing or command execution. +pub async fn session_abort(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}/abort", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Send a new command to a session for execution by the AI assistant. +pub async fn session_command(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_command_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_command_request = session_command_request; + + let uri_str = format!("{}/session/{sessionID}/command", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_command_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SessionPrompt200Response`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SessionPrompt200Response`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Create a new OpenCode session for interacting with AI assistants and managing conversations. +pub async fn session_create(configuration: &configuration::Configuration, directory: Option<&str>, session_create_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_session_create_request = session_create_request; + + let uri_str = format!("{}/session", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_create_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Session`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Session`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Delete a session and permanently remove all associated data, including messages and history. +pub async fn session_delete(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get all file changes (diffs) made during this session. +pub async fn session_diff(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, message_id: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_query_message_id = message_id; + + let uri_str = format!("{}/session/{sessionID}/diff", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref param_value) = p_query_message_id { + req_builder = req_builder.query(&[("messageID", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::FileDiff>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::FileDiff>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Create a new session by forking an existing session at a specific message point. +pub async fn session_fork(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_fork_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_fork_request = session_fork_request; + + let uri_str = format!("{}/session/{sessionID}/fork", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_fork_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Session`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Session`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Analyze the current application and create an AGENTS.md file with project-specific agent configurations. +pub async fn session_init(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_init_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_init_request = session_init_request; + + let uri_str = format!("{}/session/{sessionID}/init", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_init_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get a list of all OpenCode sessions, sorted by most recently updated. +pub async fn session_list(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/session", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Session>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Session>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve a specific message from a session by its message ID. +pub async fn session_message(configuration: &configuration::Configuration, session_id: &str, message_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_path_message_id = message_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}/message/{messageID}", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id), messageID=crate::apis::urlencode(p_path_message_id)); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SessionMessages200ResponseInner`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SessionMessages200ResponseInner`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve all messages in a session, including user prompts and AI responses. +pub async fn session_messages(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, limit: Option) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_query_limit = limit; + + let uri_str = format!("{}/session/{sessionID}/message", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref param_value) = p_query_limit { + req_builder = req_builder.query(&[("limit", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::SessionMessages200ResponseInner>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::SessionMessages200ResponseInner>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Create and send a new message to a session, streaming the AI response. +pub async fn session_prompt(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_prompt_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_prompt_request = session_prompt_request; + + let uri_str = format!("{}/session/{sessionID}/message", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_prompt_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SessionPrompt200Response`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SessionPrompt200Response`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Create and send a new message to a session asynchronously, starting the session if needed and returning immediately. +pub async fn session_prompt_async(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_prompt_request: Option) -> Result<(), Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_prompt_request = session_prompt_request; + + let uri_str = format!("{}/session/{sessionID}/prompt_async", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_prompt_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + + if !status.is_client_error() && !status.is_server_error() { + Ok(()) + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Revert a specific message in a session, undoing its effects and restoring the previous state. +pub async fn session_revert(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_revert_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_revert_request = session_revert_request; + + let uri_str = format!("{}/session/{sessionID}/revert", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_revert_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Session`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Session`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Create a shareable link for a session, allowing others to view the conversation. +pub async fn session_share(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}/share", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Session`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Session`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Execute a shell command within the session context and return the AI's response. +pub async fn session_shell(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_shell_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_shell_request = session_shell_request; + + let uri_str = format!("{}/session/{sessionID}/shell", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_shell_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AssistantMessage`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AssistantMessage`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve the current status of all sessions, including active, idle, and completed states. +pub async fn session_status(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/session/status", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `std::collections::HashMap<String, models::SessionStatus>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap<String, models::SessionStatus>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Generate a concise summary of the session using AI compaction to preserve key information. +pub async fn session_summarize(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_summarize_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_summarize_request = session_summarize_request; + + let uri_str = format!("{}/session/{sessionID}/summarize", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_summarize_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve the todo list associated with a specific session, showing tasks and action items. +pub async fn session_todo(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}/todo", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Todo>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Todo>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Restore all previously reverted messages in a session. +pub async fn session_unrevert(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}/unrevert", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Session`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Session`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Remove the shareable link for a session, making it private again. +pub async fn session_unshare(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}/share", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Session`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Session`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Update properties of an existing session, such as title or other metadata. +pub async fn session_update(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>, session_update_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + let p_body_session_update_request = session_update_request; + + let uri_str = format!("{}/session/{sessionID}", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_session_update_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Session`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Session`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get a list of all available tool IDs, including both built-in tools and dynamically registered tools. +pub async fn tool_ids(configuration: &configuration::Configuration, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/experimental/tool/ids", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<String>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<String>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Get a list of available tools with their JSON schema parameters for a specific provider and model combination. +pub async fn tool_list(configuration: &configuration::Configuration, provider: &str, model: &str, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_provider = provider; + let p_query_model = model; + let p_query_directory = directory; + + let uri_str = format!("{}/experimental/tool", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + req_builder = req_builder.query(&[("provider", &p_query_provider.to_string())]); + req_builder = req_builder.query(&[("model", &p_query_model.to_string())]); + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::ToolListItem>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::ToolListItem>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Append prompt to the TUI +pub async fn tui_append_prompt(configuration: &configuration::Configuration, directory: Option<&str>, find_text200_response_inner_path: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_find_text200_response_inner_path = find_text200_response_inner_path; + + let uri_str = format!("{}/tui/append-prompt", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_find_text200_response_inner_path); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Clear the prompt +pub async fn tui_clear_prompt(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/tui/clear-prompt", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve the next TUI (Terminal User Interface) request from the queue for processing. +pub async fn tui_control_next(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/tui/control/next", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TuiControlNext200Response`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TuiControlNext200Response`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Submit a response to the TUI request queue to complete a pending request. +pub async fn tui_control_response(configuration: &configuration::Configuration, directory: Option<&str>, body: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_body = body; + + let uri_str = format!("{}/tui/control/response", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_body); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Execute a TUI command (e.g. agent_cycle) +pub async fn tui_execute_command(configuration: &configuration::Configuration, directory: Option<&str>, tui_execute_command_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_tui_execute_command_request = tui_execute_command_request; + + let uri_str = format!("{}/tui/execute-command", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_tui_execute_command_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Open the help dialog in the TUI to display user assistance information. +pub async fn tui_open_help(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/tui/open-help", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Open the model dialog +pub async fn tui_open_models(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/tui/open-models", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Open the session dialog +pub async fn tui_open_sessions(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/tui/open-sessions", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Open the theme dialog +pub async fn tui_open_themes(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/tui/open-themes", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Publish a TUI event +pub async fn tui_publish(configuration: &configuration::Configuration, directory: Option<&str>, tui_publish_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_tui_publish_request = tui_publish_request; + + let uri_str = format!("{}/tui/publish", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_tui_publish_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Show a toast notification in the TUI +pub async fn tui_show_toast(configuration: &configuration::Configuration, directory: Option<&str>, tui_show_toast_request: Option) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + let p_body_tui_show_toast_request = tui_show_toast_request; + + let uri_str = format!("{}/tui/show-toast", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + req_builder = req_builder.json(&p_body_tui_show_toast_request); + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Submit the prompt +pub async fn tui_submit_prompt(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/tui/submit-prompt", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `bool`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `bool`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve version control system (VCS) information for the current project, such as git branch. +pub async fn vcs_get(configuration: &configuration::Configuration, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_query_directory = directory; + + let uri_str = format!("{}/vcs", configuration.base_path); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::VcsInfo`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::VcsInfo`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + diff --git a/crates/opencode-client/src/apis/mod.rs b/crates/opencode-client/src/apis/mod.rs new file mode 100644 index 0000000..f213bf7 --- /dev/null +++ b/crates/opencode-client/src/apis/mod.rs @@ -0,0 +1,117 @@ +use std::error; +use std::fmt; + +#[derive(Debug, Clone)] +pub struct ResponseContent { + pub status: reqwest::StatusCode, + pub content: String, + pub entity: Option, +} + +#[derive(Debug)] +pub enum Error { + Reqwest(reqwest::Error), + Serde(serde_json::Error), + Io(std::io::Error), + ResponseError(ResponseContent), +} + +impl fmt::Display for Error { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + let (module, e) = match self { + Error::Reqwest(e) => ("reqwest", e.to_string()), + Error::Serde(e) => ("serde", e.to_string()), + Error::Io(e) => ("IO", e.to_string()), + Error::ResponseError(e) => ("response", format!("status code {}", e.status)), + }; + write!(f, "error in {}: {}", module, e) + } +} + +impl error::Error for Error { + fn source(&self) -> Option<&(dyn error::Error + 'static)> { + Some(match self { + Error::Reqwest(e) => e, + Error::Serde(e) => e, + Error::Io(e) => e, + Error::ResponseError(_) => return None, + }) + } +} + +impl From for Error { + fn from(e: reqwest::Error) -> Self { + Error::Reqwest(e) + } +} + +impl From for Error { + fn from(e: serde_json::Error) -> Self { + Error::Serde(e) + } +} + +impl From for Error { + fn from(e: std::io::Error) -> Self { + Error::Io(e) + } +} + +pub fn urlencode>(s: T) -> String { + ::url::form_urlencoded::byte_serialize(s.as_ref().as_bytes()).collect() +} + +pub fn parse_deep_object(prefix: &str, value: &serde_json::Value) -> Vec<(String, String)> { + if let serde_json::Value::Object(object) = value { + let mut params = vec![]; + + for (key, value) in object { + match value { + serde_json::Value::Object(_) => params.append(&mut parse_deep_object( + &format!("{}[{}]", prefix, key), + value, + )), + serde_json::Value::Array(array) => { + for (i, value) in array.iter().enumerate() { + params.append(&mut parse_deep_object( + &format!("{}[{}][{}]", prefix, key, i), + value, + )); + } + }, + serde_json::Value::String(s) => params.push((format!("{}[{}]", prefix, key), s.clone())), + _ => params.push((format!("{}[{}]", prefix, key), value.to_string())), + } + } + + return params; + } + + unimplemented!("Only objects are supported with style=deepObject") +} + +/// Internal use only +/// A content type supported by this client. +#[allow(dead_code)] +enum ContentType { + Json, + Text, + Unsupported(String) +} + +impl From<&str> for ContentType { + fn from(content_type: &str) -> Self { + if content_type.starts_with("application") && content_type.contains("json") { + return Self::Json; + } else if content_type.starts_with("text/plain") { + return Self::Text; + } else { + return Self::Unsupported(content_type.to_string()); + } + } +} + +pub mod default_api; +pub mod session_api; + +pub mod configuration; diff --git a/crates/opencode-client/src/apis/session_api.rs b/crates/opencode-client/src/apis/session_api.rs new file mode 100644 index 0000000..8e21b51 --- /dev/null +++ b/crates/opencode-client/src/apis/session_api.rs @@ -0,0 +1,118 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + + +use reqwest; +use serde::{Deserialize, Serialize, de::Error as _}; +use crate::{apis::ResponseContent, models}; +use super::{Error, configuration, ContentType}; + + +/// struct for typed errors of method [`session_children`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionChildrenError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + +/// struct for typed errors of method [`session_get`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum SessionGetError { + Status400(models::BadRequestError), + Status404(models::NotFoundError), + UnknownValue(serde_json::Value), +} + + +/// Retrieve all child sessions that were forked from the specified parent session. +pub async fn session_children(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>) -> Result, Error> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}/children", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec<models::Session>`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec<models::Session>`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + +/// Retrieve detailed information about a specific OpenCode session. +pub async fn session_get(configuration: &configuration::Configuration, session_id: &str, directory: Option<&str>) -> Result> { + // add a prefix to parameters to efficiently prevent name collisions + let p_path_session_id = session_id; + let p_query_directory = directory; + + let uri_str = format!("{}/session/{sessionID}", configuration.base_path, sessionID=crate::apis::urlencode(p_path_session_id)); + let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str); + + if let Some(ref param_value) = p_query_directory { + req_builder = req_builder.query(&[("directory", ¶m_value.to_string())]); + } + if let Some(ref user_agent) = configuration.user_agent { + req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone()); + } + + let req = req_builder.build()?; + let resp = configuration.client.execute(req).await?; + + let status = resp.status(); + let content_type = resp + .headers() + .get("content-type") + .and_then(|v| v.to_str().ok()) + .unwrap_or("application/octet-stream"); + let content_type = super::ContentType::from(content_type); + + if !status.is_client_error() && !status.is_server_error() { + let content = resp.text().await?; + match content_type { + ContentType::Json => serde_json::from_str(&content).map_err(Error::from), + ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Session`"))), + ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Session`")))), + } + } else { + let content = resp.text().await?; + let entity: Option = serde_json::from_str(&content).ok(); + Err(Error::ResponseError(ResponseContent { status, content, entity })) + } +} + diff --git a/crates/opencode-client/src/lib.rs b/crates/opencode-client/src/lib.rs new file mode 100644 index 0000000..668498c --- /dev/null +++ b/crates/opencode-client/src/lib.rs @@ -0,0 +1,17 @@ +#![allow(unused_imports)] +#![allow(clippy::too_many_arguments)] +#![allow(clippy::needless_return)] +#![allow(clippy::redundant_field_names)] +#![allow(clippy::enum_variant_names)] +#![allow(clippy::derivable_impls)] +#![allow(clippy::empty_docs)] +#![allow(clippy::len_zero)] + +extern crate serde_repr; +extern crate serde; +extern crate serde_json; +extern crate url; +extern crate reqwest; + +pub mod apis; +pub mod models; diff --git a/crates/opencode-client/src/models/agent.rs b/crates/opencode-client/src/models/agent.rs new file mode 100644 index 0000000..e02c00e --- /dev/null +++ b/crates/opencode-client/src/models/agent.rs @@ -0,0 +1,85 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Agent { + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(rename = "mode")] + pub mode: Mode, + #[serde(rename = "native", skip_serializing_if = "Option::is_none")] + pub native: Option, + #[serde(rename = "hidden", skip_serializing_if = "Option::is_none")] + pub hidden: Option, + #[serde(rename = "default", skip_serializing_if = "Option::is_none")] + pub default: Option, + #[serde(rename = "topP", skip_serializing_if = "Option::is_none")] + pub top_p: Option, + #[serde(rename = "temperature", skip_serializing_if = "Option::is_none")] + pub temperature: Option, + #[serde(rename = "color", skip_serializing_if = "Option::is_none")] + pub color: Option, + #[serde(rename = "permission")] + pub permission: Box, + #[serde(rename = "model", skip_serializing_if = "Option::is_none")] + pub model: Option>, + #[serde(rename = "prompt", skip_serializing_if = "Option::is_none")] + pub prompt: Option, + #[serde(rename = "tools")] + pub tools: std::collections::HashMap, + #[serde(rename = "options")] + pub options: std::collections::HashMap, + #[serde(rename = "maxSteps", skip_serializing_if = "Option::is_none")] + pub max_steps: Option, +} + +impl Agent { + pub fn new(name: String, mode: Mode, permission: models::AgentPermission, tools: std::collections::HashMap, options: std::collections::HashMap) -> Agent { + Agent { + name, + description: None, + mode, + native: None, + hidden: None, + default: None, + top_p: None, + temperature: None, + color: None, + permission: Box::new(permission), + model: None, + prompt: None, + tools, + options, + max_steps: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Mode { + #[serde(rename = "subagent")] + Subagent, + #[serde(rename = "primary")] + Primary, + #[serde(rename = "all")] + All, +} + +impl Default for Mode { + fn default() -> Mode { + Self::Subagent + } +} + diff --git a/crates/opencode-client/src/models/agent_config.rs b/crates/opencode-client/src/models/agent_config.rs new file mode 100644 index 0000000..0423a38 --- /dev/null +++ b/crates/opencode-client/src/models/agent_config.rs @@ -0,0 +1,76 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AgentConfig { + #[serde(rename = "model", skip_serializing_if = "Option::is_none")] + pub model: Option, + #[serde(rename = "temperature", skip_serializing_if = "Option::is_none")] + pub temperature: Option, + #[serde(rename = "top_p", skip_serializing_if = "Option::is_none")] + pub top_p: Option, + #[serde(rename = "prompt", skip_serializing_if = "Option::is_none")] + pub prompt: Option, + #[serde(rename = "tools", skip_serializing_if = "Option::is_none")] + pub tools: Option>, + #[serde(rename = "disable", skip_serializing_if = "Option::is_none")] + pub disable: Option, + /// Description of when to use the agent + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(rename = "mode", skip_serializing_if = "Option::is_none")] + pub mode: Option, + /// Hex color code for the agent (e.g., #FF5733) + #[serde(rename = "color", skip_serializing_if = "Option::is_none")] + pub color: Option, + /// Maximum number of agentic iterations before forcing text-only response + #[serde(rename = "maxSteps", skip_serializing_if = "Option::is_none")] + pub max_steps: Option, + #[serde(rename = "permission", skip_serializing_if = "Option::is_none")] + pub permission: Option>, +} + +impl AgentConfig { + pub fn new() -> AgentConfig { + AgentConfig { + model: None, + temperature: None, + top_p: None, + prompt: None, + tools: None, + disable: None, + description: None, + mode: None, + color: None, + max_steps: None, + permission: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Mode { + #[serde(rename = "subagent")] + Subagent, + #[serde(rename = "primary")] + Primary, + #[serde(rename = "all")] + All, +} + +impl Default for Mode { + fn default() -> Mode { + Self::Subagent + } +} + diff --git a/crates/opencode-client/src/models/agent_config_permission.rs b/crates/opencode-client/src/models/agent_config_permission.rs new file mode 100644 index 0000000..76e86d3 --- /dev/null +++ b/crates/opencode-client/src/models/agent_config_permission.rs @@ -0,0 +1,106 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AgentConfigPermission { + #[serde(rename = "edit", skip_serializing_if = "Option::is_none")] + pub edit: Option, + #[serde(rename = "bash", skip_serializing_if = "Option::is_none")] + pub bash: Option>, + #[serde(rename = "skill", skip_serializing_if = "Option::is_none")] + pub skill: Option>, + #[serde(rename = "webfetch", skip_serializing_if = "Option::is_none")] + pub webfetch: Option, + #[serde(rename = "doom_loop", skip_serializing_if = "Option::is_none")] + pub doom_loop: Option, + #[serde(rename = "external_directory", skip_serializing_if = "Option::is_none")] + pub external_directory: Option, +} + +impl AgentConfigPermission { + pub fn new() -> AgentConfigPermission { + AgentConfigPermission { + edit: None, + bash: None, + skill: None, + webfetch: None, + doom_loop: None, + external_directory: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Edit { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for Edit { + fn default() -> Edit { + Self::Ask + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Webfetch { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for Webfetch { + fn default() -> Webfetch { + Self::Ask + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum DoomLoop { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for DoomLoop { + fn default() -> DoomLoop { + Self::Ask + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum ExternalDirectory { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for ExternalDirectory { + fn default() -> ExternalDirectory { + Self::Ask + } +} + diff --git a/crates/opencode-client/src/models/agent_config_permission_bash.rs b/crates/opencode-client/src/models/agent_config_permission_bash.rs new file mode 100644 index 0000000..bdcf3ec --- /dev/null +++ b/crates/opencode-client/src/models/agent_config_permission_bash.rs @@ -0,0 +1,24 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AgentConfigPermissionBash { +} + +impl AgentConfigPermissionBash { + pub fn new() -> AgentConfigPermissionBash { + AgentConfigPermissionBash { + } + } +} + diff --git a/crates/opencode-client/src/models/agent_part.rs b/crates/opencode-client/src/models/agent_part.rs new file mode 100644 index 0000000..e658c84 --- /dev/null +++ b/crates/opencode-client/src/models/agent_part.rs @@ -0,0 +1,54 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AgentPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "source", skip_serializing_if = "Option::is_none")] + pub source: Option>, +} + +impl AgentPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, name: String) -> AgentPart { + AgentPart { + id, + session_id, + message_id, + r#type, + name, + source: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "agent")] + Agent, +} + +impl Default for Type { + fn default() -> Type { + Self::Agent + } +} + diff --git a/crates/opencode-client/src/models/agent_part_input.rs b/crates/opencode-client/src/models/agent_part_input.rs new file mode 100644 index 0000000..1c48c38 --- /dev/null +++ b/crates/opencode-client/src/models/agent_part_input.rs @@ -0,0 +1,48 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AgentPartInput { + #[serde(rename = "id", skip_serializing_if = "Option::is_none")] + pub id: Option, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "source", skip_serializing_if = "Option::is_none")] + pub source: Option>, +} + +impl AgentPartInput { + pub fn new(r#type: Type, name: String) -> AgentPartInput { + AgentPartInput { + id: None, + r#type, + name, + source: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "agent")] + Agent, +} + +impl Default for Type { + fn default() -> Type { + Self::Agent + } +} + diff --git a/crates/opencode-client/src/models/agent_part_source.rs b/crates/opencode-client/src/models/agent_part_source.rs new file mode 100644 index 0000000..20dbcc9 --- /dev/null +++ b/crates/opencode-client/src/models/agent_part_source.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AgentPartSource { + #[serde(rename = "value")] + pub value: String, + #[serde(rename = "start")] + pub start: i32, + #[serde(rename = "end")] + pub end: i32, +} + +impl AgentPartSource { + pub fn new(value: String, start: i32, end: i32) -> AgentPartSource { + AgentPartSource { + value, + start, + end, + } + } +} + diff --git a/crates/opencode-client/src/models/agent_permission.rs b/crates/opencode-client/src/models/agent_permission.rs new file mode 100644 index 0000000..4a006d5 --- /dev/null +++ b/crates/opencode-client/src/models/agent_permission.rs @@ -0,0 +1,138 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AgentPermission { + #[serde(rename = "edit")] + pub edit: Edit, + #[serde(rename = "bash")] + pub bash: Bash, + #[serde(rename = "skill")] + pub skill: Skill, + #[serde(rename = "webfetch", skip_serializing_if = "Option::is_none")] + pub webfetch: Option, + #[serde(rename = "doom_loop", skip_serializing_if = "Option::is_none")] + pub doom_loop: Option, + #[serde(rename = "external_directory", skip_serializing_if = "Option::is_none")] + pub external_directory: Option, +} + +impl AgentPermission { + pub fn new(edit: Edit, bash: Bash, skill: Skill) -> AgentPermission { + AgentPermission { + edit, + bash, + skill, + webfetch: None, + doom_loop: None, + external_directory: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Edit { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for Edit { + fn default() -> Edit { + Self::Ask + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Bash { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for Bash { + fn default() -> Bash { + Self::Ask + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Skill { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for Skill { + fn default() -> Skill { + Self::Ask + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Webfetch { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for Webfetch { + fn default() -> Webfetch { + Self::Ask + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum DoomLoop { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for DoomLoop { + fn default() -> DoomLoop { + Self::Ask + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum ExternalDirectory { + #[serde(rename = "ask")] + Ask, + #[serde(rename = "allow")] + Allow, + #[serde(rename = "deny")] + Deny, +} + +impl Default for ExternalDirectory { + fn default() -> ExternalDirectory { + Self::Ask + } +} + diff --git a/crates/opencode-client/src/models/api_auth.rs b/crates/opencode-client/src/models/api_auth.rs new file mode 100644 index 0000000..ab03341 --- /dev/null +++ b/crates/opencode-client/src/models/api_auth.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ApiAuth { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "key")] + pub key: String, +} + +impl ApiAuth { + pub fn new(r#type: Type, key: String) -> ApiAuth { + ApiAuth { + r#type, + key, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "api")] + Api, +} + +impl Default for Type { + fn default() -> Type { + Self::Api + } +} + diff --git a/crates/opencode-client/src/models/api_error.rs b/crates/opencode-client/src/models/api_error.rs new file mode 100644 index 0000000..fcbe3df --- /dev/null +++ b/crates/opencode-client/src/models/api_error.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ApiError { + #[serde(rename = "name")] + pub name: Name, + #[serde(rename = "data")] + pub data: Box, +} + +impl ApiError { + pub fn new(name: Name, data: models::ApiErrorData) -> ApiError { + ApiError { + name, + data: Box::new(data), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Name { + #[serde(rename = "APIError")] + ApiError, +} + +impl Default for Name { + fn default() -> Name { + Self::ApiError + } +} + diff --git a/crates/opencode-client/src/models/api_error_data.rs b/crates/opencode-client/src/models/api_error_data.rs new file mode 100644 index 0000000..45f796e --- /dev/null +++ b/crates/opencode-client/src/models/api_error_data.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ApiErrorData { + #[serde(rename = "message")] + pub message: String, + #[serde(rename = "statusCode", skip_serializing_if = "Option::is_none")] + pub status_code: Option, + #[serde(rename = "isRetryable")] + pub is_retryable: bool, + #[serde(rename = "responseHeaders", skip_serializing_if = "Option::is_none")] + pub response_headers: Option>, + #[serde(rename = "responseBody", skip_serializing_if = "Option::is_none")] + pub response_body: Option, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, +} + +impl ApiErrorData { + pub fn new(message: String, is_retryable: bool) -> ApiErrorData { + ApiErrorData { + message, + status_code: None, + is_retryable, + response_headers: None, + response_body: None, + metadata: None, + } + } +} + diff --git a/crates/opencode-client/src/models/app_log_request.rs b/crates/opencode-client/src/models/app_log_request.rs new file mode 100644 index 0000000..3ff249a --- /dev/null +++ b/crates/opencode-client/src/models/app_log_request.rs @@ -0,0 +1,58 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AppLogRequest { + /// Service name for the log entry + #[serde(rename = "service")] + pub service: String, + /// Log level + #[serde(rename = "level")] + pub level: Level, + /// Log message + #[serde(rename = "message")] + pub message: String, + /// Additional metadata for the log entry + #[serde(rename = "extra", skip_serializing_if = "Option::is_none")] + pub extra: Option>, +} + +impl AppLogRequest { + pub fn new(service: String, level: Level, message: String) -> AppLogRequest { + AppLogRequest { + service, + level, + message, + extra: None, + } + } +} +/// Log level +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Level { + #[serde(rename = "debug")] + Debug, + #[serde(rename = "info")] + Info, + #[serde(rename = "error")] + Error, + #[serde(rename = "warn")] + Warn, +} + +impl Default for Level { + fn default() -> Level { + Self::Debug + } +} + diff --git a/crates/opencode-client/src/models/assistant_message.rs b/crates/opencode-client/src/models/assistant_message.rs new file mode 100644 index 0000000..7b2c776 --- /dev/null +++ b/crates/opencode-client/src/models/assistant_message.rs @@ -0,0 +1,81 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AssistantMessage { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "role")] + pub role: Role, + #[serde(rename = "time")] + pub time: Box, + #[serde(rename = "error", skip_serializing_if = "Option::is_none")] + pub error: Option>, + #[serde(rename = "parentID")] + pub parent_id: String, + #[serde(rename = "modelID")] + pub model_id: String, + #[serde(rename = "providerID")] + pub provider_id: String, + #[serde(rename = "mode")] + pub mode: String, + #[serde(rename = "agent")] + pub agent: String, + #[serde(rename = "path")] + pub path: Box, + #[serde(rename = "summary", skip_serializing_if = "Option::is_none")] + pub summary: Option, + #[serde(rename = "cost")] + pub cost: f64, + #[serde(rename = "tokens")] + pub tokens: Box, + #[serde(rename = "finish", skip_serializing_if = "Option::is_none")] + pub finish: Option, +} + +impl AssistantMessage { + pub fn new(id: String, session_id: String, role: Role, time: models::AssistantMessageTime, parent_id: String, model_id: String, provider_id: String, mode: String, agent: String, path: models::AssistantMessagePath, cost: f64, tokens: models::AssistantMessageTokens) -> AssistantMessage { + AssistantMessage { + id, + session_id, + role, + time: Box::new(time), + error: None, + parent_id, + model_id, + provider_id, + mode, + agent, + path: Box::new(path), + summary: None, + cost, + tokens: Box::new(tokens), + finish: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Role { + #[serde(rename = "assistant")] + Assistant, +} + +impl Default for Role { + fn default() -> Role { + Self::Assistant + } +} + diff --git a/crates/opencode-client/src/models/assistant_message_error.rs b/crates/opencode-client/src/models/assistant_message_error.rs new file mode 100644 index 0000000..d924467 --- /dev/null +++ b/crates/opencode-client/src/models/assistant_message_error.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AssistantMessageError { + #[serde(rename = "name")] + pub name: Name, + #[serde(rename = "data")] + pub data: Box, +} + +impl AssistantMessageError { + pub fn new(name: Name, data: models::ApiErrorData) -> AssistantMessageError { + AssistantMessageError { + name, + data: Box::new(data), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Name { + #[serde(rename = "APIError")] + ApiError, +} + +impl Default for Name { + fn default() -> Name { + Self::ApiError + } +} + diff --git a/crates/opencode-client/src/models/assistant_message_path.rs b/crates/opencode-client/src/models/assistant_message_path.rs new file mode 100644 index 0000000..250e2af --- /dev/null +++ b/crates/opencode-client/src/models/assistant_message_path.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AssistantMessagePath { + #[serde(rename = "cwd")] + pub cwd: String, + #[serde(rename = "root")] + pub root: String, +} + +impl AssistantMessagePath { + pub fn new(cwd: String, root: String) -> AssistantMessagePath { + AssistantMessagePath { + cwd, + root, + } + } +} + diff --git a/crates/opencode-client/src/models/assistant_message_time.rs b/crates/opencode-client/src/models/assistant_message_time.rs new file mode 100644 index 0000000..32f8e0e --- /dev/null +++ b/crates/opencode-client/src/models/assistant_message_time.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AssistantMessageTime { + #[serde(rename = "created", default)] + pub created: f64, + #[serde(rename = "completed", default, skip_serializing_if = "Option::is_none")] + pub completed: Option, +} + +impl AssistantMessageTime { + pub fn new(created: f64) -> AssistantMessageTime { + AssistantMessageTime { + created, + completed: None, + } + } +} + diff --git a/crates/opencode-client/src/models/assistant_message_tokens.rs b/crates/opencode-client/src/models/assistant_message_tokens.rs new file mode 100644 index 0000000..4ff9185 --- /dev/null +++ b/crates/opencode-client/src/models/assistant_message_tokens.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AssistantMessageTokens { + #[serde(rename = "input")] + pub input: f64, + #[serde(rename = "output")] + pub output: f64, + #[serde(rename = "reasoning")] + pub reasoning: f64, + #[serde(rename = "cache")] + pub cache: Box, +} + +impl AssistantMessageTokens { + pub fn new(input: f64, output: f64, reasoning: f64, cache: models::AssistantMessageTokensCache) -> AssistantMessageTokens { + AssistantMessageTokens { + input, + output, + reasoning, + cache: Box::new(cache), + } + } +} + diff --git a/crates/opencode-client/src/models/assistant_message_tokens_cache.rs b/crates/opencode-client/src/models/assistant_message_tokens_cache.rs new file mode 100644 index 0000000..f470527 --- /dev/null +++ b/crates/opencode-client/src/models/assistant_message_tokens_cache.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct AssistantMessageTokensCache { + #[serde(rename = "read")] + pub read: f64, + #[serde(rename = "write")] + pub write: f64, +} + +impl AssistantMessageTokensCache { + pub fn new(read: f64, write: f64) -> AssistantMessageTokensCache { + AssistantMessageTokensCache { + read, + write, + } + } +} + diff --git a/crates/opencode-client/src/models/auth.rs b/crates/opencode-client/src/models/auth.rs new file mode 100644 index 0000000..3c94cd9 --- /dev/null +++ b/crates/opencode-client/src/models/auth.rs @@ -0,0 +1,61 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Auth { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "refresh")] + pub refresh: String, + #[serde(rename = "access")] + pub access: String, + #[serde(rename = "expires")] + pub expires: f64, + #[serde(rename = "enterpriseUrl", skip_serializing_if = "Option::is_none")] + pub enterprise_url: Option, + #[serde(rename = "key")] + pub key: String, + #[serde(rename = "token")] + pub token: String, +} + +impl Auth { + pub fn new(r#type: Type, refresh: String, access: String, expires: f64, key: String, token: String) -> Auth { + Auth { + r#type, + refresh, + access, + expires, + enterprise_url: None, + key, + token, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "oauth")] + Oauth, + #[serde(rename = "api")] + Api, + #[serde(rename = "wellknown")] + Wellknown, +} + +impl Default for Type { + fn default() -> Type { + Self::Oauth + } +} + diff --git a/crates/opencode-client/src/models/bad_request_error.rs b/crates/opencode-client/src/models/bad_request_error.rs new file mode 100644 index 0000000..7dfc848 --- /dev/null +++ b/crates/opencode-client/src/models/bad_request_error.rs @@ -0,0 +1,45 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct BadRequestError { + #[serde(rename = "data", deserialize_with = "Option::deserialize")] + pub data: Option, + #[serde(rename = "errors")] + pub errors: Vec>, + #[serde(rename = "success")] + pub success: Success, +} + +impl BadRequestError { + pub fn new(data: Option, errors: Vec>, success: Success) -> BadRequestError { + BadRequestError { + data, + errors, + success, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Success { + #[serde(rename = "false")] + False, +} + +impl Default for Success { + fn default() -> Success { + Self::False + } +} + diff --git a/crates/opencode-client/src/models/command.rs b/crates/opencode-client/src/models/command.rs new file mode 100644 index 0000000..c7ac19a --- /dev/null +++ b/crates/opencode-client/src/models/command.rs @@ -0,0 +1,45 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Command { + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(rename = "agent", skip_serializing_if = "Option::is_none")] + pub agent: Option, + #[serde(rename = "model", skip_serializing_if = "Option::is_none")] + pub model: Option, + #[serde(rename = "template")] + pub template: Box, + #[serde(rename = "subtask", skip_serializing_if = "Option::is_none")] + pub subtask: Option, + #[serde(rename = "hints")] + pub hints: Vec, +} + +impl Command { + pub fn new(name: String, template: models::CommandTemplate, hints: Vec) -> Command { + Command { + name, + description: None, + agent: None, + model: None, + template: Box::new(template), + subtask: None, + hints, + } + } +} + diff --git a/crates/opencode-client/src/models/command_template.rs b/crates/opencode-client/src/models/command_template.rs new file mode 100644 index 0000000..174ade6 --- /dev/null +++ b/crates/opencode-client/src/models/command_template.rs @@ -0,0 +1,24 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct CommandTemplate { +} + +impl CommandTemplate { + pub fn new() -> CommandTemplate { + CommandTemplate { + } + } +} + diff --git a/crates/opencode-client/src/models/compaction_part.rs b/crates/opencode-client/src/models/compaction_part.rs new file mode 100644 index 0000000..0bc3fb0 --- /dev/null +++ b/crates/opencode-client/src/models/compaction_part.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct CompactionPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "auto")] + pub auto: bool, +} + +impl CompactionPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, auto: bool) -> CompactionPart { + CompactionPart { + id, + session_id, + message_id, + r#type, + auto, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "compaction")] + Compaction, +} + +impl Default for Type { + fn default() -> Type { + Self::Compaction + } +} + diff --git a/crates/opencode-client/src/models/config.rs b/crates/opencode-client/src/models/config.rs new file mode 100644 index 0000000..876fbc9 --- /dev/null +++ b/crates/opencode-client/src/models/config.rs @@ -0,0 +1,150 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Config { + /// JSON schema reference for configuration validation + #[serde(rename = "$schema", skip_serializing_if = "Option::is_none")] + pub dollar_schema: Option, + /// Theme name to use for the interface + #[serde(rename = "theme", skip_serializing_if = "Option::is_none")] + pub theme: Option, + #[serde(rename = "keybinds", skip_serializing_if = "Option::is_none")] + pub keybinds: Option>, + #[serde(rename = "logLevel", skip_serializing_if = "Option::is_none")] + pub log_level: Option, + #[serde(rename = "tui", skip_serializing_if = "Option::is_none")] + pub tui: Option>, + #[serde(rename = "server", skip_serializing_if = "Option::is_none")] + pub server: Option>, + /// Command configuration, see https://opencode.ai/docs/commands + #[serde(rename = "command", skip_serializing_if = "Option::is_none")] + pub command: Option>, + #[serde(rename = "watcher", skip_serializing_if = "Option::is_none")] + pub watcher: Option>, + #[serde(rename = "plugin", skip_serializing_if = "Option::is_none")] + pub plugin: Option>, + #[serde(rename = "snapshot", skip_serializing_if = "Option::is_none")] + pub snapshot: Option, + /// Control sharing behavior:'manual' allows manual sharing via commands, 'auto' enables automatic sharing, 'disabled' disables all sharing + #[serde(rename = "share", skip_serializing_if = "Option::is_none")] + pub share: Option, + /// @deprecated Use 'share' field instead. Share newly created sessions automatically + #[serde(rename = "autoshare", skip_serializing_if = "Option::is_none")] + pub autoshare: Option, + #[serde(rename = "autoupdate", skip_serializing_if = "Option::is_none")] + pub autoupdate: Option>, + /// Disable providers that are loaded automatically + #[serde(rename = "disabled_providers", skip_serializing_if = "Option::is_none")] + pub disabled_providers: Option>, + /// When set, ONLY these providers will be enabled. All other providers will be ignored + #[serde(rename = "enabled_providers", skip_serializing_if = "Option::is_none")] + pub enabled_providers: Option>, + /// Model to use in the format of provider/model, eg anthropic/claude-2 + #[serde(rename = "model", skip_serializing_if = "Option::is_none")] + pub model: Option, + /// Small model to use for tasks like title generation in the format of provider/model + #[serde(rename = "small_model", skip_serializing_if = "Option::is_none")] + pub small_model: Option, + /// Default agent to use when none is specified. Must be a primary agent. Falls back to 'build' if not set or if the specified agent is invalid. + #[serde(rename = "default_agent", skip_serializing_if = "Option::is_none")] + pub default_agent: Option, + /// Custom username to display in conversations instead of system username + #[serde(rename = "username", skip_serializing_if = "Option::is_none")] + pub username: Option, + #[serde(rename = "mode", skip_serializing_if = "Option::is_none")] + pub mode: Option, + #[serde(rename = "agent", skip_serializing_if = "Option::is_none")] + pub agent: Option, + /// Custom provider configurations and model overrides + #[serde(rename = "provider", skip_serializing_if = "Option::is_none")] + pub provider: Option>, + /// MCP (Model Context Protocol) server configurations + #[serde(rename = "mcp", skip_serializing_if = "Option::is_none")] + pub mcp: Option>, + #[serde(rename = "formatter", skip_serializing_if = "Option::is_none")] + pub formatter: Option>, + #[serde(rename = "lsp", skip_serializing_if = "Option::is_none")] + pub lsp: Option>, + /// Additional instruction files or patterns to include + #[serde(rename = "instructions", skip_serializing_if = "Option::is_none")] + pub instructions: Option>, + #[serde(rename = "layout", skip_serializing_if = "Option::is_none")] + pub layout: Option, + #[serde(rename = "permission", skip_serializing_if = "Option::is_none")] + pub permission: Option>, + #[serde(rename = "tools", skip_serializing_if = "Option::is_none")] + pub tools: Option>, + #[serde(rename = "enterprise", skip_serializing_if = "Option::is_none")] + pub enterprise: Option>, + #[serde(rename = "compaction", skip_serializing_if = "Option::is_none")] + pub compaction: Option>, + #[serde(rename = "experimental", skip_serializing_if = "Option::is_none")] + pub experimental: Option>, +} + +impl Config { + pub fn new() -> Config { + Config { + dollar_schema: None, + theme: None, + keybinds: None, + log_level: None, + tui: None, + server: None, + command: None, + watcher: None, + plugin: None, + snapshot: None, + share: None, + autoshare: None, + autoupdate: None, + disabled_providers: None, + enabled_providers: None, + model: None, + small_model: None, + default_agent: None, + username: None, + mode: None, + agent: None, + provider: None, + mcp: None, + formatter: None, + lsp: None, + instructions: None, + layout: None, + permission: None, + tools: None, + enterprise: None, + compaction: None, + experimental: None, + } + } +} +/// Control sharing behavior:'manual' allows manual sharing via commands, 'auto' enables automatic sharing, 'disabled' disables all sharing +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Share { + #[serde(rename = "manual")] + Manual, + #[serde(rename = "auto")] + Auto, + #[serde(rename = "disabled")] + Disabled, +} + +impl Default for Share { + fn default() -> Share { + Self::Manual + } +} + diff --git a/crates/opencode-client/src/models/config_agent.rs b/crates/opencode-client/src/models/config_agent.rs new file mode 100644 index 0000000..16321e2 --- /dev/null +++ b/crates/opencode-client/src/models/config_agent.rs @@ -0,0 +1,47 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// ConfigAgent : Agent configuration, see https://opencode.ai/docs/agent +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigAgent { + #[serde(rename = "plan", skip_serializing_if = "Option::is_none")] + pub plan: Option, + #[serde(rename = "build", skip_serializing_if = "Option::is_none")] + pub build: Option, + #[serde(rename = "general", skip_serializing_if = "Option::is_none")] + pub general: Option, + #[serde(rename = "explore", skip_serializing_if = "Option::is_none")] + pub explore: Option, + #[serde(rename = "title", skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(rename = "summary", skip_serializing_if = "Option::is_none")] + pub summary: Option, + #[serde(rename = "compaction", skip_serializing_if = "Option::is_none")] + pub compaction: Option, +} + +impl ConfigAgent { + /// Agent configuration, see https://opencode.ai/docs/agent + pub fn new() -> ConfigAgent { + ConfigAgent { + plan: None, + build: None, + general: None, + explore: None, + title: None, + summary: None, + compaction: None, + } + } +} + diff --git a/crates/opencode-client/src/models/config_autoupdate.rs b/crates/opencode-client/src/models/config_autoupdate.rs new file mode 100644 index 0000000..0024f1b --- /dev/null +++ b/crates/opencode-client/src/models/config_autoupdate.rs @@ -0,0 +1,26 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// ConfigAutoupdate : Automatically update to the latest version. Set to true to auto-update, false to disable, or 'notify' to show update notifications +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigAutoupdate { +} + +impl ConfigAutoupdate { + /// Automatically update to the latest version. Set to true to auto-update, false to disable, or 'notify' to show update notifications + pub fn new() -> ConfigAutoupdate { + ConfigAutoupdate { + } + } +} + diff --git a/crates/opencode-client/src/models/config_command_value.rs b/crates/opencode-client/src/models/config_command_value.rs new file mode 100644 index 0000000..4d4a40f --- /dev/null +++ b/crates/opencode-client/src/models/config_command_value.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigCommandValue { + #[serde(rename = "template")] + pub template: String, + #[serde(rename = "description", skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(rename = "agent", skip_serializing_if = "Option::is_none")] + pub agent: Option, + #[serde(rename = "model", skip_serializing_if = "Option::is_none")] + pub model: Option, + #[serde(rename = "subtask", skip_serializing_if = "Option::is_none")] + pub subtask: Option, +} + +impl ConfigCommandValue { + pub fn new(template: String) -> ConfigCommandValue { + ConfigCommandValue { + template, + description: None, + agent: None, + model: None, + subtask: None, + } + } +} + diff --git a/crates/opencode-client/src/models/config_compaction.rs b/crates/opencode-client/src/models/config_compaction.rs new file mode 100644 index 0000000..9051b03 --- /dev/null +++ b/crates/opencode-client/src/models/config_compaction.rs @@ -0,0 +1,32 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigCompaction { + /// Enable automatic compaction when context is full (default: true) + #[serde(rename = "auto", skip_serializing_if = "Option::is_none")] + pub auto: Option, + /// Enable pruning of old tool outputs (default: true) + #[serde(rename = "prune", skip_serializing_if = "Option::is_none")] + pub prune: Option, +} + +impl ConfigCompaction { + pub fn new() -> ConfigCompaction { + ConfigCompaction { + auto: None, + prune: None, + } + } +} + diff --git a/crates/opencode-client/src/models/config_enterprise.rs b/crates/opencode-client/src/models/config_enterprise.rs new file mode 100644 index 0000000..192b3a6 --- /dev/null +++ b/crates/opencode-client/src/models/config_enterprise.rs @@ -0,0 +1,28 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigEnterprise { + /// Enterprise URL + #[serde(rename = "url", skip_serializing_if = "Option::is_none")] + pub url: Option, +} + +impl ConfigEnterprise { + pub fn new() -> ConfigEnterprise { + ConfigEnterprise { + url: None, + } + } +} + diff --git a/crates/opencode-client/src/models/config_experimental.rs b/crates/opencode-client/src/models/config_experimental.rs new file mode 100644 index 0000000..2fb2baf --- /dev/null +++ b/crates/opencode-client/src/models/config_experimental.rs @@ -0,0 +1,54 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigExperimental { + #[serde(rename = "hook", skip_serializing_if = "Option::is_none")] + pub hook: Option>, + /// Number of retries for chat completions on failure + #[serde(rename = "chatMaxRetries", skip_serializing_if = "Option::is_none")] + pub chat_max_retries: Option, + #[serde(rename = "disable_paste_summary", skip_serializing_if = "Option::is_none")] + pub disable_paste_summary: Option, + /// Enable the batch tool + #[serde(rename = "batch_tool", skip_serializing_if = "Option::is_none")] + pub batch_tool: Option, + /// Enable OpenTelemetry spans for AI SDK calls (using the 'experimental_telemetry' flag) + #[serde(rename = "openTelemetry", skip_serializing_if = "Option::is_none")] + pub open_telemetry: Option, + /// Tools that should only be available to primary agents. + #[serde(rename = "primary_tools", skip_serializing_if = "Option::is_none")] + pub primary_tools: Option>, + /// Continue the agent loop when a tool call is denied + #[serde(rename = "continue_loop_on_deny", skip_serializing_if = "Option::is_none")] + pub continue_loop_on_deny: Option, + /// Timeout in milliseconds for model context protocol (MCP) requests + #[serde(rename = "mcp_timeout", skip_serializing_if = "Option::is_none")] + pub mcp_timeout: Option, +} + +impl ConfigExperimental { + pub fn new() -> ConfigExperimental { + ConfigExperimental { + hook: None, + chat_max_retries: None, + disable_paste_summary: None, + batch_tool: None, + open_telemetry: None, + primary_tools: None, + continue_loop_on_deny: None, + mcp_timeout: None, + } + } +} + diff --git a/crates/opencode-client/src/models/config_experimental_hook.rs b/crates/opencode-client/src/models/config_experimental_hook.rs new file mode 100644 index 0000000..69861fd --- /dev/null +++ b/crates/opencode-client/src/models/config_experimental_hook.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigExperimentalHook { + #[serde(rename = "file_edited", skip_serializing_if = "Option::is_none")] + pub file_edited: Option>>, + #[serde(rename = "session_completed", skip_serializing_if = "Option::is_none")] + pub session_completed: Option>, +} + +impl ConfigExperimentalHook { + pub fn new() -> ConfigExperimentalHook { + ConfigExperimentalHook { + file_edited: None, + session_completed: None, + } + } +} + diff --git a/crates/opencode-client/src/models/config_experimental_hook_file_edited_value_inner.rs b/crates/opencode-client/src/models/config_experimental_hook_file_edited_value_inner.rs new file mode 100644 index 0000000..cf39444 --- /dev/null +++ b/crates/opencode-client/src/models/config_experimental_hook_file_edited_value_inner.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigExperimentalHookFileEditedValueInner { + #[serde(rename = "command")] + pub command: Vec, + #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] + pub environment: Option>, +} + +impl ConfigExperimentalHookFileEditedValueInner { + pub fn new(command: Vec) -> ConfigExperimentalHookFileEditedValueInner { + ConfigExperimentalHookFileEditedValueInner { + command, + environment: None, + } + } +} + diff --git a/crates/opencode-client/src/models/config_formatter.rs b/crates/opencode-client/src/models/config_formatter.rs new file mode 100644 index 0000000..5b4a031 --- /dev/null +++ b/crates/opencode-client/src/models/config_formatter.rs @@ -0,0 +1,24 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigFormatter { +} + +impl ConfigFormatter { + pub fn new() -> ConfigFormatter { + ConfigFormatter { + } + } +} + diff --git a/crates/opencode-client/src/models/config_formatter_any_of_value.rs b/crates/opencode-client/src/models/config_formatter_any_of_value.rs new file mode 100644 index 0000000..267fc81 --- /dev/null +++ b/crates/opencode-client/src/models/config_formatter_any_of_value.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigFormatterAnyOfValue { + #[serde(rename = "disabled", skip_serializing_if = "Option::is_none")] + pub disabled: Option, + #[serde(rename = "command", skip_serializing_if = "Option::is_none")] + pub command: Option>, + #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] + pub environment: Option>, + #[serde(rename = "extensions", skip_serializing_if = "Option::is_none")] + pub extensions: Option>, +} + +impl ConfigFormatterAnyOfValue { + pub fn new() -> ConfigFormatterAnyOfValue { + ConfigFormatterAnyOfValue { + disabled: None, + command: None, + environment: None, + extensions: None, + } + } +} + diff --git a/crates/opencode-client/src/models/config_lsp.rs b/crates/opencode-client/src/models/config_lsp.rs new file mode 100644 index 0000000..33fee06 --- /dev/null +++ b/crates/opencode-client/src/models/config_lsp.rs @@ -0,0 +1,24 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigLsp { +} + +impl ConfigLsp { + pub fn new() -> ConfigLsp { + ConfigLsp { + } + } +} + diff --git a/crates/opencode-client/src/models/config_lsp_any_of_value.rs b/crates/opencode-client/src/models/config_lsp_any_of_value.rs new file mode 100644 index 0000000..d006a1b --- /dev/null +++ b/crates/opencode-client/src/models/config_lsp_any_of_value.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigLspAnyOfValue { + #[serde(rename = "disabled")] + pub disabled: bool, + #[serde(rename = "command")] + pub command: Vec, + #[serde(rename = "extensions", skip_serializing_if = "Option::is_none")] + pub extensions: Option>, + #[serde(rename = "env", skip_serializing_if = "Option::is_none")] + pub env: Option>, + #[serde(rename = "initialization", skip_serializing_if = "Option::is_none")] + pub initialization: Option>, +} + +impl ConfigLspAnyOfValue { + pub fn new(disabled: bool, command: Vec) -> ConfigLspAnyOfValue { + ConfigLspAnyOfValue { + disabled, + command, + extensions: None, + env: None, + initialization: None, + } + } +} + diff --git a/crates/opencode-client/src/models/config_lsp_any_of_value_any_of.rs b/crates/opencode-client/src/models/config_lsp_any_of_value_any_of.rs new file mode 100644 index 0000000..f822eca --- /dev/null +++ b/crates/opencode-client/src/models/config_lsp_any_of_value_any_of.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigLspAnyOfValueAnyOf { + #[serde(rename = "disabled")] + pub disabled: Disabled, +} + +impl ConfigLspAnyOfValueAnyOf { + pub fn new(disabled: Disabled) -> ConfigLspAnyOfValueAnyOf { + ConfigLspAnyOfValueAnyOf { + disabled, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Disabled { + #[serde(rename = "true")] + True, +} + +impl Default for Disabled { + fn default() -> Disabled { + Self::True + } +} + diff --git a/crates/opencode-client/src/models/config_lsp_any_of_value_any_of_1.rs b/crates/opencode-client/src/models/config_lsp_any_of_value_any_of_1.rs new file mode 100644 index 0000000..ef46d47 --- /dev/null +++ b/crates/opencode-client/src/models/config_lsp_any_of_value_any_of_1.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigLspAnyOfValueAnyOf1 { + #[serde(rename = "command")] + pub command: Vec, + #[serde(rename = "extensions", skip_serializing_if = "Option::is_none")] + pub extensions: Option>, + #[serde(rename = "disabled", skip_serializing_if = "Option::is_none")] + pub disabled: Option, + #[serde(rename = "env", skip_serializing_if = "Option::is_none")] + pub env: Option>, + #[serde(rename = "initialization", skip_serializing_if = "Option::is_none")] + pub initialization: Option>, +} + +impl ConfigLspAnyOfValueAnyOf1 { + pub fn new(command: Vec) -> ConfigLspAnyOfValueAnyOf1 { + ConfigLspAnyOfValueAnyOf1 { + command, + extensions: None, + disabled: None, + env: None, + initialization: None, + } + } +} + diff --git a/crates/opencode-client/src/models/config_mode.rs b/crates/opencode-client/src/models/config_mode.rs new file mode 100644 index 0000000..603836f --- /dev/null +++ b/crates/opencode-client/src/models/config_mode.rs @@ -0,0 +1,32 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// ConfigMode : @deprecated Use `agent` field instead. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigMode { + #[serde(rename = "build", skip_serializing_if = "Option::is_none")] + pub build: Option, + #[serde(rename = "plan", skip_serializing_if = "Option::is_none")] + pub plan: Option, +} + +impl ConfigMode { + /// @deprecated Use `agent` field instead. + pub fn new() -> ConfigMode { + ConfigMode { + build: None, + plan: None, + } + } +} + diff --git a/crates/opencode-client/src/models/config_providers_200_response.rs b/crates/opencode-client/src/models/config_providers_200_response.rs new file mode 100644 index 0000000..9a1048e --- /dev/null +++ b/crates/opencode-client/src/models/config_providers_200_response.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigProviders200Response { + #[serde(rename = "providers")] + pub providers: Vec, + #[serde(rename = "default")] + pub default: std::collections::HashMap, +} + +impl ConfigProviders200Response { + pub fn new(providers: Vec, default: std::collections::HashMap) -> ConfigProviders200Response { + ConfigProviders200Response { + providers, + default, + } + } +} + diff --git a/crates/opencode-client/src/models/config_tui.rs b/crates/opencode-client/src/models/config_tui.rs new file mode 100644 index 0000000..607fd21 --- /dev/null +++ b/crates/opencode-client/src/models/config_tui.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// ConfigTui : TUI specific settings +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigTui { + /// TUI scroll speed + #[serde(rename = "scroll_speed", skip_serializing_if = "Option::is_none")] + pub scroll_speed: Option, + #[serde(rename = "scroll_acceleration", skip_serializing_if = "Option::is_none")] + pub scroll_acceleration: Option>, + /// Control diff rendering style: 'auto' adapts to terminal width, 'stacked' always shows single column + #[serde(rename = "diff_style", skip_serializing_if = "Option::is_none")] + pub diff_style: Option, +} + +impl ConfigTui { + /// TUI specific settings + pub fn new() -> ConfigTui { + ConfigTui { + scroll_speed: None, + scroll_acceleration: None, + diff_style: None, + } + } +} +/// Control diff rendering style: 'auto' adapts to terminal width, 'stacked' always shows single column +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum DiffStyle { + #[serde(rename = "auto")] + Auto, + #[serde(rename = "stacked")] + Stacked, +} + +impl Default for DiffStyle { + fn default() -> DiffStyle { + Self::Auto + } +} + diff --git a/crates/opencode-client/src/models/config_tui_scroll_acceleration.rs b/crates/opencode-client/src/models/config_tui_scroll_acceleration.rs new file mode 100644 index 0000000..5a88bd0 --- /dev/null +++ b/crates/opencode-client/src/models/config_tui_scroll_acceleration.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// ConfigTuiScrollAcceleration : Scroll acceleration settings +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigTuiScrollAcceleration { + /// Enable scroll acceleration + #[serde(rename = "enabled")] + pub enabled: bool, +} + +impl ConfigTuiScrollAcceleration { + /// Scroll acceleration settings + pub fn new(enabled: bool) -> ConfigTuiScrollAcceleration { + ConfigTuiScrollAcceleration { + enabled, + } + } +} + diff --git a/crates/opencode-client/src/models/config_watcher.rs b/crates/opencode-client/src/models/config_watcher.rs new file mode 100644 index 0000000..22f60c3 --- /dev/null +++ b/crates/opencode-client/src/models/config_watcher.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ConfigWatcher { + #[serde(rename = "ignore", skip_serializing_if = "Option::is_none")] + pub ignore: Option>, +} + +impl ConfigWatcher { + pub fn new() -> ConfigWatcher { + ConfigWatcher { + ignore: None, + } + } +} + diff --git a/crates/opencode-client/src/models/event.rs b/crates/opencode-client/src/models/event.rs new file mode 100644 index 0000000..90ea08b --- /dev/null +++ b/crates/opencode-client/src/models/event.rs @@ -0,0 +1,110 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Event { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: serde_json::Value, +} + +impl Event { + pub fn new(r#type: Type, properties: serde_json::Value) -> Event { + Event { + r#type, + properties, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "tui.prompt.append")] + TuiPromptAppend, + #[serde(rename = "tui.command.execute")] + TuiCommandExecute, + #[serde(rename = "tui.toast.show")] + TuiToastShow, + #[serde(rename = "installation.updated")] + InstallationUpdated, + #[serde(rename = "installation.update-available")] + InstallationUpdateAvailable, + #[serde(rename = "project.updated")] + ProjectUpdated, + #[serde(rename = "server.instance.disposed")] + ServerInstanceDisposed, + #[serde(rename = "file.edited")] + FileEdited, + #[serde(rename = "lsp.client.diagnostics")] + LspClientDiagnostics, + #[serde(rename = "todo.updated")] + TodoUpdated, + #[serde(rename = "session.status")] + SessionStatus, + #[serde(rename = "session.idle")] + SessionIdle, + #[serde(rename = "pty.created")] + PtyCreated, + #[serde(rename = "pty.updated")] + PtyUpdated, + #[serde(rename = "pty.exited")] + PtyExited, + #[serde(rename = "pty.deleted")] + PtyDeleted, + #[serde(rename = "lsp.updated")] + LspUpdated, + #[serde(rename = "mcp.tools.changed")] + McpToolsChanged, + #[serde(rename = "file.watcher.updated")] + FileWatcherUpdated, + #[serde(rename = "message.updated")] + MessageUpdated, + #[serde(rename = "message.removed")] + MessageRemoved, + #[serde(rename = "message.part.updated")] + MessagePartUpdated, + #[serde(rename = "message.part.removed")] + MessagePartRemoved, + #[serde(rename = "permission.updated")] + PermissionUpdated, + #[serde(rename = "permission.replied")] + PermissionReplied, + #[serde(rename = "command.executed")] + CommandExecuted, + #[serde(rename = "vcs.branch.updated")] + VcsBranchUpdated, + #[serde(rename = "session.compacted")] + SessionCompacted, + #[serde(rename = "session.created")] + SessionCreated, + #[serde(rename = "session.updated")] + SessionUpdated, + #[serde(rename = "session.deleted")] + SessionDeleted, + #[serde(rename = "session.diff")] + SessionDiff, + #[serde(rename = "session.error")] + SessionError, + #[serde(rename = "server.connected")] + ServerConnected, + #[serde(rename = "global.disposed")] + GlobalDisposed, +} + +impl Default for Type { + fn default() -> Type { + Self::TuiPromptAppend + } +} + diff --git a/crates/opencode-client/src/models/event_command_executed.rs b/crates/opencode-client/src/models/event_command_executed.rs new file mode 100644 index 0000000..18f1b7f --- /dev/null +++ b/crates/opencode-client/src/models/event_command_executed.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventCommandExecuted { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventCommandExecuted { + pub fn new(r#type: Type, properties: models::EventCommandExecutedProperties) -> EventCommandExecuted { + EventCommandExecuted { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "command.executed")] + CommandExecuted, +} + +impl Default for Type { + fn default() -> Type { + Self::CommandExecuted + } +} + diff --git a/crates/opencode-client/src/models/event_command_executed_properties.rs b/crates/opencode-client/src/models/event_command_executed_properties.rs new file mode 100644 index 0000000..72458f2 --- /dev/null +++ b/crates/opencode-client/src/models/event_command_executed_properties.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventCommandExecutedProperties { + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "arguments")] + pub arguments: String, + #[serde(rename = "messageID")] + pub message_id: String, +} + +impl EventCommandExecutedProperties { + pub fn new(name: String, session_id: String, arguments: String, message_id: String) -> EventCommandExecutedProperties { + EventCommandExecutedProperties { + name, + session_id, + arguments, + message_id, + } + } +} + diff --git a/crates/opencode-client/src/models/event_file_edited.rs b/crates/opencode-client/src/models/event_file_edited.rs new file mode 100644 index 0000000..edbfecc --- /dev/null +++ b/crates/opencode-client/src/models/event_file_edited.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventFileEdited { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventFileEdited { + pub fn new(r#type: Type, properties: models::EventFileEditedProperties) -> EventFileEdited { + EventFileEdited { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "file.edited")] + FileEdited, +} + +impl Default for Type { + fn default() -> Type { + Self::FileEdited + } +} + diff --git a/crates/opencode-client/src/models/event_file_edited_properties.rs b/crates/opencode-client/src/models/event_file_edited_properties.rs new file mode 100644 index 0000000..89c2910 --- /dev/null +++ b/crates/opencode-client/src/models/event_file_edited_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventFileEditedProperties { + #[serde(rename = "file")] + pub file: String, +} + +impl EventFileEditedProperties { + pub fn new(file: String) -> EventFileEditedProperties { + EventFileEditedProperties { + file, + } + } +} + diff --git a/crates/opencode-client/src/models/event_file_watcher_updated.rs b/crates/opencode-client/src/models/event_file_watcher_updated.rs new file mode 100644 index 0000000..09768ac --- /dev/null +++ b/crates/opencode-client/src/models/event_file_watcher_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventFileWatcherUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventFileWatcherUpdated { + pub fn new(r#type: Type, properties: models::EventFileWatcherUpdatedProperties) -> EventFileWatcherUpdated { + EventFileWatcherUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "file.watcher.updated")] + FileWatcherUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::FileWatcherUpdated + } +} + diff --git a/crates/opencode-client/src/models/event_file_watcher_updated_properties.rs b/crates/opencode-client/src/models/event_file_watcher_updated_properties.rs new file mode 100644 index 0000000..9c9f6bb --- /dev/null +++ b/crates/opencode-client/src/models/event_file_watcher_updated_properties.rs @@ -0,0 +1,46 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventFileWatcherUpdatedProperties { + #[serde(rename = "file")] + pub file: String, + #[serde(rename = "event")] + pub event: Event, +} + +impl EventFileWatcherUpdatedProperties { + pub fn new(file: String, event: Event) -> EventFileWatcherUpdatedProperties { + EventFileWatcherUpdatedProperties { + file, + event, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Event { + #[serde(rename = "add")] + Add, + #[serde(rename = "change")] + Change, + #[serde(rename = "unlink")] + Unlink, +} + +impl Default for Event { + fn default() -> Event { + Self::Add + } +} + diff --git a/crates/opencode-client/src/models/event_global_disposed.rs b/crates/opencode-client/src/models/event_global_disposed.rs new file mode 100644 index 0000000..9f3b711 --- /dev/null +++ b/crates/opencode-client/src/models/event_global_disposed.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventGlobalDisposed { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: serde_json::Value, +} + +impl EventGlobalDisposed { + pub fn new(r#type: Type, properties: serde_json::Value) -> EventGlobalDisposed { + EventGlobalDisposed { + r#type, + properties, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "global.disposed")] + GlobalDisposed, +} + +impl Default for Type { + fn default() -> Type { + Self::GlobalDisposed + } +} + diff --git a/crates/opencode-client/src/models/event_installation_update_available.rs b/crates/opencode-client/src/models/event_installation_update_available.rs new file mode 100644 index 0000000..f017bbb --- /dev/null +++ b/crates/opencode-client/src/models/event_installation_update_available.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventInstallationUpdateAvailable { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventInstallationUpdateAvailable { + pub fn new(r#type: Type, properties: models::EventInstallationUpdatedProperties) -> EventInstallationUpdateAvailable { + EventInstallationUpdateAvailable { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "installation.update-available")] + InstallationUpdateAvailable, +} + +impl Default for Type { + fn default() -> Type { + Self::InstallationUpdateAvailable + } +} + diff --git a/crates/opencode-client/src/models/event_installation_updated.rs b/crates/opencode-client/src/models/event_installation_updated.rs new file mode 100644 index 0000000..ecce206 --- /dev/null +++ b/crates/opencode-client/src/models/event_installation_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventInstallationUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventInstallationUpdated { + pub fn new(r#type: Type, properties: models::EventInstallationUpdatedProperties) -> EventInstallationUpdated { + EventInstallationUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "installation.updated")] + InstallationUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::InstallationUpdated + } +} + diff --git a/crates/opencode-client/src/models/event_installation_updated_properties.rs b/crates/opencode-client/src/models/event_installation_updated_properties.rs new file mode 100644 index 0000000..a02c0a3 --- /dev/null +++ b/crates/opencode-client/src/models/event_installation_updated_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventInstallationUpdatedProperties { + #[serde(rename = "version")] + pub version: String, +} + +impl EventInstallationUpdatedProperties { + pub fn new(version: String) -> EventInstallationUpdatedProperties { + EventInstallationUpdatedProperties { + version, + } + } +} + diff --git a/crates/opencode-client/src/models/event_lsp_client_diagnostics.rs b/crates/opencode-client/src/models/event_lsp_client_diagnostics.rs new file mode 100644 index 0000000..57ab0e1 --- /dev/null +++ b/crates/opencode-client/src/models/event_lsp_client_diagnostics.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventLspClientDiagnostics { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventLspClientDiagnostics { + pub fn new(r#type: Type, properties: models::EventLspClientDiagnosticsProperties) -> EventLspClientDiagnostics { + EventLspClientDiagnostics { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "lsp.client.diagnostics")] + LspClientDiagnostics, +} + +impl Default for Type { + fn default() -> Type { + Self::LspClientDiagnostics + } +} + diff --git a/crates/opencode-client/src/models/event_lsp_client_diagnostics_properties.rs b/crates/opencode-client/src/models/event_lsp_client_diagnostics_properties.rs new file mode 100644 index 0000000..f11030d --- /dev/null +++ b/crates/opencode-client/src/models/event_lsp_client_diagnostics_properties.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventLspClientDiagnosticsProperties { + #[serde(rename = "serverID")] + pub server_id: String, + #[serde(rename = "path")] + pub path: String, +} + +impl EventLspClientDiagnosticsProperties { + pub fn new(server_id: String, path: String) -> EventLspClientDiagnosticsProperties { + EventLspClientDiagnosticsProperties { + server_id, + path, + } + } +} + diff --git a/crates/opencode-client/src/models/event_lsp_updated.rs b/crates/opencode-client/src/models/event_lsp_updated.rs new file mode 100644 index 0000000..3b0d123 --- /dev/null +++ b/crates/opencode-client/src/models/event_lsp_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventLspUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: serde_json::Value, +} + +impl EventLspUpdated { + pub fn new(r#type: Type, properties: serde_json::Value) -> EventLspUpdated { + EventLspUpdated { + r#type, + properties, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "lsp.updated")] + LspUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::LspUpdated + } +} + diff --git a/crates/opencode-client/src/models/event_mcp_tools_changed.rs b/crates/opencode-client/src/models/event_mcp_tools_changed.rs new file mode 100644 index 0000000..11d546c --- /dev/null +++ b/crates/opencode-client/src/models/event_mcp_tools_changed.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMcpToolsChanged { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventMcpToolsChanged { + pub fn new(r#type: Type, properties: models::EventMcpToolsChangedProperties) -> EventMcpToolsChanged { + EventMcpToolsChanged { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "mcp.tools.changed")] + McpToolsChanged, +} + +impl Default for Type { + fn default() -> Type { + Self::McpToolsChanged + } +} + diff --git a/crates/opencode-client/src/models/event_mcp_tools_changed_properties.rs b/crates/opencode-client/src/models/event_mcp_tools_changed_properties.rs new file mode 100644 index 0000000..6215f32 --- /dev/null +++ b/crates/opencode-client/src/models/event_mcp_tools_changed_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMcpToolsChangedProperties { + #[serde(rename = "server")] + pub server: String, +} + +impl EventMcpToolsChangedProperties { + pub fn new(server: String) -> EventMcpToolsChangedProperties { + EventMcpToolsChangedProperties { + server, + } + } +} + diff --git a/crates/opencode-client/src/models/event_message_part_removed.rs b/crates/opencode-client/src/models/event_message_part_removed.rs new file mode 100644 index 0000000..04013b2 --- /dev/null +++ b/crates/opencode-client/src/models/event_message_part_removed.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMessagePartRemoved { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventMessagePartRemoved { + pub fn new(r#type: Type, properties: models::EventMessagePartRemovedProperties) -> EventMessagePartRemoved { + EventMessagePartRemoved { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "message.part.removed")] + MessagePartRemoved, +} + +impl Default for Type { + fn default() -> Type { + Self::MessagePartRemoved + } +} + diff --git a/crates/opencode-client/src/models/event_message_part_removed_properties.rs b/crates/opencode-client/src/models/event_message_part_removed_properties.rs new file mode 100644 index 0000000..4914b84 --- /dev/null +++ b/crates/opencode-client/src/models/event_message_part_removed_properties.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMessagePartRemovedProperties { + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "partID")] + pub part_id: String, +} + +impl EventMessagePartRemovedProperties { + pub fn new(session_id: String, message_id: String, part_id: String) -> EventMessagePartRemovedProperties { + EventMessagePartRemovedProperties { + session_id, + message_id, + part_id, + } + } +} + diff --git a/crates/opencode-client/src/models/event_message_part_updated.rs b/crates/opencode-client/src/models/event_message_part_updated.rs new file mode 100644 index 0000000..e9d89c3 --- /dev/null +++ b/crates/opencode-client/src/models/event_message_part_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMessagePartUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventMessagePartUpdated { + pub fn new(r#type: Type, properties: models::EventMessagePartUpdatedProperties) -> EventMessagePartUpdated { + EventMessagePartUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "message.part.updated")] + MessagePartUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::MessagePartUpdated + } +} + diff --git a/crates/opencode-client/src/models/event_message_part_updated_properties.rs b/crates/opencode-client/src/models/event_message_part_updated_properties.rs new file mode 100644 index 0000000..a7ecdb9 --- /dev/null +++ b/crates/opencode-client/src/models/event_message_part_updated_properties.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMessagePartUpdatedProperties { + #[serde(rename = "part")] + pub part: Box, + #[serde(rename = "delta", skip_serializing_if = "Option::is_none")] + pub delta: Option, +} + +impl EventMessagePartUpdatedProperties { + pub fn new(part: models::Part) -> EventMessagePartUpdatedProperties { + EventMessagePartUpdatedProperties { + part: Box::new(part), + delta: None, + } + } +} + diff --git a/crates/opencode-client/src/models/event_message_removed.rs b/crates/opencode-client/src/models/event_message_removed.rs new file mode 100644 index 0000000..b00ce5f --- /dev/null +++ b/crates/opencode-client/src/models/event_message_removed.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMessageRemoved { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventMessageRemoved { + pub fn new(r#type: Type, properties: models::EventMessageRemovedProperties) -> EventMessageRemoved { + EventMessageRemoved { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "message.removed")] + MessageRemoved, +} + +impl Default for Type { + fn default() -> Type { + Self::MessageRemoved + } +} + diff --git a/crates/opencode-client/src/models/event_message_removed_properties.rs b/crates/opencode-client/src/models/event_message_removed_properties.rs new file mode 100644 index 0000000..c0e34ae --- /dev/null +++ b/crates/opencode-client/src/models/event_message_removed_properties.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMessageRemovedProperties { + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, +} + +impl EventMessageRemovedProperties { + pub fn new(session_id: String, message_id: String) -> EventMessageRemovedProperties { + EventMessageRemovedProperties { + session_id, + message_id, + } + } +} + diff --git a/crates/opencode-client/src/models/event_message_updated.rs b/crates/opencode-client/src/models/event_message_updated.rs new file mode 100644 index 0000000..abdd3ca --- /dev/null +++ b/crates/opencode-client/src/models/event_message_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMessageUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventMessageUpdated { + pub fn new(r#type: Type, properties: models::EventMessageUpdatedProperties) -> EventMessageUpdated { + EventMessageUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "message.updated")] + MessageUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::MessageUpdated + } +} + diff --git a/crates/opencode-client/src/models/event_message_updated_properties.rs b/crates/opencode-client/src/models/event_message_updated_properties.rs new file mode 100644 index 0000000..a216ff3 --- /dev/null +++ b/crates/opencode-client/src/models/event_message_updated_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventMessageUpdatedProperties { + #[serde(rename = "info")] + pub info: Box, +} + +impl EventMessageUpdatedProperties { + pub fn new(info: models::Message) -> EventMessageUpdatedProperties { + EventMessageUpdatedProperties { + info: Box::new(info), + } + } +} + diff --git a/crates/opencode-client/src/models/event_permission_replied.rs b/crates/opencode-client/src/models/event_permission_replied.rs new file mode 100644 index 0000000..2930219 --- /dev/null +++ b/crates/opencode-client/src/models/event_permission_replied.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPermissionReplied { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventPermissionReplied { + pub fn new(r#type: Type, properties: models::EventPermissionRepliedProperties) -> EventPermissionReplied { + EventPermissionReplied { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "permission.replied")] + PermissionReplied, +} + +impl Default for Type { + fn default() -> Type { + Self::PermissionReplied + } +} + diff --git a/crates/opencode-client/src/models/event_permission_replied_properties.rs b/crates/opencode-client/src/models/event_permission_replied_properties.rs new file mode 100644 index 0000000..ee4e714 --- /dev/null +++ b/crates/opencode-client/src/models/event_permission_replied_properties.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPermissionRepliedProperties { + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "permissionID")] + pub permission_id: String, + #[serde(rename = "response")] + pub response: String, +} + +impl EventPermissionRepliedProperties { + pub fn new(session_id: String, permission_id: String, response: String) -> EventPermissionRepliedProperties { + EventPermissionRepliedProperties { + session_id, + permission_id, + response, + } + } +} + diff --git a/crates/opencode-client/src/models/event_permission_updated.rs b/crates/opencode-client/src/models/event_permission_updated.rs new file mode 100644 index 0000000..c0d7f3b --- /dev/null +++ b/crates/opencode-client/src/models/event_permission_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPermissionUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventPermissionUpdated { + pub fn new(r#type: Type, properties: models::Permission) -> EventPermissionUpdated { + EventPermissionUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "permission.updated")] + PermissionUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::PermissionUpdated + } +} + diff --git a/crates/opencode-client/src/models/event_project_updated.rs b/crates/opencode-client/src/models/event_project_updated.rs new file mode 100644 index 0000000..bcc8244 --- /dev/null +++ b/crates/opencode-client/src/models/event_project_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventProjectUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventProjectUpdated { + pub fn new(r#type: Type, properties: models::Project) -> EventProjectUpdated { + EventProjectUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "project.updated")] + ProjectUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::ProjectUpdated + } +} + diff --git a/crates/opencode-client/src/models/event_pty_created.rs b/crates/opencode-client/src/models/event_pty_created.rs new file mode 100644 index 0000000..05dc8fe --- /dev/null +++ b/crates/opencode-client/src/models/event_pty_created.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPtyCreated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventPtyCreated { + pub fn new(r#type: Type, properties: models::EventPtyCreatedProperties) -> EventPtyCreated { + EventPtyCreated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "pty.created")] + PtyCreated, +} + +impl Default for Type { + fn default() -> Type { + Self::PtyCreated + } +} + diff --git a/crates/opencode-client/src/models/event_pty_created_properties.rs b/crates/opencode-client/src/models/event_pty_created_properties.rs new file mode 100644 index 0000000..5586d1d --- /dev/null +++ b/crates/opencode-client/src/models/event_pty_created_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPtyCreatedProperties { + #[serde(rename = "info")] + pub info: Box, +} + +impl EventPtyCreatedProperties { + pub fn new(info: models::Pty) -> EventPtyCreatedProperties { + EventPtyCreatedProperties { + info: Box::new(info), + } + } +} + diff --git a/crates/opencode-client/src/models/event_pty_deleted.rs b/crates/opencode-client/src/models/event_pty_deleted.rs new file mode 100644 index 0000000..22e2c84 --- /dev/null +++ b/crates/opencode-client/src/models/event_pty_deleted.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPtyDeleted { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventPtyDeleted { + pub fn new(r#type: Type, properties: models::EventPtyDeletedProperties) -> EventPtyDeleted { + EventPtyDeleted { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "pty.deleted")] + PtyDeleted, +} + +impl Default for Type { + fn default() -> Type { + Self::PtyDeleted + } +} + diff --git a/crates/opencode-client/src/models/event_pty_deleted_properties.rs b/crates/opencode-client/src/models/event_pty_deleted_properties.rs new file mode 100644 index 0000000..c68d879 --- /dev/null +++ b/crates/opencode-client/src/models/event_pty_deleted_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPtyDeletedProperties { + #[serde(rename = "id")] + pub id: String, +} + +impl EventPtyDeletedProperties { + pub fn new(id: String) -> EventPtyDeletedProperties { + EventPtyDeletedProperties { + id, + } + } +} + diff --git a/crates/opencode-client/src/models/event_pty_exited.rs b/crates/opencode-client/src/models/event_pty_exited.rs new file mode 100644 index 0000000..5171c89 --- /dev/null +++ b/crates/opencode-client/src/models/event_pty_exited.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPtyExited { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventPtyExited { + pub fn new(r#type: Type, properties: models::EventPtyExitedProperties) -> EventPtyExited { + EventPtyExited { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "pty.exited")] + PtyExited, +} + +impl Default for Type { + fn default() -> Type { + Self::PtyExited + } +} + diff --git a/crates/opencode-client/src/models/event_pty_exited_properties.rs b/crates/opencode-client/src/models/event_pty_exited_properties.rs new file mode 100644 index 0000000..2d80d3a --- /dev/null +++ b/crates/opencode-client/src/models/event_pty_exited_properties.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPtyExitedProperties { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "exitCode")] + pub exit_code: f64, +} + +impl EventPtyExitedProperties { + pub fn new(id: String, exit_code: f64) -> EventPtyExitedProperties { + EventPtyExitedProperties { + id, + exit_code, + } + } +} + diff --git a/crates/opencode-client/src/models/event_pty_updated.rs b/crates/opencode-client/src/models/event_pty_updated.rs new file mode 100644 index 0000000..b0ebbef --- /dev/null +++ b/crates/opencode-client/src/models/event_pty_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventPtyUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventPtyUpdated { + pub fn new(r#type: Type, properties: models::EventPtyCreatedProperties) -> EventPtyUpdated { + EventPtyUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "pty.updated")] + PtyUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::PtyUpdated + } +} + diff --git a/crates/opencode-client/src/models/event_server_connected.rs b/crates/opencode-client/src/models/event_server_connected.rs new file mode 100644 index 0000000..ea8f5ec --- /dev/null +++ b/crates/opencode-client/src/models/event_server_connected.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventServerConnected { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: serde_json::Value, +} + +impl EventServerConnected { + pub fn new(r#type: Type, properties: serde_json::Value) -> EventServerConnected { + EventServerConnected { + r#type, + properties, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "server.connected")] + ServerConnected, +} + +impl Default for Type { + fn default() -> Type { + Self::ServerConnected + } +} + diff --git a/crates/opencode-client/src/models/event_server_instance_disposed.rs b/crates/opencode-client/src/models/event_server_instance_disposed.rs new file mode 100644 index 0000000..b8dc74a --- /dev/null +++ b/crates/opencode-client/src/models/event_server_instance_disposed.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventServerInstanceDisposed { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventServerInstanceDisposed { + pub fn new(r#type: Type, properties: models::EventServerInstanceDisposedProperties) -> EventServerInstanceDisposed { + EventServerInstanceDisposed { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "server.instance.disposed")] + ServerInstanceDisposed, +} + +impl Default for Type { + fn default() -> Type { + Self::ServerInstanceDisposed + } +} + diff --git a/crates/opencode-client/src/models/event_server_instance_disposed_properties.rs b/crates/opencode-client/src/models/event_server_instance_disposed_properties.rs new file mode 100644 index 0000000..d298e41 --- /dev/null +++ b/crates/opencode-client/src/models/event_server_instance_disposed_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventServerInstanceDisposedProperties { + #[serde(rename = "directory")] + pub directory: String, +} + +impl EventServerInstanceDisposedProperties { + pub fn new(directory: String) -> EventServerInstanceDisposedProperties { + EventServerInstanceDisposedProperties { + directory, + } + } +} + diff --git a/crates/opencode-client/src/models/event_session_compacted.rs b/crates/opencode-client/src/models/event_session_compacted.rs new file mode 100644 index 0000000..3ce59e4 --- /dev/null +++ b/crates/opencode-client/src/models/event_session_compacted.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionCompacted { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventSessionCompacted { + pub fn new(r#type: Type, properties: models::EventSessionIdleProperties) -> EventSessionCompacted { + EventSessionCompacted { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "session.compacted")] + SessionCompacted, +} + +impl Default for Type { + fn default() -> Type { + Self::SessionCompacted + } +} + diff --git a/crates/opencode-client/src/models/event_session_created.rs b/crates/opencode-client/src/models/event_session_created.rs new file mode 100644 index 0000000..cef8242 --- /dev/null +++ b/crates/opencode-client/src/models/event_session_created.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionCreated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventSessionCreated { + pub fn new(r#type: Type, properties: models::EventSessionCreatedProperties) -> EventSessionCreated { + EventSessionCreated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "session.created")] + SessionCreated, +} + +impl Default for Type { + fn default() -> Type { + Self::SessionCreated + } +} + diff --git a/crates/opencode-client/src/models/event_session_created_properties.rs b/crates/opencode-client/src/models/event_session_created_properties.rs new file mode 100644 index 0000000..673d010 --- /dev/null +++ b/crates/opencode-client/src/models/event_session_created_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionCreatedProperties { + #[serde(rename = "info")] + pub info: Box, +} + +impl EventSessionCreatedProperties { + pub fn new(info: models::Session) -> EventSessionCreatedProperties { + EventSessionCreatedProperties { + info: Box::new(info), + } + } +} + diff --git a/crates/opencode-client/src/models/event_session_deleted.rs b/crates/opencode-client/src/models/event_session_deleted.rs new file mode 100644 index 0000000..098dfaf --- /dev/null +++ b/crates/opencode-client/src/models/event_session_deleted.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionDeleted { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventSessionDeleted { + pub fn new(r#type: Type, properties: models::EventSessionCreatedProperties) -> EventSessionDeleted { + EventSessionDeleted { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "session.deleted")] + SessionDeleted, +} + +impl Default for Type { + fn default() -> Type { + Self::SessionDeleted + } +} + diff --git a/crates/opencode-client/src/models/event_session_diff.rs b/crates/opencode-client/src/models/event_session_diff.rs new file mode 100644 index 0000000..6895b1e --- /dev/null +++ b/crates/opencode-client/src/models/event_session_diff.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionDiff { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventSessionDiff { + pub fn new(r#type: Type, properties: models::EventSessionDiffProperties) -> EventSessionDiff { + EventSessionDiff { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "session.diff")] + SessionDiff, +} + +impl Default for Type { + fn default() -> Type { + Self::SessionDiff + } +} + diff --git a/crates/opencode-client/src/models/event_session_diff_properties.rs b/crates/opencode-client/src/models/event_session_diff_properties.rs new file mode 100644 index 0000000..b414c46 --- /dev/null +++ b/crates/opencode-client/src/models/event_session_diff_properties.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionDiffProperties { + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "diff")] + pub diff: Vec, +} + +impl EventSessionDiffProperties { + pub fn new(session_id: String, diff: Vec) -> EventSessionDiffProperties { + EventSessionDiffProperties { + session_id, + diff, + } + } +} + diff --git a/crates/opencode-client/src/models/event_session_error.rs b/crates/opencode-client/src/models/event_session_error.rs new file mode 100644 index 0000000..17c8592 --- /dev/null +++ b/crates/opencode-client/src/models/event_session_error.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionError { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventSessionError { + pub fn new(r#type: Type, properties: models::EventSessionErrorProperties) -> EventSessionError { + EventSessionError { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "session.error")] + SessionError, +} + +impl Default for Type { + fn default() -> Type { + Self::SessionError + } +} + diff --git a/crates/opencode-client/src/models/event_session_error_properties.rs b/crates/opencode-client/src/models/event_session_error_properties.rs new file mode 100644 index 0000000..1cf209a --- /dev/null +++ b/crates/opencode-client/src/models/event_session_error_properties.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionErrorProperties { + #[serde(rename = "sessionID", skip_serializing_if = "Option::is_none")] + pub session_id: Option, + #[serde(rename = "error", skip_serializing_if = "Option::is_none")] + pub error: Option>, +} + +impl EventSessionErrorProperties { + pub fn new() -> EventSessionErrorProperties { + EventSessionErrorProperties { + session_id: None, + error: None, + } + } +} + diff --git a/crates/opencode-client/src/models/event_session_idle.rs b/crates/opencode-client/src/models/event_session_idle.rs new file mode 100644 index 0000000..bf87813 --- /dev/null +++ b/crates/opencode-client/src/models/event_session_idle.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionIdle { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventSessionIdle { + pub fn new(r#type: Type, properties: models::EventSessionIdleProperties) -> EventSessionIdle { + EventSessionIdle { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "session.idle")] + SessionIdle, +} + +impl Default for Type { + fn default() -> Type { + Self::SessionIdle + } +} + diff --git a/crates/opencode-client/src/models/event_session_idle_properties.rs b/crates/opencode-client/src/models/event_session_idle_properties.rs new file mode 100644 index 0000000..e3ea8c5 --- /dev/null +++ b/crates/opencode-client/src/models/event_session_idle_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionIdleProperties { + #[serde(rename = "sessionID")] + pub session_id: String, +} + +impl EventSessionIdleProperties { + pub fn new(session_id: String) -> EventSessionIdleProperties { + EventSessionIdleProperties { + session_id, + } + } +} + diff --git a/crates/opencode-client/src/models/event_session_status.rs b/crates/opencode-client/src/models/event_session_status.rs new file mode 100644 index 0000000..5bc59f6 --- /dev/null +++ b/crates/opencode-client/src/models/event_session_status.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionStatus { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventSessionStatus { + pub fn new(r#type: Type, properties: models::EventSessionStatusProperties) -> EventSessionStatus { + EventSessionStatus { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "session.status")] + SessionStatus, +} + +impl Default for Type { + fn default() -> Type { + Self::SessionStatus + } +} + diff --git a/crates/opencode-client/src/models/event_session_status_properties.rs b/crates/opencode-client/src/models/event_session_status_properties.rs new file mode 100644 index 0000000..de9eeef --- /dev/null +++ b/crates/opencode-client/src/models/event_session_status_properties.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionStatusProperties { + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "status")] + pub status: Box, +} + +impl EventSessionStatusProperties { + pub fn new(session_id: String, status: models::SessionStatus) -> EventSessionStatusProperties { + EventSessionStatusProperties { + session_id, + status: Box::new(status), + } + } +} + diff --git a/crates/opencode-client/src/models/event_session_updated.rs b/crates/opencode-client/src/models/event_session_updated.rs new file mode 100644 index 0000000..95cadb7 --- /dev/null +++ b/crates/opencode-client/src/models/event_session_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventSessionUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventSessionUpdated { + pub fn new(r#type: Type, properties: models::EventSessionCreatedProperties) -> EventSessionUpdated { + EventSessionUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "session.updated")] + SessionUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::SessionUpdated + } +} + diff --git a/crates/opencode-client/src/models/event_todo_updated.rs b/crates/opencode-client/src/models/event_todo_updated.rs new file mode 100644 index 0000000..8dc99f4 --- /dev/null +++ b/crates/opencode-client/src/models/event_todo_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventTodoUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventTodoUpdated { + pub fn new(r#type: Type, properties: models::EventTodoUpdatedProperties) -> EventTodoUpdated { + EventTodoUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "todo.updated")] + TodoUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::TodoUpdated + } +} + diff --git a/crates/opencode-client/src/models/event_todo_updated_properties.rs b/crates/opencode-client/src/models/event_todo_updated_properties.rs new file mode 100644 index 0000000..41d4799 --- /dev/null +++ b/crates/opencode-client/src/models/event_todo_updated_properties.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventTodoUpdatedProperties { + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "todos")] + pub todos: Vec, +} + +impl EventTodoUpdatedProperties { + pub fn new(session_id: String, todos: Vec) -> EventTodoUpdatedProperties { + EventTodoUpdatedProperties { + session_id, + todos, + } + } +} + diff --git a/crates/opencode-client/src/models/event_tui_command_execute.rs b/crates/opencode-client/src/models/event_tui_command_execute.rs new file mode 100644 index 0000000..a904f11 --- /dev/null +++ b/crates/opencode-client/src/models/event_tui_command_execute.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventTuiCommandExecute { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventTuiCommandExecute { + pub fn new(r#type: Type, properties: models::EventTuiCommandExecuteProperties) -> EventTuiCommandExecute { + EventTuiCommandExecute { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "tui.command.execute")] + TuiCommandExecute, +} + +impl Default for Type { + fn default() -> Type { + Self::TuiCommandExecute + } +} + diff --git a/crates/opencode-client/src/models/event_tui_command_execute_properties.rs b/crates/opencode-client/src/models/event_tui_command_execute_properties.rs new file mode 100644 index 0000000..eea3d29 --- /dev/null +++ b/crates/opencode-client/src/models/event_tui_command_execute_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventTuiCommandExecuteProperties { + #[serde(rename = "command")] + pub command: Box, +} + +impl EventTuiCommandExecuteProperties { + pub fn new(command: models::EventTuiCommandExecutePropertiesCommand) -> EventTuiCommandExecuteProperties { + EventTuiCommandExecuteProperties { + command: Box::new(command), + } + } +} + diff --git a/crates/opencode-client/src/models/event_tui_command_execute_properties_command.rs b/crates/opencode-client/src/models/event_tui_command_execute_properties_command.rs new file mode 100644 index 0000000..19e86be --- /dev/null +++ b/crates/opencode-client/src/models/event_tui_command_execute_properties_command.rs @@ -0,0 +1,24 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventTuiCommandExecutePropertiesCommand { +} + +impl EventTuiCommandExecutePropertiesCommand { + pub fn new() -> EventTuiCommandExecutePropertiesCommand { + EventTuiCommandExecutePropertiesCommand { + } + } +} + diff --git a/crates/opencode-client/src/models/event_tui_prompt_append.rs b/crates/opencode-client/src/models/event_tui_prompt_append.rs new file mode 100644 index 0000000..a880b9e --- /dev/null +++ b/crates/opencode-client/src/models/event_tui_prompt_append.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventTuiPromptAppend { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventTuiPromptAppend { + pub fn new(r#type: Type, properties: models::FindText200ResponseInnerPath) -> EventTuiPromptAppend { + EventTuiPromptAppend { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "tui.prompt.append")] + TuiPromptAppend, +} + +impl Default for Type { + fn default() -> Type { + Self::TuiPromptAppend + } +} + diff --git a/crates/opencode-client/src/models/event_tui_toast_show.rs b/crates/opencode-client/src/models/event_tui_toast_show.rs new file mode 100644 index 0000000..999ab7c --- /dev/null +++ b/crates/opencode-client/src/models/event_tui_toast_show.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventTuiToastShow { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventTuiToastShow { + pub fn new(r#type: Type, properties: models::TuiShowToastRequest) -> EventTuiToastShow { + EventTuiToastShow { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "tui.toast.show")] + TuiToastShow, +} + +impl Default for Type { + fn default() -> Type { + Self::TuiToastShow + } +} + diff --git a/crates/opencode-client/src/models/event_vcs_branch_updated.rs b/crates/opencode-client/src/models/event_vcs_branch_updated.rs new file mode 100644 index 0000000..4d1fcba --- /dev/null +++ b/crates/opencode-client/src/models/event_vcs_branch_updated.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventVcsBranchUpdated { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl EventVcsBranchUpdated { + pub fn new(r#type: Type, properties: models::EventVcsBranchUpdatedProperties) -> EventVcsBranchUpdated { + EventVcsBranchUpdated { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "vcs.branch.updated")] + VcsBranchUpdated, +} + +impl Default for Type { + fn default() -> Type { + Self::VcsBranchUpdated + } +} + diff --git a/crates/opencode-client/src/models/event_vcs_branch_updated_properties.rs b/crates/opencode-client/src/models/event_vcs_branch_updated_properties.rs new file mode 100644 index 0000000..e33ec4a --- /dev/null +++ b/crates/opencode-client/src/models/event_vcs_branch_updated_properties.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct EventVcsBranchUpdatedProperties { + #[serde(rename = "branch", skip_serializing_if = "Option::is_none")] + pub branch: Option, +} + +impl EventVcsBranchUpdatedProperties { + pub fn new() -> EventVcsBranchUpdatedProperties { + EventVcsBranchUpdatedProperties { + branch: None, + } + } +} + diff --git a/crates/opencode-client/src/models/file.rs b/crates/opencode-client/src/models/file.rs new file mode 100644 index 0000000..06c002c --- /dev/null +++ b/crates/opencode-client/src/models/file.rs @@ -0,0 +1,52 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct File { + #[serde(rename = "path")] + pub path: String, + #[serde(rename = "added")] + pub added: i32, + #[serde(rename = "removed")] + pub removed: i32, + #[serde(rename = "status")] + pub status: Status, +} + +impl File { + pub fn new(path: String, added: i32, removed: i32, status: Status) -> File { + File { + path, + added, + removed, + status, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "added")] + Added, + #[serde(rename = "deleted")] + Deleted, + #[serde(rename = "modified")] + Modified, +} + +impl Default for Status { + fn default() -> Status { + Self::Added + } +} + diff --git a/crates/opencode-client/src/models/file_content.rs b/crates/opencode-client/src/models/file_content.rs new file mode 100644 index 0000000..7938f8c --- /dev/null +++ b/crates/opencode-client/src/models/file_content.rs @@ -0,0 +1,66 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FileContent { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "content")] + pub content: String, + #[serde(rename = "diff", skip_serializing_if = "Option::is_none")] + pub diff: Option, + #[serde(rename = "patch", skip_serializing_if = "Option::is_none")] + pub patch: Option>, + #[serde(rename = "encoding", skip_serializing_if = "Option::is_none")] + pub encoding: Option, + #[serde(rename = "mimeType", skip_serializing_if = "Option::is_none")] + pub mime_type: Option, +} + +impl FileContent { + pub fn new(r#type: Type, content: String) -> FileContent { + FileContent { + r#type, + content, + diff: None, + patch: None, + encoding: None, + mime_type: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "text")] + Text, +} + +impl Default for Type { + fn default() -> Type { + Self::Text + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Encoding { + #[serde(rename = "base64")] + Base64, +} + +impl Default for Encoding { + fn default() -> Encoding { + Self::Base64 + } +} + diff --git a/crates/opencode-client/src/models/file_content_patch.rs b/crates/opencode-client/src/models/file_content_patch.rs new file mode 100644 index 0000000..cfc5a1b --- /dev/null +++ b/crates/opencode-client/src/models/file_content_patch.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FileContentPatch { + #[serde(rename = "oldFileName")] + pub old_file_name: String, + #[serde(rename = "newFileName")] + pub new_file_name: String, + #[serde(rename = "oldHeader", skip_serializing_if = "Option::is_none")] + pub old_header: Option, + #[serde(rename = "newHeader", skip_serializing_if = "Option::is_none")] + pub new_header: Option, + #[serde(rename = "hunks")] + pub hunks: Vec, + #[serde(rename = "index", skip_serializing_if = "Option::is_none")] + pub index: Option, +} + +impl FileContentPatch { + pub fn new(old_file_name: String, new_file_name: String, hunks: Vec) -> FileContentPatch { + FileContentPatch { + old_file_name, + new_file_name, + old_header: None, + new_header: None, + hunks, + index: None, + } + } +} + diff --git a/crates/opencode-client/src/models/file_content_patch_hunks_inner.rs b/crates/opencode-client/src/models/file_content_patch_hunks_inner.rs new file mode 100644 index 0000000..68dd648 --- /dev/null +++ b/crates/opencode-client/src/models/file_content_patch_hunks_inner.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FileContentPatchHunksInner { + #[serde(rename = "oldStart")] + pub old_start: f64, + #[serde(rename = "oldLines")] + pub old_lines: f64, + #[serde(rename = "newStart")] + pub new_start: f64, + #[serde(rename = "newLines")] + pub new_lines: f64, + #[serde(rename = "lines")] + pub lines: Vec, +} + +impl FileContentPatchHunksInner { + pub fn new(old_start: f64, old_lines: f64, new_start: f64, new_lines: f64, lines: Vec) -> FileContentPatchHunksInner { + FileContentPatchHunksInner { + old_start, + old_lines, + new_start, + new_lines, + lines, + } + } +} + diff --git a/crates/opencode-client/src/models/file_diff.rs b/crates/opencode-client/src/models/file_diff.rs new file mode 100644 index 0000000..3d8fe13 --- /dev/null +++ b/crates/opencode-client/src/models/file_diff.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FileDiff { + #[serde(rename = "file")] + pub file: String, + #[serde(rename = "before")] + pub before: String, + #[serde(rename = "after")] + pub after: String, + #[serde(rename = "additions")] + pub additions: f64, + #[serde(rename = "deletions")] + pub deletions: f64, +} + +impl FileDiff { + pub fn new(file: String, before: String, after: String, additions: f64, deletions: f64) -> FileDiff { + FileDiff { + file, + before, + after, + additions, + deletions, + } + } +} + diff --git a/crates/opencode-client/src/models/file_node.rs b/crates/opencode-client/src/models/file_node.rs new file mode 100644 index 0000000..941f558 --- /dev/null +++ b/crates/opencode-client/src/models/file_node.rs @@ -0,0 +1,53 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FileNode { + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "path")] + pub path: String, + #[serde(rename = "absolute")] + pub absolute: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "ignored")] + pub ignored: bool, +} + +impl FileNode { + pub fn new(name: String, path: String, absolute: String, r#type: Type, ignored: bool) -> FileNode { + FileNode { + name, + path, + absolute, + r#type, + ignored, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "file")] + File, + #[serde(rename = "directory")] + Directory, +} + +impl Default for Type { + fn default() -> Type { + Self::File + } +} + diff --git a/crates/opencode-client/src/models/file_part.rs b/crates/opencode-client/src/models/file_part.rs new file mode 100644 index 0000000..a290a15 --- /dev/null +++ b/crates/opencode-client/src/models/file_part.rs @@ -0,0 +1,60 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FilePart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "mime")] + pub mime: String, + #[serde(rename = "filename", skip_serializing_if = "Option::is_none")] + pub filename: Option, + #[serde(rename = "url")] + pub url: String, + #[serde(rename = "source", skip_serializing_if = "Option::is_none")] + pub source: Option>, +} + +impl FilePart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, mime: String, url: String) -> FilePart { + FilePart { + id, + session_id, + message_id, + r#type, + mime, + filename: None, + url, + source: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "file")] + File, +} + +impl Default for Type { + fn default() -> Type { + Self::File + } +} + diff --git a/crates/opencode-client/src/models/file_part_input.rs b/crates/opencode-client/src/models/file_part_input.rs new file mode 100644 index 0000000..a9952ef --- /dev/null +++ b/crates/opencode-client/src/models/file_part_input.rs @@ -0,0 +1,54 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FilePartInput { + #[serde(rename = "id", skip_serializing_if = "Option::is_none")] + pub id: Option, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "mime")] + pub mime: String, + #[serde(rename = "filename", skip_serializing_if = "Option::is_none")] + pub filename: Option, + #[serde(rename = "url")] + pub url: String, + #[serde(rename = "source", skip_serializing_if = "Option::is_none")] + pub source: Option>, +} + +impl FilePartInput { + pub fn new(r#type: Type, mime: String, url: String) -> FilePartInput { + FilePartInput { + id: None, + r#type, + mime, + filename: None, + url, + source: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "file")] + File, +} + +impl Default for Type { + fn default() -> Type { + Self::File + } +} + diff --git a/crates/opencode-client/src/models/file_part_source.rs b/crates/opencode-client/src/models/file_part_source.rs new file mode 100644 index 0000000..fcfacbd --- /dev/null +++ b/crates/opencode-client/src/models/file_part_source.rs @@ -0,0 +1,56 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FilePartSource { + #[serde(rename = "text")] + pub text: Box, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "path")] + pub path: String, + #[serde(rename = "range")] + pub range: Box, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "kind")] + pub kind: i32, +} + +impl FilePartSource { + pub fn new(text: models::FilePartSourceText, r#type: Type, path: String, range: models::Range, name: String, kind: i32) -> FilePartSource { + FilePartSource { + text: Box::new(text), + r#type, + path, + range: Box::new(range), + name, + kind, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "file")] + File, + #[serde(rename = "symbol")] + Symbol, +} + +impl Default for Type { + fn default() -> Type { + Self::File + } +} + diff --git a/crates/opencode-client/src/models/file_part_source_text.rs b/crates/opencode-client/src/models/file_part_source_text.rs new file mode 100644 index 0000000..1c1cc6e --- /dev/null +++ b/crates/opencode-client/src/models/file_part_source_text.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FilePartSourceText { + #[serde(rename = "value")] + pub value: String, + #[serde(rename = "start")] + pub start: i32, + #[serde(rename = "end")] + pub end: i32, +} + +impl FilePartSourceText { + pub fn new(value: String, start: i32, end: i32) -> FilePartSourceText { + FilePartSourceText { + value, + start, + end, + } + } +} + diff --git a/crates/opencode-client/src/models/file_source.rs b/crates/opencode-client/src/models/file_source.rs new file mode 100644 index 0000000..6eb96f7 --- /dev/null +++ b/crates/opencode-client/src/models/file_source.rs @@ -0,0 +1,45 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FileSource { + #[serde(rename = "text")] + pub text: Box, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "path")] + pub path: String, +} + +impl FileSource { + pub fn new(text: models::FilePartSourceText, r#type: Type, path: String) -> FileSource { + FileSource { + text: Box::new(text), + r#type, + path, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "file")] + File, +} + +impl Default for Type { + fn default() -> Type { + Self::File + } +} + diff --git a/crates/opencode-client/src/models/find_text_200_response_inner.rs b/crates/opencode-client/src/models/find_text_200_response_inner.rs new file mode 100644 index 0000000..6ad2586 --- /dev/null +++ b/crates/opencode-client/src/models/find_text_200_response_inner.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FindText200ResponseInner { + #[serde(rename = "path")] + pub path: Box, + #[serde(rename = "lines")] + pub lines: Box, + #[serde(rename = "line_number")] + pub line_number: f64, + #[serde(rename = "absolute_offset")] + pub absolute_offset: f64, + #[serde(rename = "submatches")] + pub submatches: Vec, +} + +impl FindText200ResponseInner { + pub fn new(path: models::FindText200ResponseInnerPath, lines: models::FindText200ResponseInnerPath, line_number: f64, absolute_offset: f64, submatches: Vec) -> FindText200ResponseInner { + FindText200ResponseInner { + path: Box::new(path), + lines: Box::new(lines), + line_number, + absolute_offset, + submatches, + } + } +} + diff --git a/crates/opencode-client/src/models/find_text_200_response_inner_path.rs b/crates/opencode-client/src/models/find_text_200_response_inner_path.rs new file mode 100644 index 0000000..df33e19 --- /dev/null +++ b/crates/opencode-client/src/models/find_text_200_response_inner_path.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FindText200ResponseInnerPath { + #[serde(rename = "text")] + pub text: String, +} + +impl FindText200ResponseInnerPath { + pub fn new(text: String) -> FindText200ResponseInnerPath { + FindText200ResponseInnerPath { + text, + } + } +} + diff --git a/crates/opencode-client/src/models/find_text_200_response_inner_submatches_inner.rs b/crates/opencode-client/src/models/find_text_200_response_inner_submatches_inner.rs new file mode 100644 index 0000000..f7a9680 --- /dev/null +++ b/crates/opencode-client/src/models/find_text_200_response_inner_submatches_inner.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FindText200ResponseInnerSubmatchesInner { + #[serde(rename = "match")] + pub r#match: Box, + #[serde(rename = "start")] + pub start: f64, + #[serde(rename = "end")] + pub end: f64, +} + +impl FindText200ResponseInnerSubmatchesInner { + pub fn new(r#match: models::FindText200ResponseInnerPath, start: f64, end: f64) -> FindText200ResponseInnerSubmatchesInner { + FindText200ResponseInnerSubmatchesInner { + r#match: Box::new(r#match), + start, + end, + } + } +} + diff --git a/crates/opencode-client/src/models/formatter_status.rs b/crates/opencode-client/src/models/formatter_status.rs new file mode 100644 index 0000000..59d0808 --- /dev/null +++ b/crates/opencode-client/src/models/formatter_status.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct FormatterStatus { + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "extensions")] + pub extensions: Vec, + #[serde(rename = "enabled")] + pub enabled: bool, +} + +impl FormatterStatus { + pub fn new(name: String, extensions: Vec, enabled: bool) -> FormatterStatus { + FormatterStatus { + name, + extensions, + enabled, + } + } +} + diff --git a/crates/opencode-client/src/models/global_event.rs b/crates/opencode-client/src/models/global_event.rs new file mode 100644 index 0000000..aa9d564 --- /dev/null +++ b/crates/opencode-client/src/models/global_event.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct GlobalEvent { + #[serde(rename = "directory")] + pub directory: String, + #[serde(rename = "payload")] + pub payload: Box, +} + +impl GlobalEvent { + pub fn new(directory: String, payload: models::Event) -> GlobalEvent { + GlobalEvent { + directory, + payload: Box::new(payload), + } + } +} + diff --git a/crates/opencode-client/src/models/global_health_200_response.rs b/crates/opencode-client/src/models/global_health_200_response.rs new file mode 100644 index 0000000..85811f1 --- /dev/null +++ b/crates/opencode-client/src/models/global_health_200_response.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct GlobalHealth200Response { + #[serde(rename = "healthy")] + pub healthy: Healthy, + #[serde(rename = "version")] + pub version: String, +} + +impl GlobalHealth200Response { + pub fn new(healthy: Healthy, version: String) -> GlobalHealth200Response { + GlobalHealth200Response { + healthy, + version, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Healthy { + #[serde(rename = "true")] + True, +} + +impl Default for Healthy { + fn default() -> Healthy { + Self::True + } +} + diff --git a/crates/opencode-client/src/models/keybinds_config.rs b/crates/opencode-client/src/models/keybinds_config.rs new file mode 100644 index 0000000..711b45c --- /dev/null +++ b/crates/opencode-client/src/models/keybinds_config.rs @@ -0,0 +1,374 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// KeybindsConfig : Custom keybind configurations +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct KeybindsConfig { + /// Leader key for keybind combinations + #[serde(rename = "leader", skip_serializing_if = "Option::is_none")] + pub leader: Option, + /// Exit the application + #[serde(rename = "app_exit", skip_serializing_if = "Option::is_none")] + pub app_exit: Option, + /// Open external editor + #[serde(rename = "editor_open", skip_serializing_if = "Option::is_none")] + pub editor_open: Option, + /// List available themes + #[serde(rename = "theme_list", skip_serializing_if = "Option::is_none")] + pub theme_list: Option, + /// Toggle sidebar + #[serde(rename = "sidebar_toggle", skip_serializing_if = "Option::is_none")] + pub sidebar_toggle: Option, + /// Toggle session scrollbar + #[serde(rename = "scrollbar_toggle", skip_serializing_if = "Option::is_none")] + pub scrollbar_toggle: Option, + /// Toggle username visibility + #[serde(rename = "username_toggle", skip_serializing_if = "Option::is_none")] + pub username_toggle: Option, + /// View status + #[serde(rename = "status_view", skip_serializing_if = "Option::is_none")] + pub status_view: Option, + /// Export session to editor + #[serde(rename = "session_export", skip_serializing_if = "Option::is_none")] + pub session_export: Option, + /// Create a new session + #[serde(rename = "session_new", skip_serializing_if = "Option::is_none")] + pub session_new: Option, + /// List all sessions + #[serde(rename = "session_list", skip_serializing_if = "Option::is_none")] + pub session_list: Option, + /// Show session timeline + #[serde(rename = "session_timeline", skip_serializing_if = "Option::is_none")] + pub session_timeline: Option, + /// Fork session from message + #[serde(rename = "session_fork", skip_serializing_if = "Option::is_none")] + pub session_fork: Option, + /// Rename session + #[serde(rename = "session_rename", skip_serializing_if = "Option::is_none")] + pub session_rename: Option, + /// Share current session + #[serde(rename = "session_share", skip_serializing_if = "Option::is_none")] + pub session_share: Option, + /// Unshare current session + #[serde(rename = "session_unshare", skip_serializing_if = "Option::is_none")] + pub session_unshare: Option, + /// Interrupt current session + #[serde(rename = "session_interrupt", skip_serializing_if = "Option::is_none")] + pub session_interrupt: Option, + /// Compact the session + #[serde(rename = "session_compact", skip_serializing_if = "Option::is_none")] + pub session_compact: Option, + /// Scroll messages up by one page + #[serde(rename = "messages_page_up", skip_serializing_if = "Option::is_none")] + pub messages_page_up: Option, + /// Scroll messages down by one page + #[serde(rename = "messages_page_down", skip_serializing_if = "Option::is_none")] + pub messages_page_down: Option, + /// Scroll messages up by half page + #[serde(rename = "messages_half_page_up", skip_serializing_if = "Option::is_none")] + pub messages_half_page_up: Option, + /// Scroll messages down by half page + #[serde(rename = "messages_half_page_down", skip_serializing_if = "Option::is_none")] + pub messages_half_page_down: Option, + /// Navigate to first message + #[serde(rename = "messages_first", skip_serializing_if = "Option::is_none")] + pub messages_first: Option, + /// Navigate to last message + #[serde(rename = "messages_last", skip_serializing_if = "Option::is_none")] + pub messages_last: Option, + /// Navigate to next message + #[serde(rename = "messages_next", skip_serializing_if = "Option::is_none")] + pub messages_next: Option, + /// Navigate to previous message + #[serde(rename = "messages_previous", skip_serializing_if = "Option::is_none")] + pub messages_previous: Option, + /// Navigate to last user message + #[serde(rename = "messages_last_user", skip_serializing_if = "Option::is_none")] + pub messages_last_user: Option, + /// Copy message + #[serde(rename = "messages_copy", skip_serializing_if = "Option::is_none")] + pub messages_copy: Option, + /// Undo message + #[serde(rename = "messages_undo", skip_serializing_if = "Option::is_none")] + pub messages_undo: Option, + /// Redo message + #[serde(rename = "messages_redo", skip_serializing_if = "Option::is_none")] + pub messages_redo: Option, + /// Toggle code block concealment in messages + #[serde(rename = "messages_toggle_conceal", skip_serializing_if = "Option::is_none")] + pub messages_toggle_conceal: Option, + /// Toggle tool details visibility + #[serde(rename = "tool_details", skip_serializing_if = "Option::is_none")] + pub tool_details: Option, + /// List available models + #[serde(rename = "model_list", skip_serializing_if = "Option::is_none")] + pub model_list: Option, + /// Next recently used model + #[serde(rename = "model_cycle_recent", skip_serializing_if = "Option::is_none")] + pub model_cycle_recent: Option, + /// Previous recently used model + #[serde(rename = "model_cycle_recent_reverse", skip_serializing_if = "Option::is_none")] + pub model_cycle_recent_reverse: Option, + /// Next favorite model + #[serde(rename = "model_cycle_favorite", skip_serializing_if = "Option::is_none")] + pub model_cycle_favorite: Option, + /// Previous favorite model + #[serde(rename = "model_cycle_favorite_reverse", skip_serializing_if = "Option::is_none")] + pub model_cycle_favorite_reverse: Option, + /// List available commands + #[serde(rename = "command_list", skip_serializing_if = "Option::is_none")] + pub command_list: Option, + /// List agents + #[serde(rename = "agent_list", skip_serializing_if = "Option::is_none")] + pub agent_list: Option, + /// Next agent + #[serde(rename = "agent_cycle", skip_serializing_if = "Option::is_none")] + pub agent_cycle: Option, + /// Previous agent + #[serde(rename = "agent_cycle_reverse", skip_serializing_if = "Option::is_none")] + pub agent_cycle_reverse: Option, + /// Cycle model variants + #[serde(rename = "variant_cycle", skip_serializing_if = "Option::is_none")] + pub variant_cycle: Option, + /// Clear input field + #[serde(rename = "input_clear", skip_serializing_if = "Option::is_none")] + pub input_clear: Option, + /// Paste from clipboard + #[serde(rename = "input_paste", skip_serializing_if = "Option::is_none")] + pub input_paste: Option, + /// Submit input + #[serde(rename = "input_submit", skip_serializing_if = "Option::is_none")] + pub input_submit: Option, + /// Insert newline in input + #[serde(rename = "input_newline", skip_serializing_if = "Option::is_none")] + pub input_newline: Option, + /// Move cursor left in input + #[serde(rename = "input_move_left", skip_serializing_if = "Option::is_none")] + pub input_move_left: Option, + /// Move cursor right in input + #[serde(rename = "input_move_right", skip_serializing_if = "Option::is_none")] + pub input_move_right: Option, + /// Move cursor up in input + #[serde(rename = "input_move_up", skip_serializing_if = "Option::is_none")] + pub input_move_up: Option, + /// Move cursor down in input + #[serde(rename = "input_move_down", skip_serializing_if = "Option::is_none")] + pub input_move_down: Option, + /// Select left in input + #[serde(rename = "input_select_left", skip_serializing_if = "Option::is_none")] + pub input_select_left: Option, + /// Select right in input + #[serde(rename = "input_select_right", skip_serializing_if = "Option::is_none")] + pub input_select_right: Option, + /// Select up in input + #[serde(rename = "input_select_up", skip_serializing_if = "Option::is_none")] + pub input_select_up: Option, + /// Select down in input + #[serde(rename = "input_select_down", skip_serializing_if = "Option::is_none")] + pub input_select_down: Option, + /// Move to start of line in input + #[serde(rename = "input_line_home", skip_serializing_if = "Option::is_none")] + pub input_line_home: Option, + /// Move to end of line in input + #[serde(rename = "input_line_end", skip_serializing_if = "Option::is_none")] + pub input_line_end: Option, + /// Select to start of line in input + #[serde(rename = "input_select_line_home", skip_serializing_if = "Option::is_none")] + pub input_select_line_home: Option, + /// Select to end of line in input + #[serde(rename = "input_select_line_end", skip_serializing_if = "Option::is_none")] + pub input_select_line_end: Option, + /// Move to start of visual line in input + #[serde(rename = "input_visual_line_home", skip_serializing_if = "Option::is_none")] + pub input_visual_line_home: Option, + /// Move to end of visual line in input + #[serde(rename = "input_visual_line_end", skip_serializing_if = "Option::is_none")] + pub input_visual_line_end: Option, + /// Select to start of visual line in input + #[serde(rename = "input_select_visual_line_home", skip_serializing_if = "Option::is_none")] + pub input_select_visual_line_home: Option, + /// Select to end of visual line in input + #[serde(rename = "input_select_visual_line_end", skip_serializing_if = "Option::is_none")] + pub input_select_visual_line_end: Option, + /// Move to start of buffer in input + #[serde(rename = "input_buffer_home", skip_serializing_if = "Option::is_none")] + pub input_buffer_home: Option, + /// Move to end of buffer in input + #[serde(rename = "input_buffer_end", skip_serializing_if = "Option::is_none")] + pub input_buffer_end: Option, + /// Select to start of buffer in input + #[serde(rename = "input_select_buffer_home", skip_serializing_if = "Option::is_none")] + pub input_select_buffer_home: Option, + /// Select to end of buffer in input + #[serde(rename = "input_select_buffer_end", skip_serializing_if = "Option::is_none")] + pub input_select_buffer_end: Option, + /// Delete line in input + #[serde(rename = "input_delete_line", skip_serializing_if = "Option::is_none")] + pub input_delete_line: Option, + /// Delete to end of line in input + #[serde(rename = "input_delete_to_line_end", skip_serializing_if = "Option::is_none")] + pub input_delete_to_line_end: Option, + /// Delete to start of line in input + #[serde(rename = "input_delete_to_line_start", skip_serializing_if = "Option::is_none")] + pub input_delete_to_line_start: Option, + /// Backspace in input + #[serde(rename = "input_backspace", skip_serializing_if = "Option::is_none")] + pub input_backspace: Option, + /// Delete character in input + #[serde(rename = "input_delete", skip_serializing_if = "Option::is_none")] + pub input_delete: Option, + /// Undo in input + #[serde(rename = "input_undo", skip_serializing_if = "Option::is_none")] + pub input_undo: Option, + /// Redo in input + #[serde(rename = "input_redo", skip_serializing_if = "Option::is_none")] + pub input_redo: Option, + /// Move word forward in input + #[serde(rename = "input_word_forward", skip_serializing_if = "Option::is_none")] + pub input_word_forward: Option, + /// Move word backward in input + #[serde(rename = "input_word_backward", skip_serializing_if = "Option::is_none")] + pub input_word_backward: Option, + /// Select word forward in input + #[serde(rename = "input_select_word_forward", skip_serializing_if = "Option::is_none")] + pub input_select_word_forward: Option, + /// Select word backward in input + #[serde(rename = "input_select_word_backward", skip_serializing_if = "Option::is_none")] + pub input_select_word_backward: Option, + /// Delete word forward in input + #[serde(rename = "input_delete_word_forward", skip_serializing_if = "Option::is_none")] + pub input_delete_word_forward: Option, + /// Delete word backward in input + #[serde(rename = "input_delete_word_backward", skip_serializing_if = "Option::is_none")] + pub input_delete_word_backward: Option, + /// Previous history item + #[serde(rename = "history_previous", skip_serializing_if = "Option::is_none")] + pub history_previous: Option, + /// Next history item + #[serde(rename = "history_next", skip_serializing_if = "Option::is_none")] + pub history_next: Option, + /// Next child session + #[serde(rename = "session_child_cycle", skip_serializing_if = "Option::is_none")] + pub session_child_cycle: Option, + /// Previous child session + #[serde(rename = "session_child_cycle_reverse", skip_serializing_if = "Option::is_none")] + pub session_child_cycle_reverse: Option, + /// Go to parent session + #[serde(rename = "session_parent", skip_serializing_if = "Option::is_none")] + pub session_parent: Option, + /// Suspend terminal + #[serde(rename = "terminal_suspend", skip_serializing_if = "Option::is_none")] + pub terminal_suspend: Option, + /// Toggle terminal title + #[serde(rename = "terminal_title_toggle", skip_serializing_if = "Option::is_none")] + pub terminal_title_toggle: Option, + /// Toggle tips on home screen + #[serde(rename = "tips_toggle", skip_serializing_if = "Option::is_none")] + pub tips_toggle: Option, +} + +impl KeybindsConfig { + /// Custom keybind configurations + pub fn new() -> KeybindsConfig { + KeybindsConfig { + leader: None, + app_exit: None, + editor_open: None, + theme_list: None, + sidebar_toggle: None, + scrollbar_toggle: None, + username_toggle: None, + status_view: None, + session_export: None, + session_new: None, + session_list: None, + session_timeline: None, + session_fork: None, + session_rename: None, + session_share: None, + session_unshare: None, + session_interrupt: None, + session_compact: None, + messages_page_up: None, + messages_page_down: None, + messages_half_page_up: None, + messages_half_page_down: None, + messages_first: None, + messages_last: None, + messages_next: None, + messages_previous: None, + messages_last_user: None, + messages_copy: None, + messages_undo: None, + messages_redo: None, + messages_toggle_conceal: None, + tool_details: None, + model_list: None, + model_cycle_recent: None, + model_cycle_recent_reverse: None, + model_cycle_favorite: None, + model_cycle_favorite_reverse: None, + command_list: None, + agent_list: None, + agent_cycle: None, + agent_cycle_reverse: None, + variant_cycle: None, + input_clear: None, + input_paste: None, + input_submit: None, + input_newline: None, + input_move_left: None, + input_move_right: None, + input_move_up: None, + input_move_down: None, + input_select_left: None, + input_select_right: None, + input_select_up: None, + input_select_down: None, + input_line_home: None, + input_line_end: None, + input_select_line_home: None, + input_select_line_end: None, + input_visual_line_home: None, + input_visual_line_end: None, + input_select_visual_line_home: None, + input_select_visual_line_end: None, + input_buffer_home: None, + input_buffer_end: None, + input_select_buffer_home: None, + input_select_buffer_end: None, + input_delete_line: None, + input_delete_to_line_end: None, + input_delete_to_line_start: None, + input_backspace: None, + input_delete: None, + input_undo: None, + input_redo: None, + input_word_forward: None, + input_word_backward: None, + input_select_word_forward: None, + input_select_word_backward: None, + input_delete_word_forward: None, + input_delete_word_backward: None, + history_previous: None, + history_next: None, + session_child_cycle: None, + session_child_cycle_reverse: None, + session_parent: None, + terminal_suspend: None, + terminal_title_toggle: None, + tips_toggle: None, + } + } +} + diff --git a/crates/opencode-client/src/models/layout_config.rs b/crates/opencode-client/src/models/layout_config.rs new file mode 100644 index 0000000..eb80109 --- /dev/null +++ b/crates/opencode-client/src/models/layout_config.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// LayoutConfig : @deprecated Always uses stretch layout. +/// @deprecated Always uses stretch layout. +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum LayoutConfig { + #[serde(rename = "auto")] + Auto, + #[serde(rename = "stretch")] + Stretch, + +} + +impl std::fmt::Display for LayoutConfig { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + match self { + Self::Auto => write!(f, "auto"), + Self::Stretch => write!(f, "stretch"), + } + } +} + +impl Default for LayoutConfig { + fn default() -> LayoutConfig { + Self::Auto + } +} + diff --git a/crates/opencode-client/src/models/log_level.rs b/crates/opencode-client/src/models/log_level.rs new file mode 100644 index 0000000..77d7129 --- /dev/null +++ b/crates/opencode-client/src/models/log_level.rs @@ -0,0 +1,45 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// LogLevel : Log level +/// Log level +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum LogLevel { + #[serde(rename = "DEBUG")] + Debug, + #[serde(rename = "INFO")] + Info, + #[serde(rename = "WARN")] + Warn, + #[serde(rename = "ERROR")] + Error, + +} + +impl std::fmt::Display for LogLevel { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + match self { + Self::Debug => write!(f, "DEBUG"), + Self::Info => write!(f, "INFO"), + Self::Warn => write!(f, "WARN"), + Self::Error => write!(f, "ERROR"), + } + } +} + +impl Default for LogLevel { + fn default() -> LogLevel { + Self::Debug + } +} + diff --git a/crates/opencode-client/src/models/lsp_status.rs b/crates/opencode-client/src/models/lsp_status.rs new file mode 100644 index 0000000..e940227 --- /dev/null +++ b/crates/opencode-client/src/models/lsp_status.rs @@ -0,0 +1,50 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct LspStatus { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "root")] + pub root: String, + #[serde(rename = "status")] + pub status: Status, +} + +impl LspStatus { + pub fn new(id: String, name: String, root: String, status: Status) -> LspStatus { + LspStatus { + id, + name, + root, + status, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "connected")] + Connected, + #[serde(rename = "error")] + Error, +} + +impl Default for Status { + fn default() -> Status { + Self::Connected + } +} + diff --git a/crates/opencode-client/src/models/mcp_add_request.rs b/crates/opencode-client/src/models/mcp_add_request.rs new file mode 100644 index 0000000..832c79a --- /dev/null +++ b/crates/opencode-client/src/models/mcp_add_request.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpAddRequest { + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "config")] + pub config: Box, +} + +impl McpAddRequest { + pub fn new(name: String, config: models::McpAddRequestConfig) -> McpAddRequest { + McpAddRequest { + name, + config: Box::new(config), + } + } +} + diff --git a/crates/opencode-client/src/models/mcp_add_request_config.rs b/crates/opencode-client/src/models/mcp_add_request_config.rs new file mode 100644 index 0000000..fdd8ead --- /dev/null +++ b/crates/opencode-client/src/models/mcp_add_request_config.rs @@ -0,0 +1,83 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpAddRequestConfig { + /// Type of MCP server connection + #[serde(rename = "type")] + pub r#type: Type, + /// Command and arguments to run the MCP server + #[serde(rename = "command")] + pub command: Vec, + /// Environment variables to set when running the MCP server + #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] + pub environment: Option>, + /// Enable or disable the MCP server on startup + #[serde(rename = "enabled", skip_serializing_if = "Option::is_none")] + pub enabled: Option, + /// Timeout in ms for fetching tools from the MCP server. Defaults to 5000 (5 seconds) if not specified. + #[serde(rename = "timeout", skip_serializing_if = "Option::is_none")] + pub timeout: Option, + /// URL of the remote MCP server (only for remote type) + #[serde(rename = "url", skip_serializing_if = "Option::is_none")] + pub url: Option, + /// Headers to send with the request + #[serde(rename = "headers", skip_serializing_if = "Option::is_none")] + pub headers: Option>, + #[serde(rename = "oauth", skip_serializing_if = "Option::is_none")] + pub oauth: Option>, +} + +impl McpAddRequestConfig { + pub fn new(r#type: Type, command: Vec, url: Option) -> McpAddRequestConfig { + McpAddRequestConfig { + r#type, + command, + environment: None, + enabled: None, + timeout: None, + url, + headers: None, + oauth: None, + } + } + + /// Create a new local MCP config (no URL required) + pub fn local(command: Vec) -> McpAddRequestConfig { + McpAddRequestConfig { + r#type: Type::Local, + command, + environment: None, + enabled: None, + timeout: None, + url: None, + headers: None, + oauth: None, + } + } +} +/// Type of MCP server connection +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "local")] + Local, + #[serde(rename = "remote")] + Remote, +} + +impl Default for Type { + fn default() -> Type { + Self::Local + } +} + diff --git a/crates/opencode-client/src/models/mcp_auth_callback_request.rs b/crates/opencode-client/src/models/mcp_auth_callback_request.rs new file mode 100644 index 0000000..694cad1 --- /dev/null +++ b/crates/opencode-client/src/models/mcp_auth_callback_request.rs @@ -0,0 +1,28 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpAuthCallbackRequest { + /// Authorization code from OAuth callback + #[serde(rename = "code")] + pub code: String, +} + +impl McpAuthCallbackRequest { + pub fn new(code: String) -> McpAuthCallbackRequest { + McpAuthCallbackRequest { + code, + } + } +} + diff --git a/crates/opencode-client/src/models/mcp_auth_remove_200_response.rs b/crates/opencode-client/src/models/mcp_auth_remove_200_response.rs new file mode 100644 index 0000000..6b902ce --- /dev/null +++ b/crates/opencode-client/src/models/mcp_auth_remove_200_response.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpAuthRemove200Response { + #[serde(rename = "success")] + pub success: Success, +} + +impl McpAuthRemove200Response { + pub fn new(success: Success) -> McpAuthRemove200Response { + McpAuthRemove200Response { + success, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Success { + #[serde(rename = "true")] + True, +} + +impl Default for Success { + fn default() -> Success { + Self::True + } +} + diff --git a/crates/opencode-client/src/models/mcp_auth_start_200_response.rs b/crates/opencode-client/src/models/mcp_auth_start_200_response.rs new file mode 100644 index 0000000..d2360d2 --- /dev/null +++ b/crates/opencode-client/src/models/mcp_auth_start_200_response.rs @@ -0,0 +1,28 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpAuthStart200Response { + /// URL to open in browser for authorization + #[serde(rename = "authorizationUrl")] + pub authorization_url: String, +} + +impl McpAuthStart200Response { + pub fn new(authorization_url: String) -> McpAuthStart200Response { + McpAuthStart200Response { + authorization_url, + } + } +} + diff --git a/crates/opencode-client/src/models/mcp_local_config.rs b/crates/opencode-client/src/models/mcp_local_config.rs new file mode 100644 index 0000000..2315283 --- /dev/null +++ b/crates/opencode-client/src/models/mcp_local_config.rs @@ -0,0 +1,56 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpLocalConfig { + /// Type of MCP server connection + #[serde(rename = "type")] + pub r#type: Type, + /// Command and arguments to run the MCP server + #[serde(rename = "command")] + pub command: Vec, + /// Environment variables to set when running the MCP server + #[serde(rename = "environment", skip_serializing_if = "Option::is_none")] + pub environment: Option>, + /// Enable or disable the MCP server on startup + #[serde(rename = "enabled", skip_serializing_if = "Option::is_none")] + pub enabled: Option, + /// Timeout in ms for fetching tools from the MCP server. Defaults to 5000 (5 seconds) if not specified. + #[serde(rename = "timeout", skip_serializing_if = "Option::is_none")] + pub timeout: Option, +} + +impl McpLocalConfig { + pub fn new(r#type: Type, command: Vec) -> McpLocalConfig { + McpLocalConfig { + r#type, + command, + environment: None, + enabled: None, + timeout: None, + } + } +} +/// Type of MCP server connection +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "local")] + Local, +} + +impl Default for Type { + fn default() -> Type { + Self::Local + } +} + diff --git a/crates/opencode-client/src/models/mcp_o_auth_config.rs b/crates/opencode-client/src/models/mcp_o_auth_config.rs new file mode 100644 index 0000000..fdb139a --- /dev/null +++ b/crates/opencode-client/src/models/mcp_o_auth_config.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpOAuthConfig { + /// OAuth client ID. If not provided, dynamic client registration (RFC 7591) will be attempted. + #[serde(rename = "clientId", skip_serializing_if = "Option::is_none")] + pub client_id: Option, + /// OAuth client secret (if required by the authorization server) + #[serde(rename = "clientSecret", skip_serializing_if = "Option::is_none")] + pub client_secret: Option, + /// OAuth scopes to request during authorization + #[serde(rename = "scope", skip_serializing_if = "Option::is_none")] + pub scope: Option, +} + +impl McpOAuthConfig { + pub fn new() -> McpOAuthConfig { + McpOAuthConfig { + client_id: None, + client_secret: None, + scope: None, + } + } +} + diff --git a/crates/opencode-client/src/models/mcp_remote_config.rs b/crates/opencode-client/src/models/mcp_remote_config.rs new file mode 100644 index 0000000..8c01b8a --- /dev/null +++ b/crates/opencode-client/src/models/mcp_remote_config.rs @@ -0,0 +1,59 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpRemoteConfig { + /// Type of MCP server connection + #[serde(rename = "type")] + pub r#type: Type, + /// URL of the remote MCP server + #[serde(rename = "url")] + pub url: String, + /// Enable or disable the MCP server on startup + #[serde(rename = "enabled", skip_serializing_if = "Option::is_none")] + pub enabled: Option, + /// Headers to send with the request + #[serde(rename = "headers", skip_serializing_if = "Option::is_none")] + pub headers: Option>, + #[serde(rename = "oauth", skip_serializing_if = "Option::is_none")] + pub oauth: Option>, + /// Timeout in ms for fetching tools from the MCP server. Defaults to 5000 (5 seconds) if not specified. + #[serde(rename = "timeout", skip_serializing_if = "Option::is_none")] + pub timeout: Option, +} + +impl McpRemoteConfig { + pub fn new(r#type: Type, url: String) -> McpRemoteConfig { + McpRemoteConfig { + r#type, + url, + enabled: None, + headers: None, + oauth: None, + timeout: None, + } + } +} +/// Type of MCP server connection +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "remote")] + Remote, +} + +impl Default for Type { + fn default() -> Type { + Self::Remote + } +} + diff --git a/crates/opencode-client/src/models/mcp_remote_config_oauth.rs b/crates/opencode-client/src/models/mcp_remote_config_oauth.rs new file mode 100644 index 0000000..46bcae2 --- /dev/null +++ b/crates/opencode-client/src/models/mcp_remote_config_oauth.rs @@ -0,0 +1,38 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// McpRemoteConfigOauth : OAuth authentication configuration for the MCP server. Set to false to disable OAuth auto-detection. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpRemoteConfigOauth { + /// OAuth client ID. If not provided, dynamic client registration (RFC 7591) will be attempted. + #[serde(rename = "clientId", skip_serializing_if = "Option::is_none")] + pub client_id: Option, + /// OAuth client secret (if required by the authorization server) + #[serde(rename = "clientSecret", skip_serializing_if = "Option::is_none")] + pub client_secret: Option, + /// OAuth scopes to request during authorization + #[serde(rename = "scope", skip_serializing_if = "Option::is_none")] + pub scope: Option, +} + +impl McpRemoteConfigOauth { + /// OAuth authentication configuration for the MCP server. Set to false to disable OAuth auto-detection. + pub fn new() -> McpRemoteConfigOauth { + McpRemoteConfigOauth { + client_id: None, + client_secret: None, + scope: None, + } + } +} + diff --git a/crates/opencode-client/src/models/mcp_status.rs b/crates/opencode-client/src/models/mcp_status.rs new file mode 100644 index 0000000..5a1a72f --- /dev/null +++ b/crates/opencode-client/src/models/mcp_status.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpStatus { + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "error", default, skip_serializing_if = "Option::is_none")] + pub error: Option, +} + +impl McpStatus { + pub fn new(status: Status) -> McpStatus { + McpStatus { + status, + error: None, + } + } +} + +/// MCP server connection status +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "connected")] + Connected, + #[serde(rename = "disabled")] + Disabled, + #[serde(rename = "failed")] + Failed, + #[serde(rename = "needs_auth")] + NeedsAuth, + #[serde(rename = "needs_client_registration")] + NeedsClientRegistration, +} + +impl Default for Status { + fn default() -> Status { + Self::Connected + } +} + diff --git a/crates/opencode-client/src/models/mcp_status_connected.rs b/crates/opencode-client/src/models/mcp_status_connected.rs new file mode 100644 index 0000000..15b1003 --- /dev/null +++ b/crates/opencode-client/src/models/mcp_status_connected.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpStatusConnected { + #[serde(rename = "status")] + pub status: Status, +} + +impl McpStatusConnected { + pub fn new(status: Status) -> McpStatusConnected { + McpStatusConnected { + status, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "connected")] + Connected, +} + +impl Default for Status { + fn default() -> Status { + Self::Connected + } +} + diff --git a/crates/opencode-client/src/models/mcp_status_disabled.rs b/crates/opencode-client/src/models/mcp_status_disabled.rs new file mode 100644 index 0000000..404ca91 --- /dev/null +++ b/crates/opencode-client/src/models/mcp_status_disabled.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpStatusDisabled { + #[serde(rename = "status")] + pub status: Status, +} + +impl McpStatusDisabled { + pub fn new(status: Status) -> McpStatusDisabled { + McpStatusDisabled { + status, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "disabled")] + Disabled, +} + +impl Default for Status { + fn default() -> Status { + Self::Disabled + } +} + diff --git a/crates/opencode-client/src/models/mcp_status_failed.rs b/crates/opencode-client/src/models/mcp_status_failed.rs new file mode 100644 index 0000000..b177d5f --- /dev/null +++ b/crates/opencode-client/src/models/mcp_status_failed.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpStatusFailed { + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "error")] + pub error: String, +} + +impl McpStatusFailed { + pub fn new(status: Status, error: String) -> McpStatusFailed { + McpStatusFailed { + status, + error, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "failed")] + Failed, +} + +impl Default for Status { + fn default() -> Status { + Self::Failed + } +} + diff --git a/crates/opencode-client/src/models/mcp_status_needs_auth.rs b/crates/opencode-client/src/models/mcp_status_needs_auth.rs new file mode 100644 index 0000000..422b91a --- /dev/null +++ b/crates/opencode-client/src/models/mcp_status_needs_auth.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpStatusNeedsAuth { + #[serde(rename = "status")] + pub status: Status, +} + +impl McpStatusNeedsAuth { + pub fn new(status: Status) -> McpStatusNeedsAuth { + McpStatusNeedsAuth { + status, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "needs_auth")] + NeedsAuth, +} + +impl Default for Status { + fn default() -> Status { + Self::NeedsAuth + } +} + diff --git a/crates/opencode-client/src/models/mcp_status_needs_client_registration.rs b/crates/opencode-client/src/models/mcp_status_needs_client_registration.rs new file mode 100644 index 0000000..7de56b9 --- /dev/null +++ b/crates/opencode-client/src/models/mcp_status_needs_client_registration.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct McpStatusNeedsClientRegistration { + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "error")] + pub error: String, +} + +impl McpStatusNeedsClientRegistration { + pub fn new(status: Status, error: String) -> McpStatusNeedsClientRegistration { + McpStatusNeedsClientRegistration { + status, + error, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "needs_client_registration")] + NeedsClientRegistration, +} + +impl Default for Status { + fn default() -> Status { + Self::NeedsClientRegistration + } +} + diff --git a/crates/opencode-client/src/models/message.rs b/crates/opencode-client/src/models/message.rs new file mode 100644 index 0000000..da8b7b7 --- /dev/null +++ b/crates/opencode-client/src/models/message.rs @@ -0,0 +1,91 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Message { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "role")] + pub role: Role, + #[serde(rename = "time", default, skip_serializing_if = "Option::is_none")] + pub time: Option>, + // UserMessage fields + #[serde(rename = "summary", default, skip_serializing_if = "Option::is_none")] + pub summary: Option, + #[serde(rename = "agent", default, skip_serializing_if = "Option::is_none")] + pub agent: Option, + #[serde(rename = "model", default, skip_serializing_if = "Option::is_none")] + pub model: Option>, + #[serde(rename = "system", default, skip_serializing_if = "Option::is_none")] + pub system: Option, + #[serde(rename = "tools", default, skip_serializing_if = "Option::is_none")] + pub tools: Option>, + #[serde(rename = "variant", default, skip_serializing_if = "Option::is_none")] + pub variant: Option, + // AssistantMessage fields + #[serde(rename = "error", default, skip_serializing_if = "Option::is_none")] + pub error: Option>, + #[serde(rename = "parentID", default, skip_serializing_if = "Option::is_none")] + pub parent_id: Option, + #[serde(rename = "modelID", default, skip_serializing_if = "Option::is_none")] + pub model_id: Option, + #[serde(rename = "providerID", default, skip_serializing_if = "Option::is_none")] + pub provider_id: Option, + #[serde(rename = "mode", default, skip_serializing_if = "Option::is_none")] + pub mode: Option, + #[serde(rename = "path", default, skip_serializing_if = "Option::is_none")] + pub path: Option>, + #[serde(rename = "cost", default, skip_serializing_if = "Option::is_none")] + pub cost: Option, + #[serde(rename = "tokens", default, skip_serializing_if = "Option::is_none")] + pub tokens: Option>, + #[serde(rename = "finish", default, skip_serializing_if = "Option::is_none")] + pub finish: Option, +} + +impl Message { + pub fn new(id: String, session_id: String, role: Role) -> Message { + Message { + id, + session_id, + role, + time: None, + summary: None, + agent: None, + model: None, + system: None, + tools: None, + variant: None, + error: None, + parent_id: None, + model_id: None, + provider_id: None, + mode: None, + path: None, + cost: None, + tokens: None, + finish: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize, Default)] +pub enum Role { + #[default] + #[serde(rename = "user")] + User, + #[serde(rename = "assistant")] + Assistant, +} diff --git a/crates/opencode-client/src/models/message_aborted_error.rs b/crates/opencode-client/src/models/message_aborted_error.rs new file mode 100644 index 0000000..20d1b72 --- /dev/null +++ b/crates/opencode-client/src/models/message_aborted_error.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct MessageAbortedError { + #[serde(rename = "name")] + pub name: Name, + #[serde(rename = "data")] + pub data: Box, +} + +impl MessageAbortedError { + pub fn new(name: Name, data: models::UnknownErrorData) -> MessageAbortedError { + MessageAbortedError { + name, + data: Box::new(data), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Name { + #[serde(rename = "MessageAbortedError")] + MessageAbortedError, +} + +impl Default for Name { + fn default() -> Name { + Self::MessageAbortedError + } +} + diff --git a/crates/opencode-client/src/models/message_output_length_error.rs b/crates/opencode-client/src/models/message_output_length_error.rs new file mode 100644 index 0000000..82ea07a --- /dev/null +++ b/crates/opencode-client/src/models/message_output_length_error.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct MessageOutputLengthError { + #[serde(rename = "name")] + pub name: Name, + #[serde(rename = "data")] + pub data: serde_json::Value, +} + +impl MessageOutputLengthError { + pub fn new(name: Name, data: serde_json::Value) -> MessageOutputLengthError { + MessageOutputLengthError { + name, + data, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Name { + #[serde(rename = "MessageOutputLengthError")] + MessageOutputLengthError, +} + +impl Default for Name { + fn default() -> Name { + Self::MessageOutputLengthError + } +} + diff --git a/crates/opencode-client/src/models/mod.rs b/crates/opencode-client/src/models/mod.rs new file mode 100644 index 0000000..8297184 --- /dev/null +++ b/crates/opencode-client/src/models/mod.rs @@ -0,0 +1,502 @@ +pub mod agent; +pub use self::agent::Agent; +pub mod agent_config; +pub use self::agent_config::AgentConfig; +pub mod agent_config_permission; +pub use self::agent_config_permission::AgentConfigPermission; +pub mod agent_config_permission_bash; +pub use self::agent_config_permission_bash::AgentConfigPermissionBash; +pub mod agent_part; +pub use self::agent_part::AgentPart; +pub mod agent_part_input; +pub use self::agent_part_input::AgentPartInput; +pub mod agent_part_source; +pub use self::agent_part_source::AgentPartSource; +pub mod agent_permission; +pub use self::agent_permission::AgentPermission; +pub mod api_auth; +pub use self::api_auth::ApiAuth; +pub mod api_error; +pub use self::api_error::ApiError; +pub mod api_error_data; +pub use self::api_error_data::ApiErrorData; +pub mod app_log_request; +pub use self::app_log_request::AppLogRequest; +pub mod assistant_message; +pub use self::assistant_message::AssistantMessage; +pub mod assistant_message_error; +pub use self::assistant_message_error::AssistantMessageError; +pub mod assistant_message_path; +pub use self::assistant_message_path::AssistantMessagePath; +pub mod assistant_message_time; +pub use self::assistant_message_time::AssistantMessageTime; +pub mod assistant_message_tokens; +pub use self::assistant_message_tokens::AssistantMessageTokens; +pub mod assistant_message_tokens_cache; +pub use self::assistant_message_tokens_cache::AssistantMessageTokensCache; +pub mod auth; +pub use self::auth::Auth; +pub mod bad_request_error; +pub use self::bad_request_error::BadRequestError; +pub mod command; +pub use self::command::Command; +pub mod command_template; +pub use self::command_template::CommandTemplate; +pub mod compaction_part; +pub use self::compaction_part::CompactionPart; +pub mod config; +pub use self::config::Config; +pub mod config_agent; +pub use self::config_agent::ConfigAgent; +pub mod config_autoupdate; +pub use self::config_autoupdate::ConfigAutoupdate; +pub mod config_command_value; +pub use self::config_command_value::ConfigCommandValue; +pub mod config_compaction; +pub use self::config_compaction::ConfigCompaction; +pub mod config_enterprise; +pub use self::config_enterprise::ConfigEnterprise; +pub mod config_experimental; +pub use self::config_experimental::ConfigExperimental; +pub mod config_experimental_hook; +pub use self::config_experimental_hook::ConfigExperimentalHook; +pub mod config_experimental_hook_file_edited_value_inner; +pub use self::config_experimental_hook_file_edited_value_inner::ConfigExperimentalHookFileEditedValueInner; +pub mod config_formatter; +pub use self::config_formatter::ConfigFormatter; +pub mod config_formatter_any_of_value; +pub use self::config_formatter_any_of_value::ConfigFormatterAnyOfValue; +pub mod config_lsp; +pub use self::config_lsp::ConfigLsp; +pub mod config_lsp_any_of_value; +pub use self::config_lsp_any_of_value::ConfigLspAnyOfValue; +pub mod config_lsp_any_of_value_any_of; +pub use self::config_lsp_any_of_value_any_of::ConfigLspAnyOfValueAnyOf; +pub mod config_lsp_any_of_value_any_of_1; +pub use self::config_lsp_any_of_value_any_of_1::ConfigLspAnyOfValueAnyOf1; +pub mod config_mode; +pub use self::config_mode::ConfigMode; +pub mod config_providers_200_response; +pub use self::config_providers_200_response::ConfigProviders200Response; +pub mod config_tui; +pub use self::config_tui::ConfigTui; +pub mod config_tui_scroll_acceleration; +pub use self::config_tui_scroll_acceleration::ConfigTuiScrollAcceleration; +pub mod config_watcher; +pub use self::config_watcher::ConfigWatcher; +pub mod event; +pub use self::event::Event; +pub mod event_command_executed; +pub use self::event_command_executed::EventCommandExecuted; +pub mod event_command_executed_properties; +pub use self::event_command_executed_properties::EventCommandExecutedProperties; +pub mod event_file_edited; +pub use self::event_file_edited::EventFileEdited; +pub mod event_file_edited_properties; +pub use self::event_file_edited_properties::EventFileEditedProperties; +pub mod event_file_watcher_updated; +pub use self::event_file_watcher_updated::EventFileWatcherUpdated; +pub mod event_file_watcher_updated_properties; +pub use self::event_file_watcher_updated_properties::EventFileWatcherUpdatedProperties; +pub mod event_global_disposed; +pub use self::event_global_disposed::EventGlobalDisposed; +pub mod event_installation_update_available; +pub use self::event_installation_update_available::EventInstallationUpdateAvailable; +pub mod event_installation_updated; +pub use self::event_installation_updated::EventInstallationUpdated; +pub mod event_installation_updated_properties; +pub use self::event_installation_updated_properties::EventInstallationUpdatedProperties; +pub mod event_lsp_client_diagnostics; +pub use self::event_lsp_client_diagnostics::EventLspClientDiagnostics; +pub mod event_lsp_client_diagnostics_properties; +pub use self::event_lsp_client_diagnostics_properties::EventLspClientDiagnosticsProperties; +pub mod event_lsp_updated; +pub use self::event_lsp_updated::EventLspUpdated; +pub mod event_mcp_tools_changed; +pub use self::event_mcp_tools_changed::EventMcpToolsChanged; +pub mod event_mcp_tools_changed_properties; +pub use self::event_mcp_tools_changed_properties::EventMcpToolsChangedProperties; +pub mod event_message_part_removed; +pub use self::event_message_part_removed::EventMessagePartRemoved; +pub mod event_message_part_removed_properties; +pub use self::event_message_part_removed_properties::EventMessagePartRemovedProperties; +pub mod event_message_part_updated; +pub use self::event_message_part_updated::EventMessagePartUpdated; +pub mod event_message_part_updated_properties; +pub use self::event_message_part_updated_properties::EventMessagePartUpdatedProperties; +pub mod event_message_removed; +pub use self::event_message_removed::EventMessageRemoved; +pub mod event_message_removed_properties; +pub use self::event_message_removed_properties::EventMessageRemovedProperties; +pub mod event_message_updated; +pub use self::event_message_updated::EventMessageUpdated; +pub mod event_message_updated_properties; +pub use self::event_message_updated_properties::EventMessageUpdatedProperties; +pub mod event_permission_replied; +pub use self::event_permission_replied::EventPermissionReplied; +pub mod event_permission_replied_properties; +pub use self::event_permission_replied_properties::EventPermissionRepliedProperties; +pub mod event_permission_updated; +pub use self::event_permission_updated::EventPermissionUpdated; +pub mod event_project_updated; +pub use self::event_project_updated::EventProjectUpdated; +pub mod event_pty_created; +pub use self::event_pty_created::EventPtyCreated; +pub mod event_pty_created_properties; +pub use self::event_pty_created_properties::EventPtyCreatedProperties; +pub mod event_pty_deleted; +pub use self::event_pty_deleted::EventPtyDeleted; +pub mod event_pty_deleted_properties; +pub use self::event_pty_deleted_properties::EventPtyDeletedProperties; +pub mod event_pty_exited; +pub use self::event_pty_exited::EventPtyExited; +pub mod event_pty_exited_properties; +pub use self::event_pty_exited_properties::EventPtyExitedProperties; +pub mod event_pty_updated; +pub use self::event_pty_updated::EventPtyUpdated; +pub mod event_server_connected; +pub use self::event_server_connected::EventServerConnected; +pub mod event_server_instance_disposed; +pub use self::event_server_instance_disposed::EventServerInstanceDisposed; +pub mod event_server_instance_disposed_properties; +pub use self::event_server_instance_disposed_properties::EventServerInstanceDisposedProperties; +pub mod event_session_compacted; +pub use self::event_session_compacted::EventSessionCompacted; +pub mod event_session_created; +pub use self::event_session_created::EventSessionCreated; +pub mod event_session_created_properties; +pub use self::event_session_created_properties::EventSessionCreatedProperties; +pub mod event_session_deleted; +pub use self::event_session_deleted::EventSessionDeleted; +pub mod event_session_diff; +pub use self::event_session_diff::EventSessionDiff; +pub mod event_session_diff_properties; +pub use self::event_session_diff_properties::EventSessionDiffProperties; +pub mod event_session_error; +pub use self::event_session_error::EventSessionError; +pub mod event_session_error_properties; +pub use self::event_session_error_properties::EventSessionErrorProperties; +pub mod event_session_idle; +pub use self::event_session_idle::EventSessionIdle; +pub mod event_session_idle_properties; +pub use self::event_session_idle_properties::EventSessionIdleProperties; +pub mod event_session_status; +pub use self::event_session_status::EventSessionStatus; +pub mod event_session_status_properties; +pub use self::event_session_status_properties::EventSessionStatusProperties; +pub mod event_session_updated; +pub use self::event_session_updated::EventSessionUpdated; +pub mod event_todo_updated; +pub use self::event_todo_updated::EventTodoUpdated; +pub mod event_todo_updated_properties; +pub use self::event_todo_updated_properties::EventTodoUpdatedProperties; +pub mod event_tui_command_execute; +pub use self::event_tui_command_execute::EventTuiCommandExecute; +pub mod event_tui_command_execute_properties; +pub use self::event_tui_command_execute_properties::EventTuiCommandExecuteProperties; +pub mod event_tui_command_execute_properties_command; +pub use self::event_tui_command_execute_properties_command::EventTuiCommandExecutePropertiesCommand; +pub mod event_tui_prompt_append; +pub use self::event_tui_prompt_append::EventTuiPromptAppend; +pub mod event_tui_toast_show; +pub use self::event_tui_toast_show::EventTuiToastShow; +pub mod event_vcs_branch_updated; +pub use self::event_vcs_branch_updated::EventVcsBranchUpdated; +pub mod event_vcs_branch_updated_properties; +pub use self::event_vcs_branch_updated_properties::EventVcsBranchUpdatedProperties; +pub mod file; +pub use self::file::File; +pub mod file_content; +pub use self::file_content::FileContent; +pub mod file_content_patch; +pub use self::file_content_patch::FileContentPatch; +pub mod file_content_patch_hunks_inner; +pub use self::file_content_patch_hunks_inner::FileContentPatchHunksInner; +pub mod file_diff; +pub use self::file_diff::FileDiff; +pub mod file_node; +pub use self::file_node::FileNode; +pub mod file_part; +pub use self::file_part::FilePart; +pub mod file_part_input; +pub use self::file_part_input::FilePartInput; +pub mod file_part_source; +pub use self::file_part_source::FilePartSource; +pub mod file_part_source_text; +pub use self::file_part_source_text::FilePartSourceText; +pub mod file_source; +pub use self::file_source::FileSource; +pub mod find_text_200_response_inner; +pub use self::find_text_200_response_inner::FindText200ResponseInner; +pub mod find_text_200_response_inner_path; +pub use self::find_text_200_response_inner_path::FindText200ResponseInnerPath; +pub mod find_text_200_response_inner_submatches_inner; +pub use self::find_text_200_response_inner_submatches_inner::FindText200ResponseInnerSubmatchesInner; +pub mod formatter_status; +pub use self::formatter_status::FormatterStatus; +pub mod global_event; +pub use self::global_event::GlobalEvent; +pub mod global_health_200_response; +pub use self::global_health_200_response::GlobalHealth200Response; +pub mod keybinds_config; +pub use self::keybinds_config::KeybindsConfig; +pub mod layout_config; +pub use self::layout_config::LayoutConfig; +pub mod log_level; +pub use self::log_level::LogLevel; +pub mod lsp_status; +pub use self::lsp_status::LspStatus; +pub mod mcp_add_request; +pub use self::mcp_add_request::McpAddRequest; +pub mod mcp_add_request_config; +pub use self::mcp_add_request_config::McpAddRequestConfig; +pub mod mcp_auth_callback_request; +pub use self::mcp_auth_callback_request::McpAuthCallbackRequest; +pub mod mcp_auth_remove_200_response; +pub use self::mcp_auth_remove_200_response::McpAuthRemove200Response; +pub mod mcp_auth_start_200_response; +pub use self::mcp_auth_start_200_response::McpAuthStart200Response; +pub mod mcp_local_config; +pub use self::mcp_local_config::McpLocalConfig; +pub mod mcp_o_auth_config; +pub use self::mcp_o_auth_config::McpOAuthConfig; +pub mod mcp_remote_config; +pub use self::mcp_remote_config::McpRemoteConfig; +pub mod mcp_remote_config_oauth; +pub use self::mcp_remote_config_oauth::McpRemoteConfigOauth; +pub mod mcp_status; +pub use self::mcp_status::McpStatus; +pub mod mcp_status_connected; +pub use self::mcp_status_connected::McpStatusConnected; +pub mod mcp_status_disabled; +pub use self::mcp_status_disabled::McpStatusDisabled; +pub mod mcp_status_failed; +pub use self::mcp_status_failed::McpStatusFailed; +pub mod mcp_status_needs_auth; +pub use self::mcp_status_needs_auth::McpStatusNeedsAuth; +pub mod mcp_status_needs_client_registration; +pub use self::mcp_status_needs_client_registration::McpStatusNeedsClientRegistration; +pub mod message; +pub use self::message::Message; +pub mod message_aborted_error; +pub use self::message_aborted_error::MessageAbortedError; +pub mod message_output_length_error; +pub use self::message_output_length_error::MessageOutputLengthError; +pub mod model; +pub use self::model::Model; +pub mod model_api; +pub use self::model_api::ModelApi; +pub mod model_capabilities; +pub use self::model_capabilities::ModelCapabilities; +pub mod model_capabilities_input; +pub use self::model_capabilities_input::ModelCapabilitiesInput; +pub mod model_capabilities_interleaved; +pub use self::model_capabilities_interleaved::ModelCapabilitiesInterleaved; +pub mod model_capabilities_interleaved_any_of; +pub use self::model_capabilities_interleaved_any_of::ModelCapabilitiesInterleavedAnyOf; +pub mod model_cost; +pub use self::model_cost::ModelCost; +pub mod model_cost_experimental_over200_k; +pub use self::model_cost_experimental_over200_k::ModelCostExperimentalOver200K; +pub mod not_found_error; +pub use self::not_found_error::NotFoundError; +pub mod o_auth; +pub use self::o_auth::OAuth; +pub mod part; +pub use self::part::Part; +pub mod part_any_of; +pub use self::part_any_of::PartAnyOf; +pub mod patch_part; +pub use self::patch_part::PatchPart; +pub mod path; +pub use self::path::Path; +pub mod permission; +pub use self::permission::Permission; +pub mod permission_pattern; +pub use self::permission_pattern::PermissionPattern; +pub mod permission_respond_request; +pub use self::permission_respond_request::PermissionRespondRequest; +pub mod project; +pub use self::project::Project; +pub mod project_time; +pub use self::project_time::ProjectTime; +pub mod project_update_request; +pub use self::project_update_request::ProjectUpdateRequest; +pub mod project_update_request_icon; +pub use self::project_update_request_icon::ProjectUpdateRequestIcon; +pub mod provider; +pub use self::provider::Provider; +pub mod provider_auth_authorization; +pub use self::provider_auth_authorization::ProviderAuthAuthorization; +pub mod provider_auth_error; +pub use self::provider_auth_error::ProviderAuthError; +pub mod provider_auth_error_data; +pub use self::provider_auth_error_data::ProviderAuthErrorData; +pub mod provider_auth_method; +pub use self::provider_auth_method::ProviderAuthMethod; +pub mod provider_config; +pub use self::provider_config::ProviderConfig; +pub mod provider_config_models_value; +pub use self::provider_config_models_value::ProviderConfigModelsValue; +pub mod provider_config_models_value_interleaved; +pub use self::provider_config_models_value_interleaved::ProviderConfigModelsValueInterleaved; +pub mod provider_config_models_value_interleaved_any_of; +pub use self::provider_config_models_value_interleaved_any_of::ProviderConfigModelsValueInterleavedAnyOf; +pub mod provider_config_models_value_variants_value; +pub use self::provider_config_models_value_variants_value::ProviderConfigModelsValueVariantsValue; +pub mod provider_config_options; +pub use self::provider_config_options::ProviderConfigOptions; +pub mod provider_config_options_timeout; +pub use self::provider_config_options_timeout::ProviderConfigOptionsTimeout; +pub mod provider_list_200_response; +pub use self::provider_list_200_response::ProviderList200Response; +pub mod provider_list_200_response_all_inner; +pub use self::provider_list_200_response_all_inner::ProviderList200ResponseAllInner; +pub mod provider_list_200_response_all_inner_models_value; +pub use self::provider_list_200_response_all_inner_models_value::ProviderList200ResponseAllInnerModelsValue; +pub mod provider_list_200_response_all_inner_models_value_cost; +pub use self::provider_list_200_response_all_inner_models_value_cost::ProviderList200ResponseAllInnerModelsValueCost; +pub mod provider_list_200_response_all_inner_models_value_cost_context_over_200k; +pub use self::provider_list_200_response_all_inner_models_value_cost_context_over_200k::ProviderList200ResponseAllInnerModelsValueCostContextOver200k; +pub mod provider_list_200_response_all_inner_models_value_interleaved; +pub use self::provider_list_200_response_all_inner_models_value_interleaved::ProviderList200ResponseAllInnerModelsValueInterleaved; +pub mod provider_list_200_response_all_inner_models_value_interleaved_any_of; +pub use self::provider_list_200_response_all_inner_models_value_interleaved_any_of::ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf; +pub mod provider_list_200_response_all_inner_models_value_limit; +pub use self::provider_list_200_response_all_inner_models_value_limit::ProviderList200ResponseAllInnerModelsValueLimit; +pub mod provider_list_200_response_all_inner_models_value_modalities; +pub use self::provider_list_200_response_all_inner_models_value_modalities::ProviderList200ResponseAllInnerModelsValueModalities; +pub mod provider_list_200_response_all_inner_models_value_provider; +pub use self::provider_list_200_response_all_inner_models_value_provider::ProviderList200ResponseAllInnerModelsValueProvider; +pub mod provider_oauth_authorize_request; +pub use self::provider_oauth_authorize_request::ProviderOauthAuthorizeRequest; +pub mod provider_oauth_callback_request; +pub use self::provider_oauth_callback_request::ProviderOauthCallbackRequest; +pub mod pty; +pub use self::pty::Pty; +pub mod pty_create_request; +pub use self::pty_create_request::PtyCreateRequest; +pub mod pty_update_request; +pub use self::pty_update_request::PtyUpdateRequest; +pub mod pty_update_request_size; +pub use self::pty_update_request_size::PtyUpdateRequestSize; +pub mod range; +pub use self::range::Range; +pub mod range_start; +pub use self::range_start::RangeStart; +pub mod reasoning_part; +pub use self::reasoning_part::ReasoningPart; +pub mod retry_part; +pub use self::retry_part::RetryPart; +pub mod server_config; +pub use self::server_config::ServerConfig; +pub mod session; +pub use self::session::Session; +pub mod session_command_request; +pub use self::session_command_request::SessionCommandRequest; +pub mod session_create_request; +pub use self::session_create_request::SessionCreateRequest; +pub mod session_fork_request; +pub use self::session_fork_request::SessionForkRequest; +pub mod session_init_request; +pub use self::session_init_request::SessionInitRequest; +pub mod session_messages_200_response_inner; +pub use self::session_messages_200_response_inner::SessionMessages200ResponseInner; +pub mod session_prompt_200_response; +pub use self::session_prompt_200_response::SessionPrompt200Response; +pub mod session_prompt_request; +pub use self::session_prompt_request::SessionPromptRequest; +pub mod session_prompt_request_model; +pub use self::session_prompt_request_model::SessionPromptRequestModel; +pub mod session_prompt_request_parts_inner; +pub use self::session_prompt_request_parts_inner::SessionPromptRequestPartsInner; +pub mod session_revert; +pub use self::session_revert::SessionRevert; +pub mod session_revert_request; +pub use self::session_revert_request::SessionRevertRequest; +pub mod session_share; +pub use self::session_share::SessionShare; +pub mod session_shell_request; +pub use self::session_shell_request::SessionShellRequest; +pub mod session_status; +pub use self::session_status::SessionStatus; +pub mod session_status_any_of; +pub use self::session_status_any_of::SessionStatusAnyOf; +pub mod session_status_any_of_1; +pub use self::session_status_any_of_1::SessionStatusAnyOf1; +pub mod session_status_any_of_2; +pub use self::session_status_any_of_2::SessionStatusAnyOf2; +pub mod session_summarize_request; +pub use self::session_summarize_request::SessionSummarizeRequest; +pub mod session_summary; +pub use self::session_summary::SessionSummary; +pub mod session_time; +pub use self::session_time::SessionTime; +pub mod session_update_request; +pub use self::session_update_request::SessionUpdateRequest; +pub mod session_update_request_time; +pub use self::session_update_request_time::SessionUpdateRequestTime; +pub mod snapshot_part; +pub use self::snapshot_part::SnapshotPart; +pub mod step_finish_part; +pub use self::step_finish_part::StepFinishPart; +pub mod step_start_part; +pub use self::step_start_part::StepStartPart; +pub mod subtask_part_input; +pub use self::subtask_part_input::SubtaskPartInput; +pub mod symbol; +pub use self::symbol::Symbol; +pub mod symbol_location; +pub use self::symbol_location::SymbolLocation; +pub mod symbol_source; +pub use self::symbol_source::SymbolSource; +pub mod text_part; +pub use self::text_part::TextPart; +pub mod text_part_input; +pub use self::text_part_input::TextPartInput; +pub mod text_part_time; +pub use self::text_part_time::TextPartTime; +pub mod todo; +pub use self::todo::Todo; +pub mod tool_list_item; +pub use self::tool_list_item::ToolListItem; +pub mod tool_part; +pub use self::tool_part::ToolPart; +pub mod tool_state; +pub use self::tool_state::ToolState; +pub mod tool_state_completed; +pub use self::tool_state_completed::ToolStateCompleted; +pub mod tool_state_completed_time; +pub use self::tool_state_completed_time::ToolStateCompletedTime; +pub mod tool_state_error; +pub use self::tool_state_error::ToolStateError; +pub mod tool_state_error_time; +pub use self::tool_state_error_time::ToolStateErrorTime; +pub mod tool_state_pending; +pub use self::tool_state_pending::ToolStatePending; +pub mod tool_state_running; +pub use self::tool_state_running::ToolStateRunning; +pub mod tool_state_running_time; +pub use self::tool_state_running_time::ToolStateRunningTime; +pub mod tui_control_next_200_response; +pub use self::tui_control_next_200_response::TuiControlNext200Response; +pub mod tui_execute_command_request; +pub use self::tui_execute_command_request::TuiExecuteCommandRequest; +pub mod tui_publish_request; +pub use self::tui_publish_request::TuiPublishRequest; +pub mod tui_show_toast_request; +pub use self::tui_show_toast_request::TuiShowToastRequest; +pub mod unknown_error; +pub use self::unknown_error::UnknownError; +pub mod unknown_error_data; +pub use self::unknown_error_data::UnknownErrorData; +pub mod user_message; +pub use self::user_message::UserMessage; +pub mod user_message_summary; +pub use self::user_message_summary::UserMessageSummary; +pub mod user_message_time; +pub use self::user_message_time::UserMessageTime; +pub mod vcs_info; +pub use self::vcs_info::VcsInfo; +pub mod well_known_auth; +pub use self::well_known_auth::WellKnownAuth; diff --git a/crates/opencode-client/src/models/model.rs b/crates/opencode-client/src/models/model.rs new file mode 100644 index 0000000..45f5b50 --- /dev/null +++ b/crates/opencode-client/src/models/model.rs @@ -0,0 +1,81 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Model { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "providerID")] + pub provider_id: String, + #[serde(rename = "api")] + pub api: Box, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "family", skip_serializing_if = "Option::is_none")] + pub family: Option, + #[serde(rename = "capabilities")] + pub capabilities: Box, + #[serde(rename = "cost")] + pub cost: Box, + #[serde(rename = "limit")] + pub limit: Box, + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "options")] + pub options: std::collections::HashMap, + #[serde(rename = "headers")] + pub headers: std::collections::HashMap, + #[serde(rename = "release_date")] + pub release_date: String, + #[serde(rename = "variants", skip_serializing_if = "Option::is_none")] + pub variants: Option>>, +} + +impl Model { + pub fn new(id: String, provider_id: String, api: models::ModelApi, name: String, capabilities: models::ModelCapabilities, cost: models::ModelCost, limit: models::ProviderList200ResponseAllInnerModelsValueLimit, status: Status, options: std::collections::HashMap, headers: std::collections::HashMap, release_date: String) -> Model { + Model { + id, + provider_id, + api: Box::new(api), + name, + family: None, + capabilities: Box::new(capabilities), + cost: Box::new(cost), + limit: Box::new(limit), + status, + options, + headers, + release_date, + variants: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "alpha")] + Alpha, + #[serde(rename = "beta")] + Beta, + #[serde(rename = "deprecated")] + Deprecated, + #[serde(rename = "active")] + Active, +} + +impl Default for Status { + fn default() -> Status { + Self::Alpha + } +} + diff --git a/crates/opencode-client/src/models/model_api.rs b/crates/opencode-client/src/models/model_api.rs new file mode 100644 index 0000000..cca01fa --- /dev/null +++ b/crates/opencode-client/src/models/model_api.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ModelApi { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "url")] + pub url: String, + #[serde(rename = "npm")] + pub npm: String, +} + +impl ModelApi { + pub fn new(id: String, url: String, npm: String) -> ModelApi { + ModelApi { + id, + url, + npm, + } + } +} + diff --git a/crates/opencode-client/src/models/model_capabilities.rs b/crates/opencode-client/src/models/model_capabilities.rs new file mode 100644 index 0000000..9193cb2 --- /dev/null +++ b/crates/opencode-client/src/models/model_capabilities.rs @@ -0,0 +1,45 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ModelCapabilities { + #[serde(rename = "temperature")] + pub temperature: bool, + #[serde(rename = "reasoning")] + pub reasoning: bool, + #[serde(rename = "attachment")] + pub attachment: bool, + #[serde(rename = "toolcall")] + pub toolcall: bool, + #[serde(rename = "input")] + pub input: Box, + #[serde(rename = "output")] + pub output: Box, + #[serde(rename = "interleaved")] + pub interleaved: Box, +} + +impl ModelCapabilities { + pub fn new(temperature: bool, reasoning: bool, attachment: bool, toolcall: bool, input: models::ModelCapabilitiesInput, output: models::ModelCapabilitiesInput, interleaved: models::ModelCapabilitiesInterleaved) -> ModelCapabilities { + ModelCapabilities { + temperature, + reasoning, + attachment, + toolcall, + input: Box::new(input), + output: Box::new(output), + interleaved: Box::new(interleaved), + } + } +} + diff --git a/crates/opencode-client/src/models/model_capabilities_input.rs b/crates/opencode-client/src/models/model_capabilities_input.rs new file mode 100644 index 0000000..40f2800 --- /dev/null +++ b/crates/opencode-client/src/models/model_capabilities_input.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ModelCapabilitiesInput { + #[serde(rename = "text")] + pub text: bool, + #[serde(rename = "audio")] + pub audio: bool, + #[serde(rename = "image")] + pub image: bool, + #[serde(rename = "video")] + pub video: bool, + #[serde(rename = "pdf")] + pub pdf: bool, +} + +impl ModelCapabilitiesInput { + pub fn new(text: bool, audio: bool, image: bool, video: bool, pdf: bool) -> ModelCapabilitiesInput { + ModelCapabilitiesInput { + text, + audio, + image, + video, + pdf, + } + } +} + diff --git a/crates/opencode-client/src/models/model_capabilities_interleaved.rs b/crates/opencode-client/src/models/model_capabilities_interleaved.rs new file mode 100644 index 0000000..ddc8bd8 --- /dev/null +++ b/crates/opencode-client/src/models/model_capabilities_interleaved.rs @@ -0,0 +1,41 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ModelCapabilitiesInterleaved { + #[serde(rename = "field")] + pub field: Field, +} + +impl ModelCapabilitiesInterleaved { + pub fn new(field: Field) -> ModelCapabilitiesInterleaved { + ModelCapabilitiesInterleaved { + field, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Field { + #[serde(rename = "reasoning_content")] + ReasoningContent, + #[serde(rename = "reasoning_details")] + ReasoningDetails, +} + +impl Default for Field { + fn default() -> Field { + Self::ReasoningContent + } +} + diff --git a/crates/opencode-client/src/models/model_capabilities_interleaved_any_of.rs b/crates/opencode-client/src/models/model_capabilities_interleaved_any_of.rs new file mode 100644 index 0000000..a180e61 --- /dev/null +++ b/crates/opencode-client/src/models/model_capabilities_interleaved_any_of.rs @@ -0,0 +1,41 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ModelCapabilitiesInterleavedAnyOf { + #[serde(rename = "field")] + pub field: Field, +} + +impl ModelCapabilitiesInterleavedAnyOf { + pub fn new(field: Field) -> ModelCapabilitiesInterleavedAnyOf { + ModelCapabilitiesInterleavedAnyOf { + field, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Field { + #[serde(rename = "reasoning_content")] + ReasoningContent, + #[serde(rename = "reasoning_details")] + ReasoningDetails, +} + +impl Default for Field { + fn default() -> Field { + Self::ReasoningContent + } +} + diff --git a/crates/opencode-client/src/models/model_cost.rs b/crates/opencode-client/src/models/model_cost.rs new file mode 100644 index 0000000..dbeb9db --- /dev/null +++ b/crates/opencode-client/src/models/model_cost.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ModelCost { + #[serde(rename = "input")] + pub input: f64, + #[serde(rename = "output")] + pub output: f64, + #[serde(rename = "cache")] + pub cache: Box, + #[serde(rename = "experimentalOver200K", skip_serializing_if = "Option::is_none")] + pub experimental_over200_k: Option>, +} + +impl ModelCost { + pub fn new(input: f64, output: f64, cache: models::AssistantMessageTokensCache) -> ModelCost { + ModelCost { + input, + output, + cache: Box::new(cache), + experimental_over200_k: None, + } + } +} + diff --git a/crates/opencode-client/src/models/model_cost_experimental_over200_k.rs b/crates/opencode-client/src/models/model_cost_experimental_over200_k.rs new file mode 100644 index 0000000..3215715 --- /dev/null +++ b/crates/opencode-client/src/models/model_cost_experimental_over200_k.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ModelCostExperimentalOver200K { + #[serde(rename = "input")] + pub input: f64, + #[serde(rename = "output")] + pub output: f64, + #[serde(rename = "cache")] + pub cache: Box, +} + +impl ModelCostExperimentalOver200K { + pub fn new(input: f64, output: f64, cache: models::AssistantMessageTokensCache) -> ModelCostExperimentalOver200K { + ModelCostExperimentalOver200K { + input, + output, + cache: Box::new(cache), + } + } +} + diff --git a/crates/opencode-client/src/models/not_found_error.rs b/crates/opencode-client/src/models/not_found_error.rs new file mode 100644 index 0000000..3a3f4e5 --- /dev/null +++ b/crates/opencode-client/src/models/not_found_error.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct NotFoundError { + #[serde(rename = "name")] + pub name: Name, + #[serde(rename = "data")] + pub data: Box, +} + +impl NotFoundError { + pub fn new(name: Name, data: models::UnknownErrorData) -> NotFoundError { + NotFoundError { + name, + data: Box::new(data), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Name { + #[serde(rename = "NotFoundError")] + NotFoundError, +} + +impl Default for Name { + fn default() -> Name { + Self::NotFoundError + } +} + diff --git a/crates/opencode-client/src/models/o_auth.rs b/crates/opencode-client/src/models/o_auth.rs new file mode 100644 index 0000000..c1d4929 --- /dev/null +++ b/crates/opencode-client/src/models/o_auth.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct OAuth { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "refresh")] + pub refresh: String, + #[serde(rename = "access")] + pub access: String, + #[serde(rename = "expires")] + pub expires: f64, + #[serde(rename = "enterpriseUrl", skip_serializing_if = "Option::is_none")] + pub enterprise_url: Option, +} + +impl OAuth { + pub fn new(r#type: Type, refresh: String, access: String, expires: f64) -> OAuth { + OAuth { + r#type, + refresh, + access, + expires, + enterprise_url: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "oauth")] + Oauth, +} + +impl Default for Type { + fn default() -> Type { + Self::Oauth + } +} + diff --git a/crates/opencode-client/src/models/part.rs b/crates/opencode-client/src/models/part.rs new file mode 100644 index 0000000..1537d68 --- /dev/null +++ b/crates/opencode-client/src/models/part.rs @@ -0,0 +1,147 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Part { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "text", default, skip_serializing_if = "Option::is_none")] + pub text: Option, + #[serde(rename = "synthetic", default, skip_serializing_if = "Option::is_none")] + pub synthetic: Option, + #[serde(rename = "ignored", default, skip_serializing_if = "Option::is_none")] + pub ignored: Option, + #[serde(rename = "time", default, skip_serializing_if = "Option::is_none")] + pub time: Option>, + #[serde(rename = "metadata", default, skip_serializing_if = "Option::is_none")] + pub metadata: Option>, + #[serde(rename = "prompt", default, skip_serializing_if = "Option::is_none")] + pub prompt: Option, + #[serde(rename = "description", default, skip_serializing_if = "Option::is_none")] + pub description: Option, + #[serde(rename = "agent", default, skip_serializing_if = "Option::is_none")] + pub agent: Option, + #[serde(rename = "command", default, skip_serializing_if = "Option::is_none")] + pub command: Option, + #[serde(rename = "mime", default, skip_serializing_if = "Option::is_none")] + pub mime: Option, + #[serde(rename = "filename", default, skip_serializing_if = "Option::is_none")] + pub filename: Option, + #[serde(rename = "url", default, skip_serializing_if = "Option::is_none")] + pub url: Option, + #[serde(rename = "source", default, skip_serializing_if = "Option::is_none")] + pub source: Option>, + #[serde(rename = "callID", default, skip_serializing_if = "Option::is_none")] + pub call_id: Option, + #[serde(rename = "tool", default, skip_serializing_if = "Option::is_none")] + pub tool: Option, + #[serde(rename = "state", default, skip_serializing_if = "Option::is_none")] + pub state: Option>, + #[serde(rename = "snapshot", default, skip_serializing_if = "Option::is_none")] + pub snapshot: Option, + #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")] + pub reason: Option, + #[serde(rename = "cost", default, skip_serializing_if = "Option::is_none")] + pub cost: Option, + #[serde(rename = "tokens", default, skip_serializing_if = "Option::is_none")] + pub tokens: Option>, + #[serde(rename = "hash", default, skip_serializing_if = "Option::is_none")] + pub hash: Option, + #[serde(rename = "files", default, skip_serializing_if = "Option::is_none")] + pub files: Option>, + #[serde(rename = "name", default, skip_serializing_if = "Option::is_none")] + pub name: Option, + #[serde(rename = "attempt", default, skip_serializing_if = "Option::is_none")] + pub attempt: Option, + #[serde(rename = "error", default, skip_serializing_if = "Option::is_none")] + pub error: Option>, + #[serde(rename = "auto", default, skip_serializing_if = "Option::is_none")] + pub auto: Option, +} + +impl Part { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type) -> Part { + Part { + id, + session_id, + message_id, + r#type, + text: None, + synthetic: None, + ignored: None, + time: None, + metadata: None, + prompt: None, + description: None, + agent: None, + command: None, + mime: None, + filename: None, + url: None, + source: None, + call_id: None, + tool: None, + state: None, + snapshot: None, + reason: None, + cost: None, + tokens: None, + hash: None, + files: None, + name: None, + attempt: None, + error: None, + auto: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "text")] + Text, + #[serde(rename = "subtask")] + Subtask, + #[serde(rename = "reasoning")] + Reasoning, + #[serde(rename = "file")] + File, + #[serde(rename = "tool")] + Tool, + #[serde(rename = "step-start")] + StepStart, + #[serde(rename = "step-finish")] + StepFinish, + #[serde(rename = "snapshot")] + Snapshot, + #[serde(rename = "patch")] + Patch, + #[serde(rename = "agent")] + Agent, + #[serde(rename = "retry")] + Retry, + #[serde(rename = "compaction")] + Compaction, +} + +impl Default for Type { + fn default() -> Type { + Self::Text + } +} diff --git a/crates/opencode-client/src/models/part_any_of.rs b/crates/opencode-client/src/models/part_any_of.rs new file mode 100644 index 0000000..f1537fa --- /dev/null +++ b/crates/opencode-client/src/models/part_any_of.rs @@ -0,0 +1,60 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct PartAnyOf { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "prompt")] + pub prompt: String, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "agent")] + pub agent: String, + #[serde(rename = "command", skip_serializing_if = "Option::is_none")] + pub command: Option, +} + +impl PartAnyOf { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, prompt: String, description: String, agent: String) -> PartAnyOf { + PartAnyOf { + id, + session_id, + message_id, + r#type, + prompt, + description, + agent, + command: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "subtask")] + Subtask, +} + +impl Default for Type { + fn default() -> Type { + Self::Subtask + } +} + diff --git a/crates/opencode-client/src/models/patch_part.rs b/crates/opencode-client/src/models/patch_part.rs new file mode 100644 index 0000000..22db0a8 --- /dev/null +++ b/crates/opencode-client/src/models/patch_part.rs @@ -0,0 +1,54 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct PatchPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "hash")] + pub hash: String, + #[serde(rename = "files")] + pub files: Vec, +} + +impl PatchPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, hash: String, files: Vec) -> PatchPart { + PatchPart { + id, + session_id, + message_id, + r#type, + hash, + files, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "patch")] + Patch, +} + +impl Default for Type { + fn default() -> Type { + Self::Patch + } +} + diff --git a/crates/opencode-client/src/models/path.rs b/crates/opencode-client/src/models/path.rs new file mode 100644 index 0000000..6c67ebb --- /dev/null +++ b/crates/opencode-client/src/models/path.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Path { + #[serde(rename = "home")] + pub home: String, + #[serde(rename = "state")] + pub state: String, + #[serde(rename = "config")] + pub config: String, + #[serde(rename = "worktree")] + pub worktree: String, + #[serde(rename = "directory")] + pub directory: String, +} + +impl Path { + pub fn new(home: String, state: String, config: String, worktree: String, directory: String) -> Path { + Path { + home, + state, + config, + worktree, + directory, + } + } +} + diff --git a/crates/opencode-client/src/models/permission.rs b/crates/opencode-client/src/models/permission.rs new file mode 100644 index 0000000..55523bc --- /dev/null +++ b/crates/opencode-client/src/models/permission.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Permission { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "type")] + pub r#type: String, + #[serde(rename = "pattern", skip_serializing_if = "Option::is_none")] + pub pattern: Option>, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "callID", skip_serializing_if = "Option::is_none")] + pub call_id: Option, + #[serde(rename = "title")] + pub title: String, + #[serde(rename = "metadata")] + pub metadata: std::collections::HashMap, + #[serde(rename = "time")] + pub time: Box, +} + +impl Permission { + pub fn new(id: String, r#type: String, session_id: String, message_id: String, title: String, metadata: std::collections::HashMap, time: models::UserMessageTime) -> Permission { + Permission { + id, + r#type, + pattern: None, + session_id, + message_id, + call_id: None, + title, + metadata, + time: Box::new(time), + } + } +} + diff --git a/crates/opencode-client/src/models/permission_pattern.rs b/crates/opencode-client/src/models/permission_pattern.rs new file mode 100644 index 0000000..e5adcdd --- /dev/null +++ b/crates/opencode-client/src/models/permission_pattern.rs @@ -0,0 +1,24 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct PermissionPattern { +} + +impl PermissionPattern { + pub fn new() -> PermissionPattern { + PermissionPattern { + } + } +} + diff --git a/crates/opencode-client/src/models/permission_respond_request.rs b/crates/opencode-client/src/models/permission_respond_request.rs new file mode 100644 index 0000000..e2f9767 --- /dev/null +++ b/crates/opencode-client/src/models/permission_respond_request.rs @@ -0,0 +1,43 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct PermissionRespondRequest { + #[serde(rename = "response")] + pub response: Response, +} + +impl PermissionRespondRequest { + pub fn new(response: Response) -> PermissionRespondRequest { + PermissionRespondRequest { + response, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Response { + #[serde(rename = "once")] + Once, + #[serde(rename = "always")] + Always, + #[serde(rename = "reject")] + Reject, +} + +impl Default for Response { + fn default() -> Response { + Self::Once + } +} + diff --git a/crates/opencode-client/src/models/project.rs b/crates/opencode-client/src/models/project.rs new file mode 100644 index 0000000..0566b61 --- /dev/null +++ b/crates/opencode-client/src/models/project.rs @@ -0,0 +1,54 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Project { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "worktree")] + pub worktree: String, + #[serde(rename = "vcs", skip_serializing_if = "Option::is_none")] + pub vcs: Option, + #[serde(rename = "name", skip_serializing_if = "Option::is_none")] + pub name: Option, + #[serde(rename = "icon", skip_serializing_if = "Option::is_none")] + pub icon: Option>, + #[serde(rename = "time")] + pub time: Box, +} + +impl Project { + pub fn new(id: String, worktree: String, time: models::ProjectTime) -> Project { + Project { + id, + worktree, + vcs: None, + name: None, + icon: None, + time: Box::new(time), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Vcs { + #[serde(rename = "git")] + Git, +} + +impl Default for Vcs { + fn default() -> Vcs { + Self::Git + } +} + diff --git a/crates/opencode-client/src/models/project_time.rs b/crates/opencode-client/src/models/project_time.rs new file mode 100644 index 0000000..d7a9638 --- /dev/null +++ b/crates/opencode-client/src/models/project_time.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProjectTime { + #[serde(rename = "created", default)] + pub created: f64, + #[serde(rename = "updated", default)] + pub updated: f64, + #[serde(rename = "initialized", default, skip_serializing_if = "Option::is_none")] + pub initialized: Option, +} + +impl ProjectTime { + pub fn new(created: f64, updated: f64) -> ProjectTime { + ProjectTime { + created, + updated, + initialized: None, + } + } +} + diff --git a/crates/opencode-client/src/models/project_update_request.rs b/crates/opencode-client/src/models/project_update_request.rs new file mode 100644 index 0000000..745b335 --- /dev/null +++ b/crates/opencode-client/src/models/project_update_request.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProjectUpdateRequest { + #[serde(rename = "name", skip_serializing_if = "Option::is_none")] + pub name: Option, + #[serde(rename = "icon", skip_serializing_if = "Option::is_none")] + pub icon: Option>, +} + +impl ProjectUpdateRequest { + pub fn new() -> ProjectUpdateRequest { + ProjectUpdateRequest { + name: None, + icon: None, + } + } +} + diff --git a/crates/opencode-client/src/models/project_update_request_icon.rs b/crates/opencode-client/src/models/project_update_request_icon.rs new file mode 100644 index 0000000..f87c6cb --- /dev/null +++ b/crates/opencode-client/src/models/project_update_request_icon.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProjectUpdateRequestIcon { + #[serde(rename = "url", skip_serializing_if = "Option::is_none")] + pub url: Option, + #[serde(rename = "color", skip_serializing_if = "Option::is_none")] + pub color: Option, +} + +impl ProjectUpdateRequestIcon { + pub fn new() -> ProjectUpdateRequestIcon { + ProjectUpdateRequestIcon { + url: None, + color: None, + } + } +} + diff --git a/crates/opencode-client/src/models/provider.rs b/crates/opencode-client/src/models/provider.rs new file mode 100644 index 0000000..1546013 --- /dev/null +++ b/crates/opencode-client/src/models/provider.rs @@ -0,0 +1,63 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Provider { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "source")] + pub source: Source, + #[serde(rename = "env")] + pub env: Vec, + #[serde(rename = "key", skip_serializing_if = "Option::is_none")] + pub key: Option, + #[serde(rename = "options")] + pub options: std::collections::HashMap, + #[serde(rename = "models")] + pub models: std::collections::HashMap, +} + +impl Provider { + pub fn new(id: String, name: String, source: Source, env: Vec, options: std::collections::HashMap, models: std::collections::HashMap) -> Provider { + Provider { + id, + name, + source, + env, + key: None, + options, + models, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Source { + #[serde(rename = "env")] + Env, + #[serde(rename = "config")] + Config, + #[serde(rename = "custom")] + Custom, + #[serde(rename = "api")] + Api, +} + +impl Default for Source { + fn default() -> Source { + Self::Env + } +} + diff --git a/crates/opencode-client/src/models/provider_auth_authorization.rs b/crates/opencode-client/src/models/provider_auth_authorization.rs new file mode 100644 index 0000000..302a9f3 --- /dev/null +++ b/crates/opencode-client/src/models/provider_auth_authorization.rs @@ -0,0 +1,47 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderAuthAuthorization { + #[serde(rename = "url")] + pub url: String, + #[serde(rename = "method")] + pub method: Method, + #[serde(rename = "instructions")] + pub instructions: String, +} + +impl ProviderAuthAuthorization { + pub fn new(url: String, method: Method, instructions: String) -> ProviderAuthAuthorization { + ProviderAuthAuthorization { + url, + method, + instructions, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Method { + #[serde(rename = "auto")] + Auto, + #[serde(rename = "code")] + Code, +} + +impl Default for Method { + fn default() -> Method { + Self::Auto + } +} + diff --git a/crates/opencode-client/src/models/provider_auth_error.rs b/crates/opencode-client/src/models/provider_auth_error.rs new file mode 100644 index 0000000..41d7272 --- /dev/null +++ b/crates/opencode-client/src/models/provider_auth_error.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderAuthError { + #[serde(rename = "name")] + pub name: Name, + #[serde(rename = "data")] + pub data: Box, +} + +impl ProviderAuthError { + pub fn new(name: Name, data: models::ProviderAuthErrorData) -> ProviderAuthError { + ProviderAuthError { + name, + data: Box::new(data), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Name { + #[serde(rename = "ProviderAuthError")] + ProviderAuthError, +} + +impl Default for Name { + fn default() -> Name { + Self::ProviderAuthError + } +} + diff --git a/crates/opencode-client/src/models/provider_auth_error_data.rs b/crates/opencode-client/src/models/provider_auth_error_data.rs new file mode 100644 index 0000000..b822752 --- /dev/null +++ b/crates/opencode-client/src/models/provider_auth_error_data.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderAuthErrorData { + #[serde(rename = "providerID")] + pub provider_id: String, + #[serde(rename = "message")] + pub message: String, +} + +impl ProviderAuthErrorData { + pub fn new(provider_id: String, message: String) -> ProviderAuthErrorData { + ProviderAuthErrorData { + provider_id, + message, + } + } +} + diff --git a/crates/opencode-client/src/models/provider_auth_method.rs b/crates/opencode-client/src/models/provider_auth_method.rs new file mode 100644 index 0000000..90b333d --- /dev/null +++ b/crates/opencode-client/src/models/provider_auth_method.rs @@ -0,0 +1,44 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderAuthMethod { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "label")] + pub label: String, +} + +impl ProviderAuthMethod { + pub fn new(r#type: Type, label: String) -> ProviderAuthMethod { + ProviderAuthMethod { + r#type, + label, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "oauth")] + Oauth, + #[serde(rename = "api")] + Api, +} + +impl Default for Type { + fn default() -> Type { + Self::Oauth + } +} + diff --git a/crates/opencode-client/src/models/provider_config.rs b/crates/opencode-client/src/models/provider_config.rs new file mode 100644 index 0000000..c9801ef --- /dev/null +++ b/crates/opencode-client/src/models/provider_config.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderConfig { + #[serde(rename = "api", skip_serializing_if = "Option::is_none")] + pub api: Option, + #[serde(rename = "name", skip_serializing_if = "Option::is_none")] + pub name: Option, + #[serde(rename = "env", skip_serializing_if = "Option::is_none")] + pub env: Option>, + #[serde(rename = "id", skip_serializing_if = "Option::is_none")] + pub id: Option, + #[serde(rename = "npm", skip_serializing_if = "Option::is_none")] + pub npm: Option, + #[serde(rename = "models", skip_serializing_if = "Option::is_none")] + pub models: Option>, + #[serde(rename = "whitelist", skip_serializing_if = "Option::is_none")] + pub whitelist: Option>, + #[serde(rename = "blacklist", skip_serializing_if = "Option::is_none")] + pub blacklist: Option>, + #[serde(rename = "options", skip_serializing_if = "Option::is_none")] + pub options: Option, +} + +impl ProviderConfig { + pub fn new() -> ProviderConfig { + ProviderConfig { + api: None, + name: None, + env: None, + id: None, + npm: None, + models: None, + whitelist: None, + blacklist: None, + options: None, + } + } +} + diff --git a/crates/opencode-client/src/models/provider_config_models_value.rs b/crates/opencode-client/src/models/provider_config_models_value.rs new file mode 100644 index 0000000..3dda5d0 --- /dev/null +++ b/crates/opencode-client/src/models/provider_config_models_value.rs @@ -0,0 +1,95 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderConfigModelsValue { + #[serde(rename = "id", skip_serializing_if = "Option::is_none")] + pub id: Option, + #[serde(rename = "name", skip_serializing_if = "Option::is_none")] + pub name: Option, + #[serde(rename = "family", skip_serializing_if = "Option::is_none")] + pub family: Option, + #[serde(rename = "release_date", skip_serializing_if = "Option::is_none")] + pub release_date: Option, + #[serde(rename = "attachment", skip_serializing_if = "Option::is_none")] + pub attachment: Option, + #[serde(rename = "reasoning", skip_serializing_if = "Option::is_none")] + pub reasoning: Option, + #[serde(rename = "temperature", skip_serializing_if = "Option::is_none")] + pub temperature: Option, + #[serde(rename = "tool_call", skip_serializing_if = "Option::is_none")] + pub tool_call: Option, + #[serde(rename = "interleaved", skip_serializing_if = "Option::is_none")] + pub interleaved: Option>, + #[serde(rename = "cost", skip_serializing_if = "Option::is_none")] + pub cost: Option>, + #[serde(rename = "limit", skip_serializing_if = "Option::is_none")] + pub limit: Option>, + #[serde(rename = "modalities", skip_serializing_if = "Option::is_none")] + pub modalities: Option>, + #[serde(rename = "experimental", skip_serializing_if = "Option::is_none")] + pub experimental: Option, + #[serde(rename = "status", skip_serializing_if = "Option::is_none")] + pub status: Option, + #[serde(rename = "options", skip_serializing_if = "Option::is_none")] + pub options: Option>, + #[serde(rename = "headers", skip_serializing_if = "Option::is_none")] + pub headers: Option>, + #[serde(rename = "provider", skip_serializing_if = "Option::is_none")] + pub provider: Option>, + /// Variant-specific configuration + #[serde(rename = "variants", skip_serializing_if = "Option::is_none")] + pub variants: Option>, +} + +impl ProviderConfigModelsValue { + pub fn new() -> ProviderConfigModelsValue { + ProviderConfigModelsValue { + id: None, + name: None, + family: None, + release_date: None, + attachment: None, + reasoning: None, + temperature: None, + tool_call: None, + interleaved: None, + cost: None, + limit: None, + modalities: None, + experimental: None, + status: None, + options: None, + headers: None, + provider: None, + variants: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "alpha")] + Alpha, + #[serde(rename = "beta")] + Beta, + #[serde(rename = "deprecated")] + Deprecated, +} + +impl Default for Status { + fn default() -> Status { + Self::Alpha + } +} + diff --git a/crates/opencode-client/src/models/provider_config_models_value_interleaved.rs b/crates/opencode-client/src/models/provider_config_models_value_interleaved.rs new file mode 100644 index 0000000..05b36a0 --- /dev/null +++ b/crates/opencode-client/src/models/provider_config_models_value_interleaved.rs @@ -0,0 +1,41 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderConfigModelsValueInterleaved { + #[serde(rename = "field")] + pub field: Field, +} + +impl ProviderConfigModelsValueInterleaved { + pub fn new(field: Field) -> ProviderConfigModelsValueInterleaved { + ProviderConfigModelsValueInterleaved { + field, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Field { + #[serde(rename = "reasoning_content")] + ReasoningContent, + #[serde(rename = "reasoning_details")] + ReasoningDetails, +} + +impl Default for Field { + fn default() -> Field { + Self::ReasoningContent + } +} + diff --git a/crates/opencode-client/src/models/provider_config_models_value_interleaved_any_of.rs b/crates/opencode-client/src/models/provider_config_models_value_interleaved_any_of.rs new file mode 100644 index 0000000..f66916b --- /dev/null +++ b/crates/opencode-client/src/models/provider_config_models_value_interleaved_any_of.rs @@ -0,0 +1,41 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderConfigModelsValueInterleavedAnyOf { + #[serde(rename = "field")] + pub field: Field, +} + +impl ProviderConfigModelsValueInterleavedAnyOf { + pub fn new(field: Field) -> ProviderConfigModelsValueInterleavedAnyOf { + ProviderConfigModelsValueInterleavedAnyOf { + field, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Field { + #[serde(rename = "reasoning_content")] + ReasoningContent, + #[serde(rename = "reasoning_details")] + ReasoningDetails, +} + +impl Default for Field { + fn default() -> Field { + Self::ReasoningContent + } +} + diff --git a/crates/opencode-client/src/models/provider_config_models_value_variants_value.rs b/crates/opencode-client/src/models/provider_config_models_value_variants_value.rs new file mode 100644 index 0000000..63949fa --- /dev/null +++ b/crates/opencode-client/src/models/provider_config_models_value_variants_value.rs @@ -0,0 +1,28 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderConfigModelsValueVariantsValue { + /// Disable this variant for the model + #[serde(rename = "disabled", skip_serializing_if = "Option::is_none")] + pub disabled: Option, +} + +impl ProviderConfigModelsValueVariantsValue { + pub fn new() -> ProviderConfigModelsValueVariantsValue { + ProviderConfigModelsValueVariantsValue { + disabled: None, + } + } +} + diff --git a/crates/opencode-client/src/models/provider_config_options.rs b/crates/opencode-client/src/models/provider_config_options.rs new file mode 100644 index 0000000..69a9373 --- /dev/null +++ b/crates/opencode-client/src/models/provider_config_options.rs @@ -0,0 +1,41 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderConfigOptions { + #[serde(rename = "apiKey", skip_serializing_if = "Option::is_none")] + pub api_key: Option, + #[serde(rename = "baseURL", skip_serializing_if = "Option::is_none")] + pub base_url: Option, + /// GitHub Enterprise URL for copilot authentication + #[serde(rename = "enterpriseUrl", skip_serializing_if = "Option::is_none")] + pub enterprise_url: Option, + /// Enable promptCacheKey for this provider (default false) + #[serde(rename = "setCacheKey", skip_serializing_if = "Option::is_none")] + pub set_cache_key: Option, + #[serde(rename = "timeout", skip_serializing_if = "Option::is_none")] + pub timeout: Option>, +} + +impl ProviderConfigOptions { + pub fn new() -> ProviderConfigOptions { + ProviderConfigOptions { + api_key: None, + base_url: None, + enterprise_url: None, + set_cache_key: None, + timeout: None, + } + } +} + diff --git a/crates/opencode-client/src/models/provider_config_options_timeout.rs b/crates/opencode-client/src/models/provider_config_options_timeout.rs new file mode 100644 index 0000000..ff527d3 --- /dev/null +++ b/crates/opencode-client/src/models/provider_config_options_timeout.rs @@ -0,0 +1,26 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// ProviderConfigOptionsTimeout : Timeout in milliseconds for requests to this provider. Default is 300000 (5 minutes). Set to false to disable timeout. +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderConfigOptionsTimeout { +} + +impl ProviderConfigOptionsTimeout { + /// Timeout in milliseconds for requests to this provider. Default is 300000 (5 minutes). Set to false to disable timeout. + pub fn new() -> ProviderConfigOptionsTimeout { + ProviderConfigOptionsTimeout { + } + } +} + diff --git a/crates/opencode-client/src/models/provider_list_200_response.rs b/crates/opencode-client/src/models/provider_list_200_response.rs new file mode 100644 index 0000000..85bea36 --- /dev/null +++ b/crates/opencode-client/src/models/provider_list_200_response.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200Response { + #[serde(rename = "all")] + pub all: Vec, + #[serde(rename = "default")] + pub default: std::collections::HashMap, + #[serde(rename = "connected")] + pub connected: Vec, +} + +impl ProviderList200Response { + pub fn new(all: Vec, default: std::collections::HashMap, connected: Vec) -> ProviderList200Response { + ProviderList200Response { + all, + default, + connected, + } + } +} + diff --git a/crates/opencode-client/src/models/provider_list_200_response_all_inner.rs b/crates/opencode-client/src/models/provider_list_200_response_all_inner.rs new file mode 100644 index 0000000..fea04b3 --- /dev/null +++ b/crates/opencode-client/src/models/provider_list_200_response_all_inner.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInner { + #[serde(rename = "api", skip_serializing_if = "Option::is_none")] + pub api: Option, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "env")] + pub env: Vec, + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "npm", skip_serializing_if = "Option::is_none")] + pub npm: Option, + #[serde(rename = "models")] + pub models: std::collections::HashMap, +} + +impl ProviderList200ResponseAllInner { + pub fn new(name: String, env: Vec, id: String, models: std::collections::HashMap) -> ProviderList200ResponseAllInner { + ProviderList200ResponseAllInner { + api: None, + name, + env, + id, + npm: None, + models, + } + } +} + diff --git a/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value.rs b/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value.rs new file mode 100644 index 0000000..b19389f --- /dev/null +++ b/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value.rs @@ -0,0 +1,94 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInnerModelsValue { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "family", skip_serializing_if = "Option::is_none")] + pub family: Option, + #[serde(rename = "release_date")] + pub release_date: String, + #[serde(rename = "attachment")] + pub attachment: bool, + #[serde(rename = "reasoning")] + pub reasoning: bool, + #[serde(rename = "temperature")] + pub temperature: bool, + #[serde(rename = "tool_call")] + pub tool_call: bool, + #[serde(rename = "interleaved", skip_serializing_if = "Option::is_none")] + pub interleaved: Option>, + #[serde(rename = "cost", skip_serializing_if = "Option::is_none")] + pub cost: Option>, + #[serde(rename = "limit")] + pub limit: Box, + #[serde(rename = "modalities", skip_serializing_if = "Option::is_none")] + pub modalities: Option>, + #[serde(rename = "experimental", skip_serializing_if = "Option::is_none")] + pub experimental: Option, + #[serde(rename = "status", skip_serializing_if = "Option::is_none")] + pub status: Option, + #[serde(rename = "options")] + pub options: std::collections::HashMap, + #[serde(rename = "headers", skip_serializing_if = "Option::is_none")] + pub headers: Option>, + #[serde(rename = "provider", skip_serializing_if = "Option::is_none")] + pub provider: Option>, + #[serde(rename = "variants", skip_serializing_if = "Option::is_none")] + pub variants: Option>>, +} + +impl ProviderList200ResponseAllInnerModelsValue { + pub fn new(id: String, name: String, release_date: String, attachment: bool, reasoning: bool, temperature: bool, tool_call: bool, limit: models::ProviderList200ResponseAllInnerModelsValueLimit, options: std::collections::HashMap) -> ProviderList200ResponseAllInnerModelsValue { + ProviderList200ResponseAllInnerModelsValue { + id, + name, + family: None, + release_date, + attachment, + reasoning, + temperature, + tool_call, + interleaved: None, + cost: None, + limit: Box::new(limit), + modalities: None, + experimental: None, + status: None, + options, + headers: None, + provider: None, + variants: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "alpha")] + Alpha, + #[serde(rename = "beta")] + Beta, + #[serde(rename = "deprecated")] + Deprecated, +} + +impl Default for Status { + fn default() -> Status { + Self::Alpha + } +} + diff --git a/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_cost.rs b/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_cost.rs new file mode 100644 index 0000000..59f2d12 --- /dev/null +++ b/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_cost.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInnerModelsValueCost { + #[serde(rename = "input")] + pub input: f64, + #[serde(rename = "output")] + pub output: f64, + #[serde(rename = "cache_read", skip_serializing_if = "Option::is_none")] + pub cache_read: Option, + #[serde(rename = "cache_write", skip_serializing_if = "Option::is_none")] + pub cache_write: Option, + #[serde(rename = "context_over_200k", skip_serializing_if = "Option::is_none")] + pub context_over_200k: Option>, +} + +impl ProviderList200ResponseAllInnerModelsValueCost { + pub fn new(input: f64, output: f64) -> ProviderList200ResponseAllInnerModelsValueCost { + ProviderList200ResponseAllInnerModelsValueCost { + input, + output, + cache_read: None, + cache_write: None, + context_over_200k: None, + } + } +} + diff --git a/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_cost_context_over_200k.rs b/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_cost_context_over_200k.rs new file mode 100644 index 0000000..428d7af --- /dev/null +++ b/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_cost_context_over_200k.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInnerModelsValueCostContextOver200k { + #[serde(rename = "input")] + pub input: f64, + #[serde(rename = "output")] + pub output: f64, + #[serde(rename = "cache_read", skip_serializing_if = "Option::is_none")] + pub cache_read: Option, + #[serde(rename = "cache_write", skip_serializing_if = "Option::is_none")] + pub cache_write: Option, +} + +impl ProviderList200ResponseAllInnerModelsValueCostContextOver200k { + pub fn new(input: f64, output: f64) -> ProviderList200ResponseAllInnerModelsValueCostContextOver200k { + ProviderList200ResponseAllInnerModelsValueCostContextOver200k { + input, + output, + cache_read: None, + cache_write: None, + } + } +} + diff --git a/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_interleaved.rs b/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_interleaved.rs new file mode 100644 index 0000000..a9cecfd --- /dev/null +++ b/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_interleaved.rs @@ -0,0 +1,41 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInnerModelsValueInterleaved { + #[serde(rename = "field")] + pub field: Field, +} + +impl ProviderList200ResponseAllInnerModelsValueInterleaved { + pub fn new(field: Field) -> ProviderList200ResponseAllInnerModelsValueInterleaved { + ProviderList200ResponseAllInnerModelsValueInterleaved { + field, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Field { + #[serde(rename = "reasoning_content")] + ReasoningContent, + #[serde(rename = "reasoning_details")] + ReasoningDetails, +} + +impl Default for Field { + fn default() -> Field { + Self::ReasoningContent + } +} + diff --git a/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_interleaved_any_of.rs b/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_interleaved_any_of.rs new file mode 100644 index 0000000..4c51ef5 --- /dev/null +++ b/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_interleaved_any_of.rs @@ -0,0 +1,41 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf { + #[serde(rename = "field")] + pub field: Field, +} + +impl ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf { + pub fn new(field: Field) -> ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf { + ProviderList200ResponseAllInnerModelsValueInterleavedAnyOf { + field, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Field { + #[serde(rename = "reasoning_content")] + ReasoningContent, + #[serde(rename = "reasoning_details")] + ReasoningDetails, +} + +impl Default for Field { + fn default() -> Field { + Self::ReasoningContent + } +} + diff --git a/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_limit.rs b/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_limit.rs new file mode 100644 index 0000000..d45b35c --- /dev/null +++ b/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_limit.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInnerModelsValueLimit { + #[serde(rename = "context")] + pub context: f64, + #[serde(rename = "output")] + pub output: f64, +} + +impl ProviderList200ResponseAllInnerModelsValueLimit { + pub fn new(context: f64, output: f64) -> ProviderList200ResponseAllInnerModelsValueLimit { + ProviderList200ResponseAllInnerModelsValueLimit { + context, + output, + } + } +} + diff --git a/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_modalities.rs b/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_modalities.rs new file mode 100644 index 0000000..767ca84 --- /dev/null +++ b/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_modalities.rs @@ -0,0 +1,70 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInnerModelsValueModalities { + #[serde(rename = "input")] + pub input: Vec, + #[serde(rename = "output")] + pub output: Vec, +} + +impl ProviderList200ResponseAllInnerModelsValueModalities { + pub fn new(input: Vec, output: Vec) -> ProviderList200ResponseAllInnerModelsValueModalities { + ProviderList200ResponseAllInnerModelsValueModalities { + input, + output, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Input { + #[serde(rename = "text")] + Text, + #[serde(rename = "audio")] + Audio, + #[serde(rename = "image")] + Image, + #[serde(rename = "video")] + Video, + #[serde(rename = "pdf")] + Pdf, +} + +impl Default for Input { + fn default() -> Input { + Self::Text + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Output { + #[serde(rename = "text")] + Text, + #[serde(rename = "audio")] + Audio, + #[serde(rename = "image")] + Image, + #[serde(rename = "video")] + Video, + #[serde(rename = "pdf")] + Pdf, +} + +impl Default for Output { + fn default() -> Output { + Self::Text + } +} + diff --git a/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_provider.rs b/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_provider.rs new file mode 100644 index 0000000..89f2768 --- /dev/null +++ b/crates/opencode-client/src/models/provider_list_200_response_all_inner_models_value_provider.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderList200ResponseAllInnerModelsValueProvider { + #[serde(rename = "npm")] + pub npm: String, +} + +impl ProviderList200ResponseAllInnerModelsValueProvider { + pub fn new(npm: String) -> ProviderList200ResponseAllInnerModelsValueProvider { + ProviderList200ResponseAllInnerModelsValueProvider { + npm, + } + } +} + diff --git a/crates/opencode-client/src/models/provider_oauth_authorize_request.rs b/crates/opencode-client/src/models/provider_oauth_authorize_request.rs new file mode 100644 index 0000000..d43cd3b --- /dev/null +++ b/crates/opencode-client/src/models/provider_oauth_authorize_request.rs @@ -0,0 +1,28 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderOauthAuthorizeRequest { + /// Auth method index + #[serde(rename = "method")] + pub method: f64, +} + +impl ProviderOauthAuthorizeRequest { + pub fn new(method: f64) -> ProviderOauthAuthorizeRequest { + ProviderOauthAuthorizeRequest { + method, + } + } +} + diff --git a/crates/opencode-client/src/models/provider_oauth_callback_request.rs b/crates/opencode-client/src/models/provider_oauth_callback_request.rs new file mode 100644 index 0000000..87c491f --- /dev/null +++ b/crates/opencode-client/src/models/provider_oauth_callback_request.rs @@ -0,0 +1,32 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ProviderOauthCallbackRequest { + /// Auth method index + #[serde(rename = "method")] + pub method: f64, + /// OAuth authorization code + #[serde(rename = "code", skip_serializing_if = "Option::is_none")] + pub code: Option, +} + +impl ProviderOauthCallbackRequest { + pub fn new(method: f64) -> ProviderOauthCallbackRequest { + ProviderOauthCallbackRequest { + method, + code: None, + } + } +} + diff --git a/crates/opencode-client/src/models/pty.rs b/crates/opencode-client/src/models/pty.rs new file mode 100644 index 0000000..537068d --- /dev/null +++ b/crates/opencode-client/src/models/pty.rs @@ -0,0 +1,59 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Pty { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "title")] + pub title: String, + #[serde(rename = "command")] + pub command: String, + #[serde(rename = "args")] + pub args: Vec, + #[serde(rename = "cwd")] + pub cwd: String, + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "pid")] + pub pid: f64, +} + +impl Pty { + pub fn new(id: String, title: String, command: String, args: Vec, cwd: String, status: Status, pid: f64) -> Pty { + Pty { + id, + title, + command, + args, + cwd, + status, + pid, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "running")] + Running, + #[serde(rename = "exited")] + Exited, +} + +impl Default for Status { + fn default() -> Status { + Self::Running + } +} + diff --git a/crates/opencode-client/src/models/pty_create_request.rs b/crates/opencode-client/src/models/pty_create_request.rs new file mode 100644 index 0000000..29b71c6 --- /dev/null +++ b/crates/opencode-client/src/models/pty_create_request.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct PtyCreateRequest { + #[serde(rename = "command", skip_serializing_if = "Option::is_none")] + pub command: Option, + #[serde(rename = "args", skip_serializing_if = "Option::is_none")] + pub args: Option>, + #[serde(rename = "cwd", skip_serializing_if = "Option::is_none")] + pub cwd: Option, + #[serde(rename = "title", skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(rename = "env", skip_serializing_if = "Option::is_none")] + pub env: Option>, +} + +impl PtyCreateRequest { + pub fn new() -> PtyCreateRequest { + PtyCreateRequest { + command: None, + args: None, + cwd: None, + title: None, + env: None, + } + } +} + diff --git a/crates/opencode-client/src/models/pty_update_request.rs b/crates/opencode-client/src/models/pty_update_request.rs new file mode 100644 index 0000000..081b6bd --- /dev/null +++ b/crates/opencode-client/src/models/pty_update_request.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct PtyUpdateRequest { + #[serde(rename = "title", skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(rename = "size", skip_serializing_if = "Option::is_none")] + pub size: Option>, +} + +impl PtyUpdateRequest { + pub fn new() -> PtyUpdateRequest { + PtyUpdateRequest { + title: None, + size: None, + } + } +} + diff --git a/crates/opencode-client/src/models/pty_update_request_size.rs b/crates/opencode-client/src/models/pty_update_request_size.rs new file mode 100644 index 0000000..5ce3849 --- /dev/null +++ b/crates/opencode-client/src/models/pty_update_request_size.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct PtyUpdateRequestSize { + #[serde(rename = "rows")] + pub rows: f64, + #[serde(rename = "cols")] + pub cols: f64, +} + +impl PtyUpdateRequestSize { + pub fn new(rows: f64, cols: f64) -> PtyUpdateRequestSize { + PtyUpdateRequestSize { + rows, + cols, + } + } +} + diff --git a/crates/opencode-client/src/models/range.rs b/crates/opencode-client/src/models/range.rs new file mode 100644 index 0000000..d07b982 --- /dev/null +++ b/crates/opencode-client/src/models/range.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Range { + #[serde(rename = "start")] + pub start: Box, + #[serde(rename = "end")] + pub end: Box, +} + +impl Range { + pub fn new(start: models::RangeStart, end: models::RangeStart) -> Range { + Range { + start: Box::new(start), + end: Box::new(end), + } + } +} + diff --git a/crates/opencode-client/src/models/range_start.rs b/crates/opencode-client/src/models/range_start.rs new file mode 100644 index 0000000..3c22ccc --- /dev/null +++ b/crates/opencode-client/src/models/range_start.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct RangeStart { + #[serde(rename = "line")] + pub line: f64, + #[serde(rename = "character")] + pub character: f64, +} + +impl RangeStart { + pub fn new(line: f64, character: f64) -> RangeStart { + RangeStart { + line, + character, + } + } +} + diff --git a/crates/opencode-client/src/models/reasoning_part.rs b/crates/opencode-client/src/models/reasoning_part.rs new file mode 100644 index 0000000..aff14d5 --- /dev/null +++ b/crates/opencode-client/src/models/reasoning_part.rs @@ -0,0 +1,57 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ReasoningPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "text")] + pub text: String, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, + #[serde(rename = "time")] + pub time: Box, +} + +impl ReasoningPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, text: String, time: models::TextPartTime) -> ReasoningPart { + ReasoningPart { + id, + session_id, + message_id, + r#type, + text, + metadata: None, + time: Box::new(time), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "reasoning")] + Reasoning, +} + +impl Default for Type { + fn default() -> Type { + Self::Reasoning + } +} + diff --git a/crates/opencode-client/src/models/retry_part.rs b/crates/opencode-client/src/models/retry_part.rs new file mode 100644 index 0000000..37174d2 --- /dev/null +++ b/crates/opencode-client/src/models/retry_part.rs @@ -0,0 +1,57 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct RetryPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "attempt")] + pub attempt: f64, + #[serde(rename = "error")] + pub error: Box, + #[serde(rename = "time")] + pub time: Box, +} + +impl RetryPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, attempt: f64, error: models::ApiError, time: models::UserMessageTime) -> RetryPart { + RetryPart { + id, + session_id, + message_id, + r#type, + attempt, + error: Box::new(error), + time: Box::new(time), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "retry")] + Retry, +} + +impl Default for Type { + fn default() -> Type { + Self::Retry + } +} + diff --git a/crates/opencode-client/src/models/server_config.rs b/crates/opencode-client/src/models/server_config.rs new file mode 100644 index 0000000..5bdba7b --- /dev/null +++ b/crates/opencode-client/src/models/server_config.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +/// ServerConfig : Server configuration for opencode serve and web commands +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ServerConfig { + /// Port to listen on + #[serde(rename = "port", skip_serializing_if = "Option::is_none")] + pub port: Option, + /// Hostname to listen on + #[serde(rename = "hostname", skip_serializing_if = "Option::is_none")] + pub hostname: Option, + /// Enable mDNS service discovery + #[serde(rename = "mdns", skip_serializing_if = "Option::is_none")] + pub mdns: Option, + /// Additional domains to allow for CORS + #[serde(rename = "cors", skip_serializing_if = "Option::is_none")] + pub cors: Option>, +} + +impl ServerConfig { + /// Server configuration for opencode serve and web commands + pub fn new() -> ServerConfig { + ServerConfig { + port: None, + hostname: None, + mdns: None, + cors: None, + } + } +} + diff --git a/crates/opencode-client/src/models/session.rs b/crates/opencode-client/src/models/session.rs new file mode 100644 index 0000000..9b80a66 --- /dev/null +++ b/crates/opencode-client/src/models/session.rs @@ -0,0 +1,54 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Session { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "projectID")] + pub project_id: String, + #[serde(rename = "directory")] + pub directory: String, + #[serde(rename = "parentID", skip_serializing_if = "Option::is_none")] + pub parent_id: Option, + #[serde(rename = "summary", skip_serializing_if = "Option::is_none")] + pub summary: Option>, + #[serde(rename = "share", skip_serializing_if = "Option::is_none")] + pub share: Option>, + #[serde(rename = "title")] + pub title: String, + #[serde(rename = "version")] + pub version: String, + #[serde(rename = "time")] + pub time: Box, + #[serde(rename = "revert", skip_serializing_if = "Option::is_none")] + pub revert: Option>, +} + +impl Session { + pub fn new(id: String, project_id: String, directory: String, title: String, version: String, time: models::SessionTime) -> Session { + Session { + id, + project_id, + directory, + parent_id: None, + summary: None, + share: None, + title, + version, + time: Box::new(time), + revert: None, + } + } +} + diff --git a/crates/opencode-client/src/models/session_command_request.rs b/crates/opencode-client/src/models/session_command_request.rs new file mode 100644 index 0000000..20b987d --- /dev/null +++ b/crates/opencode-client/src/models/session_command_request.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionCommandRequest { + #[serde(rename = "messageID", skip_serializing_if = "Option::is_none")] + pub message_id: Option, + #[serde(rename = "agent", skip_serializing_if = "Option::is_none")] + pub agent: Option, + #[serde(rename = "model", skip_serializing_if = "Option::is_none")] + pub model: Option, + #[serde(rename = "arguments")] + pub arguments: String, + #[serde(rename = "command")] + pub command: String, + #[serde(rename = "variant", skip_serializing_if = "Option::is_none")] + pub variant: Option, +} + +impl SessionCommandRequest { + pub fn new(arguments: String, command: String) -> SessionCommandRequest { + SessionCommandRequest { + message_id: None, + agent: None, + model: None, + arguments, + command, + variant: None, + } + } +} + diff --git a/crates/opencode-client/src/models/session_create_request.rs b/crates/opencode-client/src/models/session_create_request.rs new file mode 100644 index 0000000..e06581c --- /dev/null +++ b/crates/opencode-client/src/models/session_create_request.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionCreateRequest { + #[serde(rename = "parentID", skip_serializing_if = "Option::is_none")] + pub parent_id: Option, + #[serde(rename = "title", skip_serializing_if = "Option::is_none")] + pub title: Option, +} + +impl SessionCreateRequest { + pub fn new() -> SessionCreateRequest { + SessionCreateRequest { + parent_id: None, + title: None, + } + } +} + diff --git a/crates/opencode-client/src/models/session_fork_request.rs b/crates/opencode-client/src/models/session_fork_request.rs new file mode 100644 index 0000000..ae4ba6e --- /dev/null +++ b/crates/opencode-client/src/models/session_fork_request.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionForkRequest { + #[serde(rename = "messageID", skip_serializing_if = "Option::is_none")] + pub message_id: Option, +} + +impl SessionForkRequest { + pub fn new() -> SessionForkRequest { + SessionForkRequest { + message_id: None, + } + } +} + diff --git a/crates/opencode-client/src/models/session_init_request.rs b/crates/opencode-client/src/models/session_init_request.rs new file mode 100644 index 0000000..aef8990 --- /dev/null +++ b/crates/opencode-client/src/models/session_init_request.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionInitRequest { + #[serde(rename = "modelID")] + pub model_id: String, + #[serde(rename = "providerID")] + pub provider_id: String, + #[serde(rename = "messageID")] + pub message_id: String, +} + +impl SessionInitRequest { + pub fn new(model_id: String, provider_id: String, message_id: String) -> SessionInitRequest { + SessionInitRequest { + model_id, + provider_id, + message_id, + } + } +} + diff --git a/crates/opencode-client/src/models/session_messages_200_response_inner.rs b/crates/opencode-client/src/models/session_messages_200_response_inner.rs new file mode 100644 index 0000000..8dc9dc8 --- /dev/null +++ b/crates/opencode-client/src/models/session_messages_200_response_inner.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionMessages200ResponseInner { + #[serde(rename = "info")] + pub info: Box, + #[serde(rename = "parts")] + pub parts: Vec, +} + +impl SessionMessages200ResponseInner { + pub fn new(info: models::Message, parts: Vec) -> SessionMessages200ResponseInner { + SessionMessages200ResponseInner { + info: Box::new(info), + parts, + } + } +} + diff --git a/crates/opencode-client/src/models/session_prompt_200_response.rs b/crates/opencode-client/src/models/session_prompt_200_response.rs new file mode 100644 index 0000000..29f7706 --- /dev/null +++ b/crates/opencode-client/src/models/session_prompt_200_response.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionPrompt200Response { + #[serde(rename = "info")] + pub info: Box, + #[serde(rename = "parts")] + pub parts: Vec, +} + +impl SessionPrompt200Response { + pub fn new(info: models::AssistantMessage, parts: Vec) -> SessionPrompt200Response { + SessionPrompt200Response { + info: Box::new(info), + parts, + } + } +} + diff --git a/crates/opencode-client/src/models/session_prompt_request.rs b/crates/opencode-client/src/models/session_prompt_request.rs new file mode 100644 index 0000000..23d0e36 --- /dev/null +++ b/crates/opencode-client/src/models/session_prompt_request.rs @@ -0,0 +1,48 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionPromptRequest { + #[serde(rename = "messageID", skip_serializing_if = "Option::is_none")] + pub message_id: Option, + #[serde(rename = "model", skip_serializing_if = "Option::is_none")] + pub model: Option>, + #[serde(rename = "agent", skip_serializing_if = "Option::is_none")] + pub agent: Option, + #[serde(rename = "noReply", skip_serializing_if = "Option::is_none")] + pub no_reply: Option, + #[serde(rename = "tools", skip_serializing_if = "Option::is_none")] + pub tools: Option>, + #[serde(rename = "system", skip_serializing_if = "Option::is_none")] + pub system: Option, + #[serde(rename = "variant", skip_serializing_if = "Option::is_none")] + pub variant: Option, + #[serde(rename = "parts")] + pub parts: Vec, +} + +impl SessionPromptRequest { + pub fn new(parts: Vec) -> SessionPromptRequest { + SessionPromptRequest { + message_id: None, + model: None, + agent: None, + no_reply: None, + tools: None, + system: None, + variant: None, + parts, + } + } +} + diff --git a/crates/opencode-client/src/models/session_prompt_request_model.rs b/crates/opencode-client/src/models/session_prompt_request_model.rs new file mode 100644 index 0000000..f7761fd --- /dev/null +++ b/crates/opencode-client/src/models/session_prompt_request_model.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionPromptRequestModel { + #[serde(rename = "providerID")] + pub provider_id: String, + #[serde(rename = "modelID")] + pub model_id: String, +} + +impl SessionPromptRequestModel { + pub fn new(provider_id: String, model_id: String) -> SessionPromptRequestModel { + SessionPromptRequestModel { + provider_id, + model_id, + } + } +} + diff --git a/crates/opencode-client/src/models/session_prompt_request_parts_inner.rs b/crates/opencode-client/src/models/session_prompt_request_parts_inner.rs new file mode 100644 index 0000000..71c7a8e --- /dev/null +++ b/crates/opencode-client/src/models/session_prompt_request_parts_inner.rs @@ -0,0 +1,90 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionPromptRequestPartsInner { + #[serde(rename = "id", skip_serializing_if = "Option::is_none")] + pub id: Option, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "text")] + pub text: String, + #[serde(rename = "synthetic", skip_serializing_if = "Option::is_none")] + pub synthetic: Option, + #[serde(rename = "ignored", skip_serializing_if = "Option::is_none")] + pub ignored: Option, + #[serde(rename = "time", skip_serializing_if = "Option::is_none")] + pub time: Option>, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, + #[serde(rename = "mime")] + pub mime: String, + #[serde(rename = "filename", skip_serializing_if = "Option::is_none")] + pub filename: Option, + #[serde(rename = "url")] + pub url: String, + #[serde(rename = "source", skip_serializing_if = "Option::is_none")] + pub source: Option>, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "prompt")] + pub prompt: String, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "agent")] + pub agent: String, + #[serde(rename = "command", skip_serializing_if = "Option::is_none")] + pub command: Option, +} + +impl SessionPromptRequestPartsInner { + pub fn new(r#type: Type, text: String, mime: String, url: String, name: String, prompt: String, description: String, agent: String) -> SessionPromptRequestPartsInner { + SessionPromptRequestPartsInner { + id: None, + r#type, + text, + synthetic: None, + ignored: None, + time: None, + metadata: None, + mime, + filename: None, + url, + source: None, + name, + prompt, + description, + agent, + command: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "text")] + Text, + #[serde(rename = "file")] + File, + #[serde(rename = "agent")] + Agent, + #[serde(rename = "subtask")] + Subtask, +} + +impl Default for Type { + fn default() -> Type { + Self::Text + } +} + diff --git a/crates/opencode-client/src/models/session_revert.rs b/crates/opencode-client/src/models/session_revert.rs new file mode 100644 index 0000000..99639f9 --- /dev/null +++ b/crates/opencode-client/src/models/session_revert.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionRevert { + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "partID", skip_serializing_if = "Option::is_none")] + pub part_id: Option, + #[serde(rename = "snapshot", skip_serializing_if = "Option::is_none")] + pub snapshot: Option, + #[serde(rename = "diff", skip_serializing_if = "Option::is_none")] + pub diff: Option, +} + +impl SessionRevert { + pub fn new(message_id: String) -> SessionRevert { + SessionRevert { + message_id, + part_id: None, + snapshot: None, + diff: None, + } + } +} + diff --git a/crates/opencode-client/src/models/session_revert_request.rs b/crates/opencode-client/src/models/session_revert_request.rs new file mode 100644 index 0000000..44144c1 --- /dev/null +++ b/crates/opencode-client/src/models/session_revert_request.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionRevertRequest { + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "partID", skip_serializing_if = "Option::is_none")] + pub part_id: Option, +} + +impl SessionRevertRequest { + pub fn new(message_id: String) -> SessionRevertRequest { + SessionRevertRequest { + message_id, + part_id: None, + } + } +} + diff --git a/crates/opencode-client/src/models/session_share.rs b/crates/opencode-client/src/models/session_share.rs new file mode 100644 index 0000000..9724e75 --- /dev/null +++ b/crates/opencode-client/src/models/session_share.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionShare { + #[serde(rename = "url")] + pub url: String, +} + +impl SessionShare { + pub fn new(url: String) -> SessionShare { + SessionShare { + url, + } + } +} + diff --git a/crates/opencode-client/src/models/session_shell_request.rs b/crates/opencode-client/src/models/session_shell_request.rs new file mode 100644 index 0000000..d2d2446 --- /dev/null +++ b/crates/opencode-client/src/models/session_shell_request.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionShellRequest { + #[serde(rename = "agent")] + pub agent: String, + #[serde(rename = "model", skip_serializing_if = "Option::is_none")] + pub model: Option>, + #[serde(rename = "command")] + pub command: String, +} + +impl SessionShellRequest { + pub fn new(agent: String, command: String) -> SessionShellRequest { + SessionShellRequest { + agent, + model: None, + command, + } + } +} + diff --git a/crates/opencode-client/src/models/session_status.rs b/crates/opencode-client/src/models/session_status.rs new file mode 100644 index 0000000..123fd73 --- /dev/null +++ b/crates/opencode-client/src/models/session_status.rs @@ -0,0 +1,52 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionStatus { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "attempt")] + pub attempt: f64, + #[serde(rename = "message")] + pub message: String, + #[serde(rename = "next")] + pub next: f64, +} + +impl SessionStatus { + pub fn new(r#type: Type, attempt: f64, message: String, next: f64) -> SessionStatus { + SessionStatus { + r#type, + attempt, + message, + next, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "idle")] + Idle, + #[serde(rename = "retry")] + Retry, + #[serde(rename = "busy")] + Busy, +} + +impl Default for Type { + fn default() -> Type { + Self::Idle + } +} + diff --git a/crates/opencode-client/src/models/session_status_any_of.rs b/crates/opencode-client/src/models/session_status_any_of.rs new file mode 100644 index 0000000..e207e24 --- /dev/null +++ b/crates/opencode-client/src/models/session_status_any_of.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionStatusAnyOf { + #[serde(rename = "type")] + pub r#type: Type, +} + +impl SessionStatusAnyOf { + pub fn new(r#type: Type) -> SessionStatusAnyOf { + SessionStatusAnyOf { + r#type, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "idle")] + Idle, +} + +impl Default for Type { + fn default() -> Type { + Self::Idle + } +} + diff --git a/crates/opencode-client/src/models/session_status_any_of_1.rs b/crates/opencode-client/src/models/session_status_any_of_1.rs new file mode 100644 index 0000000..734f2bd --- /dev/null +++ b/crates/opencode-client/src/models/session_status_any_of_1.rs @@ -0,0 +1,48 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionStatusAnyOf1 { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "attempt")] + pub attempt: f64, + #[serde(rename = "message")] + pub message: String, + #[serde(rename = "next")] + pub next: f64, +} + +impl SessionStatusAnyOf1 { + pub fn new(r#type: Type, attempt: f64, message: String, next: f64) -> SessionStatusAnyOf1 { + SessionStatusAnyOf1 { + r#type, + attempt, + message, + next, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "retry")] + Retry, +} + +impl Default for Type { + fn default() -> Type { + Self::Retry + } +} + diff --git a/crates/opencode-client/src/models/session_status_any_of_2.rs b/crates/opencode-client/src/models/session_status_any_of_2.rs new file mode 100644 index 0000000..1b80b47 --- /dev/null +++ b/crates/opencode-client/src/models/session_status_any_of_2.rs @@ -0,0 +1,39 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionStatusAnyOf2 { + #[serde(rename = "type")] + pub r#type: Type, +} + +impl SessionStatusAnyOf2 { + pub fn new(r#type: Type) -> SessionStatusAnyOf2 { + SessionStatusAnyOf2 { + r#type, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "busy")] + Busy, +} + +impl Default for Type { + fn default() -> Type { + Self::Busy + } +} + diff --git a/crates/opencode-client/src/models/session_summarize_request.rs b/crates/opencode-client/src/models/session_summarize_request.rs new file mode 100644 index 0000000..2233ef8 --- /dev/null +++ b/crates/opencode-client/src/models/session_summarize_request.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionSummarizeRequest { + #[serde(rename = "providerID")] + pub provider_id: String, + #[serde(rename = "modelID")] + pub model_id: String, + #[serde(rename = "auto", skip_serializing_if = "Option::is_none")] + pub auto: Option, +} + +impl SessionSummarizeRequest { + pub fn new(provider_id: String, model_id: String) -> SessionSummarizeRequest { + SessionSummarizeRequest { + provider_id, + model_id, + auto: None, + } + } +} + diff --git a/crates/opencode-client/src/models/session_summary.rs b/crates/opencode-client/src/models/session_summary.rs new file mode 100644 index 0000000..44a6bd6 --- /dev/null +++ b/crates/opencode-client/src/models/session_summary.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionSummary { + #[serde(rename = "additions")] + pub additions: f64, + #[serde(rename = "deletions")] + pub deletions: f64, + #[serde(rename = "files")] + pub files: f64, + #[serde(rename = "diffs", skip_serializing_if = "Option::is_none")] + pub diffs: Option>, +} + +impl SessionSummary { + pub fn new(additions: f64, deletions: f64, files: f64) -> SessionSummary { + SessionSummary { + additions, + deletions, + files, + diffs: None, + } + } +} + diff --git a/crates/opencode-client/src/models/session_time.rs b/crates/opencode-client/src/models/session_time.rs new file mode 100644 index 0000000..cacdb6d --- /dev/null +++ b/crates/opencode-client/src/models/session_time.rs @@ -0,0 +1,36 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionTime { + #[serde(rename = "created", default)] + pub created: f64, + #[serde(rename = "updated", default)] + pub updated: f64, + #[serde(rename = "compacting", default, skip_serializing_if = "Option::is_none")] + pub compacting: Option, + #[serde(rename = "archived", default, skip_serializing_if = "Option::is_none")] + pub archived: Option, +} + +impl SessionTime { + pub fn new(created: f64, updated: f64) -> SessionTime { + SessionTime { + created, + updated, + compacting: None, + archived: None, + } + } +} + diff --git a/crates/opencode-client/src/models/session_update_request.rs b/crates/opencode-client/src/models/session_update_request.rs new file mode 100644 index 0000000..3396a60 --- /dev/null +++ b/crates/opencode-client/src/models/session_update_request.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionUpdateRequest { + #[serde(rename = "title", skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(rename = "time", skip_serializing_if = "Option::is_none")] + pub time: Option>, +} + +impl SessionUpdateRequest { + pub fn new() -> SessionUpdateRequest { + SessionUpdateRequest { + title: None, + time: None, + } + } +} + diff --git a/crates/opencode-client/src/models/session_update_request_time.rs b/crates/opencode-client/src/models/session_update_request_time.rs new file mode 100644 index 0000000..dde093e --- /dev/null +++ b/crates/opencode-client/src/models/session_update_request_time.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SessionUpdateRequestTime { + #[serde(rename = "archived", skip_serializing_if = "Option::is_none")] + pub archived: Option, +} + +impl SessionUpdateRequestTime { + pub fn new() -> SessionUpdateRequestTime { + SessionUpdateRequestTime { + archived: None, + } + } +} + diff --git a/crates/opencode-client/src/models/snapshot_part.rs b/crates/opencode-client/src/models/snapshot_part.rs new file mode 100644 index 0000000..b52618d --- /dev/null +++ b/crates/opencode-client/src/models/snapshot_part.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SnapshotPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "snapshot")] + pub snapshot: String, +} + +impl SnapshotPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, snapshot: String) -> SnapshotPart { + SnapshotPart { + id, + session_id, + message_id, + r#type, + snapshot, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "snapshot")] + Snapshot, +} + +impl Default for Type { + fn default() -> Type { + Self::Snapshot + } +} + diff --git a/crates/opencode-client/src/models/step_finish_part.rs b/crates/opencode-client/src/models/step_finish_part.rs new file mode 100644 index 0000000..f6e1418 --- /dev/null +++ b/crates/opencode-client/src/models/step_finish_part.rs @@ -0,0 +1,60 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct StepFinishPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "reason")] + pub reason: String, + #[serde(rename = "snapshot", skip_serializing_if = "Option::is_none")] + pub snapshot: Option, + #[serde(rename = "cost")] + pub cost: f64, + #[serde(rename = "tokens")] + pub tokens: Box, +} + +impl StepFinishPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, reason: String, cost: f64, tokens: models::AssistantMessageTokens) -> StepFinishPart { + StepFinishPart { + id, + session_id, + message_id, + r#type, + reason, + snapshot: None, + cost, + tokens: Box::new(tokens), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "step-finish")] + StepFinish, +} + +impl Default for Type { + fn default() -> Type { + Self::StepFinish + } +} + diff --git a/crates/opencode-client/src/models/step_start_part.rs b/crates/opencode-client/src/models/step_start_part.rs new file mode 100644 index 0000000..d55e1c6 --- /dev/null +++ b/crates/opencode-client/src/models/step_start_part.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct StepStartPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "snapshot", skip_serializing_if = "Option::is_none")] + pub snapshot: Option, +} + +impl StepStartPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type) -> StepStartPart { + StepStartPart { + id, + session_id, + message_id, + r#type, + snapshot: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "step-start")] + StepStart, +} + +impl Default for Type { + fn default() -> Type { + Self::StepStart + } +} + diff --git a/crates/opencode-client/src/models/subtask_part_input.rs b/crates/opencode-client/src/models/subtask_part_input.rs new file mode 100644 index 0000000..a7e7ba6 --- /dev/null +++ b/crates/opencode-client/src/models/subtask_part_input.rs @@ -0,0 +1,54 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SubtaskPartInput { + #[serde(rename = "id", skip_serializing_if = "Option::is_none")] + pub id: Option, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "prompt")] + pub prompt: String, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "agent")] + pub agent: String, + #[serde(rename = "command", skip_serializing_if = "Option::is_none")] + pub command: Option, +} + +impl SubtaskPartInput { + pub fn new(r#type: Type, prompt: String, description: String, agent: String) -> SubtaskPartInput { + SubtaskPartInput { + id: None, + r#type, + prompt, + description, + agent, + command: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "subtask")] + Subtask, +} + +impl Default for Type { + fn default() -> Type { + Self::Subtask + } +} + diff --git a/crates/opencode-client/src/models/symbol.rs b/crates/opencode-client/src/models/symbol.rs new file mode 100644 index 0000000..b472623 --- /dev/null +++ b/crates/opencode-client/src/models/symbol.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Symbol { + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "kind")] + pub kind: f64, + #[serde(rename = "location")] + pub location: Box, +} + +impl Symbol { + pub fn new(name: String, kind: f64, location: models::SymbolLocation) -> Symbol { + Symbol { + name, + kind, + location: Box::new(location), + } + } +} + diff --git a/crates/opencode-client/src/models/symbol_location.rs b/crates/opencode-client/src/models/symbol_location.rs new file mode 100644 index 0000000..29515c6 --- /dev/null +++ b/crates/opencode-client/src/models/symbol_location.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SymbolLocation { + #[serde(rename = "uri")] + pub uri: String, + #[serde(rename = "range")] + pub range: Box, +} + +impl SymbolLocation { + pub fn new(uri: String, range: models::Range) -> SymbolLocation { + SymbolLocation { + uri, + range: Box::new(range), + } + } +} + diff --git a/crates/opencode-client/src/models/symbol_source.rs b/crates/opencode-client/src/models/symbol_source.rs new file mode 100644 index 0000000..d0a7184 --- /dev/null +++ b/crates/opencode-client/src/models/symbol_source.rs @@ -0,0 +1,54 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct SymbolSource { + #[serde(rename = "text")] + pub text: Box, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "path")] + pub path: String, + #[serde(rename = "range")] + pub range: Box, + #[serde(rename = "name")] + pub name: String, + #[serde(rename = "kind")] + pub kind: i32, +} + +impl SymbolSource { + pub fn new(text: models::FilePartSourceText, r#type: Type, path: String, range: models::Range, name: String, kind: i32) -> SymbolSource { + SymbolSource { + text: Box::new(text), + r#type, + path, + range: Box::new(range), + name, + kind, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "symbol")] + Symbol, +} + +impl Default for Type { + fn default() -> Type { + Self::Symbol + } +} + diff --git a/crates/opencode-client/src/models/text_part.rs b/crates/opencode-client/src/models/text_part.rs new file mode 100644 index 0000000..3e1076f --- /dev/null +++ b/crates/opencode-client/src/models/text_part.rs @@ -0,0 +1,63 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TextPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "text")] + pub text: String, + #[serde(rename = "synthetic", skip_serializing_if = "Option::is_none")] + pub synthetic: Option, + #[serde(rename = "ignored", skip_serializing_if = "Option::is_none")] + pub ignored: Option, + #[serde(rename = "time", skip_serializing_if = "Option::is_none")] + pub time: Option>, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, +} + +impl TextPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, text: String) -> TextPart { + TextPart { + id, + session_id, + message_id, + r#type, + text, + synthetic: None, + ignored: None, + time: None, + metadata: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "text")] + Text, +} + +impl Default for Type { + fn default() -> Type { + Self::Text + } +} + diff --git a/crates/opencode-client/src/models/text_part_input.rs b/crates/opencode-client/src/models/text_part_input.rs new file mode 100644 index 0000000..90dd80a --- /dev/null +++ b/crates/opencode-client/src/models/text_part_input.rs @@ -0,0 +1,57 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TextPartInput { + #[serde(rename = "id", skip_serializing_if = "Option::is_none")] + pub id: Option, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "text")] + pub text: String, + #[serde(rename = "synthetic", skip_serializing_if = "Option::is_none")] + pub synthetic: Option, + #[serde(rename = "ignored", skip_serializing_if = "Option::is_none")] + pub ignored: Option, + #[serde(rename = "time", skip_serializing_if = "Option::is_none")] + pub time: Option>, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, +} + +impl TextPartInput { + pub fn new(r#type: Type, text: String) -> TextPartInput { + TextPartInput { + id: None, + r#type, + text, + synthetic: None, + ignored: None, + time: None, + metadata: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "text")] + Text, +} + +impl Default for Type { + fn default() -> Type { + Self::Text + } +} + diff --git a/crates/opencode-client/src/models/text_part_time.rs b/crates/opencode-client/src/models/text_part_time.rs new file mode 100644 index 0000000..189fd28 --- /dev/null +++ b/crates/opencode-client/src/models/text_part_time.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TextPartTime { + #[serde(rename = "start")] + pub start: f64, + #[serde(rename = "end", skip_serializing_if = "Option::is_none")] + pub end: Option, +} + +impl TextPartTime { + pub fn new(start: f64) -> TextPartTime { + TextPartTime { + start, + end: None, + } + } +} + diff --git a/crates/opencode-client/src/models/todo.rs b/crates/opencode-client/src/models/todo.rs new file mode 100644 index 0000000..10f861d --- /dev/null +++ b/crates/opencode-client/src/models/todo.rs @@ -0,0 +1,40 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct Todo { + /// Brief description of the task + #[serde(rename = "content")] + pub content: String, + /// Current status of the task: pending, in_progress, completed, cancelled + #[serde(rename = "status")] + pub status: String, + /// Priority level of the task: high, medium, low + #[serde(rename = "priority")] + pub priority: String, + /// Unique identifier for the todo item + #[serde(rename = "id")] + pub id: String, +} + +impl Todo { + pub fn new(content: String, status: String, priority: String, id: String) -> Todo { + Todo { + content, + status, + priority, + id, + } + } +} + diff --git a/crates/opencode-client/src/models/tool_list_item.rs b/crates/opencode-client/src/models/tool_list_item.rs new file mode 100644 index 0000000..6ae9131 --- /dev/null +++ b/crates/opencode-client/src/models/tool_list_item.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolListItem { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "description")] + pub description: String, + #[serde(rename = "parameters", deserialize_with = "Option::deserialize")] + pub parameters: Option, +} + +impl ToolListItem { + pub fn new(id: String, description: String, parameters: Option) -> ToolListItem { + ToolListItem { + id, + description, + parameters, + } + } +} + diff --git a/crates/opencode-client/src/models/tool_part.rs b/crates/opencode-client/src/models/tool_part.rs new file mode 100644 index 0000000..7bafa59 --- /dev/null +++ b/crates/opencode-client/src/models/tool_part.rs @@ -0,0 +1,60 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolPart { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "messageID")] + pub message_id: String, + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "callID")] + pub call_id: String, + #[serde(rename = "tool")] + pub tool: String, + #[serde(rename = "state")] + pub state: Box, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, +} + +impl ToolPart { + pub fn new(id: String, session_id: String, message_id: String, r#type: Type, call_id: String, tool: String, state: models::ToolState) -> ToolPart { + ToolPart { + id, + session_id, + message_id, + r#type, + call_id, + tool, + state: Box::new(state), + metadata: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "tool")] + Tool, +} + +impl Default for Type { + fn default() -> Type { + Self::Tool + } +} + diff --git a/crates/opencode-client/src/models/tool_state.rs b/crates/opencode-client/src/models/tool_state.rs new file mode 100644 index 0000000..7ae7140 --- /dev/null +++ b/crates/opencode-client/src/models/tool_state.rs @@ -0,0 +1,63 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolState { + #[serde(rename = "status", default)] + pub status: Status, + #[serde(rename = "input", default, skip_serializing_if = "Option::is_none")] + pub input: Option>, + #[serde(rename = "raw", default, skip_serializing_if = "Option::is_none")] + pub raw: Option, + #[serde(rename = "title", default, skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(rename = "metadata", default, skip_serializing_if = "Option::is_none")] + pub metadata: Option>, + #[serde(rename = "time", default, skip_serializing_if = "Option::is_none")] + pub time: Option>, + #[serde(rename = "output", default, skip_serializing_if = "Option::is_none")] + pub output: Option, + #[serde(rename = "attachments", default, skip_serializing_if = "Option::is_none")] + pub attachments: Option>, + #[serde(rename = "error", default, skip_serializing_if = "Option::is_none")] + pub error: Option, +} + +impl ToolState { + pub fn new(status: Status) -> ToolState { + ToolState { + status, + input: None, + raw: None, + title: None, + metadata: None, + time: None, + output: None, + attachments: None, + error: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize, Default)] +pub enum Status { + #[default] + #[serde(rename = "pending")] + Pending, + #[serde(rename = "running")] + Running, + #[serde(rename = "completed")] + Completed, + #[serde(rename = "error")] + Error, +} diff --git a/crates/opencode-client/src/models/tool_state_completed.rs b/crates/opencode-client/src/models/tool_state_completed.rs new file mode 100644 index 0000000..9573107 --- /dev/null +++ b/crates/opencode-client/src/models/tool_state_completed.rs @@ -0,0 +1,57 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolStateCompleted { + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "input")] + pub input: std::collections::HashMap, + #[serde(rename = "output")] + pub output: String, + #[serde(rename = "title")] + pub title: String, + #[serde(rename = "metadata")] + pub metadata: std::collections::HashMap, + #[serde(rename = "time")] + pub time: Box, + #[serde(rename = "attachments", skip_serializing_if = "Option::is_none")] + pub attachments: Option>, +} + +impl ToolStateCompleted { + pub fn new(status: Status, input: std::collections::HashMap, output: String, title: String, metadata: std::collections::HashMap, time: models::ToolStateCompletedTime) -> ToolStateCompleted { + ToolStateCompleted { + status, + input, + output, + title, + metadata, + time: Box::new(time), + attachments: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "completed")] + Completed, +} + +impl Default for Status { + fn default() -> Status { + Self::Completed + } +} + diff --git a/crates/opencode-client/src/models/tool_state_completed_time.rs b/crates/opencode-client/src/models/tool_state_completed_time.rs new file mode 100644 index 0000000..af009e9 --- /dev/null +++ b/crates/opencode-client/src/models/tool_state_completed_time.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolStateCompletedTime { + #[serde(rename = "start")] + pub start: f64, + #[serde(rename = "end")] + pub end: f64, + #[serde(rename = "compacted", skip_serializing_if = "Option::is_none")] + pub compacted: Option, +} + +impl ToolStateCompletedTime { + pub fn new(start: f64, end: f64) -> ToolStateCompletedTime { + ToolStateCompletedTime { + start, + end, + compacted: None, + } + } +} + diff --git a/crates/opencode-client/src/models/tool_state_error.rs b/crates/opencode-client/src/models/tool_state_error.rs new file mode 100644 index 0000000..9fe286a --- /dev/null +++ b/crates/opencode-client/src/models/tool_state_error.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolStateError { + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "input")] + pub input: std::collections::HashMap, + #[serde(rename = "error")] + pub error: String, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, + #[serde(rename = "time")] + pub time: Box, +} + +impl ToolStateError { + pub fn new(status: Status, input: std::collections::HashMap, error: String, time: models::ToolStateErrorTime) -> ToolStateError { + ToolStateError { + status, + input, + error, + metadata: None, + time: Box::new(time), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "error")] + Error, +} + +impl Default for Status { + fn default() -> Status { + Self::Error + } +} + diff --git a/crates/opencode-client/src/models/tool_state_error_time.rs b/crates/opencode-client/src/models/tool_state_error_time.rs new file mode 100644 index 0000000..a32917b --- /dev/null +++ b/crates/opencode-client/src/models/tool_state_error_time.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolStateErrorTime { + #[serde(rename = "start")] + pub start: f64, + #[serde(rename = "end")] + pub end: f64, +} + +impl ToolStateErrorTime { + pub fn new(start: f64, end: f64) -> ToolStateErrorTime { + ToolStateErrorTime { + start, + end, + } + } +} + diff --git a/crates/opencode-client/src/models/tool_state_pending.rs b/crates/opencode-client/src/models/tool_state_pending.rs new file mode 100644 index 0000000..5b0383e --- /dev/null +++ b/crates/opencode-client/src/models/tool_state_pending.rs @@ -0,0 +1,45 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolStatePending { + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "input")] + pub input: std::collections::HashMap, + #[serde(rename = "raw")] + pub raw: String, +} + +impl ToolStatePending { + pub fn new(status: Status, input: std::collections::HashMap, raw: String) -> ToolStatePending { + ToolStatePending { + status, + input, + raw, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "pending")] + Pending, +} + +impl Default for Status { + fn default() -> Status { + Self::Pending + } +} + diff --git a/crates/opencode-client/src/models/tool_state_running.rs b/crates/opencode-client/src/models/tool_state_running.rs new file mode 100644 index 0000000..7e7c5aa --- /dev/null +++ b/crates/opencode-client/src/models/tool_state_running.rs @@ -0,0 +1,51 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolStateRunning { + #[serde(rename = "status")] + pub status: Status, + #[serde(rename = "input")] + pub input: std::collections::HashMap, + #[serde(rename = "title", skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(rename = "metadata", skip_serializing_if = "Option::is_none")] + pub metadata: Option>, + #[serde(rename = "time")] + pub time: Box, +} + +impl ToolStateRunning { + pub fn new(status: Status, input: std::collections::HashMap, time: models::ToolStateRunningTime) -> ToolStateRunning { + ToolStateRunning { + status, + input, + title: None, + metadata: None, + time: Box::new(time), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Status { + #[serde(rename = "running")] + Running, +} + +impl Default for Status { + fn default() -> Status { + Self::Running + } +} + diff --git a/crates/opencode-client/src/models/tool_state_running_time.rs b/crates/opencode-client/src/models/tool_state_running_time.rs new file mode 100644 index 0000000..470a39b --- /dev/null +++ b/crates/opencode-client/src/models/tool_state_running_time.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct ToolStateRunningTime { + #[serde(rename = "start")] + pub start: f64, +} + +impl ToolStateRunningTime { + pub fn new(start: f64) -> ToolStateRunningTime { + ToolStateRunningTime { + start, + } + } +} + diff --git a/crates/opencode-client/src/models/tui_control_next_200_response.rs b/crates/opencode-client/src/models/tui_control_next_200_response.rs new file mode 100644 index 0000000..48e08af --- /dev/null +++ b/crates/opencode-client/src/models/tui_control_next_200_response.rs @@ -0,0 +1,30 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TuiControlNext200Response { + #[serde(rename = "path")] + pub path: String, + #[serde(rename = "body", deserialize_with = "Option::deserialize")] + pub body: Option, +} + +impl TuiControlNext200Response { + pub fn new(path: String, body: Option) -> TuiControlNext200Response { + TuiControlNext200Response { + path, + body, + } + } +} + diff --git a/crates/opencode-client/src/models/tui_execute_command_request.rs b/crates/opencode-client/src/models/tui_execute_command_request.rs new file mode 100644 index 0000000..b8e65e9 --- /dev/null +++ b/crates/opencode-client/src/models/tui_execute_command_request.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TuiExecuteCommandRequest { + #[serde(rename = "command")] + pub command: String, +} + +impl TuiExecuteCommandRequest { + pub fn new(command: String) -> TuiExecuteCommandRequest { + TuiExecuteCommandRequest { + command, + } + } +} + diff --git a/crates/opencode-client/src/models/tui_publish_request.rs b/crates/opencode-client/src/models/tui_publish_request.rs new file mode 100644 index 0000000..b47ab01 --- /dev/null +++ b/crates/opencode-client/src/models/tui_publish_request.rs @@ -0,0 +1,46 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TuiPublishRequest { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "properties")] + pub properties: Box, +} + +impl TuiPublishRequest { + pub fn new(r#type: Type, properties: models::TuiShowToastRequest) -> TuiPublishRequest { + TuiPublishRequest { + r#type, + properties: Box::new(properties), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "tui.prompt.append")] + TuiPromptAppend, + #[serde(rename = "tui.command.execute")] + TuiCommandExecute, + #[serde(rename = "tui.toast.show")] + TuiToastShow, +} + +impl Default for Type { + fn default() -> Type { + Self::TuiPromptAppend + } +} + diff --git a/crates/opencode-client/src/models/tui_show_toast_request.rs b/crates/opencode-client/src/models/tui_show_toast_request.rs new file mode 100644 index 0000000..7a9a180 --- /dev/null +++ b/crates/opencode-client/src/models/tui_show_toast_request.rs @@ -0,0 +1,55 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct TuiShowToastRequest { + #[serde(rename = "title", skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(rename = "message")] + pub message: String, + #[serde(rename = "variant")] + pub variant: Variant, + /// Duration in milliseconds + #[serde(rename = "duration", skip_serializing_if = "Option::is_none")] + pub duration: Option, +} + +impl TuiShowToastRequest { + pub fn new(message: String, variant: Variant) -> TuiShowToastRequest { + TuiShowToastRequest { + title: None, + message, + variant, + duration: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Variant { + #[serde(rename = "info")] + Info, + #[serde(rename = "success")] + Success, + #[serde(rename = "warning")] + Warning, + #[serde(rename = "error")] + Error, +} + +impl Default for Variant { + fn default() -> Variant { + Self::Info + } +} + diff --git a/crates/opencode-client/src/models/unknown_error.rs b/crates/opencode-client/src/models/unknown_error.rs new file mode 100644 index 0000000..6169c93 --- /dev/null +++ b/crates/opencode-client/src/models/unknown_error.rs @@ -0,0 +1,42 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct UnknownError { + #[serde(rename = "name")] + pub name: Name, + #[serde(rename = "data")] + pub data: Box, +} + +impl UnknownError { + pub fn new(name: Name, data: models::UnknownErrorData) -> UnknownError { + UnknownError { + name, + data: Box::new(data), + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Name { + #[serde(rename = "UnknownError")] + UnknownError, +} + +impl Default for Name { + fn default() -> Name { + Self::UnknownError + } +} + diff --git a/crates/opencode-client/src/models/unknown_error_data.rs b/crates/opencode-client/src/models/unknown_error_data.rs new file mode 100644 index 0000000..a69924f --- /dev/null +++ b/crates/opencode-client/src/models/unknown_error_data.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct UnknownErrorData { + #[serde(rename = "message")] + pub message: String, +} + +impl UnknownErrorData { + pub fn new(message: String) -> UnknownErrorData { + UnknownErrorData { + message, + } + } +} + diff --git a/crates/opencode-client/src/models/user_message.rs b/crates/opencode-client/src/models/user_message.rs new file mode 100644 index 0000000..386a99e --- /dev/null +++ b/crates/opencode-client/src/models/user_message.rs @@ -0,0 +1,66 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct UserMessage { + #[serde(rename = "id")] + pub id: String, + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(rename = "role")] + pub role: Role, + #[serde(rename = "time")] + pub time: Box, + #[serde(rename = "summary", skip_serializing_if = "Option::is_none")] + pub summary: Option>, + #[serde(rename = "agent")] + pub agent: String, + #[serde(rename = "model")] + pub model: Box, + #[serde(rename = "system", skip_serializing_if = "Option::is_none")] + pub system: Option, + #[serde(rename = "tools", skip_serializing_if = "Option::is_none")] + pub tools: Option>, + #[serde(rename = "variant", skip_serializing_if = "Option::is_none")] + pub variant: Option, +} + +impl UserMessage { + pub fn new(id: String, session_id: String, role: Role, time: models::UserMessageTime, agent: String, model: models::SessionPromptRequestModel) -> UserMessage { + UserMessage { + id, + session_id, + role, + time: Box::new(time), + summary: None, + agent, + model: Box::new(model), + system: None, + tools: None, + variant: None, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Role { + #[serde(rename = "user")] + User, +} + +impl Default for Role { + fn default() -> Role { + Self::User + } +} + diff --git a/crates/opencode-client/src/models/user_message_summary.rs b/crates/opencode-client/src/models/user_message_summary.rs new file mode 100644 index 0000000..fb52632 --- /dev/null +++ b/crates/opencode-client/src/models/user_message_summary.rs @@ -0,0 +1,33 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct UserMessageSummary { + #[serde(rename = "title", skip_serializing_if = "Option::is_none")] + pub title: Option, + #[serde(rename = "body", skip_serializing_if = "Option::is_none")] + pub body: Option, + #[serde(rename = "diffs")] + pub diffs: Vec, +} + +impl UserMessageSummary { + pub fn new(diffs: Vec) -> UserMessageSummary { + UserMessageSummary { + title: None, + body: None, + diffs, + } + } +} + diff --git a/crates/opencode-client/src/models/user_message_time.rs b/crates/opencode-client/src/models/user_message_time.rs new file mode 100644 index 0000000..3a2980d --- /dev/null +++ b/crates/opencode-client/src/models/user_message_time.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct UserMessageTime { + #[serde(rename = "created", default)] + pub created: f64, +} + +impl UserMessageTime { + pub fn new(created: f64) -> UserMessageTime { + UserMessageTime { + created, + } + } +} + diff --git a/crates/opencode-client/src/models/vcs_info.rs b/crates/opencode-client/src/models/vcs_info.rs new file mode 100644 index 0000000..ade0eaf --- /dev/null +++ b/crates/opencode-client/src/models/vcs_info.rs @@ -0,0 +1,27 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct VcsInfo { + #[serde(rename = "branch")] + pub branch: String, +} + +impl VcsInfo { + pub fn new(branch: String) -> VcsInfo { + VcsInfo { + branch, + } + } +} + diff --git a/crates/opencode-client/src/models/well_known_auth.rs b/crates/opencode-client/src/models/well_known_auth.rs new file mode 100644 index 0000000..278c7ec --- /dev/null +++ b/crates/opencode-client/src/models/well_known_auth.rs @@ -0,0 +1,45 @@ +/* + * opencode + * + * opencode api + * + * The version of the OpenAPI document: 0.0.3 + * + * Generated by: https://openapi-generator.tech + */ + +use crate::models; +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Default, Debug, PartialEq, Serialize, Deserialize)] +pub struct WellKnownAuth { + #[serde(rename = "type")] + pub r#type: Type, + #[serde(rename = "key")] + pub key: String, + #[serde(rename = "token")] + pub token: String, +} + +impl WellKnownAuth { + pub fn new(r#type: Type, key: String, token: String) -> WellKnownAuth { + WellKnownAuth { + r#type, + key, + token, + } + } +} +/// +#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] +pub enum Type { + #[serde(rename = "wellknown")] + Wellknown, +} + +impl Default for Type { + fn default() -> Type { + Self::Wellknown + } +} + diff --git a/crates/opencode/Cargo.toml b/crates/opencode/Cargo.toml deleted file mode 100644 index 105f5f6..0000000 --- a/crates/opencode/Cargo.toml +++ /dev/null @@ -1,22 +0,0 @@ -[package] -name = "opencode" -version.workspace = true -edition.workspace = true -rust-version.workspace = true - -[dependencies] -opencode_core.workspace = true -tokio.workspace = true -reqwest.workspace = true -futures.workspace = true -eventsource-stream.workspace = true -bytes.workspace = true -serde.workspace = true -serde_json.workspace = true -thiserror.workspace = true -tracing.workspace = true -uuid.workspace = true -chrono.workspace = true - -[dev-dependencies] -tokio = { workspace = true, features = ["test-util"] } diff --git a/crates/opencode/src/client.rs b/crates/opencode/src/client.rs deleted file mode 100644 index 79cd251..0000000 --- a/crates/opencode/src/client.rs +++ /dev/null @@ -1,186 +0,0 @@ -use reqwest::Client; - -use crate::error::{OpenCodeError, Result}; -use crate::types::{ - CreateSessionRequest, Message, MessageResponse, SendMessageRequest, Session, - SessionListResponse, SessionMessagesResponse, -}; - -pub struct OpenCodeClient { - base_url: String, - client: Client, -} - -impl OpenCodeClient { - pub fn new(base_url: impl Into) -> Self { - Self { - base_url: base_url.into(), - client: Client::new(), - } - } - - pub fn with_client(base_url: impl Into, client: Client) -> Self { - Self { - base_url: base_url.into(), - client, - } - } - - pub async fn create_session(&self, title: Option) -> Result { - let request = CreateSessionRequest { - title, - parent_id: None, - }; - - let response = self - .client - .post(format!("{}/session", self.base_url)) - .json(&request) - .send() - .await?; - - self.handle_response(response).await - } - - pub async fn get_session(&self, session_id: &str) -> Result { - let response = self - .client - .get(format!("{}/session/{}", self.base_url, session_id)) - .send() - .await?; - - self.handle_response(response).await - } - - pub async fn list_sessions(&self) -> Result> { - let response = self - .client - .get(format!("{}/sessions", self.base_url)) - .send() - .await?; - - let list: SessionListResponse = self.handle_response(response).await?; - Ok(list.sessions) - } - - pub async fn send_message( - &self, - session_id: &str, - prompt: &str, - model: Option<&str>, - ) -> Result { - let mut request = SendMessageRequest::new(prompt); - if let Some(m) = model { - request = request.with_model(m); - } - - let response = self - .client - .post(format!("{}/session/{}/message", self.base_url, session_id)) - .json(&request) - .send() - .await?; - - self.handle_response(response).await - } - - pub async fn send_message_async(&self, session_id: &str, prompt: &str) -> Result<()> { - let request = SendMessageRequest::new(prompt); - - let response = self - .client - .post(format!( - "{}/session/{}/prompt_async", - self.base_url, session_id - )) - .json(&request) - .send() - .await?; - - if !response.status().is_success() { - let status = response.status(); - let body = response.text().await.unwrap_or_default(); - return Err(OpenCodeError::InvalidResponse(format!( - "Status {}: {}", - status, body - ))); - } - - Ok(()) - } - - pub async fn abort_session(&self, session_id: &str) -> Result<()> { - let response = self - .client - .post(format!("{}/session/{}/abort", self.base_url, session_id)) - .send() - .await?; - - if !response.status().is_success() { - let status = response.status(); - let body = response.text().await.unwrap_or_default(); - return Err(OpenCodeError::InvalidResponse(format!( - "Status {}: {}", - status, body - ))); - } - - Ok(()) - } - - pub async fn get_messages(&self, session_id: &str) -> Result> { - let response = self - .client - .get(format!("{}/session/{}/messages", self.base_url, session_id)) - .send() - .await?; - - let messages: SessionMessagesResponse = self.handle_response(response).await?; - Ok(messages.messages) - } - - async fn handle_response( - &self, - response: reqwest::Response, - ) -> Result { - let status = response.status(); - - if status == reqwest::StatusCode::NOT_FOUND { - return Err(OpenCodeError::SessionNotFound( - "Resource not found".to_string(), - )); - } - - if !status.is_success() { - let body = response.text().await.unwrap_or_default(); - return Err(OpenCodeError::InvalidResponse(format!( - "Status {}: {}", - status, body - ))); - } - - let body = response.json().await?; - Ok(body) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_client_creation() { - let client = OpenCodeClient::new("http://localhost:4096"); - assert_eq!(client.base_url, "http://localhost:4096"); - } - - #[test] - fn test_send_message_request() { - let request = SendMessageRequest::new("Hello world"); - assert_eq!(request.parts.len(), 1); - assert!(request.model.is_none()); - - let request_with_model = SendMessageRequest::new("Hello").with_model("gpt-4"); - assert_eq!(request_with_model.model, Some("gpt-4".to_string())); - } -} diff --git a/crates/opencode/src/error.rs b/crates/opencode/src/error.rs deleted file mode 100644 index e07c1c5..0000000 --- a/crates/opencode/src/error.rs +++ /dev/null @@ -1,24 +0,0 @@ -use thiserror::Error; - -#[derive(Debug, Error)] -pub enum OpenCodeError { - #[error("HTTP request failed: {0}")] - Request(#[from] reqwest::Error), - - #[error("JSON serialization failed: {0}")] - Serialization(#[from] serde_json::Error), - - #[error("Session not found: {0}")] - SessionNotFound(String), - - #[error("Invalid response: {0}")] - InvalidResponse(String), - - #[error("Connection failed: {0}")] - Connection(String), - - #[error("Event stream error: {0}")] - EventStream(String), -} - -pub type Result = std::result::Result; diff --git a/crates/opencode/src/events.rs b/crates/opencode/src/events.rs deleted file mode 100644 index 8f21681..0000000 --- a/crates/opencode/src/events.rs +++ /dev/null @@ -1,108 +0,0 @@ -use eventsource_stream::Eventsource; -use futures::StreamExt; -use serde::Deserialize; -use tokio::sync::mpsc; - -use crate::error::{OpenCodeError, Result}; - -#[derive(Debug, Clone, Deserialize)] -#[serde(tag = "type", rename_all = "snake_case")] -pub enum OpenCodeEvent { - #[serde(rename = "session.message")] - SessionMessage { session_id: String, content: String }, - - #[serde(rename = "session.completed")] - SessionCompleted { session_id: String }, - - #[serde(rename = "session.error")] - SessionError { session_id: String, error: String }, - - #[serde(rename = "task.status_changed")] - TaskStatusChanged { task_id: String, status: String }, - - #[serde(other)] - Unknown, -} - -pub struct EventStream { - base_url: String, - client: reqwest::Client, -} - -impl EventStream { - pub fn new(base_url: impl Into) -> Self { - Self { - base_url: base_url.into(), - client: reqwest::Client::new(), - } - } - - pub async fn connect(&self) -> Result { - let url = format!("{}/event", self.base_url); - - let response = self - .client - .get(&url) - .header("Accept", "text/event-stream") - .send() - .await - .map_err(OpenCodeError::Request)?; - - if !response.status().is_success() { - return Err(OpenCodeError::Connection(format!( - "Failed to connect to event stream: {}", - response.status() - ))); - } - - let (tx, rx) = mpsc::channel::>(100); - - let byte_stream = response.bytes_stream(); - - tokio::spawn(async move { - let mut event_stream = byte_stream.eventsource(); - - while let Some(event_result) = event_stream.next().await { - match event_result { - Ok(event) => { - if event.data.is_empty() { - continue; - } - - match serde_json::from_str::(&event.data) { - Ok(parsed) => { - if tx.send(Ok(parsed)).await.is_err() { - break; - } - } - Err(e) => { - tracing::warn!( - "Failed to parse event: {} - data: {}", - e, - event.data - ); - } - } - } - Err(e) => { - let err_msg = format!("{}", e); - let _ = tx.send(Err(OpenCodeError::EventStream(err_msg))).await; - break; - } - } - } - }); - - Ok(EventReceiver { rx }) - } -} - -pub struct EventReceiver { - rx: mpsc::Receiver>, -} - -impl EventReceiver { - pub async fn next_event(&mut self) -> Option> { - self.rx.recv().await - } -} diff --git a/crates/opencode/src/lib.rs b/crates/opencode/src/lib.rs deleted file mode 100644 index 01a11b1..0000000 --- a/crates/opencode/src/lib.rs +++ /dev/null @@ -1,9 +0,0 @@ -pub mod client; -pub mod error; -pub mod events; -pub mod types; - -pub use client::OpenCodeClient; -pub use error::{OpenCodeError, Result}; -pub use events::{EventReceiver, EventStream, OpenCodeEvent}; -pub use types::*; diff --git a/crates/opencode/src/types.rs b/crates/opencode/src/types.rs deleted file mode 100644 index 4a51b79..0000000 --- a/crates/opencode/src/types.rs +++ /dev/null @@ -1,75 +0,0 @@ -use chrono::{DateTime, Utc}; -use serde::{Deserialize, Serialize}; - -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct Session { - pub id: String, - pub title: Option, - pub parent_id: Option, - pub created_at: Option>, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct CreateSessionRequest { - pub title: Option, - pub parent_id: Option, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -#[serde(tag = "type", rename_all = "snake_case")] -pub enum Part { - Text { text: String }, -} - -impl Part { - pub fn text(content: impl Into) -> Self { - Self::Text { - text: content.into(), - } - } -} - -#[derive(Debug, Clone, Serialize, Deserialize, Default)] -pub struct SendMessageRequest { - pub parts: Vec, - #[serde(skip_serializing_if = "Option::is_none")] - pub model: Option, -} - -impl SendMessageRequest { - pub fn new(prompt: impl Into) -> Self { - Self { - parts: vec![Part::text(prompt)], - model: None, - } - } - - pub fn with_model(mut self, model: impl Into) -> Self { - self.model = Some(model.into()); - self - } -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct Message { - pub id: String, - pub role: String, - pub content: String, - pub created_at: Option>, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct MessageResponse { - pub session_id: String, - pub message: Message, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct SessionListResponse { - pub sessions: Vec, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct SessionMessagesResponse { - pub messages: Vec, -} diff --git a/crates/orchestrator/Cargo.toml b/crates/orchestrator/Cargo.toml index e6a1cc2..5cdd67a 100644 --- a/crates/orchestrator/Cargo.toml +++ b/crates/orchestrator/Cargo.toml @@ -4,13 +4,21 @@ version.workspace = true edition.workspace = true rust-version.workspace = true +[features] +default = [] +typescript = ["ts-rs"] +openapi = ["utoipa"] + [dependencies] +ts-rs = { workspace = true, optional = true } +utoipa = { workspace = true, optional = true } opencode_core.workspace = true -opencode.workspace = true +opencode_client.workspace = true db.workspace = true vcs.workspace = true events.workspace = true -tokio = { workspace = true, features = ["fs"] } +tokio = { workspace = true, features = ["fs", "sync"] } +tokio-stream = { version = "0.1", features = ["sync"] } serde.workspace = true serde_json.workspace = true thiserror.workspace = true @@ -18,6 +26,13 @@ tracing.workspace = true uuid.workspace = true chrono.workspace = true async-trait.workspace = true +futures = "0.3" +json-patch = "3" +axum = { workspace = true } +reqwest = { workspace = true } +eventsource-stream.workspace = true +bytes.workspace = true +urlencoding = "2" [dev-dependencies] tokio = { workspace = true, features = ["test-util"] } diff --git a/crates/orchestrator/src/activity_store.rs b/crates/orchestrator/src/activity_store.rs new file mode 100644 index 0000000..07f9373 --- /dev/null +++ b/crates/orchestrator/src/activity_store.rs @@ -0,0 +1,683 @@ +use std::collections::{HashMap, VecDeque}; +use std::sync::{Arc, RwLock}; + +use axum::extract::ws::Message as WsMessage; +use chrono::{DateTime, Utc}; +use db::{CreateSessionActivity, SessionActivityRepository}; +use futures::{Stream, StreamExt}; +use serde::{Deserialize, Serialize}; +use tokio::sync::broadcast; +use tokio_stream::wrappers::BroadcastStream; +use uuid::Uuid; + +const HISTORY_BYTES_LIMIT: usize = 10 * 1024 * 1024; +const CHANNEL_CAPACITY: usize = 1000; + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[cfg_attr(feature = "typescript", derive(ts_rs::TS))] +#[cfg_attr(feature = "typescript", ts(export))] +#[serde(tag = "type", rename_all = "snake_case")] +pub enum SessionActivityMsg { + ToolCall { + id: String, + tool_name: String, + #[cfg_attr(feature = "typescript", ts(type = "Record | null"))] + args: Option, + timestamp: DateTime, + }, + ToolResult { + id: String, + tool_name: String, + #[cfg_attr(feature = "typescript", ts(type = "Record | null"))] + args: Option, + result: String, + success: bool, + timestamp: DateTime, + }, + AgentMessage { + id: String, + content: String, + is_partial: bool, + timestamp: DateTime, + }, + Reasoning { + id: String, + content: String, + timestamp: DateTime, + }, + StepStart { + id: String, + step_name: Option, + timestamp: DateTime, + }, + JsonPatch { + #[cfg_attr(feature = "typescript", ts(type = "unknown[]"))] + patch: json_patch::Patch, + timestamp: DateTime, + }, + Finished { + success: bool, + error: Option, + timestamp: DateTime, + }, +} + +impl SessionActivityMsg { + pub fn id(&self) -> Option<&str> { + match self { + Self::ToolCall { id, .. } => Some(id), + Self::ToolResult { id, .. } => Some(id), + Self::AgentMessage { id, .. } => Some(id), + Self::Reasoning { id, .. } => Some(id), + Self::StepStart { id, .. } => Some(id), + Self::JsonPatch { .. } => None, + Self::Finished { .. } => None, + } + } + + pub fn approx_bytes(&self) -> usize { + const OVERHEAD: usize = 64; + match self { + Self::ToolCall { tool_name, args, .. } => { + OVERHEAD + tool_name.len() + args.as_ref().map(|a| a.to_string().len()).unwrap_or(0) + } + Self::ToolResult { tool_name, result, args, .. } => { + OVERHEAD + + tool_name.len() + + result.len() + + args.as_ref().map(|a| a.to_string().len()).unwrap_or(0) + } + Self::AgentMessage { content, .. } => OVERHEAD + content.len(), + Self::Reasoning { content, .. } => OVERHEAD + content.len(), + Self::StepStart { step_name, .. } => { + OVERHEAD + step_name.as_ref().map(|s| s.len()).unwrap_or(0) + } + Self::JsonPatch { patch, .. } => { + OVERHEAD + serde_json::to_string(patch).map(|s| s.len()).unwrap_or(2) + } + Self::Finished { error, .. } => OVERHEAD + error.as_ref().map(|e| e.len()).unwrap_or(0), + } + } + + pub fn to_ws_message(&self) -> Result { + let json = serde_json::to_string(self)?; + Ok(WsMessage::Text(json.into())) + } + + pub fn to_ws_message_unchecked(&self) -> WsMessage { + let json = match self { + Self::Finished { .. } => serde_json::to_string(self) + .unwrap_or_else(|_| r#"{"type":"finished","success":false}"#.to_string()), + _ => serde_json::to_string(self) + .unwrap_or_else(|_| r#"{"type":"error","message":"serialization_failed"}"#.to_string()), + }; + WsMessage::Text(json.into()) + } + + pub fn tool_call(id: impl Into, tool_name: impl Into, args: Option) -> Self { + Self::ToolCall { + id: id.into(), + tool_name: tool_name.into(), + args, + timestamp: Utc::now(), + } + } + + pub fn tool_result( + id: impl Into, + tool_name: impl Into, + args: Option, + result: impl Into, + success: bool, + ) -> Self { + Self::ToolResult { + id: id.into(), + tool_name: tool_name.into(), + args, + result: result.into(), + success, + timestamp: Utc::now(), + } + } + + pub fn agent_message(id: impl Into, content: impl Into, is_partial: bool) -> Self { + Self::AgentMessage { + id: id.into(), + content: content.into(), + is_partial, + timestamp: Utc::now(), + } + } + + pub fn finished(success: bool, error: Option) -> Self { + Self::Finished { + success, + error, + timestamp: Utc::now(), + } + } +} + +#[derive(Clone)] +struct StoredMsg { + msg: SessionActivityMsg, + bytes: usize, +} + +struct StoreInner { + history: VecDeque, + total_bytes: usize, +} + +pub struct SessionActivityStore { + session_id: Uuid, + inner: RwLock, + sender: broadcast::Sender, + repository: Option, +} + +impl SessionActivityStore { + pub fn new(session_id: Uuid) -> Self { + let (sender, _) = broadcast::channel(CHANNEL_CAPACITY); + Self { + session_id, + inner: RwLock::new(StoreInner { + history: VecDeque::with_capacity(64), + total_bytes: 0, + }), + sender, + repository: None, + } + } + + pub fn with_repository(mut self, repository: SessionActivityRepository) -> Self { + self.repository = Some(repository); + self + } + + pub fn session_id(&self) -> Uuid { + self.session_id + } + + /// Load historical activities from DB into the in-memory store. + /// Call this after creating the store to populate it with persisted activities. + pub async fn load_from_db(&self) -> Result { + let Some(ref repo) = self.repository else { + return Ok(0); + }; + + let activities = repo.find_by_session_id(self.session_id).await?; + let count = activities.len(); + + let mut inner = self.inner.write().unwrap(); + for activity in activities { + // Reconstruct SessionActivityMsg from stored data + if let Some(msg) = self.activity_to_msg(&activity) { + let bytes = msg.approx_bytes(); + + // Check memory limit + while inner.total_bytes.saturating_add(bytes) > HISTORY_BYTES_LIMIT { + if let Some(front) = inner.history.pop_front() { + inner.total_bytes = inner.total_bytes.saturating_sub(front.bytes); + } else { + break; + } + } + + inner.history.push_back(StoredMsg { msg, bytes }); + inner.total_bytes = inner.total_bytes.saturating_add(bytes); + } + } + + Ok(count) + } + + fn activity_to_msg(&self, activity: &db::models::SessionActivity) -> Option { + // Reconstruct the message from the stored JSON data + // The data field should contain the full serialized message + serde_json::from_value(activity.data.clone()).ok() + } + + pub fn push(&self, msg: SessionActivityMsg) { + let _ = self.sender.send(msg.clone()); + + // Persist to DB asynchronously if repository is available + if let Some(ref repo) = self.repository { + let repo = repo.clone(); + let session_id = self.session_id; + let msg_clone = msg.clone(); + tokio::spawn(async move { + let activity_type = match &msg_clone { + SessionActivityMsg::ToolCall { .. } => "tool_call", + SessionActivityMsg::ToolResult { .. } => "tool_result", + SessionActivityMsg::AgentMessage { .. } => "agent_message", + SessionActivityMsg::Reasoning { .. } => "reasoning", + SessionActivityMsg::StepStart { .. } => "step_start", + SessionActivityMsg::JsonPatch { .. } => "json_patch", + SessionActivityMsg::Finished { .. } => "finished", + }; + let activity_id = msg_clone.id().map(|s| s.to_string()); + let data = serde_json::to_value(&msg_clone).unwrap_or(serde_json::Value::Null); + + let create = CreateSessionActivity::new( + session_id, + activity_type, + activity_id, + data, + ); + + if let Err(e) = repo.create(&create).await { + tracing::warn!("Failed to persist activity to DB: {:?}", e); + } + }); + } + + let bytes = msg.approx_bytes(); + let mut inner = self.inner.write().unwrap(); + + while inner.total_bytes.saturating_add(bytes) > HISTORY_BYTES_LIMIT { + if let Some(front) = inner.history.pop_front() { + inner.total_bytes = inner.total_bytes.saturating_sub(front.bytes); + } else { + break; + } + } + + inner.history.push_back(StoredMsg { msg, bytes }); + inner.total_bytes = inner.total_bytes.saturating_add(bytes); + } + + pub fn push_tool_call(&self, id: impl Into, tool_name: impl Into, args: Option) { + self.push(SessionActivityMsg::tool_call(id, tool_name, args)); + } + + pub fn push_tool_result( + &self, + id: impl Into, + tool_name: impl Into, + args: Option, + result: impl Into, + success: bool, + ) { + self.push(SessionActivityMsg::tool_result(id, tool_name, args, result, success)); + } + + pub fn push_agent_message(&self, id: impl Into, content: impl Into, is_partial: bool) { + self.push(SessionActivityMsg::agent_message(id, content, is_partial)); + } + + pub fn push_patch(&self, patch: json_patch::Patch) { + self.push(SessionActivityMsg::JsonPatch { + patch, + timestamp: Utc::now(), + }); + } + + pub fn push_finished(&self, success: bool, error: Option) { + self.push(SessionActivityMsg::finished(success, error)); + } + + pub fn subscribe(&self) -> broadcast::Receiver { + self.sender.subscribe() + } + + pub fn get_history(&self) -> Vec { + self.inner + .read() + .unwrap() + .history + .iter() + .map(|s| s.msg.clone()) + .collect() + } + + pub fn history_plus_stream( + &self, + ) -> impl Stream> + Send + 'static { + let history = self.get_history(); + let rx = self.subscribe(); + + let hist_stream = futures::stream::iter(history.into_iter().map(Ok::<_, std::io::Error>)); + let live_stream = BroadcastStream::new(rx).filter_map( + |res: Result| async move { res.ok().map(Ok::<_, std::io::Error>) }, + ); + + hist_stream.chain(live_stream) + } + + pub fn history_len(&self) -> usize { + self.inner.read().unwrap().history.len() + } + + pub fn history_bytes(&self) -> usize { + self.inner.read().unwrap().total_bytes + } + + pub fn subscriber_count(&self) -> usize { + self.sender.receiver_count() + } +} + +#[derive(Clone, Default)] +pub struct SessionActivityRegistry { + stores: Arc>>>, + repository: Option, +} + +impl SessionActivityRegistry { + pub fn new() -> Self { + Self { + stores: Arc::new(RwLock::new(HashMap::new())), + repository: None, + } + } + + pub fn with_repository(mut self, repository: SessionActivityRepository) -> Self { + self.repository = Some(repository); + self + } + + pub fn get_or_create(&self, session_id: Uuid) -> Arc { + { + let stores = self.stores.read().unwrap(); + if let Some(store) = stores.get(&session_id) { + return Arc::clone(store); + } + } + + let mut stores = self.stores.write().unwrap(); + if let Some(store) = stores.get(&session_id) { + return Arc::clone(store); + } + + let store = if let Some(ref repo) = self.repository { + SessionActivityStore::new(session_id).with_repository(repo.clone()) + } else { + SessionActivityStore::new(session_id) + }; + let store = Arc::new(store); + stores.insert(session_id, Arc::clone(&store)); + store + } + + /// Get or create a store, loading history from DB if available. + /// This is an async version that ensures historical data is loaded. + pub async fn get_or_create_with_history(&self, session_id: Uuid) -> Arc { + // Check if already exists + { + let stores = self.stores.read().unwrap(); + if let Some(store) = stores.get(&session_id) { + return Arc::clone(store); + } + } + + // Create the store outside the lock + let store = if let Some(ref repo) = self.repository { + SessionActivityStore::new(session_id).with_repository(repo.clone()) + } else { + SessionActivityStore::new(session_id) + }; + let store = Arc::new(store); + + // Load from DB if repository is available (before acquiring write lock) + if self.repository.is_some() { + if let Err(e) = store.load_from_db().await { + tracing::warn!("Failed to load activities from DB for session {}: {:?}", session_id, e); + } + } + + // Now acquire write lock and insert (or return existing if race) + let mut stores = self.stores.write().unwrap(); + if let Some(existing) = stores.get(&session_id) { + // Another task created the store while we were loading + return Arc::clone(existing); + } + + stores.insert(session_id, Arc::clone(&store)); + store + } + + pub fn get(&self, session_id: &Uuid) -> Option> { + self.stores.read().unwrap().get(session_id).cloned() + } + + pub fn remove(&self, session_id: &Uuid) -> Option> { + self.stores.write().unwrap().remove(session_id) + } + + pub fn session_ids(&self) -> Vec { + self.stores.read().unwrap().keys().copied().collect() + } + + pub fn len(&self) -> usize { + self.stores.read().unwrap().len() + } + + pub fn is_empty(&self) -> bool { + self.stores.read().unwrap().is_empty() + } + + pub fn repository(&self) -> Option<&SessionActivityRepository> { + self.repository.as_ref() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_activity_msg_creation() { + let tool_call = SessionActivityMsg::tool_call("tc-1", "read_file", None); + assert!(matches!(tool_call, SessionActivityMsg::ToolCall { .. })); + assert_eq!(tool_call.id(), Some("tc-1")); + + let tool_result = SessionActivityMsg::tool_result( + "tc-1", + "read_file", + None, + "file contents", + true, + ); + assert!(matches!(tool_result, SessionActivityMsg::ToolResult { .. })); + + let finished = SessionActivityMsg::finished(true, None); + assert!(matches!(finished, SessionActivityMsg::Finished { .. })); + assert_eq!(finished.id(), None); + } + + #[test] + fn test_activity_msg_serialization() { + let msg = SessionActivityMsg::tool_call("tc-1", "bash", Some(serde_json::json!({"command": "ls"}))); + let json = serde_json::to_string(&msg).unwrap(); + assert!(json.contains("tool_call")); + assert!(json.contains("bash")); + assert!(json.contains("tc-1")); + } + + #[test] + fn test_store_push_and_history() { + let store = SessionActivityStore::new(Uuid::new_v4()); + + store.push_tool_call("tc-1", "read_file", None); + store.push_tool_result("tc-1", "read_file", None, "contents", true); + store.push_agent_message("msg-1", "Hello", false); + + let history = store.get_history(); + assert_eq!(history.len(), 3); + assert!(matches!(history[0], SessionActivityMsg::ToolCall { .. })); + assert!(matches!(history[1], SessionActivityMsg::ToolResult { .. })); + assert!(matches!(history[2], SessionActivityMsg::AgentMessage { .. })); + } + + #[tokio::test] + async fn test_store_broadcast() { + let store = Arc::new(SessionActivityStore::new(Uuid::new_v4())); + + let mut rx = store.subscribe(); + + store.push_tool_call("tc-1", "test_tool", None); + + let msg = rx.recv().await.unwrap(); + assert!(matches!(msg, SessionActivityMsg::ToolCall { tool_name, .. } if tool_name == "test_tool")); + } + + #[test] + fn test_registry_get_or_create() { + let registry = SessionActivityRegistry::new(); + let session_id = Uuid::new_v4(); + + let store1 = registry.get_or_create(session_id); + let store2 = registry.get_or_create(session_id); + + assert_eq!(store1.session_id(), store2.session_id()); + assert_eq!(registry.len(), 1); + } + + #[test] + fn test_registry_remove() { + let registry = SessionActivityRegistry::new(); + let session_id = Uuid::new_v4(); + + registry.get_or_create(session_id); + assert_eq!(registry.len(), 1); + + registry.remove(&session_id); + assert!(registry.is_empty()); + } + + #[test] + fn test_ws_message_conversion() { + let msg = SessionActivityMsg::tool_call("tc-1", "bash", None); + let ws_msg = msg.to_ws_message().unwrap(); + assert!(matches!(ws_msg, WsMessage::Text(_))); + } + + #[tokio::test] + async fn test_history_plus_stream_returns_history_first() { + use futures::StreamExt; + + let store = Arc::new(SessionActivityStore::new(Uuid::new_v4())); + + store.push_tool_call("tc-1", "read_file", None); + store.push_tool_result("tc-1", "read_file", None, "contents", true); + store.push_agent_message("msg-1", "Processing...", false); + + let mut stream = std::pin::pin!(store.history_plus_stream()); + + let msg1 = stream.next().await.unwrap().unwrap(); + assert!(matches!(msg1, SessionActivityMsg::ToolCall { id, .. } if id == "tc-1")); + + let msg2 = stream.next().await.unwrap().unwrap(); + assert!(matches!(msg2, SessionActivityMsg::ToolResult { id, .. } if id == "tc-1")); + + let msg3 = stream.next().await.unwrap().unwrap(); + assert!(matches!(msg3, SessionActivityMsg::AgentMessage { id, .. } if id == "msg-1")); + } + + #[tokio::test] + async fn test_history_plus_stream_then_live() { + use futures::StreamExt; + use tokio::time::{timeout, Duration}; + + let store = Arc::new(SessionActivityStore::new(Uuid::new_v4())); + + store.push_tool_call("tc-1", "read_file", None); + + let store_clone = Arc::clone(&store); + let mut stream = std::pin::pin!(store.history_plus_stream()); + + let history_msg = stream.next().await.unwrap().unwrap(); + assert!(matches!(history_msg, SessionActivityMsg::ToolCall { id, .. } if id == "tc-1")); + + tokio::spawn(async move { + tokio::time::sleep(Duration::from_millis(10)).await; + store_clone.push_tool_call("tc-2", "write_file", None); + }); + + let live_msg = timeout(Duration::from_millis(100), stream.next()) + .await + .expect("should receive live message") + .unwrap() + .unwrap(); + assert!(matches!(live_msg, SessionActivityMsg::ToolCall { id, .. } if id == "tc-2")); + } + + #[tokio::test] + async fn test_reconnect_gets_full_history() { + use futures::StreamExt; + use tokio::time::{timeout, Duration}; + + let store = Arc::new(SessionActivityStore::new(Uuid::new_v4())); + + store.push_tool_call("tc-1", "read_file", None); + store.push_tool_result("tc-1", "read_file", None, "contents", true); + + { + let mut stream1 = std::pin::pin!(store.history_plus_stream()); + let _ = stream1.next().await; + let _ = stream1.next().await; + } + + store.push_agent_message("msg-1", "Done", false); + + let mut stream2 = std::pin::pin!(store.history_plus_stream()); + + let msg1 = timeout(Duration::from_millis(100), stream2.next()) + .await + .expect("should get history msg 1") + .unwrap() + .unwrap(); + let msg2 = timeout(Duration::from_millis(100), stream2.next()) + .await + .expect("should get history msg 2") + .unwrap() + .unwrap(); + let msg3 = timeout(Duration::from_millis(100), stream2.next()) + .await + .expect("should get history msg 3") + .unwrap() + .unwrap(); + + assert!(matches!(msg1, SessionActivityMsg::ToolCall { .. })); + assert!(matches!(msg2, SessionActivityMsg::ToolResult { .. })); + assert!(matches!(msg3, SessionActivityMsg::AgentMessage { .. })); + } + + #[test] + fn test_finished_message() { + let store = SessionActivityStore::new(Uuid::new_v4()); + + store.push_tool_call("tc-1", "bash", None); + store.push_finished(true, None); + + let history = store.get_history(); + assert_eq!(history.len(), 2); + + match &history[1] { + SessionActivityMsg::Finished { success, error, .. } => { + assert!(*success); + assert!(error.is_none()); + } + _ => panic!("Expected Finished message"), + } + } + + #[test] + fn test_finished_with_error() { + let store = SessionActivityStore::new(Uuid::new_v4()); + + store.push_finished(false, Some("Task failed".to_string())); + + let history = store.get_history(); + assert_eq!(history.len(), 1); + + match &history[0] { + SessionActivityMsg::Finished { success, error, .. } => { + assert!(!*success); + assert_eq!(error.as_deref(), Some("Task failed")); + } + _ => panic!("Expected Finished message"), + } + } +} diff --git a/crates/orchestrator/src/error.rs b/crates/orchestrator/src/error.rs index a77d901..1ccb6a0 100644 --- a/crates/orchestrator/src/error.rs +++ b/crates/orchestrator/src/error.rs @@ -9,7 +9,7 @@ pub enum OrchestratorError { TaskNotFound(String), #[error("OpenCode error: {0}")] - OpenCode(#[from] opencode::OpenCodeError), + OpenCodeError(String), #[error("Database error: {0}")] Database(#[from] db::DbError), diff --git a/crates/orchestrator/src/executor.rs b/crates/orchestrator/src/executor.rs index c1fab0f..0c8b06e 100644 --- a/crates/orchestrator/src/executor.rs +++ b/crates/orchestrator/src/executor.rs @@ -1,17 +1,58 @@ -use db::SessionRepository; +use db::{SessionRepository, TaskRepository}; use events::{Event, EventBus, EventEnvelope}; -use opencode::OpenCodeClient; -use opencode_core::{Session, SessionPhase, Task, TaskStatus}; +use opencode_client::apis::configuration::Configuration; +use opencode_client::apis::default_api; +use opencode_client::models::{ + McpAddRequest, McpAddRequestConfig, + Part, SessionCreateRequest, SessionPromptRequest, SessionPromptRequestPartsInner, + Session as OpenCodeSession, +}; +use opencode_core::{Session, SessionPhase, Task, TaskStatus, UpdateTaskRequest}; use std::path::PathBuf; use std::sync::Arc; -use tracing::{info, warn}; +use tracing::{debug, error, info, instrument, warn}; +use uuid::Uuid; use vcs::{Workspace, WorkspaceManager}; +use crate::activity_store::{SessionActivityMsg, SessionActivityRegistry, SessionActivityStore}; use crate::error::{OrchestratorError, Result}; -use crate::files::FileManager; +use crate::files::{ + FileManager, FindingSeverity, FindingStatus, ReviewFinding, ReviewFindings, +}; +use crate::opencode_events::{ExecutorEvent, OpenCodeEventSubscriber}; use crate::prompts::PhasePrompts; use crate::state_machine::TaskStateMachine; +/// Raw JSON response from AI review +#[derive(Debug, serde::Deserialize)] +struct RawReviewResponse { + approved: bool, + summary: String, + #[serde(default)] + findings: Vec, +} + +#[derive(Debug, serde::Deserialize)] +struct RawFinding { + #[serde(default)] + file_path: Option, + #[serde(default)] + line_start: Option, + #[serde(default)] + line_end: Option, + title: String, + description: String, + #[serde(default = "default_severity")] + severity: String, +} + +fn default_severity() -> String { + "warning".to_string() +} + +const DEFAULT_PROVIDER_ID: &str = "anthropic"; +const DEFAULT_MODEL_ID: &str = "claude-sonnet-4-20250514"; + #[derive(Debug, Clone)] pub struct ExecutorConfig { pub require_plan_approval: bool, @@ -56,27 +97,52 @@ impl ExecutorConfig { } pub struct TaskExecutor { - opencode: Arc, + opencode_config: Arc, config: ExecutorConfig, file_manager: FileManager, workspace_manager: Option>, session_repo: Option>, + task_repo: Option>, event_bus: Option, + activity_registry: Option, + provider_id: String, + model_id: String, +} + +/// Result returned immediately when starting async execution +#[derive(Debug, Clone)] +pub struct StartedExecution { + /// The Studio session ID (our internal ID) + pub session_id: Uuid, + /// The OpenCode session ID (external) + pub opencode_session_id: String, + /// The phase being executed + pub phase: SessionPhase, } impl TaskExecutor { - pub fn new(opencode: Arc, config: ExecutorConfig) -> Self { + pub fn new(opencode_config: Arc, config: ExecutorConfig) -> Self { let file_manager = FileManager::new(&config.repo_path); Self { - opencode, + opencode_config, config, file_manager, workspace_manager: None, session_repo: None, + task_repo: None, event_bus: None, + activity_registry: None, + provider_id: DEFAULT_PROVIDER_ID.to_string(), + model_id: DEFAULT_MODEL_ID.to_string(), } } + pub fn with_model(mut self, provider_id: &str, model_id: &str) -> Self { + self.provider_id = provider_id.to_string(); + self.model_id = model_id.to_string(); + self + } + pub fn with_workspace_manager(mut self, manager: Arc) -> Self { self.workspace_manager = Some(manager); self @@ -87,13 +153,35 @@ impl TaskExecutor { self } + pub fn with_task_repo(mut self, repo: Arc) -> Self { + self.task_repo = Some(repo); + self + } + pub fn with_event_bus(mut self, bus: EventBus) -> Self { self.event_bus = Some(bus); self } + pub fn with_activity_registry(mut self, registry: SessionActivityRegistry) -> Self { + self.activity_registry = Some(registry); + self + } + + /// Get a reference to the file manager for reading plans/reviews + pub fn file_manager(&self) -> &FileManager { + &self.file_manager + } + + #[instrument(skip(self, task), fields(task_id = %task.id, task_title = %task.title))] pub fn transition(&self, task: &mut Task, to: TaskStatus) -> Result<()> { let from = task.status; + info!( + from = %from.as_str(), + to = %to.as_str(), + "Task state transition" + ); + TaskStateMachine::validate_transition(&task.status, &to)?; task.status = to; task.updated_at = chrono::Utc::now(); @@ -104,6 +192,12 @@ impl TaskExecutor { to_status: to.as_str().to_string(), }); + debug!( + task_id = %task.id, + new_status = %to.as_str(), + "State transition completed" + ); + Ok(()) } @@ -127,37 +221,435 @@ impl TaskExecutor { Ok(()) } + fn extract_text_from_parts(parts: &[Part]) -> String { + parts + .iter() + .filter_map(|part| { + if part.r#type == opencode_client::models::part::Type::Text { + part.text.as_deref() + } else { + None + } + }) + .collect::>() + .join("\n") + } + + fn extract_text_from_messages_inner( + msg: &opencode_client::models::SessionMessages200ResponseInner, + ) -> String { + Self::extract_text_from_parts(&msg.parts) + } + + fn create_text_part(text: &str) -> SessionPromptRequestPartsInner { + SessionPromptRequestPartsInner { + r#type: opencode_client::models::session_prompt_request_parts_inner::Type::Text, + text: text.to_string(), + id: None, + synthetic: None, + ignored: None, + time: None, + metadata: None, + mime: String::new(), + filename: None, + url: String::new(), + source: None, + name: String::new(), + prompt: String::new(), + description: String::new(), + agent: String::new(), + command: None, + } + } + + pub fn parse_message_parts(parts: &[Part]) -> Vec { + use opencode_client::models::part::Type; + + let mut activities = Vec::new(); + + for part in parts { + match part.r#type { + Type::Text => { + let id = format!("text-{}", uuid::Uuid::new_v4()); + let text = part.text.as_deref().unwrap_or(""); + activities.push(SessionActivityMsg::agent_message(&id, text, false)); + } + Type::Reasoning => { + let id = format!("reasoning-{}", uuid::Uuid::new_v4()); + activities.push(SessionActivityMsg::Reasoning { + id, + content: part.text.clone().unwrap_or_default(), + timestamp: chrono::Utc::now(), + }); + } + Type::Tool => { + let call_id = part.call_id.as_deref().unwrap_or(""); + let tool_name = part.tool.as_deref().unwrap_or("unknown"); + + if let Some(ref state) = part.state { + let output = state.output.as_deref().unwrap_or(""); + let error = state.error.as_deref().unwrap_or(""); + let is_completed = !output.is_empty() || !error.is_empty(); + + if is_completed { + let success = error.is_empty(); + let result = if success { output } else { error }; + activities.push(SessionActivityMsg::tool_result( + call_id, + tool_name, + None, + result, + success, + )); + } else { + activities.push(SessionActivityMsg::tool_call( + call_id, + tool_name, + None, + )); + } + } else { + // No state yet, treat as pending tool call + activities.push(SessionActivityMsg::tool_call( + call_id, + tool_name, + None, + )); + } + } + Type::StepStart => { + let id = format!("step-{}", uuid::Uuid::new_v4()); + activities.push(SessionActivityMsg::StepStart { + id, + step_name: None, + timestamp: chrono::Utc::now(), + }); + } + _ => { + debug!("Skipping part type: {:?}", part.r#type); + } + } + } + + activities + } + + /// Parse SSE part format (different from HTTP response Part struct) + /// SSE parts have: id, messageID, sessionID, text, time.start/end, type + /// Tool parts have: callID, tool, state.status/input/output/error + fn parse_sse_part(part: &serde_json::Value) -> Option { + let part_type = part.get("type")?.as_str()?; + let id = part.get("id").and_then(|v| v.as_str()).unwrap_or("unknown"); + + match part_type { + "text" => { + let text = part.get("text").and_then(|v| v.as_str()).unwrap_or(""); + // Check if this is a partial or complete message + let is_partial = part.get("time") + .and_then(|t| t.get("end")) + .is_none(); + Some(SessionActivityMsg::agent_message(id, text, is_partial)) + } + "reasoning" => { + let content = part.get("text").and_then(|v| v.as_str()).unwrap_or(""); + Some(SessionActivityMsg::Reasoning { + id: id.to_string(), + content: content.to_string(), + timestamp: chrono::Utc::now(), + }) + } + "tool" => { + let call_id = part.get("callID").and_then(|v| v.as_str()).unwrap_or(id); + let tool_name = part.get("tool").and_then(|v| v.as_str()).unwrap_or("unknown"); + let state = part.get("state"); + + let status = state + .and_then(|s| s.get("status")) + .and_then(|v| v.as_str()) + .unwrap_or("pending"); + + // If status is "completed" or "error", it's a finished tool call + // OpenCode uses "completed" for success, not "success" + if status == "completed" || status == "error" { + let success = status == "completed"; + let output = state + .and_then(|s| s.get("output")) + .and_then(|v| v.as_str()) + .unwrap_or(""); + let error = state + .and_then(|s| s.get("error")) + .and_then(|v| v.as_str()) + .unwrap_or(""); + let result = if success { output } else { error }; + + Some(SessionActivityMsg::tool_result( + call_id, + tool_name, + None, + result, + success, + )) + } else { + // Pending or running - emit tool call + Some(SessionActivityMsg::tool_call(call_id, tool_name, None)) + } + } + "step-start" => { + Some(SessionActivityMsg::StepStart { + id: id.to_string(), + step_name: None, + timestamp: chrono::Utc::now(), + }) + } + _ => { + debug!(part_type = %part_type, "Skipping unknown SSE part type"); + None + } + } + } + + fn push_activities_to_store(&self, store: &SessionActivityStore, parts: &[Part]) { + for activity in Self::parse_message_parts(parts) { + store.push(activity); + } + } + + fn get_activity_store(&self, session_id: Uuid) -> Option> { + self.activity_registry + .as_ref() + .map(|reg| reg.get_or_create(session_id)) + } + + async fn create_opencode_session(&self) -> Result { + self.create_opencode_session_in_dir(&self.config.repo_path).await + } + + async fn create_opencode_session_in_dir(&self, working_dir: &std::path::Path) -> Result { + let request = SessionCreateRequest { + title: None, + parent_id: None, + }; + + // Pass the working directory so OpenCode works in the correct context + let directory = working_dir.to_str(); + info!( + directory = ?directory, + "Creating OpenCode session in directory" + ); + + default_api::session_create(&self.opencode_config, directory, Some(request)) + .await + .map_err(|e| { + error!(error = %e, directory = ?directory, "Failed to create OpenCode session"); + OrchestratorError::OpenCodeError(format!("Failed to create session: {}", e)) + }) + } + + /// Add the MCP findings server to OpenCode for a specific review session + async fn add_mcp_findings_server( + &self, + task_id: Uuid, + session_id: Uuid, + workspace_path: &std::path::Path, + ) -> Result<()> { + let mcp_binary = self.get_mcp_binary_path(); + + let mut environment = std::collections::HashMap::new(); + environment.insert("OPENCODE_TASK_ID".to_string(), task_id.to_string()); + environment.insert("OPENCODE_SESSION_ID".to_string(), session_id.to_string()); + environment.insert( + "OPENCODE_WORKSPACE_PATH".to_string(), + workspace_path.to_string_lossy().to_string(), + ); + + let mut config = McpAddRequestConfig::local(vec![mcp_binary]); + config.environment = Some(environment); + config.enabled = Some(true); + config.timeout = Some(10000); // 10 seconds + + let request = McpAddRequest::new("opencode-findings".to_string(), config); + let directory = workspace_path.to_str(); + + info!( + task_id = %task_id, + session_id = %session_id, + "Adding MCP findings server to OpenCode" + ); + + default_api::mcp_add(&self.opencode_config, directory, Some(request)) + .await + .map_err(|e| { + error!(error = %e, "Failed to add MCP findings server"); + OrchestratorError::OpenCodeError(format!("Failed to add MCP server: {}", e)) + })?; + + // Connect the MCP server + default_api::mcp_connect(&self.opencode_config, "opencode-findings", directory) + .await + .map_err(|e| { + error!(error = %e, "Failed to connect MCP findings server"); + OrchestratorError::OpenCodeError(format!("Failed to connect MCP server: {}", e)) + })?; + + info!("MCP findings server connected"); + Ok(()) + } + + /// Remove the MCP findings server from OpenCode + async fn remove_mcp_findings_server(&self, workspace_path: &std::path::Path) -> Result<()> { + let directory = workspace_path.to_str(); + + info!("Disconnecting MCP findings server"); + + // Disconnect the MCP server (ignore errors - server might already be disconnected) + if let Err(e) = default_api::mcp_disconnect(&self.opencode_config, "opencode-findings", directory).await { + warn!(error = %e, "Failed to disconnect MCP findings server (may already be disconnected)"); + } + + Ok(()) + } + + /// Get the path to the MCP findings binary + fn get_mcp_binary_path(&self) -> String { + // In development, use the debug build path + // In production, this would be installed alongside the main binary + if cfg!(debug_assertions) { + // Try to find the binary relative to the current executable + if let Ok(exe_path) = std::env::current_exe() { + if let Some(parent) = exe_path.parent() { + let mcp_path = parent.join("opencode-mcp-findings"); + if mcp_path.exists() { + return mcp_path.to_string_lossy().to_string(); + } + } + } + } + // Fall back to assuming it's in PATH + "opencode-mcp-findings".to_string() + } + + async fn send_opencode_message_with_activity( + &self, + session_id: &str, + prompt: &str, + activity_store: Option<&SessionActivityStore>, + ) -> Result { + self.send_opencode_message_in_dir(session_id, prompt, activity_store, &self.config.repo_path).await + } + + async fn send_opencode_message_in_dir( + &self, + session_id: &str, + prompt: &str, + activity_store: Option<&SessionActivityStore>, + working_dir: &std::path::Path, + ) -> Result { + let model = opencode_client::models::SessionPromptRequestModel { + provider_id: self.provider_id.clone(), + model_id: self.model_id.clone(), + }; + + let request = SessionPromptRequest { + parts: vec![Self::create_text_part(prompt)], + model: Some(Box::new(model)), + message_id: None, + agent: None, + no_reply: None, + tools: None, + system: None, + variant: None, + }; + + let directory = working_dir.to_str(); + let response = + default_api::session_prompt(&self.opencode_config, session_id, directory, Some(request)) + .await + .map_err(|e| { + error!(error = %e, directory = ?directory, "Failed to send message to OpenCode"); + OrchestratorError::OpenCodeError(format!("Failed to send message: {}", e)) + })?; + + if let Some(store) = activity_store { + self.push_activities_to_store(store, &response.parts); + } + + Ok(Self::extract_text_from_parts(&response.parts)) + } + + #[instrument(skip(self, task), fields(task_id = %task.id, status = %task.status.as_str()))] pub async fn execute_phase(&self, task: &mut Task) -> Result { - match task.status { + info!( + task_id = %task.id, + current_status = %task.status.as_str(), + "Executing phase for task" + ); + + let result = match task.status { TaskStatus::Todo => { + debug!("Task in TODO, transitioning to PLANNING"); self.transition(task, TaskStatus::Planning)?; self.run_planning_session(task).await } - TaskStatus::Planning => self.run_planning_session(task).await, + TaskStatus::Planning => { + debug!("Task in PLANNING, running planning session"); + self.run_planning_session(task).await + } TaskStatus::PlanningReview => { if self.config.require_plan_approval { + info!("Plan requires approval, awaiting human review"); Ok(PhaseResult::AwaitingApproval { phase: SessionPhase::Planning, }) } else { + debug!("Auto-approving plan, transitioning to IN_PROGRESS"); self.transition(task, TaskStatus::InProgress)?; self.run_implementation_session(task).await } } - TaskStatus::InProgress => self.run_implementation_session(task).await, - TaskStatus::AiReview => self.run_ai_review(task, 0).await, + TaskStatus::InProgress => { + debug!("Task IN_PROGRESS, running implementation session"); + self.run_implementation_session(task).await + } + TaskStatus::AiReview => { + debug!("Task in AI_REVIEW, running AI review"); + self.run_ai_review(task, 0).await + } + TaskStatus::Fix => { + debug!("Task in FIX, running fix session"); + self.run_fix_session(task).await + } TaskStatus::Review => { if self.config.require_human_review { + info!("Implementation requires human review, awaiting approval"); Ok(PhaseResult::AwaitingApproval { phase: SessionPhase::Review, }) } else { + debug!("Auto-approving review, transitioning to DONE"); self.transition(task, TaskStatus::Done)?; Ok(PhaseResult::Completed) } } - TaskStatus::Done => Ok(PhaseResult::Completed), + TaskStatus::Done => { + debug!("Task already DONE"); + Ok(PhaseResult::Completed) + } + }; + + match &result { + Ok(phase_result) => info!( + task_id = %task.id, + result = ?phase_result, + "Phase execution completed" + ), + Err(e) => error!( + task_id = %task.id, + error = %e, + "Phase execution failed" + ), } + + result } pub async fn run_full_cycle(&self, task: &mut Task) -> Result { @@ -234,35 +726,552 @@ impl TaskExecutor { Ok(PhaseResult::Completed) } + pub async fn start_phase_async(&self, task: &mut Task) -> Result { + info!( + task_id = %task.id, + current_status = %task.status.as_str(), + "Starting async phase execution" + ); + + let phase = match task.status { + TaskStatus::Todo | TaskStatus::Planning => SessionPhase::Planning, + TaskStatus::PlanningReview | TaskStatus::InProgress => SessionPhase::Implementation, + TaskStatus::AiReview => SessionPhase::Review, + TaskStatus::Fix => SessionPhase::Fix, + TaskStatus::Review => SessionPhase::Review, + TaskStatus::Done => { + return Err(OrchestratorError::ExecutionFailed( + "Task is already done".to_string(), + )); + } + }; + + if task.status == TaskStatus::Todo { + self.transition(task, TaskStatus::Planning)?; + } + + // For implementation phase, create workspace if not already created + if phase == SessionPhase::Implementation && task.workspace_path.is_none() { + if let Some(ref wm) = self.workspace_manager { + debug!("Setting up VCS workspace for async task execution"); + match wm.setup_workspace(&task.id.to_string()).await { + Ok(workspace) => { + task.workspace_path = Some(workspace.path.to_string_lossy().to_string()); + info!( + workspace_path = %workspace.path.display(), + branch = %workspace.branch_name, + "VCS workspace created for async execution" + ); + self.emit_event(Event::WorkspaceCreated { + task_id: task.id, + path: workspace.path.to_string_lossy().to_string(), + }); + } + Err(e) => { + error!(error = %e, "Failed to setup workspace for async execution"); + return Err(OrchestratorError::ExecutionFailed( + format!("Failed to setup workspace: {}", e) + )); + } + } + // Persist workspace_path to database + if let Some(ref repo) = self.task_repo { + let update = UpdateTaskRequest { + workspace_path: task.workspace_path.clone(), + ..Default::default() + }; + if let Err(e) = repo.update(task.id, &update).await { + error!(error = %e, "Failed to persist workspace_path to database"); + } + } + } else { + warn!("No workspace manager configured, implementation will run in root directory"); + } + } + + // Determine working directory - use workspace if available, otherwise root + let working_dir = task.workspace_path + .as_ref() + .map(PathBuf::from) + .unwrap_or_else(|| self.config.repo_path.clone()); + + let opencode_session = self.create_opencode_session_in_dir(&working_dir).await?; + let opencode_session_id = opencode_session.id.to_string(); + + let mut session = Session::new(task.id, phase); + session.start(opencode_session_id.clone()); + self.persist_session(&session).await?; + + self.emit_event(Event::SessionStarted { + session_id: session.id, + task_id: task.id, + phase: session.phase.as_str().to_string(), + status: session.status.as_str().to_string(), + opencode_session_id: session.opencode_session_id.clone(), + created_at: session.created_at, + }); + + // For review phase, set up MCP server before spawning background task + let mcp_setup_success = if phase == SessionPhase::Review && task.status == TaskStatus::AiReview { + match self + .add_mcp_findings_server(task.id, session.id, &working_dir) + .await + { + Ok(_) => { + info!(task_id = %task.id, "MCP findings server added for async review"); + true + } + Err(e) => { + warn!(error = %e, "Failed to add MCP server, falling back to JSON parsing"); + false + } + } + } else { + false + }; + + let prompt = match phase { + SessionPhase::Planning => PhasePrompts::planning(task), + SessionPhase::Implementation => { + let plan = if self.file_manager.plan_exists(task.id).await { + self.file_manager.read_plan(task.id).await.ok() + } else { + None + }; + PhasePrompts::implementation_with_plan(task, plan.as_deref()) + } + SessionPhase::Review => { + let diff = self.get_workspace_diff(task).await.unwrap_or_default(); + if mcp_setup_success { + PhasePrompts::review_with_mcp(task, &diff) + } else { + PhasePrompts::review(task, &diff) + } + } + SessionPhase::Fix => { + // Fix phase uses MCP to read findings and fix them + PhasePrompts::fix_with_mcp(task) + } + }; + + let task_id = task.id; + let task_status = task.status; + let studio_session_id = session.id; + let opencode_session_id_clone = opencode_session_id.clone(); + let opencode_config = Arc::clone(&self.opencode_config); + let session_repo = self.session_repo.clone(); + let task_repo = self.task_repo.clone(); + let event_bus = self.event_bus.clone(); + let activity_registry = self.activity_registry.clone(); + let file_manager = self.file_manager.clone(); + let provider_id = self.provider_id.clone(); + let model_id = self.model_id.clone(); + let base_url = opencode_config + .base_path + .trim_end_matches("/api") + .to_string(); + // Use working_dir (workspace if available, otherwise root) + let execution_dir = working_dir.clone(); + + let mcp_workspace = if mcp_setup_success { + Some(working_dir.clone()) + } else { + None + }; + + tokio::spawn(async move { + Self::run_background_execution( + opencode_config, + opencode_session_id_clone, + studio_session_id, + task_id, + task_status, + phase, + prompt, + session_repo, + task_repo, + event_bus, + activity_registry, + file_manager, + provider_id, + model_id, + base_url, + execution_dir, + mcp_workspace, + ) + .await + }); + + info!( + task_id = %task.id, + session_id = %session.id, + opencode_session_id = %opencode_session_id, + "Async execution started, returning immediately" + ); + + Ok(StartedExecution { + session_id: session.id, + opencode_session_id, + phase, + }) + } + + #[allow(clippy::too_many_arguments)] + async fn run_background_execution( + opencode_config: Arc, + opencode_session_id: String, + studio_session_id: Uuid, + task_id: Uuid, + initial_task_status: TaskStatus, + phase: SessionPhase, + prompt: String, + session_repo: Option>, + task_repo: Option>, + event_bus: Option, + activity_registry: Option, + file_manager: FileManager, + provider_id: String, + model_id: String, + base_url: String, + repo_path: PathBuf, + mcp_workspace: Option, + ) { + info!( + task_id = %task_id, + opencode_session_id = %opencode_session_id, + phase = %phase.as_str(), + "Background execution started" + ); + + let activity_store = activity_registry + .as_ref() + .map(|reg| reg.get_or_create(studio_session_id)); + + let subscriber = OpenCodeEventSubscriber::new( + &base_url, + &opencode_session_id, + repo_path.to_string_lossy().to_string(), + ); + let mut event_rx = subscriber.subscribe(); + + let model = opencode_client::models::SessionPromptRequestModel { + provider_id, + model_id, + }; + + let request = SessionPromptRequest { + parts: vec![Self::create_text_part(&prompt)], + model: Some(Box::new(model)), + message_id: None, + agent: None, + no_reply: None, + tools: None, + system: None, + variant: None, + }; + + info!( + task_id = %task_id, + opencode_session_id = %opencode_session_id, + "Sending prompt to OpenCode (this may take a while)..." + ); + + // Spawn a task to process SSE events + // We use session_prompt_async which returns immediately, then wait for + // SSE to signal completion via session.idle event + let activity_store_for_sse = activity_store.clone(); + let opencode_session_id_for_sse = opencode_session_id.clone(); + let task_id_for_sse = task_id; + let sse_task = tokio::spawn(async move { + debug!("SSE event processor started"); + while let Some(event) = event_rx.recv().await { + match event { + ExecutorEvent::SessionIdle { .. } => { + info!( + task_id = %task_id_for_sse, + opencode_session_id = %opencode_session_id_for_sse, + "OpenCode session completed (idle via SSE)" + ); + break; + } + ExecutorEvent::MessagePartUpdated { session_id: event_session_id, part, .. } => { + debug!( + event_session_id = %event_session_id, + our_session_id = %opencode_session_id_for_sse, + "Received MessagePartUpdated event" + ); + if let Some(ref store) = activity_store_for_sse { + // Parse SSE part format directly (different from HTTP response Part struct) + if let Some(activity) = TaskExecutor::parse_sse_part(&part) { + debug!("Parsed activity from SSE part"); + store.push(activity); + } + } else { + warn!("activity_store is None, cannot store activity"); + } + } + ExecutorEvent::Error { message } => { + error!(error = %message, "SSE error during execution"); + break; + } + ExecutorEvent::Disconnected => { + debug!("SSE disconnected"); + break; + } + ExecutorEvent::DirectActivity { activity } => { + debug!(activity_type = ?std::mem::discriminant(&activity), "Received direct activity event"); + if let Some(ref store) = activity_store_for_sse { + store.push(activity); + } else { + warn!("activity_store is None, cannot store direct activity"); + } + } + _ => {} + } + } + debug!("SSE event processor finished"); + }); + + // Use session_prompt_async which returns immediately + // We rely on SSE to monitor progress and detect completion + // Pass the project directory so OpenCode works in the correct context + let directory = repo_path.to_str(); + let send_result = default_api::session_prompt_async( + &opencode_config, + &opencode_session_id, + directory, + Some(request), + ) + .await; + + let mut success = true; + let mut error_msg = None; + + match send_result { + Ok(()) => { + info!( + task_id = %task_id, + opencode_session_id = %opencode_session_id, + "OpenCode prompt sent, waiting for completion via SSE" + ); + + // Wait for SSE task to finish (it will receive idle event when done) + let _ = sse_task.await; + info!(task_id = %task_id, "Background execution completed successfully"); + + // After completion, fetch messages and save artifacts (plan, review) if needed + if phase == SessionPhase::Planning { + match default_api::session_messages( + &opencode_config, + &opencode_session_id, + directory, + None, + ) + .await + { + Ok(messages) => { + // Find the last assistant message and extract text + if let Some(last_msg) = messages.iter().rev().find(|m| { + matches!( + m.info.role, + opencode_client::models::message::Role::Assistant + ) + }) { + let plan_content = Self::extract_text_from_messages_inner(last_msg); + if !plan_content.is_empty() { + match file_manager.write_plan(task_id, &plan_content).await { + Ok(path) => { + info!( + task_id = %task_id, + plan_path = %path.display(), + "Plan saved successfully" + ); + } + Err(e) => { + error!( + task_id = %task_id, + error = %e, + "Failed to save plan file" + ); + } + } + } else { + warn!(task_id = %task_id, "No text content found in assistant message"); + } + } else { + warn!(task_id = %task_id, "No assistant message found in session"); + } + } + Err(e) => { + error!( + task_id = %task_id, + error = %e, + "Failed to fetch session messages for plan extraction" + ); + } + } + } + } + Err(e) => { + error!(task_id = %task_id, error = %e, "Failed to send prompt to OpenCode"); + success = false; + error_msg = Some(e.to_string()); + } + } + + if let Some(ref store) = activity_store { + store.push_finished(success, error_msg.clone()); + } + + if let Some(ref repo) = session_repo { + let mut session = Session::new(task_id, phase); + session.id = studio_session_id; + session.opencode_session_id = Some(opencode_session_id.clone()); + session.status = if success { + opencode_core::SessionStatus::Completed + } else { + opencode_core::SessionStatus::Failed + }; + if let Err(e) = repo.update(&session).await { + error!(error = %e, "Failed to update session status"); + } + } + + if success { + let next_status = match phase { + SessionPhase::Planning => TaskStatus::PlanningReview, + SessionPhase::Implementation => TaskStatus::AiReview, + SessionPhase::Review => { + if initial_task_status == TaskStatus::AiReview { + TaskStatus::Review + } else { + TaskStatus::Done + } + } + // Fix phase transitions back to AiReview for re-evaluation + SessionPhase::Fix => TaskStatus::AiReview, + }; + + if let Some(ref repo) = task_repo { + let update = UpdateTaskRequest { + status: Some(next_status), + ..Default::default() + }; + if let Err(e) = repo.update(task_id, &update).await { + error!(error = %e, "Failed to update task status"); + } else { + info!( + task_id = %task_id, + new_status = %next_status.as_str(), + "Task status updated after background execution" + ); + } + } + + if let Some(ref bus) = event_bus { + bus.publish(EventEnvelope::new(Event::TaskStatusChanged { + task_id, + from_status: initial_task_status.as_str().to_string(), + to_status: next_status.as_str().to_string(), + })); + } + } + + if let Some(ref bus) = event_bus { + bus.publish(EventEnvelope::new(Event::SessionEnded { + session_id: studio_session_id, + task_id, + success, + })); + } + + // Cleanup MCP server if it was set up + if let Some(workspace_path) = mcp_workspace { + debug!("Cleaning up MCP findings server"); + if let Err(e) = default_api::mcp_disconnect( + &opencode_config, + "opencode-findings", + workspace_path.to_str(), + ) + .await + { + warn!(error = %e, "Failed to disconnect MCP findings server"); + } + } + } + + #[instrument(skip(self, task), fields(task_id = %task.id))] async fn run_planning_session(&self, task: &mut Task) -> Result { - info!("Running planning session for task {}", task.id); + info!( + task_id = %task.id, + task_title = %task.title, + "Starting PLANNING session" + ); let mut session = Session::new(task.id, SessionPhase::Planning); - let opencode_session = self - .opencode - .create_session(Some(format!("Planning: {}", task.title))) - .await?; + debug!("Creating OpenCode session for planning"); + let opencode_session = self.create_opencode_session().await?; + let session_id_str = opencode_session.id.to_string(); + + info!( + opencode_session_id = %session_id_str, + "OpenCode session created" + ); - session.start(opencode_session.id.clone()); + session.start(session_id_str.clone()); self.persist_session(&session).await?; + let activity_store = self.get_activity_store(session.id); + self.emit_event(Event::SessionStarted { session_id: session.id, task_id: task.id, + phase: session.phase.as_str().to_string(), + status: session.status.as_str().to_string(), + opencode_session_id: session.opencode_session_id.clone(), + created_at: session.created_at, }); + debug!("Generating planning prompt"); let prompt = PhasePrompts::planning(task); - let response = self - .opencode - .send_message(&opencode_session.id, &prompt, None) - .await?; + debug!(prompt_length = prompt.len(), "Sending planning prompt to OpenCode"); + + let response_content = self + .send_opencode_message_with_activity( + &session_id_str, + &prompt, + activity_store.as_deref(), + ) + .await; + + let response_content = match response_content { + Ok(content) => { + if let Some(ref store) = activity_store { + store.push_finished(true, None); + } + content + } + Err(e) => { + if let Some(ref store) = activity_store { + store.push_finished(false, Some(e.to_string())); + } + return Err(e); + } + }; + + info!( + response_length = response_content.len(), + "Received planning response" + ); let plan_path = self .file_manager - .write_plan(task.id, &response.message.content) + .write_plan(task.id, &response_content) .await?; + info!(plan_path = %plan_path.display(), "Plan saved to file"); + session.complete(); self.update_session(&session).await?; @@ -274,53 +1283,122 @@ impl TaskExecutor { self.transition(task, TaskStatus::PlanningReview)?; + info!( + task_id = %task.id, + "PLANNING session completed, awaiting review" + ); + Ok(PhaseResult::PlanCreated { - session_id: opencode_session.id, + session_id: session_id_str, plan_path: plan_path.to_string_lossy().to_string(), }) } + #[instrument(skip(self, task), fields(task_id = %task.id))] async fn run_implementation_session(&self, task: &mut Task) -> Result { - info!("Running implementation session for task {}", task.id); + info!( + task_id = %task.id, + task_title = %task.title, + "Starting IMPLEMENTATION session" + ); let mut session = Session::new(task.id, SessionPhase::Implementation); if let Some(ref wm) = self.workspace_manager { + debug!("Setting up VCS workspace for task"); let workspace = wm.setup_workspace(&task.id.to_string()).await.map_err(|e| { + error!(error = %e, "Failed to setup workspace"); OrchestratorError::ExecutionFailed(format!("Failed to setup workspace: {}", e)) })?; task.workspace_path = Some(workspace.path.to_string_lossy().to_string()); + info!( + workspace_path = %workspace.path.display(), + branch = %workspace.branch_name, + "VCS workspace created" + ); + self.emit_event(Event::WorkspaceCreated { task_id: task.id, path: workspace.path.to_string_lossy().to_string(), }); + } else { + warn!("No workspace manager configured, skipping VCS workspace setup"); } - let opencode_session = self - .opencode - .create_session(Some(format!("Implementation: {}", task.title))) - .await?; + // Determine working directory - use workspace if available, otherwise root + let working_dir = task.workspace_path + .as_ref() + .map(PathBuf::from) + .unwrap_or_else(|| self.config.repo_path.clone()); + + debug!( + working_dir = %working_dir.display(), + has_workspace = task.workspace_path.is_some(), + "Creating OpenCode session for implementation" + ); + let opencode_session = self.create_opencode_session_in_dir(&working_dir).await?; + let session_id_str = opencode_session.id.to_string(); + + info!( + opencode_session_id = %session_id_str, + working_dir = %working_dir.display(), + "OpenCode session created for implementation" + ); - session.start(opencode_session.id.clone()); + session.start(session_id_str.clone()); self.persist_session(&session).await?; + let activity_store = self.get_activity_store(session.id); + self.emit_event(Event::SessionStarted { session_id: session.id, task_id: task.id, + phase: session.phase.as_str().to_string(), + status: session.status.as_str().to_string(), + opencode_session_id: session.opencode_session_id.clone(), + created_at: session.created_at, }); let plan = if self.file_manager.plan_exists(task.id).await { + debug!("Loading existing plan for implementation"); self.file_manager.read_plan(task.id).await.ok() } else { + debug!("No existing plan found, proceeding without plan"); None }; + debug!( + has_plan = plan.is_some(), + "Generating implementation prompt" + ); let prompt = PhasePrompts::implementation_with_plan(task, plan.as_deref()); - let _response = self - .opencode - .send_message(&opencode_session.id, &prompt, None) - .await?; + debug!(prompt_length = prompt.len(), "Sending implementation prompt to OpenCode"); + + let response = self + .send_opencode_message_in_dir( + &session_id_str, + &prompt, + activity_store.as_deref(), + &working_dir, + ) + .await; + + match response { + Ok(_) => { + if let Some(ref store) = activity_store { + store.push_finished(true, None); + } + } + Err(e) => { + if let Some(ref store) = activity_store { + store.push_finished(false, Some(e.to_string())); + } + return Err(e); + } + } + + info!("Implementation response received from OpenCode"); session.complete(); self.update_session(&session).await?; @@ -333,67 +1411,415 @@ impl TaskExecutor { self.transition(task, TaskStatus::AiReview)?; + info!( + task_id = %task.id, + "IMPLEMENTATION session completed, proceeding to AI review" + ); + Ok(PhaseResult::SessionCreated { - session_id: opencode_session.id, + session_id: session_id_str, }) } + #[instrument(skip(self, task), fields(task_id = %task.id, iteration = iteration))] async fn run_ai_review(&self, task: &mut Task, iteration: u32) -> Result { info!( - "Running AI review session for task {} (iteration {})", - task.id, iteration + task_id = %task.id, + iteration = iteration, + max_iterations = self.config.max_review_iterations, + "Starting AI_REVIEW session with MCP" ); let mut session = Session::new(task.id, SessionPhase::Review); - let opencode_session = self - .opencode - .create_session(Some(format!("AI Review: {}", task.title))) + debug!("Creating OpenCode session for AI review"); + let opencode_session = self.create_opencode_session().await?; + let session_id_str = opencode_session.id.to_string(); + + info!( + opencode_session_id = %session_id_str, + "OpenCode session created for AI review" + ); + + session.start(session_id_str.clone()); + self.persist_session(&session).await?; + + let activity_store = self.get_activity_store(session.id); + + self.emit_event(Event::SessionStarted { + session_id: session.id, + task_id: task.id, + phase: session.phase.as_str().to_string(), + status: session.status.as_str().to_string(), + opencode_session_id: session.opencode_session_id.clone(), + created_at: session.created_at, + }); + + // Get workspace path for MCP server + let workspace_path = task + .workspace_path + .as_ref() + .map(PathBuf::from) + .unwrap_or_else(|| self.config.repo_path.clone()); + + // Add MCP findings server to OpenCode + if let Err(e) = self + .add_mcp_findings_server(task.id, session.id, &workspace_path) + .await + { + warn!(error = %e, "Failed to add MCP server, falling back to JSON parsing"); + // Fall back to non-MCP review if MCP server fails to start + return self.run_ai_review_json_fallback(task, session, session_id_str, activity_store, iteration).await; + } + + debug!("Getting workspace diff for review"); + let diff = self.get_workspace_diff(task).await?; + debug!(diff_length = diff.len(), "Workspace diff retrieved"); + + // Use MCP-based prompt + let prompt = PhasePrompts::review_with_mcp(task, &diff); + debug!(prompt_length = prompt.len(), "Sending MCP review prompt to OpenCode"); + + let response_content = self + .send_opencode_message_with_activity( + &session_id_str, + &prompt, + activity_store.as_deref(), + ) + .await; + + // Disconnect MCP server after review (ignore errors) + let _ = self.remove_mcp_findings_server(&workspace_path).await; + + let response_content = match response_content { + Ok(content) => content, + Err(e) => { + if let Some(ref store) = activity_store { + store.push_finished(false, Some(e.to_string())); + } + return Err(e); + } + }; + + info!( + response_length = response_content.len(), + "Received AI review response" + ); + + // Save raw review for reference + let _review_path = self + .file_manager + .write_review(task.id, &response_content) .await?; - session.start(opencode_session.id.clone()); + session.complete(); + self.update_session(&session).await?; + + // Read findings from file (written by MCP server) + let review_result = match self.file_manager.read_findings(task.id).await { + Ok(Some(findings)) => { + info!( + approved = findings.approved, + finding_count = findings.findings.len(), + "AI review findings read from MCP server" + ); + + if findings.approved || findings.findings.is_empty() { + ReviewResult::Approved + } else { + ReviewResult::FindingsDetected(findings.findings.len()) + } + } + Ok(None) => { + // No findings file - try to parse from response as fallback + warn!("No MCP findings file found, falling back to JSON parsing"); + match Self::parse_review_json(&response_content, task.id, session.id) { + Ok(findings) => { + self.file_manager.write_findings(task.id, &findings).await?; + if findings.approved || findings.findings.is_empty() { + ReviewResult::Approved + } else { + ReviewResult::FindingsDetected(findings.findings.len()) + } + } + Err(_) => Self::parse_review_response(&response_content), + } + } + Err(e) => { + warn!(error = %e, "Failed to read MCP findings, falling back to JSON parsing"); + match Self::parse_review_json(&response_content, task.id, session.id) { + Ok(findings) => { + self.file_manager.write_findings(task.id, &findings).await?; + if findings.approved || findings.findings.is_empty() { + ReviewResult::Approved + } else { + ReviewResult::FindingsDetected(findings.findings.len()) + } + } + Err(_) => Self::parse_review_response(&response_content), + } + } + }; + + let success = matches!(review_result, ReviewResult::Approved); + + if let Some(ref store) = activity_store { + store.push_finished(success, None); + } + + info!( + review_result = ?review_result, + "AI review result processed" + ); + + self.emit_event(Event::SessionEnded { + session_id: session.id, + task_id: task.id, + success, + }); + + match review_result { + ReviewResult::Approved => { + info!(task_id = %task.id, "AI review APPROVED, proceeding to human review"); + self.transition(task, TaskStatus::Review)?; + Ok(PhaseResult::ReviewPassed { + session_id: session_id_str, + }) + } + ReviewResult::FindingsDetected(count) => { + info!( + task_id = %task.id, + finding_count = count, + "AI review found issues, waiting for user action" + ); + // Stay in ai_review state - user must choose to fix or skip + Ok(PhaseResult::ReviewFailed { + session_id: session_id_str, + feedback: format!("{} issues found. Review findings and choose to fix or skip.", count), + iteration, + }) + } + ReviewResult::ChangesRequested(feedback) => { + warn!( + task_id = %task.id, + iteration = iteration, + feedback_preview = %feedback.chars().take(200).collect::(), + "AI review REJECTED (legacy format), changes requested" + ); + // Legacy behavior - auto transition to InProgress + self.transition(task, TaskStatus::InProgress)?; + Ok(PhaseResult::ReviewFailed { + session_id: session_id_str, + feedback, + iteration, + }) + } + } + } + + /// Run a fix session to address findings from AI review + #[instrument(skip(self, task), fields(task_id = %task.id))] + async fn run_fix_session(&self, task: &mut Task) -> Result { + info!( + task_id = %task.id, + "Starting FIX session with MCP" + ); + + let mut session = Session::new(task.id, SessionPhase::Fix); + + debug!("Creating OpenCode session for fix"); + let opencode_session = self.create_opencode_session().await?; + let session_id_str = opencode_session.id.to_string(); + + info!( + opencode_session_id = %session_id_str, + "OpenCode session created for fix" + ); + + session.start(session_id_str.clone()); self.persist_session(&session).await?; + let activity_store = self.get_activity_store(session.id); + self.emit_event(Event::SessionStarted { session_id: session.id, task_id: task.id, + phase: session.phase.as_str().to_string(), + status: session.status.as_str().to_string(), + opencode_session_id: session.opencode_session_id.clone(), + created_at: session.created_at, + }); + + // Get workspace path for MCP server + let workspace_path = task + .workspace_path + .as_ref() + .map(PathBuf::from) + .unwrap_or_else(|| self.config.repo_path.clone()); + + // Add MCP findings server to OpenCode + if let Err(e) = self + .add_mcp_findings_server(task.id, session.id, &workspace_path) + .await + { + warn!(error = %e, "Failed to add MCP server for fix session"); + session.fail(); + self.update_session(&session).await?; + + if let Some(ref store) = activity_store { + store.push_finished(false, Some(e.to_string())); + } + + return Err(OrchestratorError::ExecutionFailed(format!( + "MCP server required for fix session: {}", + e + ))); + } + + // Use fix prompt with MCP + let prompt = PhasePrompts::fix_with_mcp(task); + debug!(prompt_length = prompt.len(), "Sending fix prompt to OpenCode"); + + let response_content = self + .send_opencode_message_with_activity( + &session_id_str, + &prompt, + activity_store.as_deref(), + ) + .await; + + // Disconnect MCP server after fix (ignore errors) + let _ = self.remove_mcp_findings_server(&workspace_path).await; + + let response_content = match response_content { + Ok(content) => content, + Err(e) => { + if let Some(ref store) = activity_store { + store.push_finished(false, Some(e.to_string())); + } + return Err(e); + } + }; + + info!( + response_length = response_content.len(), + "Received fix session response" + ); + + session.complete(); + self.update_session(&session).await?; + + if let Some(ref store) = activity_store { + store.push_finished(true, None); + } + + self.emit_event(Event::SessionEnded { + session_id: session.id, + task_id: task.id, + success: true, }); + // After fix, transition back to AI Review for re-evaluation + info!(task_id = %task.id, "Fix session completed, transitioning to AI Review"); + self.transition(task, TaskStatus::AiReview)?; + + Ok(PhaseResult::FixCompleted { + session_id: session_id_str, + }) + } + + /// Fallback method for AI review without MCP (uses JSON parsing) + async fn run_ai_review_json_fallback( + &self, + task: &mut Task, + mut session: Session, + session_id_str: String, + activity_store: Option>, + iteration: u32, + ) -> Result { + debug!("Getting workspace diff for review"); let diff = self.get_workspace_diff(task).await?; + debug!(diff_length = diff.len(), "Workspace diff retrieved"); + let prompt = PhasePrompts::review(task, &diff); + debug!(prompt_length = prompt.len(), "Sending review prompt to OpenCode"); - let response = self - .opencode - .send_message(&opencode_session.id, &prompt, None) - .await?; + let response_content = self + .send_opencode_message_with_activity( + &session_id_str, + &prompt, + activity_store.as_deref(), + ) + .await; + + let response_content = match response_content { + Ok(content) => content, + Err(e) => { + if let Some(ref store) = activity_store { + store.push_finished(false, Some(e.to_string())); + } + return Err(e); + } + }; + + info!( + response_length = response_content.len(), + "Received AI review response" + ); let _review_path = self .file_manager - .write_review(task.id, &response.message.content) + .write_review(task.id, &response_content) .await?; session.complete(); self.update_session(&session).await?; - let review_result = Self::parse_review_response(&response.message.content); + let review_result = match Self::parse_review_json(&response_content, task.id, session.id) { + Ok(findings) => { + self.file_manager.write_findings(task.id, &findings).await?; + if findings.approved || findings.findings.is_empty() { + ReviewResult::Approved + } else { + ReviewResult::FindingsDetected(findings.findings.len()) + } + } + Err(_) => { + warn!("Falling back to legacy text-based review parsing"); + Self::parse_review_response(&response_content) + } + }; + + let success = matches!(review_result, ReviewResult::Approved); + + if let Some(ref store) = activity_store { + store.push_finished(success, None); + } self.emit_event(Event::SessionEnded { session_id: session.id, task_id: task.id, - success: matches!(review_result, ReviewResult::Approved), + success, }); match review_result { ReviewResult::Approved => { self.transition(task, TaskStatus::Review)?; Ok(PhaseResult::ReviewPassed { - session_id: opencode_session.id, + session_id: session_id_str, + }) + } + ReviewResult::FindingsDetected(count) => { + Ok(PhaseResult::ReviewFailed { + session_id: session_id_str, + feedback: format!("{} issues found. Review findings and choose to fix or skip.", count), + iteration, }) } ReviewResult::ChangesRequested(feedback) => { self.transition(task, TaskStatus::InProgress)?; Ok(PhaseResult::ReviewFailed { - session_id: opencode_session.id, + session_id: session_id_str, feedback, iteration, }) @@ -418,6 +1844,83 @@ impl TaskExecutor { Ok("(no workspace configured - diff unavailable)".to_string()) } + /// Parse JSON review response and create ReviewFindings + fn parse_review_json( + content: &str, + task_id: Uuid, + session_id: Uuid, + ) -> Result { + // Try to extract JSON from markdown code blocks or raw content + let json_str = Self::extract_json_from_response(content); + + let raw: RawReviewResponse = serde_json::from_str(&json_str).map_err(|e| { + warn!( + error = %e, + content_preview = %content.chars().take(500).collect::(), + "Failed to parse review JSON, falling back to text parsing" + ); + OrchestratorError::ExecutionFailed(format!("Failed to parse review JSON: {}", e)) + })?; + + // Convert raw findings to ReviewFinding + let findings: Vec = raw + .findings + .into_iter() + .enumerate() + .map(|(i, f)| ReviewFinding { + id: format!("finding-{}", i + 1), + file_path: f.file_path, + line_start: f.line_start, + line_end: f.line_end, + title: f.title, + description: f.description, + severity: match f.severity.to_lowercase().as_str() { + "error" => FindingSeverity::Error, + "info" => FindingSeverity::Info, + _ => FindingSeverity::Warning, + }, + status: FindingStatus::Pending, + }) + .collect(); + + Ok(ReviewFindings::with_findings( + task_id, + session_id, + raw.summary, + findings, + )) + } + + /// Extract JSON from response that might be wrapped in markdown code blocks + fn extract_json_from_response(content: &str) -> String { + // Try to find JSON in ```json ... ``` blocks + if let Some(start) = content.find("```json") { + if let Some(end) = content[start..].find("```\n").or(content[start..].rfind("```")) { + let json_start = start + 7; // length of "```json" + let json_content = &content[json_start..start + end]; + return json_content.trim().to_string(); + } + } + + // Try to find JSON in ``` ... ``` blocks + if let Some(start) = content.find("```\n{") { + if let Some(end) = content[start + 4..].find("\n```") { + return content[start + 4..start + 4 + end].trim().to_string(); + } + } + + // Try to find raw JSON (starts with { and ends with }) + if let Some(start) = content.find('{') { + if let Some(end) = content.rfind('}') { + return content[start..=end].to_string(); + } + } + + // Return as-is, let JSON parser handle the error + content.to_string() + } + + /// Legacy text-based review parsing (fallback) fn parse_review_response(content: &str) -> ReviewResult { let content_upper = content.to_uppercase(); @@ -455,29 +1958,65 @@ impl TaskExecutor { } } + #[instrument(skip(self, task, feedback), fields(task_id = %task.id))] pub async fn run_fix_iteration(&self, task: &mut Task, feedback: &str) -> Result { - info!("Running fix iteration for task {}", task.id); + info!( + task_id = %task.id, + feedback_length = feedback.len(), + "Starting FIX iteration based on review feedback" + ); let mut session = Session::new(task.id, SessionPhase::Implementation); - let opencode_session = self - .opencode - .create_session(Some(format!("Fix: {}", task.title))) - .await?; + debug!("Creating OpenCode session for fix iteration"); + let opencode_session = self.create_opencode_session().await?; + let session_id_str = opencode_session.id.to_string(); + + info!( + opencode_session_id = %session_id_str, + "OpenCode session created for fix iteration" + ); - session.start(opencode_session.id.clone()); + session.start(session_id_str.clone()); self.persist_session(&session).await?; + let activity_store = self.get_activity_store(session.id); + self.emit_event(Event::SessionStarted { session_id: session.id, task_id: task.id, + phase: session.phase.as_str().to_string(), + status: session.status.as_str().to_string(), + opencode_session_id: session.opencode_session_id.clone(), + created_at: session.created_at, }); let prompt = PhasePrompts::fix_issues(task, feedback); - let _response = self - .opencode - .send_message(&opencode_session.id, &prompt, None) - .await?; + debug!(prompt_length = prompt.len(), "Sending fix prompt to OpenCode"); + + let response = self + .send_opencode_message_with_activity( + &session_id_str, + &prompt, + activity_store.as_deref(), + ) + .await; + + match response { + Ok(_) => { + if let Some(ref store) = activity_store { + store.push_finished(true, None); + } + } + Err(e) => { + if let Some(ref store) = activity_store { + store.push_finished(false, Some(e.to_string())); + } + return Err(e); + } + } + + info!("Fix iteration response received from OpenCode"); session.complete(); self.update_session(&session).await?; @@ -490,24 +2029,48 @@ impl TaskExecutor { self.transition(task, TaskStatus::AiReview)?; + info!( + task_id = %task.id, + "FIX iteration completed, returning to AI review" + ); + Ok(PhaseResult::SessionCreated { - session_id: opencode_session.id, + session_id: session_id_str, }) } + #[instrument(skip(self, task), fields(task_id = %task.id))] pub async fn approve_plan(&self, task: &mut Task) -> Result<()> { + info!(task_id = %task.id, "Plan APPROVED by human reviewer"); + if task.status != TaskStatus::PlanningReview { + warn!( + current_status = %task.status.as_str(), + "Cannot approve plan - task not in PlanningReview state" + ); return Err(OrchestratorError::InvalidTransition { from: task.status.as_str().to_string(), to: "InProgress (plan approval)".to_string(), }); } self.transition(task, TaskStatus::InProgress)?; + info!(task_id = %task.id, "Task ready for implementation"); Ok(()) } + #[instrument(skip(self, task, feedback), fields(task_id = %task.id))] pub async fn reject_plan(&self, task: &mut Task, feedback: &str) -> Result { + info!( + task_id = %task.id, + feedback_length = feedback.len(), + "Plan REJECTED by human reviewer, re-planning" + ); + if task.status != TaskStatus::PlanningReview { + warn!( + current_status = %task.status.as_str(), + "Cannot reject plan - task not in PlanningReview state" + ); return Err(OrchestratorError::InvalidTransition { from: task.status.as_str().to_string(), to: "Planning (plan rejection)".to_string(), @@ -516,49 +2079,95 @@ impl TaskExecutor { self.transition(task, TaskStatus::Planning)?; let mut session = Session::new(task.id, SessionPhase::Planning); - let opencode_session = self - .opencode - .create_session(Some(format!("Re-planning: {}", task.title))) - .await?; + let opencode_session = self.create_opencode_session().await?; + let session_id_str = opencode_session.id.to_string(); + + info!( + opencode_session_id = %session_id_str, + "OpenCode session created for re-planning" + ); - session.start(opencode_session.id.clone()); + session.start(session_id_str.clone()); self.persist_session(&session).await?; + let activity_store = self.get_activity_store(session.id); + let prompt = PhasePrompts::replan(task, feedback); - let response = self - .opencode - .send_message(&opencode_session.id, &prompt, None) - .await?; + let response_content = self + .send_opencode_message_with_activity( + &session_id_str, + &prompt, + activity_store.as_deref(), + ) + .await; + + let response_content = match response_content { + Ok(content) => { + if let Some(ref store) = activity_store { + store.push_finished(true, None); + } + content + } + Err(e) => { + if let Some(ref store) = activity_store { + store.push_finished(false, Some(e.to_string())); + } + return Err(e); + } + }; let plan_path = self .file_manager - .write_plan(task.id, &response.message.content) + .write_plan(task.id, &response_content) .await?; + info!(plan_path = %plan_path.display(), "New plan saved"); + session.complete(); self.update_session(&session).await?; self.transition(task, TaskStatus::PlanningReview)?; + info!(task_id = %task.id, "Re-planning completed, awaiting review"); + Ok(PhaseResult::PlanCreated { - session_id: opencode_session.id, + session_id: session_id_str, plan_path: plan_path.to_string_lossy().to_string(), }) } + #[instrument(skip(self, task), fields(task_id = %task.id))] pub async fn approve_review(&self, task: &mut Task) -> Result<()> { + info!(task_id = %task.id, "Implementation APPROVED by human reviewer"); + if task.status != TaskStatus::Review { + warn!( + current_status = %task.status.as_str(), + "Cannot approve review - task not in Review state" + ); return Err(OrchestratorError::InvalidTransition { from: task.status.as_str().to_string(), to: "Done (review approval)".to_string(), }); } self.transition(task, TaskStatus::Done)?; + info!(task_id = %task.id, "Task COMPLETED successfully"); Ok(()) } + #[instrument(skip(self, task, feedback), fields(task_id = %task.id))] pub async fn reject_review(&self, task: &mut Task, feedback: &str) -> Result { + info!( + task_id = %task.id, + feedback_length = feedback.len(), + "Implementation REJECTED by human reviewer, running fix iteration" + ); + if task.status != TaskStatus::Review { + warn!( + current_status = %task.status.as_str(), + "Cannot reject review - task not in Review state" + ); return Err(OrchestratorError::InvalidTransition { from: task.status.as_str().to_string(), to: "InProgress (review rejection)".to_string(), @@ -588,6 +2197,10 @@ pub enum PhaseResult { feedback: String, iteration: u32, }, + /// Fix session completed - will auto-transition back to AI Review + FixCompleted { + session_id: String, + }, MaxIterationsExceeded { iterations: u32, }, @@ -598,6 +2211,8 @@ pub enum PhaseResult { pub enum ReviewResult { Approved, ChangesRequested(String), + /// Structured findings detected - task stays in ai_review waiting for user action + FindingsDetected(usize), } #[cfg(test)] diff --git a/crates/orchestrator/src/files.rs b/crates/orchestrator/src/files.rs index 3169ce3..a99ef3d 100644 --- a/crates/orchestrator/src/files.rs +++ b/crates/orchestrator/src/files.rs @@ -1,9 +1,12 @@ -//! File management for plans and reviews +//! File management for plans, reviews, and findings //! -//! Handles reading/writing of plan and review markdown files in the -//! `.opencode-studio/kanban/` directory structure. +//! Handles reading/writing of plan and review markdown files and +//! structured findings JSON in the `.opencode-studio/kanban/` directory structure. use std::path::PathBuf; + +use chrono::{DateTime, Utc}; +use serde::{Deserialize, Serialize}; use tokio::fs; use tracing::{debug, info}; use uuid::Uuid; @@ -18,6 +21,117 @@ const KANBAN_DIR: &str = "kanban"; const PLANS_DIR: &str = "plans"; /// Directory for review files const REVIEWS_DIR: &str = "reviews"; +/// Directory for findings files +const FINDINGS_DIR: &str = "findings"; + +// ============================================================================ +// Review Findings Types +// ============================================================================ + +/// Severity level of a finding +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "lowercase")] +#[cfg_attr(feature = "typescript", derive(ts_rs::TS))] +#[cfg_attr(feature = "typescript", ts(export))] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +pub enum FindingSeverity { + Error, + Warning, + Info, +} + +impl FindingSeverity { + pub fn as_str(&self) -> &'static str { + match self { + FindingSeverity::Error => "error", + FindingSeverity::Warning => "warning", + FindingSeverity::Info => "info", + } + } +} + +/// Status of a finding +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "lowercase")] +#[cfg_attr(feature = "typescript", derive(ts_rs::TS))] +#[cfg_attr(feature = "typescript", ts(export))] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +pub enum FindingStatus { + Pending, + Fixed, + Skipped, +} + +/// A single review finding +#[derive(Debug, Clone, Serialize, Deserialize)] +#[cfg_attr(feature = "typescript", derive(ts_rs::TS))] +#[cfg_attr(feature = "typescript", ts(export))] +#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))] +pub struct ReviewFinding { + pub id: String, + #[serde(skip_serializing_if = "Option::is_none")] + pub file_path: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub line_start: Option, + #[serde(skip_serializing_if = "Option::is_none")] + pub line_end: Option, + pub title: String, + pub description: String, + pub severity: FindingSeverity, + pub status: FindingStatus, +} + +/// Collection of findings from an AI review +#[derive(Debug, Clone, Serialize, Deserialize)] +#[cfg_attr(feature = "typescript", derive(ts_rs::TS))] +#[cfg_attr(feature = "typescript", ts(export))] +pub struct ReviewFindings { + pub task_id: Uuid, + pub session_id: Uuid, + pub approved: bool, + pub created_at: DateTime, + pub summary: String, + pub findings: Vec, +} + +impl ReviewFindings { + /// Create a new approved review with no findings + pub fn approved(task_id: Uuid, session_id: Uuid, summary: String) -> Self { + Self { + task_id, + session_id, + approved: true, + created_at: Utc::now(), + summary, + findings: Vec::new(), + } + } + + /// Create a new review with findings + pub fn with_findings( + task_id: Uuid, + session_id: Uuid, + summary: String, + findings: Vec, + ) -> Self { + Self { + task_id, + session_id, + approved: findings.is_empty(), + created_at: Utc::now(), + summary, + findings, + } + } + + /// Count pending findings + pub fn pending_count(&self) -> usize { + self.findings + .iter() + .filter(|f| f.status == FindingStatus::Pending) + .count() + } +} /// Manages plan and review files for tasks #[derive(Debug, Clone)] @@ -50,6 +164,14 @@ impl FileManager { .join(REVIEWS_DIR) } + /// Get the path to the findings directory + pub fn findings_dir(&self) -> PathBuf { + self.base_path + .join(STUDIO_DIR) + .join(KANBAN_DIR) + .join(FINDINGS_DIR) + } + /// Get the path to a plan file for a task pub fn plan_path(&self, task_id: Uuid) -> PathBuf { self.plans_dir().join(format!("{}.md", task_id)) @@ -60,12 +182,21 @@ impl FileManager { self.reviews_dir().join(format!("{}.md", task_id)) } + /// Get the path to a findings file for a task + pub fn findings_path(&self, task_id: Uuid) -> PathBuf { + self.findings_dir().join(format!("{}.json", task_id)) + } + /// Ensure all required directories exist pub async fn ensure_directories(&self) -> Result<()> { let plans_dir = self.plans_dir(); let reviews_dir = self.reviews_dir(); + let findings_dir = self.findings_dir(); - debug!("Ensuring directories exist: {:?}, {:?}", plans_dir, reviews_dir); + debug!( + "Ensuring directories exist: {:?}, {:?}, {:?}", + plans_dir, reviews_dir, findings_dir + ); fs::create_dir_all(&plans_dir).await.map_err(|e| { OrchestratorError::ExecutionFailed(format!( @@ -81,6 +212,13 @@ impl FileManager { )) })?; + fs::create_dir_all(&findings_dir).await.map_err(|e| { + OrchestratorError::ExecutionFailed(format!( + "Failed to create findings directory {:?}: {}", + findings_dir, e + )) + })?; + Ok(()) } @@ -198,6 +336,125 @@ impl FileManager { Ok(()) } + // ======================================================================== + // Findings Methods + // ======================================================================== + + /// Write findings to a JSON file for a task (atomic write) + pub async fn write_findings(&self, task_id: Uuid, findings: &ReviewFindings) -> Result { + self.ensure_directories().await?; + let path = self.findings_path(task_id); + let temp_path = self.findings_dir().join(format!(".{}.tmp", task_id)); + + info!("Writing findings to {:?}", path); + + let json = serde_json::to_string_pretty(findings).map_err(|e| { + OrchestratorError::ExecutionFailed(format!("Failed to serialize findings: {}", e)) + })?; + + fs::write(&temp_path, &json).await.map_err(|e| { + OrchestratorError::ExecutionFailed(format!( + "Failed to write temp findings file {:?}: {}", + temp_path, e + )) + })?; + + fs::rename(&temp_path, &path).await.map_err(|e| { + OrchestratorError::ExecutionFailed(format!( + "Failed to rename findings file {:?} -> {:?}: {}", + temp_path, path, e + )) + })?; + + Ok(path) + } + + /// Read findings from a JSON file for a task + pub async fn read_findings(&self, task_id: Uuid) -> Result> { + let path = self.findings_path(task_id); + + if !fs::try_exists(&path).await.unwrap_or(false) { + return Ok(None); + } + + debug!("Reading findings from {:?}", path); + let content = fs::read_to_string(&path).await.map_err(|e| { + OrchestratorError::ExecutionFailed(format!( + "Failed to read findings file {:?}: {}", + path, e + )) + })?; + + let findings: ReviewFindings = serde_json::from_str(&content).map_err(|e| { + OrchestratorError::ExecutionFailed(format!( + "Failed to parse findings file {:?}: {}", + path, e + )) + })?; + + Ok(Some(findings)) + } + + /// Check if findings exist for a task + pub async fn findings_exists(&self, task_id: Uuid) -> bool { + fs::try_exists(self.findings_path(task_id)) + .await + .unwrap_or(false) + } + + /// Delete findings file for a task + pub async fn delete_findings(&self, task_id: Uuid) -> Result<()> { + let path = self.findings_path(task_id); + if fs::try_exists(&path).await.unwrap_or(false) { + fs::remove_file(&path).await.map_err(|e| { + OrchestratorError::ExecutionFailed(format!( + "Failed to delete findings file {:?}: {}", + path, e + )) + })?; + } + Ok(()) + } + + /// Update status of specific findings in the file + pub async fn update_findings_status( + &self, + task_id: Uuid, + finding_ids: &[String], + status: FindingStatus, + ) -> Result<()> { + let mut findings = self + .read_findings(task_id) + .await? + .ok_or_else(|| OrchestratorError::ExecutionFailed("Findings file not found".into()))?; + + for finding in &mut findings.findings { + if finding_ids.contains(&finding.id) { + finding.status = status; + } + } + + self.write_findings(task_id, &findings).await?; + Ok(()) + } + + /// Mark all pending findings as skipped + pub async fn skip_all_findings(&self, task_id: Uuid) -> Result<()> { + let mut findings = self + .read_findings(task_id) + .await? + .ok_or_else(|| OrchestratorError::ExecutionFailed("Findings file not found".into()))?; + + for finding in &mut findings.findings { + if finding.status == FindingStatus::Pending { + finding.status = FindingStatus::Skipped; + } + } + + self.write_findings(task_id, &findings).await?; + Ok(()) + } + /// Get the relative path for a plan (used in prompts) pub fn plan_relative_path(&self, task_id: Uuid) -> String { format!( diff --git a/crates/orchestrator/src/lib.rs b/crates/orchestrator/src/lib.rs index d8a8c5a..5fb40df 100644 --- a/crates/orchestrator/src/lib.rs +++ b/crates/orchestrator/src/lib.rs @@ -1,10 +1,18 @@ +pub mod activity_store; pub mod error; pub mod executor; pub mod files; +pub mod mcp_config; +pub mod opencode_events; pub mod prompts; pub mod state_machine; +pub use activity_store::{SessionActivityMsg, SessionActivityRegistry, SessionActivityStore}; pub use error::{OrchestratorError, Result}; -pub use executor::{ExecutorConfig, PhaseResult, ReviewResult, TaskExecutor}; -pub use files::FileManager; +pub use executor::{ExecutorConfig, PhaseResult, ReviewResult, StartedExecution, TaskExecutor}; +pub use files::{ + FileManager, FindingSeverity, FindingStatus, ReviewFinding, ReviewFindings, +}; +pub use mcp_config::{expand_env_vars, McpBinarySource, McpServerSpec, PhaseMcpConfig}; +pub use opencode_events::{ExecutorEvent, OpenCodeEventSubscriber, SessionStatus as OpenCodeSessionStatus}; pub use state_machine::TaskStateMachine; diff --git a/crates/orchestrator/src/mcp_config.rs b/crates/orchestrator/src/mcp_config.rs new file mode 100644 index 0000000..888d721 --- /dev/null +++ b/crates/orchestrator/src/mcp_config.rs @@ -0,0 +1,178 @@ +//! MCP (Model Context Protocol) configuration for different execution phases. +//! +//! This module defines which MCP servers are available for each session phase, +//! allowing different tools to be exposed based on the current task phase. +//! This helps optimize context window usage by only loading relevant tools. + +use opencode_core::SessionPhase; +use serde::{Deserialize, Serialize}; +use std::collections::HashMap; +use std::path::PathBuf; + +/// Specification for an MCP server that can be attached to a session. +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct McpServerSpec { + /// Unique name for this MCP server (e.g., "opencode-findings") + pub name: String, + + /// Path to the MCP server binary, or "builtin:" for built-in servers + pub binary: McpBinarySource, + + /// Environment variables to pass to the MCP server. + /// Supported placeholders: {task_id}, {session_id}, {workspace_path} + pub env_vars: HashMap, + + /// Timeout in milliseconds for MCP operations + #[serde(default = "default_timeout")] + pub timeout_ms: u32, +} + +fn default_timeout() -> u32 { + 10000 // 10 seconds +} + +/// Source of the MCP binary +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum McpBinarySource { + /// Built-in MCP server (e.g., "builtin:findings") + Builtin(String), + /// Path to external MCP binary + Path(PathBuf), +} + +impl McpBinarySource { + /// Check if this is the built-in findings server + pub fn is_findings_server(&self) -> bool { + matches!(self, McpBinarySource::Builtin(name) if name == "builtin:findings") + } + + /// Get the binary path, resolving built-in servers + pub fn resolve_path(&self, mcp_binary_dir: Option<&PathBuf>) -> Option { + match self { + McpBinarySource::Builtin(name) if name == "builtin:findings" => { + // Try to find the opencode-mcp-findings binary + if let Some(dir) = mcp_binary_dir { + Some(dir.join("opencode-mcp-findings")) + } else { + // Try common locations + let candidates = [ + PathBuf::from("./target/debug/opencode-mcp-findings"), + PathBuf::from("./target/release/opencode-mcp-findings"), + PathBuf::from("/usr/local/bin/opencode-mcp-findings"), + ]; + candidates.into_iter().find(|p| p.exists()) + } + } + McpBinarySource::Builtin(_) => None, // Unknown built-in + McpBinarySource::Path(path) => Some(path.clone()), + } + } +} + +/// Configuration for MCP servers per session phase. +#[derive(Debug, Clone, Default)] +pub struct PhaseMcpConfig { + /// Map of session phases to their MCP server specifications + phase_servers: HashMap>, +} + +impl PhaseMcpConfig { + /// Create a new empty configuration + pub fn new() -> Self { + Self { + phase_servers: HashMap::new(), + } + } + + /// Create the default configuration with findings server for Review and Fix phases + pub fn default_config() -> Self { + let mut config = Self::new(); + + // Findings MCP server specification + let findings_server = McpServerSpec { + name: "opencode-findings".to_string(), + binary: McpBinarySource::Builtin("builtin:findings".to_string()), + env_vars: [ + ("OPENCODE_TASK_ID".to_string(), "{task_id}".to_string()), + ("OPENCODE_SESSION_ID".to_string(), "{session_id}".to_string()), + ("OPENCODE_WORKSPACE_PATH".to_string(), "{workspace_path}".to_string()), + ] + .into_iter() + .collect(), + timeout_ms: 10000, + }; + + // AI Review phase gets findings server (to create findings) + config.add_server(SessionPhase::Review, findings_server.clone()); + + // Fix phase gets findings server (to read and mark findings as fixed) + config.add_server(SessionPhase::Fix, findings_server); + + config + } + + /// Add an MCP server to a phase + pub fn add_server(&mut self, phase: SessionPhase, server: McpServerSpec) { + self.phase_servers + .entry(phase) + .or_insert_with(Vec::new) + .push(server); + } + + /// Get MCP servers for a specific phase + pub fn get_servers(&self, phase: &SessionPhase) -> Option<&Vec> { + self.phase_servers.get(phase) + } + + /// Check if a phase has any MCP servers configured + pub fn has_servers(&self, phase: &SessionPhase) -> bool { + self.phase_servers + .get(phase) + .map(|servers| !servers.is_empty()) + .unwrap_or(false) + } + + /// Get all configured phases + pub fn configured_phases(&self) -> Vec<&SessionPhase> { + self.phase_servers.keys().collect() + } +} + +/// Helper to expand environment variable placeholders +pub fn expand_env_vars( + template: &str, + task_id: &str, + session_id: &str, + workspace_path: &str, +) -> String { + template + .replace("{task_id}", task_id) + .replace("{session_id}", session_id) + .replace("{workspace_path}", workspace_path) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_default_config_has_review_phase() { + let config = PhaseMcpConfig::default_config(); + assert!(config.has_servers(&SessionPhase::Review)); + assert!(config.has_servers(&SessionPhase::Fix)); + assert!(!config.has_servers(&SessionPhase::Planning)); + assert!(!config.has_servers(&SessionPhase::Implementation)); + } + + #[test] + fn test_expand_env_vars() { + let result = expand_env_vars( + "{task_id}-{session_id}", + "task-123", + "session-456", + "/workspace", + ); + assert_eq!(result, "task-123-session-456"); + } +} diff --git a/crates/orchestrator/src/opencode_events.rs b/crates/orchestrator/src/opencode_events.rs new file mode 100644 index 0000000..41946b0 --- /dev/null +++ b/crates/orchestrator/src/opencode_events.rs @@ -0,0 +1,549 @@ +//! OpenCode SSE event subscriber for real-time session monitoring. +//! +//! Subscribes to OpenCode's `/event` SSE endpoint to receive real-time updates +//! about session status, message parts, and other events. + +use eventsource_stream::{Event as SseEvent, Eventsource}; +use futures::StreamExt; +use serde::{Deserialize, Serialize}; +use tokio::sync::mpsc; +use tracing::{debug, error, info, warn}; + +/// OpenCode event types we care about +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(tag = "type", rename_all = "snake_case")] +pub enum OpenCodeEvent { + #[serde(rename = "session.status")] + SessionStatus { + properties: SessionStatusProps, + }, + #[serde(rename = "session.idle")] + SessionIdle { + properties: SessionIdleProps, + }, + #[serde(rename = "session.updated")] + SessionUpdated { + properties: SessionUpdatedProps, + }, + #[serde(rename = "message.part.updated")] + MessagePartUpdated { + properties: MessagePartUpdatedProps, + }, + #[serde(rename = "message.updated")] + MessageUpdated { + properties: MessageUpdatedProps, + }, + // Direct activity events (streamed during execution) + #[serde(rename = "step_start")] + StepStart { + id: String, + step_name: Option, + timestamp: String, + }, + #[serde(rename = "reasoning")] + Reasoning { + id: String, + content: String, + timestamp: String, + }, + #[serde(rename = "agent_message")] + AgentMessage { + id: String, + content: String, + is_partial: bool, + timestamp: String, + }, + #[serde(rename = "finished")] + Finished { + success: bool, + error: Option, + timestamp: String, + }, + // Tool events + #[serde(rename = "tool_call")] + ToolCall { + id: String, + tool_name: String, + #[serde(default)] + args: Option, + timestamp: String, + }, + #[serde(rename = "tool_result")] + ToolResult { + id: String, + tool_name: String, + #[serde(default)] + args: Option, + result: String, + success: bool, + timestamp: String, + }, + #[serde(other)] + Unknown, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct SessionStatusProps { + #[serde(rename = "sessionID")] + pub session_id: String, + pub status: SessionStatusValue, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct SessionStatusValue { + #[serde(rename = "type")] + pub status_type: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct SessionIdleProps { + #[serde(rename = "sessionID")] + pub session_id: String, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct SessionUpdatedProps { + #[serde(rename = "sessionID")] + pub session_id: String, + #[serde(default)] + pub title: Option, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct MessagePartUpdatedProps { + pub part: serde_json::Value, + #[serde(default)] + pub delta: Option, +} + +impl MessagePartUpdatedProps { + /// Extract session_id from the part object (OpenCode puts it inside part.sessionID) + pub fn session_id(&self) -> Option { + self.part.get("sessionID").and_then(|v| v.as_str()).map(String::from) + } +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct MessageUpdatedProps { + pub message: serde_json::Value, +} + +/// Parsed session status from OpenCode +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum SessionStatus { + Running, + Idle, + Completed, + Error, + Unknown(String), +} + +impl From<&str> for SessionStatus { + fn from(s: &str) -> Self { + match s.to_lowercase().as_str() { + "running" | "busy" => SessionStatus::Running, + "idle" => SessionStatus::Idle, + "completed" => SessionStatus::Completed, + "error" => SessionStatus::Error, + other => SessionStatus::Unknown(other.to_string()), + } + } +} + +/// Configuration for the OpenCode event subscriber +#[derive(Debug, Clone)] +pub struct OpenCodeEventConfig { + pub base_url: String, + pub session_id: String, + pub directory: String, +} + +/// Events emitted by the subscriber for the executor to handle +#[derive(Debug, Clone)] +pub enum ExecutorEvent { + /// Session became idle (AI finished responding) + SessionIdle { session_id: String }, + /// Session status changed + StatusChanged { session_id: String, status: SessionStatus }, + /// Message part updated (tool call, text, etc.) + MessagePartUpdated { session_id: String, part: serde_json::Value, delta: Option }, + /// Direct activity event (step_start, reasoning, agent_message, finished) + DirectActivity { activity: crate::activity_store::SessionActivityMsg }, + /// Connection error + Error { message: String }, + /// Stream ended + Disconnected, +} + +/// OpenCode SSE event subscriber +pub struct OpenCodeEventSubscriber { + config: OpenCodeEventConfig, + client: reqwest::Client, +} + +impl OpenCodeEventSubscriber { + pub fn new( + base_url: impl Into, + session_id: impl Into, + directory: impl Into, + ) -> Self { + Self { + config: OpenCodeEventConfig { + base_url: base_url.into(), + session_id: session_id.into(), + directory: directory.into(), + }, + client: reqwest::Client::new(), + } + } + + /// Subscribe to OpenCode events and return a channel receiver for executor events + pub fn subscribe(self) -> mpsc::Receiver { + let (tx, rx) = mpsc::channel(100); + let config = self.config.clone(); + let client = self.client.clone(); + + tokio::spawn(async move { + if let Err(e) = Self::run_subscription(client, config, tx.clone()).await { + error!(error = %e, "OpenCode event subscription failed"); + let _ = tx.send(ExecutorEvent::Error { message: e.to_string() }).await; + } + let _ = tx.send(ExecutorEvent::Disconnected).await; + }); + + rx + } + + async fn run_subscription( + client: reqwest::Client, + config: OpenCodeEventConfig, + tx: mpsc::Sender, + ) -> Result<(), Box> { + let url = format!( + "{}/event?directory={}", + config.base_url, + urlencoding::encode(&config.directory) + ); + info!(url = %url, session_id = %config.session_id, directory = %config.directory, "Subscribing to OpenCode SSE events"); + + let response = client + .get(&url) + .header("Accept", "text/event-stream") + .send() + .await?; + + if !response.status().is_success() { + error!(status = %response.status(), "Failed to connect to OpenCode SSE"); + return Err(format!("Failed to connect to SSE: {}", response.status()).into()); + } + + info!(session_id = %config.session_id, "SSE connection established, waiting for events"); + + let stream = response.bytes_stream(); + let mut event_stream = stream.eventsource(); + let mut event_count = 0u32; + + while let Some(event_result) = event_stream.next().await { + match event_result { + Ok(event) => { + event_count += 1; + debug!( + session_id = %config.session_id, + event_type = %event.event, + data_len = event.data.len(), + event_count = event_count, + "Received SSE event" + ); + + if let Some(executor_event) = Self::process_sse_event(&event, &config.session_id) { + let is_idle = matches!(executor_event, ExecutorEvent::SessionIdle { .. }); + + if is_idle { + info!( + session_id = %config.session_id, + event_count = event_count, + "Session became idle, stopping SSE subscription" + ); + } + + if tx.send(executor_event).await.is_err() { + debug!("Receiver dropped, stopping subscription"); + break; + } + + // Stop on idle - session completed + if is_idle { + break; + } + } + } + Err(e) => { + warn!(error = %e, session_id = %config.session_id, "SSE stream error"); + // Continue on transient errors + } + } + } + + info!(session_id = %config.session_id, event_count = event_count, "SSE subscription ended"); + Ok(()) + } + + fn process_sse_event(event: &SseEvent, target_session_id: &str) -> Option { + // Skip empty events or comments + if event.data.is_empty() { + return None; + } + + let parsed: OpenCodeEvent = match serde_json::from_str(&event.data) { + Ok(e) => e, + Err(e) => { + debug!(error = %e, data = %event.data, "Failed to parse OpenCode event"); + return None; + } + }; + + // Log what type was parsed + debug!(parsed_type = ?std::mem::discriminant(&parsed), "Parsed OpenCode event type"); + + match parsed { + OpenCodeEvent::SessionIdle { properties } => { + if properties.session_id == target_session_id { + Some(ExecutorEvent::SessionIdle { + session_id: properties.session_id, + }) + } else { + None + } + } + OpenCodeEvent::SessionStatus { properties } => { + if properties.session_id == target_session_id { + let status_type = &properties.status.status_type; + info!( + session_id = %properties.session_id, + status_type = %status_type, + "Received session.status event" + ); + // Treat "idle" status as SessionIdle event + if status_type == "idle" { + Some(ExecutorEvent::SessionIdle { + session_id: properties.session_id, + }) + } else { + Some(ExecutorEvent::StatusChanged { + session_id: properties.session_id, + status: SessionStatus::from(status_type.as_str()), + }) + } + } else { + None + } + } + OpenCodeEvent::MessagePartUpdated { properties } => { + // Extract session_id from the part object, or use target session as fallback + let event_session_id = properties.session_id() + .unwrap_or_else(|| target_session_id.to_string()); + + debug!( + event_session_id = %event_session_id, + target_session_id = %target_session_id, + part_type = ?properties.part.get("type"), + "Processing MessagePartUpdated" + ); + + if event_session_id == target_session_id { + info!( + session_id = %event_session_id, + part_type = ?properties.part.get("type"), + "Forwarding MessagePartUpdated to executor" + ); + Some(ExecutorEvent::MessagePartUpdated { + session_id: event_session_id, + part: properties.part, + delta: properties.delta, + }) + } else { + debug!( + event_session_id = %event_session_id, + target_session_id = %target_session_id, + "Ignoring MessagePartUpdated for different session" + ); + None + } + } + OpenCodeEvent::SessionUpdated { properties } => { + if properties.session_id == target_session_id { + debug!(session_id = %properties.session_id, "Session updated"); + } + None + } + OpenCodeEvent::MessageUpdated { .. } => None, + // Direct activity events - convert to SessionActivityMsg and forward + OpenCodeEvent::StepStart { id, step_name, timestamp } => { + info!(id = %id, "Received step_start event"); + let ts = chrono::DateTime::parse_from_rfc3339(×tamp) + .map(|dt| dt.with_timezone(&chrono::Utc)) + .unwrap_or_else(|_| chrono::Utc::now()); + Some(ExecutorEvent::DirectActivity { + activity: crate::activity_store::SessionActivityMsg::StepStart { + id, + step_name, + timestamp: ts, + }, + }) + } + OpenCodeEvent::Reasoning { id, content, timestamp } => { + debug!(id = %id, content_len = content.len(), "Received reasoning event"); + let ts = chrono::DateTime::parse_from_rfc3339(×tamp) + .map(|dt| dt.with_timezone(&chrono::Utc)) + .unwrap_or_else(|_| chrono::Utc::now()); + Some(ExecutorEvent::DirectActivity { + activity: crate::activity_store::SessionActivityMsg::Reasoning { + id, + content, + timestamp: ts, + }, + }) + } + OpenCodeEvent::AgentMessage { id, content, is_partial, timestamp } => { + info!(id = %id, is_partial = is_partial, "Received agent_message event"); + let ts = chrono::DateTime::parse_from_rfc3339(×tamp) + .map(|dt| dt.with_timezone(&chrono::Utc)) + .unwrap_or_else(|_| chrono::Utc::now()); + Some(ExecutorEvent::DirectActivity { + activity: crate::activity_store::SessionActivityMsg::AgentMessage { + id, + content, + is_partial, + timestamp: ts, + }, + }) + } + OpenCodeEvent::Finished { success, error, timestamp } => { + info!(success = success, "Received finished event"); + let ts = chrono::DateTime::parse_from_rfc3339(×tamp) + .map(|dt| dt.with_timezone(&chrono::Utc)) + .unwrap_or_else(|_| chrono::Utc::now()); + Some(ExecutorEvent::DirectActivity { + activity: crate::activity_store::SessionActivityMsg::Finished { + success, + error, + timestamp: ts, + }, + }) + } + OpenCodeEvent::ToolCall { id, tool_name, args, timestamp } => { + info!(id = %id, tool_name = %tool_name, "Received tool_call event"); + let ts = chrono::DateTime::parse_from_rfc3339(×tamp) + .map(|dt| dt.with_timezone(&chrono::Utc)) + .unwrap_or_else(|_| chrono::Utc::now()); + Some(ExecutorEvent::DirectActivity { + activity: crate::activity_store::SessionActivityMsg::ToolCall { + id, + tool_name, + args, + timestamp: ts, + }, + }) + } + OpenCodeEvent::ToolResult { id, tool_name, args, result, success, timestamp } => { + info!(id = %id, tool_name = %tool_name, success = success, "Received tool_result event"); + let ts = chrono::DateTime::parse_from_rfc3339(×tamp) + .map(|dt| dt.with_timezone(&chrono::Utc)) + .unwrap_or_else(|_| chrono::Utc::now()); + Some(ExecutorEvent::DirectActivity { + activity: crate::activity_store::SessionActivityMsg::ToolResult { + id, + tool_name, + args, + result, + success, + timestamp: ts, + }, + }) + } + OpenCodeEvent::Unknown => None, + } + } +} + +/// Helper to wait for session completion with timeout +pub async fn wait_for_session_completion( + base_url: &str, + session_id: &str, + directory: &str, + timeout: std::time::Duration, +) -> Result<(), String> { + let subscriber = OpenCodeEventSubscriber::new(base_url, session_id, directory); + let mut rx = subscriber.subscribe(); + + let result = tokio::time::timeout(timeout, async { + while let Some(event) = rx.recv().await { + match event { + ExecutorEvent::SessionIdle { .. } => return Ok(()), + ExecutorEvent::StatusChanged { status: SessionStatus::Completed, .. } => return Ok(()), + ExecutorEvent::StatusChanged { status: SessionStatus::Error, .. } => { + return Err("Session ended with error".to_string()); + } + ExecutorEvent::Error { message } => return Err(message), + ExecutorEvent::Disconnected => return Err("Connection lost".to_string()), + _ => continue, + } + } + Err("Event stream ended unexpectedly".to_string()) + }) + .await; + + match result { + Ok(inner) => inner, + Err(_) => Err("Timeout waiting for session completion".to_string()), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_parse_session_idle() { + let json = r#"{"type":"session.idle","properties":{"sessionID":"ses_123"}}"#; + let event: OpenCodeEvent = serde_json::from_str(json).unwrap(); + + match event { + OpenCodeEvent::SessionIdle { properties } => { + assert_eq!(properties.session_id, "ses_123"); + } + _ => panic!("Expected SessionIdle"), + } + } + + #[test] + fn test_parse_session_status() { + let json = r#"{"type":"session.status","properties":{"sessionID":"ses_456","status":{"type":"running"}}}"#; + let event: OpenCodeEvent = serde_json::from_str(json).unwrap(); + + match event { + OpenCodeEvent::SessionStatus { properties } => { + assert_eq!(properties.session_id, "ses_456"); + assert_eq!(properties.status.status_type, "running"); + } + _ => panic!("Expected SessionStatus"), + } + } + + #[test] + fn test_parse_unknown_event() { + let json = r#"{"type":"some.unknown.event","properties":{}}"#; + let event: OpenCodeEvent = serde_json::from_str(json).unwrap(); + assert!(matches!(event, OpenCodeEvent::Unknown)); + } + + #[test] + fn test_session_status_from_str() { + assert_eq!(SessionStatus::from("running"), SessionStatus::Running); + assert_eq!(SessionStatus::from("idle"), SessionStatus::Idle); + assert_eq!(SessionStatus::from("IDLE"), SessionStatus::Idle); + assert!(matches!(SessionStatus::from("custom"), SessionStatus::Unknown(_))); + } +} diff --git a/crates/orchestrator/src/prompts.rs b/crates/orchestrator/src/prompts.rs index b91b03a..afa2e40 100644 --- a/crates/orchestrator/src/prompts.rs +++ b/crates/orchestrator/src/prompts.rs @@ -113,15 +113,187 @@ Start implementation now."#, 4. Security concerns 5. Breaking changes -## Output -Save your review to: `.opencode-studio/kanban/reviews/{id}.md` +## Output Format +You MUST respond with a JSON object in this exact format: + +```json +{{ + "approved": true, + "summary": "Overall assessment of the changes...", + "findings": [] +}} +``` + +If there are issues, include them in the findings array: + +```json +{{ + "approved": false, + "summary": "Overall assessment...", + "findings": [ + {{ + "file_path": "src/main.rs", + "line_start": 42, + "line_end": 45, + "title": "Missing error handling", + "description": "The function does not handle the case when the input is invalid. This could lead to a panic at runtime.", + "severity": "error" + }}, + {{ + "file_path": "src/utils.rs", + "line_start": 10, + "title": "Consider using const", + "description": "This value could be a const instead of a let binding for better optimization.", + "severity": "info" + }} + ] +}} +``` -If approved, respond with: APPROVED -If changes needed, respond with: CHANGES_REQUESTED and explain what needs fixing."#, +Severity levels: +- "error" - Must be fixed before merge +- "warning" - Should be fixed but not blocking +- "info" - Suggestion for improvement + +Respond ONLY with the JSON object, no additional text."#, title = task.title, description = task.description, - diff = diff, - id = task.id + diff = diff + ) + } + + /// Generate prompt for AI review using MCP tools + pub fn review_with_mcp(task: &Task, diff: &str) -> String { + format!( + r#"Review the following code changes for task: {title} + +## Task Description +{description} + +## Diff +``` +{diff} +``` + +## Review Criteria +1. Code quality and style +2. Correctness - does it solve the task? +3. Tests - are they adequate? +4. Security concerns +5. Breaking changes + +## How to Report Findings + +You have access to the "opencode-findings" MCP server with the following tools: + +1. **create_finding** - Use this to report each issue you find: + - `file_path`: The file where the issue is located (optional) + - `line_start`: Starting line number (optional) + - `line_end`: Ending line number (optional) + - `title`: Short description of the issue (max 100 chars) + - `description`: Detailed explanation of the issue + - `severity`: "error" (must fix), "warning" (should fix), or "info" (suggestion) + +2. **list_findings** - Use this to see all findings you've created + +3. **approve_review** - Use this when the code has NO issues or only info-level suggestions + - `summary`: Overall assessment of the changes + - `approved`: true + +4. **complete_review** - Use this when there ARE issues that need to be fixed + - `summary`: Overall assessment of the changes + - `approved`: false (if there are error-level issues) + +## Instructions + +1. Analyze the diff carefully +2. For each issue found, call `create_finding` with the appropriate details +3. After reviewing all changes: + - If no issues or only info-level issues: call `approve_review` + - If there are error/warning issues: call `complete_review` with approved=false + +Start reviewing now."#, + title = task.title, + description = task.description, + diff = diff + ) + } + + /// Generate prompt for fixing specific findings + pub fn fix_findings(task: &Task, findings: &[crate::files::ReviewFinding]) -> String { + let findings_text = findings + .iter() + .enumerate() + .map(|(i, f)| { + let location = match (&f.file_path, f.line_start) { + (Some(path), Some(line)) => format!("{path}:{line}"), + (Some(path), None) => path.clone(), + _ => "Unknown location".to_string(), + }; + format!( + "{}. [{:?}] {} ({})\n {}\n", + i + 1, + f.severity, + f.title, + location, + f.description + ) + }) + .collect::>() + .join("\n"); + + format!( + r#"Fix the following issues identified in the code review for task: {title} + +## Issues to Fix +{findings_text} + +## Instructions +1. Address each issue mentioned above +2. Make minimal changes - only fix what's needed +3. Ensure the fix is complete and correct +4. Update tests if the fix requires it + +Fix the issues now."#, + title = task.title, + findings_text = findings_text + ) + } + + /// Generate prompt for fix phase using MCP tools + pub fn fix_with_mcp(task: &Task) -> String { + format!( + r#"Fix the issues identified in the code review for task: {title} + +## Task Description +{description} + +## How to Use MCP Tools + +You have access to the "opencode-findings" MCP server with the following tools: + +1. **list_findings** - First, use this to see all findings that need to be fixed + - Returns a list of findings with their IDs, locations, and descriptions + +2. **get_finding** - Get details about a specific finding + - `finding_id`: The ID of the finding + +3. **mark_fixed** - After fixing an issue, mark it as fixed + - `finding_id`: The ID of the finding you fixed + +## Instructions + +1. Call `list_findings` to see all issues that need fixing +2. For each finding: + - Read the finding details + - Navigate to the file and line mentioned + - Fix the issue + - Call `mark_fixed` with the finding ID +3. After fixing all issues, the review will be re-run automatically + +Start by listing the findings and fixing them one by one."#, + title = task.title, + description = task.description ) } diff --git a/crates/orchestrator/src/state_machine.rs b/crates/orchestrator/src/state_machine.rs index 62d8757..01a71d2 100644 --- a/crates/orchestrator/src/state_machine.rs +++ b/crates/orchestrator/src/state_machine.rs @@ -1,4 +1,5 @@ use opencode_core::TaskStatus; +use tracing::{debug, warn}; use crate::error::{OrchestratorError, Result}; @@ -9,8 +10,19 @@ impl TaskStateMachine { let allowed = Self::allowed_transitions(from); if allowed.contains(to) { + debug!( + from = %from.as_str(), + to = %to.as_str(), + "State transition validated" + ); Ok(()) } else { + warn!( + from = %from.as_str(), + to = %to.as_str(), + allowed = ?allowed.iter().map(|s| s.as_str()).collect::>(), + "Invalid state transition attempted" + ); Err(OrchestratorError::InvalidTransition { from: from.as_str().to_string(), to: to.as_str().to_string(), @@ -24,7 +36,10 @@ impl TaskStateMachine { TaskStatus::Planning => vec![TaskStatus::PlanningReview, TaskStatus::Todo], TaskStatus::PlanningReview => vec![TaskStatus::InProgress, TaskStatus::Planning], TaskStatus::InProgress => vec![TaskStatus::AiReview, TaskStatus::PlanningReview], - TaskStatus::AiReview => vec![TaskStatus::Review, TaskStatus::InProgress], + // AiReview can go to: Fix (fix findings), Review (skip/approved), InProgress (back to impl) + TaskStatus::AiReview => vec![TaskStatus::Fix, TaskStatus::Review, TaskStatus::InProgress], + // Fix goes back to AiReview for re-review after fixing + TaskStatus::Fix => vec![TaskStatus::AiReview], TaskStatus::Review => vec![TaskStatus::Done, TaskStatus::InProgress], TaskStatus::Done => vec![], } @@ -40,7 +55,11 @@ impl TaskStateMachine { TaskStatus::Planning => Some(TaskStatus::PlanningReview), TaskStatus::PlanningReview => Some(TaskStatus::InProgress), TaskStatus::InProgress => Some(TaskStatus::AiReview), + // From AiReview, default next is Review (approved/skip path) + // Use transition_to_fix() for the fix path TaskStatus::AiReview => Some(TaskStatus::Review), + // Fix goes back to AiReview + TaskStatus::Fix => Some(TaskStatus::AiReview), TaskStatus::Review => Some(TaskStatus::Done), TaskStatus::Done => None, } @@ -53,6 +72,8 @@ impl TaskStateMachine { TaskStatus::PlanningReview => Some(TaskStatus::Planning), TaskStatus::InProgress => Some(TaskStatus::PlanningReview), TaskStatus::AiReview => Some(TaskStatus::InProgress), + // Fix comes after AiReview + TaskStatus::Fix => Some(TaskStatus::AiReview), TaskStatus::Review => Some(TaskStatus::AiReview), TaskStatus::Done => Some(TaskStatus::Review), } diff --git a/crates/server/Cargo.toml b/crates/server/Cargo.toml index ae6960f..3e1aeb4 100644 --- a/crates/server/Cargo.toml +++ b/crates/server/Cargo.toml @@ -5,19 +5,21 @@ edition.workspace = true [features] default = [] -typescript = ["ts-rs", "opencode_core/typescript", "events/typescript", "vcs/typescript", "websocket/typescript"] +typescript = ["ts-rs", "opencode_core/typescript", "events/typescript", "vcs/typescript", "orchestrator/typescript"] [dependencies] opencode_core = { workspace = true } -opencode = { workspace = true } -orchestrator = { workspace = true } +opencode_client = { workspace = true } +orchestrator = { workspace = true, features = ["openapi"] } db = { workspace = true } vcs = { workspace = true } events = { workspace = true } -websocket = { workspace = true } + github = { workspace = true } sqlx = { workspace = true } tokio = { workspace = true } +tokio-stream = "0.1" +futures = { workspace = true } axum = { workspace = true } tower-http = { workspace = true } serde = { workspace = true } @@ -32,6 +34,8 @@ chrono = { workspace = true } utoipa = { workspace = true } utoipa-axum = { workspace = true } utoipa-swagger-ui = { workspace = true } +dirs = "5" +toml = "0.8" [[bin]] name = "generate-types" @@ -45,3 +49,5 @@ wiremock = "0.6" tempfile = "3.14" uuid = { workspace = true } serde_json = { workspace = true } +futures-util = "0.3" +orchestrator = { workspace = true } diff --git a/crates/server/src/bin/generate_types.rs b/crates/server/src/bin/generate_types.rs index 946e3c7..1a6adb4 100644 --- a/crates/server/src/bin/generate_types.rs +++ b/crates/server/src/bin/generate_types.rs @@ -23,8 +23,7 @@ fn main() { .expect("Failed to export CreateTaskRequest"); opencode_core::UpdateTaskRequest::export_all_to(out_dir) .expect("Failed to export UpdateTaskRequest"); - opencode_core::SessionPhase::export_all_to(out_dir) - .expect("Failed to export SessionPhase"); + opencode_core::SessionPhase::export_all_to(out_dir).expect("Failed to export SessionPhase"); opencode_core::SessionStatus::export_all_to(out_dir) .expect("Failed to export SessionStatus"); opencode_core::Session::export_all_to(out_dir).expect("Failed to export Session"); @@ -42,19 +41,12 @@ fn main() { vcs::ConflictFile::export_all_to(out_dir).expect("Failed to export ConflictFile"); vcs::ConflictType::export_all_to(out_dir).expect("Failed to export ConflictType"); - websocket::ClientMessage::export_all_to(out_dir).expect("Failed to export ClientMessage"); - websocket::ServerMessage::export_all_to(out_dir).expect("Failed to export ServerMessage"); - websocket::SubscriptionFilter::export_all_to(out_dir) - .expect("Failed to export SubscriptionFilter"); - server::routes::TransitionRequest::export_all_to(out_dir) .expect("Failed to export TransitionRequest"); server::routes::TransitionResponse::export_all_to(out_dir) .expect("Failed to export TransitionResponse"); server::routes::ExecuteResponse::export_all_to(out_dir) .expect("Failed to export ExecuteResponse"); - server::routes::PhaseResultDto::export_all_to(out_dir) - .expect("Failed to export PhaseResultDto"); server::routes::WorkspaceResponse::export_all_to(out_dir) .expect("Failed to export WorkspaceResponse"); server::routes::DiffResponse::export_all_to(out_dir) @@ -64,6 +56,9 @@ fn main() { server::routes::MergeResponse::export_all_to(out_dir) .expect("Failed to export MergeResponse"); + orchestrator::SessionActivityMsg::export_all_to(out_dir) + .expect("Failed to export SessionActivityMsg"); + println!("Types exported to {}", out_dir.display()); generate_index(out_dir); @@ -72,7 +67,9 @@ fn main() { #[cfg(not(feature = "typescript"))] { eprintln!("Error: typescript feature is not enabled"); - eprintln!("Run with: cargo run --package server --bin generate-types --features typescript"); + eprintln!( + "Run with: cargo run --package server --bin generate-types --features typescript" + ); std::process::exit(1); } } @@ -105,18 +102,15 @@ export * from './MergeResult'; export * from './ConflictFile'; export * from './ConflictType'; -export * from './ClientMessage'; -export * from './ServerMessage'; -export * from './SubscriptionFilter'; - export * from './TransitionRequest'; export * from './TransitionResponse'; export * from './ExecuteResponse'; -export * from './PhaseResultDto'; export * from './WorkspaceResponse'; export * from './DiffResponse'; export * from './MergeRequest'; export * from './MergeResponse'; + +export * from './SessionActivityMsg'; "#; file.write_all(exports.as_bytes()) diff --git a/crates/server/src/error.rs b/crates/server/src/error.rs index 7d65040..adb88b4 100644 --- a/crates/server/src/error.rs +++ b/crates/server/src/error.rs @@ -3,6 +3,8 @@ use axum::response::{IntoResponse, Response}; use axum::Json; use serde::Serialize; +use crate::project_manager::ProjectError; + #[derive(Debug)] #[allow(dead_code)] pub enum AppError { @@ -12,6 +14,7 @@ pub enum AppError { Internal(String), Database(db::DbError), Vcs(vcs::VcsError), + Project(ProjectError), } #[derive(Serialize)] @@ -70,6 +73,31 @@ impl IntoResponse for AppError { ), } } + AppError::Project(err) => { + tracing::warn!("Project error: {:?}", err); + match &err { + ProjectError::NoProjectOpen => ( + StatusCode::BAD_REQUEST, + "no_project_open", + "No project is currently open".to_string(), + ), + ProjectError::PathNotFound(path) => ( + StatusCode::BAD_REQUEST, + "path_not_found", + format!("Path not found: {}", path.display()), + ), + ProjectError::NotVcsRepo(path) => ( + StatusCode::BAD_REQUEST, + "not_vcs_repo", + format!("Not a git or jujutsu repository: {}", path.display()), + ), + _ => ( + StatusCode::INTERNAL_SERVER_ERROR, + "project_error", + err.to_string(), + ), + } + } }; let body = Json(ErrorResponse { @@ -92,3 +120,9 @@ impl From for AppError { AppError::Vcs(err) } } + +impl From for AppError { + fn from(err: ProjectError) -> Self { + AppError::Project(err) + } +} diff --git a/crates/server/src/lib.rs b/crates/server/src/lib.rs index 70d60d3..992e76e 100644 --- a/crates/server/src/lib.rs +++ b/crates/server/src/lib.rs @@ -1,10 +1,12 @@ pub mod error; +pub mod project_manager; pub mod routes; pub mod state; use axum::routing::{get, post}; use axum::Router; use tower_http::cors::CorsLayer; +use tower_http::services::{ServeDir, ServeFile}; use tower_http::trace::TraceLayer; use utoipa::OpenApi; use utoipa_swagger_ui::SwaggerUi; @@ -20,7 +22,14 @@ use state::AppState; ), paths( routes::health_check, - routes::get_project_info, + routes::project::get_project_info, + routes::projects::open_project, + routes::projects::init_project, + routes::projects::get_current_project, + routes::projects::get_recent_projects, + routes::projects::remove_recent_project, + routes::projects::clear_recent_projects, + routes::projects::validate_project_path, routes::list_tasks, routes::create_task, routes::get_task, @@ -28,29 +37,55 @@ use state::AppState; routes::delete_task, routes::transition_task, routes::execute_task, + routes::get_task_plan, + routes::get_task_findings, + routes::fix_findings, + routes::skip_findings, routes::list_sessions, routes::get_session, routes::list_sessions_for_task, routes::delete_session, + + routes::sse::events_stream, + routes::sse::session_activity_stream, routes::list_workspaces, routes::create_workspace_for_task, routes::get_workspace_status, routes::get_workspace_diff, routes::merge_workspace, routes::delete_workspace, + routes::filesystem::browse_directory, ), components(schemas( routes::HealthResponse, - routes::ProjectInfo, + routes::projects::ProjectInfo, + routes::projects::OpenProjectRequest, + routes::projects::OpenProjectResponse, + routes::projects::InitProjectRequest, + routes::projects::InitProjectResponse, + routes::projects::CurrentProjectResponse, + routes::projects::ProjectErrorResponse, + routes::projects::RecentProject, + routes::projects::RecentProjectsResponse, + routes::projects::ValidatePathRequest, + routes::projects::ValidatePathResponse, + routes::projects::RemoveRecentRequest, + routes::projects::RemoveRecentResponse, + routes::projects::ClearRecentResponse, routes::TransitionRequest, routes::TransitionResponse, routes::ExecuteResponse, - routes::PhaseResultDto, + routes::PlanResponse, + routes::FindingsResponse, + routes::FixFindingsRequest, routes::WorkspaceResponse, routes::WorkspaceStatusResponse, routes::DiffResponse, routes::MergeRequest, routes::MergeResponse, + routes::filesystem::BrowseQuery, + routes::filesystem::BrowseResponse, + routes::filesystem::DirectoryEntry, opencode_core::Task, opencode_core::TaskStatus, opencode_core::CreateTaskRequest, @@ -61,19 +96,31 @@ use state::AppState; )), tags( (name = "health", description = "Health check endpoints"), - (name = "project", description = "Project info endpoints"), + (name = "project", description = "Legacy project info endpoints"), + (name = "projects", description = "Project management endpoints"), (name = "tasks", description = "Task management endpoints"), (name = "sessions", description = "Session management endpoints"), + (name = "events", description = "Real-time event streaming (SSE)"), (name = "workspaces", description = "Workspace management endpoints"), + (name = "filesystem", description = "Filesystem browsing endpoints"), ) )] pub struct ApiDoc; pub fn create_router(state: AppState) -> Router { - Router::new() + let app_dir = state.app_dir.clone(); + + let api_router = Router::new() .merge(SwaggerUi::new("/swagger-ui").url("/api/openapi.json", ApiDoc::openapi())) .route("/health", get(routes::health_check)) - .route("/api/project", get(routes::get_project_info)) + .route("/api/project", get(routes::project::get_project_info)) + .route("/api/projects/open", post(routes::projects::open_project)) + .route("/api/projects/init", post(routes::projects::init_project)) + .route("/api/projects/current", get(routes::projects::get_current_project)) + .route("/api/projects/recent", get(routes::projects::get_recent_projects)) + .route("/api/projects/recent/remove", post(routes::projects::remove_recent_project)) + .route("/api/projects/recent/clear", post(routes::projects::clear_recent_projects)) + .route("/api/projects/validate", post(routes::projects::validate_project_path)) .route( "/api/tasks", get(routes::list_tasks).post(routes::create_task), @@ -86,6 +133,10 @@ pub fn create_router(state: AppState) -> Router { ) .route("/api/tasks/{id}/transition", post(routes::transition_task)) .route("/api/tasks/{id}/execute", post(routes::execute_task)) + .route("/api/tasks/{id}/plan", get(routes::get_task_plan)) + .route("/api/tasks/{id}/findings", get(routes::get_task_findings)) + .route("/api/tasks/{id}/findings/fix", post(routes::fix_findings)) + .route("/api/tasks/{id}/findings/skip", post(routes::skip_findings)) .route( "/api/tasks/{id}/sessions", get(routes::list_sessions_for_task), @@ -99,6 +150,11 @@ pub fn create_router(state: AppState) -> Router { "/api/sessions/{id}", get(routes::get_session).delete(routes::delete_session), ) + .route( + "/api/sessions/{id}/activity", + get(routes::sse::session_activity_stream), + ) + .route("/api/events", get(routes::sse::events_stream)) .route("/api/workspaces", get(routes::list_workspaces)) .route( "/api/workspaces/{id}", @@ -106,8 +162,16 @@ pub fn create_router(state: AppState) -> Router { ) .route("/api/workspaces/{id}/diff", get(routes::get_workspace_diff)) .route("/api/workspaces/{id}/merge", post(routes::merge_workspace)) - .route("/ws", get(routes::websocket_handler)) + .route("/api/filesystem/browse", get(routes::filesystem::browse_directory)) .layer(TraceLayer::new_for_http()) .layer(CorsLayer::permissive()) - .with_state(state) + .with_state(state); + + if let Some(app_dir) = app_dir { + let index_file = app_dir.join("index.html"); + let serve_dir = ServeDir::new(&app_dir).not_found_service(ServeFile::new(&index_file)); + api_router.fallback_service(serve_dir) + } else { + api_router + } } diff --git a/crates/server/src/main.rs b/crates/server/src/main.rs index 044d775..b439eab 100644 --- a/crates/server/src/main.rs +++ b/crates/server/src/main.rs @@ -1,4 +1,5 @@ use server::{create_router, state::AppState}; +use std::path::PathBuf; use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt}; #[tokio::main] @@ -11,20 +12,41 @@ async fn main() -> anyhow::Result<()> { ) .init(); - let database_url = - std::env::var("DATABASE_URL").unwrap_or_else(|_| "sqlite:./studio.db".to_string()); let opencode_url = std::env::var("OPENCODE_URL").unwrap_or_else(|_| "http://localhost:4096".to_string()); - tracing::info!("Connecting to database: {}", database_url); tracing::info!("OpenCode server URL: {}", opencode_url); - let pool = db::create_pool(&database_url).await?; - db::run_migrations(&pool).await?; + let state = AppState::new(&opencode_url); + + if let Some(project_path) = std::env::var("PROJECT_PATH").ok().map(PathBuf::from) { + tracing::info!("Opening project from PROJECT_PATH: {:?}", project_path); + state.open_project(&project_path).await?; + } else if let Ok(database_url) = std::env::var("DATABASE_URL") { + if database_url.starts_with("sqlite:") { + let db_path = database_url.strip_prefix("sqlite:").unwrap_or(&database_url); + let db_path = PathBuf::from(db_path); + + if let Some(studio_dir) = db_path.parent() { + if let Some(project_path) = studio_dir.parent() { + if project_path.join(".git").exists() || project_path.join(".jj").exists() { + tracing::info!( + "Opening project from DATABASE_URL: {:?}", + project_path + ); + state.open_project(project_path).await?; + } + } + } + } + } else { + match state.auto_open_last_project().await { + Ok(true) => tracing::info!("Auto-opened last project"), + Ok(false) => tracing::info!("No project to auto-open"), + Err(e) => tracing::warn!("Failed to auto-open last project: {}", e), + } + } - tracing::info!("Database migrations completed"); - - let state = AppState::new(pool, &opencode_url); let app = create_router(state); let port = std::env::var("PORT") diff --git a/crates/server/src/project_manager.rs b/crates/server/src/project_manager.rs new file mode 100644 index 0000000..4c879ea --- /dev/null +++ b/crates/server/src/project_manager.rs @@ -0,0 +1,735 @@ +//! Project lifecycle management for multi-project support. +//! +//! Handles opening, initializing, and switching between projects at runtime. + +use db::{SessionActivityRepository, SessionRepository, TaskRepository}; +use events::EventBus; +use opencode_client::apis::configuration::Configuration as OpenCodeConfig; +use orchestrator::{ExecutorConfig, SessionActivityRegistry, TaskExecutor}; +use serde::{Deserialize, Serialize}; +use sqlx::SqlitePool; +use std::path::{Path, PathBuf}; +use std::sync::Arc; +use tokio::sync::RwLock; +use vcs::{GitVcs, JujutsuVcs, VersionControl, WorkspaceConfig, WorkspaceManager}; + +const STUDIO_DIR: &str = ".opencode-studio"; +const PROJECT_CONFIG_FILE: &str = "config.toml"; +const KANBAN_DIR: &str = "kanban"; +const PLANS_DIR: &str = "plans"; +const REVIEWS_DIR: &str = "reviews"; + +/// Errors that can occur during project operations. +#[derive(Debug, thiserror::Error)] +pub enum ProjectError { + #[error("Path not found: {0}")] + PathNotFound(PathBuf), + + #[error("Path is not a directory: {0}")] + NotDirectory(PathBuf), + + #[error("Not a git or jujutsu repository: {0}")] + NotVcsRepo(PathBuf), + + #[error("Failed to initialize project: {0}")] + InitFailed(String), + + #[error("Database connection failed: {0}")] + DbConnectFailed(#[from] sqlx::Error), + + #[error("Database migration failed: {0}")] + MigrationFailed(#[from] sqlx::migrate::MigrateError), + + #[error("No project is currently open")] + NoProjectOpen, + + #[error("IO error: {0}")] + Io(#[from] std::io::Error), + + #[error("Config error: {0}")] + Config(String), +} + +/// Error code for API responses. +#[derive(Debug, Clone, Serialize)] +#[serde(rename_all = "SCREAMING_SNAKE_CASE")] +pub enum ProjectErrorCode { + PathNotFound, + NotDirectory, + NotVcsRepo, + InitFailed, + DbConnectFailed, + NoProjectOpen, + IoError, + ConfigError, +} + +impl From<&ProjectError> for ProjectErrorCode { + fn from(err: &ProjectError) -> Self { + match err { + ProjectError::PathNotFound(_) => Self::PathNotFound, + ProjectError::NotDirectory(_) => Self::NotDirectory, + ProjectError::NotVcsRepo(_) => Self::NotVcsRepo, + ProjectError::InitFailed(_) => Self::InitFailed, + ProjectError::DbConnectFailed(_) => Self::DbConnectFailed, + ProjectError::MigrationFailed(_) => Self::DbConnectFailed, + ProjectError::NoProjectOpen => Self::NoProjectOpen, + ProjectError::Io(_) => Self::IoError, + ProjectError::Config(_) => Self::ConfigError, + } + } +} + +/// Project-specific configuration stored in .opencode-studio/config.toml +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ProjectConfig { + #[serde(default)] + pub name: Option, + + #[serde(default = "default_plan_approval")] + pub require_plan_approval: bool, + + #[serde(default = "default_human_review")] + pub require_human_review: bool, + + #[serde(default = "default_max_iterations")] + pub max_iterations: u32, +} + +impl Default for ProjectConfig { + fn default() -> Self { + Self { + name: None, + require_plan_approval: true, + require_human_review: true, + max_iterations: 3, + } + } +} + +fn default_plan_approval() -> bool { + true +} + +fn default_human_review() -> bool { + true +} + +fn default_max_iterations() -> u32 { + 3 +} + +/// Information about a project for API responses. +#[derive(Debug, Clone, Serialize)] +pub struct ProjectInfo { + pub name: String, + pub path: String, + pub vcs: String, + pub tasks_count: i64, + pub initialized: bool, +} + +/// Result of opening a project. +#[derive(Debug, Clone, Serialize)] +pub struct OpenProjectResult { + pub project: ProjectInfo, + /// True if we just created .opencode-studio/ structure + pub was_initialized: bool, +} + +/// Result of initializing a project. +#[derive(Debug, Clone, Serialize)] +pub struct InitProjectResult { + pub project: ProjectInfo, + pub already_initialized: bool, +} + +/// Per-project context holding all project-specific resources. +/// +/// This is swapped out when switching between projects. +#[derive(Clone)] +pub struct ProjectContext { + pub path: PathBuf, + pub pool: SqlitePool, + pub task_repository: TaskRepository, + pub session_repository: SessionRepository, + pub task_executor: Arc, + pub workspace_manager: Arc, + pub activity_registry: SessionActivityRegistry, + pub config: ProjectConfig, +} + +impl ProjectContext { + /// Create a new project context from a path. + /// + /// This connects to the project's database and sets up all resources. + pub async fn new( + path: PathBuf, + opencode_url: &str, + event_bus: EventBus, + ) -> Result { + if !path.exists() { + return Err(ProjectError::PathNotFound(path)); + } + if !path.is_dir() { + return Err(ProjectError::NotDirectory(path)); + } + + let vcs_type = detect_vcs(&path); + if vcs_type == "none" { + return Err(ProjectError::NotVcsRepo(path)); + } + + let studio_dir = path.join(STUDIO_DIR); + let config = load_project_config(&studio_dir); + + let db_path = studio_dir.join("studio.db"); + let database_url = format!("sqlite:{}", db_path.display()); + let pool = db::create_pool(&database_url).await?; + db::run_migrations(&pool).await?; + + let workspace_base = path + .parent() + .map(|p| p.join(".workspaces")) + .unwrap_or_else(|| PathBuf::from("../.workspaces")); + + let vcs = detect_vcs_impl(&path, &workspace_base); + let ws_config = WorkspaceConfig::new(workspace_base.clone()); + let workspace_manager = Arc::new(WorkspaceManager::new(vcs, ws_config, path.clone())); + + let session_repository = SessionRepository::new(pool.clone()); + let task_repository = TaskRepository::new(pool.clone()); + let activity_repository = SessionActivityRepository::new(pool.clone()); + + let activity_registry = SessionActivityRegistry::new() + .with_repository(activity_repository); + + let mut opencode_config = OpenCodeConfig::new(); + opencode_config.base_path = opencode_url.to_string(); + let opencode_config = Arc::new(opencode_config); + + let executor_config = ExecutorConfig::new(&path) + .with_plan_approval(config.require_plan_approval) + .with_human_review(config.require_human_review) + .with_max_iterations(config.max_iterations); + + let task_executor = TaskExecutor::new(opencode_config, executor_config) + .with_workspace_manager(workspace_manager.clone()) + .with_session_repo(Arc::new(session_repository.clone())) + .with_task_repo(Arc::new(task_repository.clone())) + .with_event_bus(event_bus) + .with_activity_registry(activity_registry.clone()); + + Ok(Self { + path, + pool, + task_repository, + session_repository, + task_executor: Arc::new(task_executor), + workspace_manager, + activity_registry, + config, + }) + } + + /// Get project info for API responses. + pub async fn info(&self) -> ProjectInfo { + let name = self + .config + .name + .clone() + .or_else(|| { + self.path + .file_name() + .and_then(|n| n.to_str()) + .map(String::from) + }) + .unwrap_or_else(|| "unknown".to_string()); + + let tasks_count = self + .task_repository + .find_all() + .await + .map(|t| t.len() as i64) + .unwrap_or(0); + + ProjectInfo { + name, + path: self.path.display().to_string(), + vcs: detect_vcs(&self.path).to_string(), + tasks_count, + initialized: true, + } + } +} + +/// Manages project lifecycle - opening, switching, closing projects. +pub struct ProjectManager { + context: Arc>>, + opencode_url: String, + event_bus: EventBus, +} + +impl ProjectManager { + /// Create a new project manager. + pub fn new(opencode_url: String, event_bus: EventBus) -> Self { + Self { + context: Arc::new(RwLock::new(None)), + opencode_url, + event_bus, + } + } + + pub async fn open(&self, path: &Path) -> Result { + if !path.exists() { + return Err(ProjectError::PathNotFound(path.to_path_buf())); + } + if !path.is_dir() { + return Err(ProjectError::NotDirectory(path.to_path_buf())); + } + + let vcs_type = detect_vcs(path); + if vcs_type == "none" { + return Err(ProjectError::NotVcsRepo(path.to_path_buf())); + } + + let studio_dir = path.join(STUDIO_DIR); + let was_initialized = if !studio_dir.exists() { + init_project_structure(path)?; + true + } else { + false + }; + + self.close().await?; + + let ctx = + ProjectContext::new(path.to_path_buf(), &self.opencode_url, self.event_bus.clone()) + .await?; + + let project_info = ctx.info().await; + + let mut guard = self.context.write().await; + *guard = Some(ctx); + + self.event_bus.publish(events::EventEnvelope::new( + events::Event::ProjectOpened { + path: project_info.path.clone(), + name: project_info.name.clone(), + was_initialized, + }, + )); + + Ok(OpenProjectResult { + project: project_info, + was_initialized, + }) + } + + /// Initialize a project without switching to it. + pub async fn init(&self, path: &Path, force: bool) -> Result { + if !path.exists() { + return Err(ProjectError::PathNotFound(path.to_path_buf())); + } + if !path.is_dir() { + return Err(ProjectError::NotDirectory(path.to_path_buf())); + } + + let vcs_type = detect_vcs(path); + if vcs_type == "none" { + return Err(ProjectError::NotVcsRepo(path.to_path_buf())); + } + + let studio_dir = path.join(STUDIO_DIR); + let already_initialized = studio_dir.exists(); + + if !already_initialized || force { + init_project_structure(path)?; + } + + let name = path + .file_name() + .and_then(|n| n.to_str()) + .unwrap_or("unknown") + .to_string(); + + Ok(InitProjectResult { + project: ProjectInfo { + name, + path: path.display().to_string(), + vcs: vcs_type.to_string(), + tasks_count: 0, + initialized: true, + }, + already_initialized, + }) + } + + /// Get the current project context. + pub async fn current(&self) -> Option { + let guard = self.context.read().await; + guard.clone() + } + + pub async fn close(&self) -> Result<(), ProjectError> { + let mut guard = self.context.write().await; + if let Some(ctx) = guard.take() { + let path = ctx.path.display().to_string(); + ctx.pool.close().await; + self.event_bus.publish(events::EventEnvelope::new( + events::Event::ProjectClosed { path }, + )); + } + Ok(()) + } + + /// Check if a project is currently open. + pub async fn is_open(&self) -> bool { + let guard = self.context.read().await; + guard.is_some() + } +} + +/// Initialize the .opencode-studio/ directory structure. +fn init_project_structure(path: &Path) -> Result<(), ProjectError> { + let studio_dir = path.join(STUDIO_DIR); + + std::fs::create_dir_all(&studio_dir)?; + std::fs::create_dir_all(studio_dir.join(KANBAN_DIR).join(PLANS_DIR))?; + std::fs::create_dir_all(studio_dir.join(KANBAN_DIR).join(REVIEWS_DIR))?; + + let config_path = studio_dir.join(PROJECT_CONFIG_FILE); + if !config_path.exists() { + let config = ProjectConfig::default(); + let toml_str = + toml::to_string_pretty(&config).map_err(|e| ProjectError::Config(e.to_string()))?; + std::fs::write(&config_path, toml_str)?; + } + + Ok(()) +} + +/// Load project configuration from .opencode-studio/config.toml +fn load_project_config(studio_dir: &Path) -> ProjectConfig { + let config_path = studio_dir.join(PROJECT_CONFIG_FILE); + + if !config_path.exists() { + return ProjectConfig::default(); + } + + std::fs::read_to_string(&config_path) + .ok() + .and_then(|content| toml::from_str(&content).ok()) + .unwrap_or_default() +} + +/// Detect VCS type from a path. +pub fn detect_vcs(path: &Path) -> &'static str { + if path.join(".jj").exists() { + "jujutsu" + } else if path.join(".git").exists() { + "git" + } else { + "none" + } +} + +fn detect_vcs_impl(repo_path: &Path, workspace_base: &Path) -> Arc { + if repo_path.join(".jj").exists() { + tracing::info!("Detected Jujutsu repository"); + Arc::new(JujutsuVcs::new( + repo_path.to_path_buf(), + workspace_base.to_path_buf(), + )) + } else { + tracing::info!("Using Git as VCS backend"); + Arc::new(GitVcs::new( + repo_path.to_path_buf(), + workspace_base.to_path_buf(), + )) + } +} + +const GLOBAL_STUDIO_DIR: &str = ".opencode-studio"; +const GLOBAL_CONFIG_FILE: &str = "global.toml"; +const MAX_RECENT_PROJECTS: usize = 10; + +/// Global configuration stored in ~/.opencode-studio/global.toml +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct GlobalConfig { + #[serde(default)] + pub recent_projects: Vec, + + #[serde(default)] + pub last_project: Option, + + #[serde(default = "default_auto_open_last")] + pub auto_open_last: bool, + + #[serde(default = "default_max_recent")] + pub max_recent: usize, +} + +impl Default for GlobalConfig { + fn default() -> Self { + Self { + recent_projects: Vec::new(), + last_project: None, + auto_open_last: true, + max_recent: MAX_RECENT_PROJECTS, + } + } +} + +fn default_auto_open_last() -> bool { + true +} + +fn default_max_recent() -> usize { + MAX_RECENT_PROJECTS +} + +/// Manages the global ~/.opencode-studio/global.toml configuration. +#[derive(Clone)] +pub struct GlobalConfigManager { + config_dir: PathBuf, +} + +impl GlobalConfigManager { + pub fn new() -> Self { + let config_dir = dirs::home_dir() + .map(|h| h.join(GLOBAL_STUDIO_DIR)) + .unwrap_or_else(|| PathBuf::from(GLOBAL_STUDIO_DIR)); + + Self { config_dir } + } + + #[cfg(test)] + pub fn with_config_dir(config_dir: PathBuf) -> Self { + Self { config_dir } + } + + fn config_path(&self) -> PathBuf { + self.config_dir.join(GLOBAL_CONFIG_FILE) + } + + fn ensure_config_dir(&self) -> Result<(), ProjectError> { + if !self.config_dir.exists() { + std::fs::create_dir_all(&self.config_dir)?; + } + Ok(()) + } + + pub fn load(&self) -> GlobalConfig { + let path = self.config_path(); + if !path.exists() { + return GlobalConfig::default(); + } + + std::fs::read_to_string(&path) + .ok() + .and_then(|content| toml::from_str(&content).ok()) + .unwrap_or_default() + } + + fn save(&self, config: &GlobalConfig) -> Result<(), ProjectError> { + self.ensure_config_dir()?; + + let toml_str = + toml::to_string_pretty(config).map_err(|e| ProjectError::Config(e.to_string()))?; + + let config_path = self.config_path(); + let temp_path = config_path.with_extension("toml.tmp"); + + std::fs::write(&temp_path, toml_str)?; + std::fs::rename(&temp_path, &config_path)?; + + Ok(()) + } + + pub fn add_recent(&self, path: &Path) -> Result<(), ProjectError> { + let mut config = self.load(); + let path_str = path.display().to_string(); + + config.recent_projects.retain(|p| p != &path_str); + config.recent_projects.insert(0, path_str); + + let max = config.max_recent.max(1); + config.recent_projects.truncate(max); + + self.save(&config) + } + + pub fn get_recent(&self) -> Vec { + self.load() + .recent_projects + .into_iter() + .map(PathBuf::from) + .collect() + } + + pub fn remove_recent(&self, path: &Path) -> Result<(), ProjectError> { + let mut config = self.load(); + let path_str = path.display().to_string(); + config.recent_projects.retain(|p| p != &path_str); + self.save(&config) + } + + pub fn clear_recent(&self) -> Result<(), ProjectError> { + let mut config = self.load(); + config.recent_projects.clear(); + config.last_project = None; + self.save(&config) + } + + pub fn set_last(&self, path: &Path) -> Result<(), ProjectError> { + let mut config = self.load(); + config.last_project = Some(path.display().to_string()); + self.save(&config) + } + + pub fn get_last(&self) -> Option { + self.load().last_project.map(PathBuf::from) + } + + pub fn should_auto_open_last(&self) -> bool { + self.load().auto_open_last + } +} + +impl Default for GlobalConfigManager { + fn default() -> Self { + Self::new() + } +} + +#[cfg(test)] +mod tests { + use super::*; + use tempfile::TempDir; + + fn create_git_repo(dir: &Path) { + std::fs::create_dir_all(dir.join(".git")).unwrap(); + } + + #[test] + fn test_detect_vcs_git() { + let tmp = TempDir::new().unwrap(); + create_git_repo(tmp.path()); + assert_eq!(detect_vcs(tmp.path()), "git"); + } + + #[test] + fn test_detect_vcs_jujutsu() { + let tmp = TempDir::new().unwrap(); + std::fs::create_dir_all(tmp.path().join(".jj")).unwrap(); + assert_eq!(detect_vcs(tmp.path()), "jujutsu"); + } + + #[test] + fn test_detect_vcs_none() { + let tmp = TempDir::new().unwrap(); + assert_eq!(detect_vcs(tmp.path()), "none"); + } + + #[test] + fn test_init_project_structure() { + let tmp = TempDir::new().unwrap(); + create_git_repo(tmp.path()); + + init_project_structure(tmp.path()).unwrap(); + + let studio_dir = tmp.path().join(STUDIO_DIR); + assert!(studio_dir.exists()); + assert!(studio_dir.join(PROJECT_CONFIG_FILE).exists()); + assert!(studio_dir.join(KANBAN_DIR).join(PLANS_DIR).exists()); + assert!(studio_dir.join(KANBAN_DIR).join(REVIEWS_DIR).exists()); + } + + #[test] + fn test_load_project_config_default() { + let tmp = TempDir::new().unwrap(); + let config = load_project_config(tmp.path()); + + assert!(config.require_plan_approval); + assert!(config.require_human_review); + assert_eq!(config.max_iterations, 3); + } + + #[test] + fn test_project_error_codes() { + let err = ProjectError::PathNotFound(PathBuf::from("/test")); + assert!(matches!( + ProjectErrorCode::from(&err), + ProjectErrorCode::PathNotFound + )); + + let err = ProjectError::NotVcsRepo(PathBuf::from("/test")); + assert!(matches!( + ProjectErrorCode::from(&err), + ProjectErrorCode::NotVcsRepo + )); + + let err = ProjectError::NoProjectOpen; + assert!(matches!( + ProjectErrorCode::from(&err), + ProjectErrorCode::NoProjectOpen + )); + } + + #[test] + fn test_global_config_manager_add_recent() { + let tmp = TempDir::new().unwrap(); + let manager = GlobalConfigManager::with_config_dir(tmp.path().to_path_buf()); + + manager.add_recent(Path::new("/project/a")).unwrap(); + manager.add_recent(Path::new("/project/b")).unwrap(); + manager.add_recent(Path::new("/project/c")).unwrap(); + + let recent = manager.get_recent(); + assert_eq!(recent.len(), 3); + assert_eq!(recent[0], PathBuf::from("/project/c")); + assert_eq!(recent[1], PathBuf::from("/project/b")); + assert_eq!(recent[2], PathBuf::from("/project/a")); + } + + #[test] + fn test_global_config_manager_deduplicates() { + let tmp = TempDir::new().unwrap(); + let manager = GlobalConfigManager::with_config_dir(tmp.path().to_path_buf()); + + manager.add_recent(Path::new("/project/a")).unwrap(); + manager.add_recent(Path::new("/project/b")).unwrap(); + manager.add_recent(Path::new("/project/a")).unwrap(); + + let recent = manager.get_recent(); + assert_eq!(recent.len(), 2); + assert_eq!(recent[0], PathBuf::from("/project/a")); + assert_eq!(recent[1], PathBuf::from("/project/b")); + } + + #[test] + fn test_global_config_manager_last_project() { + let tmp = TempDir::new().unwrap(); + let manager = GlobalConfigManager::with_config_dir(tmp.path().to_path_buf()); + + assert!(manager.get_last().is_none()); + + manager.set_last(Path::new("/project/x")).unwrap(); + assert_eq!(manager.get_last(), Some(PathBuf::from("/project/x"))); + } + + #[test] + fn test_global_config_manager_truncates_recent() { + let tmp = TempDir::new().unwrap(); + let manager = GlobalConfigManager::with_config_dir(tmp.path().to_path_buf()); + + for i in 0..15 { + manager.add_recent(Path::new(&format!("/project/{}", i))).unwrap(); + } + + let recent = manager.get_recent(); + assert_eq!(recent.len(), MAX_RECENT_PROJECTS); + assert_eq!(recent[0], PathBuf::from("/project/14")); + } +} diff --git a/crates/server/src/routes/filesystem.rs b/crates/server/src/routes/filesystem.rs new file mode 100644 index 0000000..b766280 --- /dev/null +++ b/crates/server/src/routes/filesystem.rs @@ -0,0 +1,114 @@ +use axum::extract::Query; +use axum::Json; +use serde::{Deserialize, Serialize}; +use std::path::PathBuf; +use utoipa::ToSchema; + +use crate::project_manager::detect_vcs; + +#[derive(Debug, Deserialize, ToSchema)] +pub struct BrowseQuery { + #[serde(default = "default_path")] + pub path: String, +} + +fn default_path() -> String { + dirs::home_dir() + .map(|p| p.display().to_string()) + .unwrap_or_else(|| "/".to_string()) +} + +#[derive(Debug, Serialize, ToSchema)] +pub struct DirectoryEntry { + pub name: String, + pub path: String, + pub is_dir: bool, + pub is_vcs_root: bool, + pub vcs: Option, +} + +#[derive(Debug, Serialize, ToSchema)] +pub struct BrowseResponse { + pub current_path: String, + pub parent_path: Option, + pub entries: Vec, + pub is_vcs_root: bool, + pub vcs: Option, +} + +#[utoipa::path( + get, + path = "/api/filesystem/browse", + params( + ("path" = Option, Query, description = "Directory path to browse") + ), + responses( + (status = 200, description = "Directory listing", body = BrowseResponse), + (status = 400, description = "Invalid path") + ), + tag = "filesystem" +)] +pub async fn browse_directory(Query(query): Query) -> Json { + let path = PathBuf::from(&query.path); + + if !path.exists() || !path.is_dir() { + let home = dirs::home_dir().unwrap_or_else(|| PathBuf::from("/")); + return Json(browse_path(&home)); + } + + Json(browse_path(&path)) +} + +fn browse_path(path: &PathBuf) -> BrowseResponse { + let current_vcs = detect_vcs(path); + let is_vcs_root = current_vcs != "none"; + + let parent_path = path.parent().map(|p| p.display().to_string()); + + let mut entries: Vec = std::fs::read_dir(path) + .ok() + .map(|read_dir| { + read_dir + .filter_map(|entry| entry.ok()) + .filter_map(|entry| { + let path = entry.path(); + let name = entry.file_name().to_string_lossy().to_string(); + + if name.starts_with('.') { + return None; + } + + let is_dir = path.is_dir(); + if !is_dir { + return None; + } + + let vcs = detect_vcs(&path); + let is_vcs_root = vcs != "none"; + + Some(DirectoryEntry { + name, + path: path.display().to_string(), + is_dir, + is_vcs_root, + vcs: if is_vcs_root { Some(vcs.to_string()) } else { None }, + }) + }) + .collect() + }) + .unwrap_or_default(); + + entries.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase())); + + BrowseResponse { + current_path: path.display().to_string(), + parent_path, + entries, + is_vcs_root, + vcs: if is_vcs_root { + Some(current_vcs.to_string()) + } else { + None + }, + } +} diff --git a/crates/server/src/routes/mod.rs b/crates/server/src/routes/mod.rs index 2e88992..987ca93 100644 --- a/crates/server/src/routes/mod.rs +++ b/crates/server/src/routes/mod.rs @@ -1,13 +1,17 @@ +pub mod filesystem; mod health; -mod project; +pub mod project; +pub mod projects; mod sessions; +pub mod sse; mod tasks; mod workspaces; -mod ws; +pub use filesystem::*; pub use health::*; pub use project::*; +pub use projects::*; pub use sessions::*; +pub use sse::*; pub use tasks::*; pub use workspaces::*; -pub use ws::*; diff --git a/crates/server/src/routes/project.rs b/crates/server/src/routes/project.rs index 9c7f313..ad3f331 100644 --- a/crates/server/src/routes/project.rs +++ b/crates/server/src/routes/project.rs @@ -1,55 +1,36 @@ -use axum::{extract::State, Json}; +use axum::extract::State; +use axum::Json; use serde::Serialize; use utoipa::ToSchema; +use crate::routes::projects::CurrentProjectResponse; use crate::state::AppState; #[derive(Debug, Serialize, ToSchema)] -pub struct ProjectInfo { +pub struct LegacyProjectInfo { pub name: String, pub path: String, pub vcs: String, pub tasks_count: i64, + pub initialized: bool, } #[utoipa::path( get, path = "/api/project", responses( - (status = 200, description = "Current project info", body = ProjectInfo) + (status = 200, description = "Current project info (legacy)", body = CurrentProjectResponse) ), tag = "project" )] -pub async fn get_project_info(State(state): State) -> Json { - let name = state - .repo_path - .file_name() - .and_then(|n| n.to_str()) - .unwrap_or("unknown") - .to_string(); +pub async fn get_project_info(State(state): State) -> Json { + let project = match state.project().await { + Ok(ctx) => { + let info = ctx.info().await; + Some(crate::routes::projects::ProjectInfo::from(info)) + } + Err(_) => None, + }; - let path = state.repo_path.display().to_string(); - - let vcs = if state.repo_path.join(".jj").exists() { - "jujutsu" - } else if state.repo_path.join(".git").exists() { - "git" - } else { - "none" - } - .to_string(); - - let tasks_count = state - .task_repository - .find_all() - .await - .map(|t| t.len() as i64) - .unwrap_or(0); - - Json(ProjectInfo { - name, - path, - vcs, - tasks_count, - }) + Json(CurrentProjectResponse { project }) } diff --git a/crates/server/src/routes/projects.rs b/crates/server/src/routes/projects.rs new file mode 100644 index 0000000..cbe03e7 --- /dev/null +++ b/crates/server/src/routes/projects.rs @@ -0,0 +1,342 @@ +use axum::extract::State; +use axum::Json; +use serde::{Deserialize, Serialize}; +use std::path::PathBuf; +use utoipa::ToSchema; + +use crate::error::AppError; +use crate::project_manager::{detect_vcs, ProjectErrorCode, ProjectInfo as ManagerProjectInfo}; +use crate::state::AppState; + +#[derive(Debug, Serialize, ToSchema)] +pub struct ProjectInfo { + pub name: String, + pub path: String, + pub vcs: String, + pub tasks_count: i64, + pub initialized: bool, +} + +impl From for ProjectInfo { + fn from(info: ManagerProjectInfo) -> Self { + Self { + name: info.name, + path: info.path, + vcs: info.vcs, + tasks_count: info.tasks_count, + initialized: info.initialized, + } + } +} + +#[derive(Debug, Deserialize, ToSchema)] +pub struct OpenProjectRequest { + pub path: String, +} + +#[derive(Debug, Serialize, ToSchema)] +pub struct OpenProjectResponse { + pub success: bool, + pub project: Option, + pub was_initialized: bool, + pub error: Option, +} + +#[derive(Debug, Serialize, ToSchema)] +pub struct ProjectErrorResponse { + pub code: String, + pub message: String, +} + +#[utoipa::path( + post, + path = "/api/projects/open", + request_body = OpenProjectRequest, + responses( + (status = 200, description = "Project opened successfully", body = OpenProjectResponse), + (status = 400, description = "Failed to open project", body = OpenProjectResponse) + ), + tag = "projects" +)] +pub async fn open_project( + State(state): State, + Json(payload): Json, +) -> Result, AppError> { + let path = PathBuf::from(&payload.path); + + match state.project_manager.open(&path).await { + Ok(result) => { + state.global_config.add_recent(&path)?; + state.global_config.set_last(&path)?; + + Ok(Json(OpenProjectResponse { + success: true, + project: Some(result.project.into()), + was_initialized: result.was_initialized, + error: None, + })) + } + Err(e) => { + let code = ProjectErrorCode::from(&e); + Ok(Json(OpenProjectResponse { + success: false, + project: None, + was_initialized: false, + error: Some(ProjectErrorResponse { + code: format!("{:?}", code), + message: e.to_string(), + }), + })) + } + } +} + +#[derive(Debug, Deserialize, ToSchema)] +pub struct InitProjectRequest { + pub path: String, + #[serde(default)] + pub force: bool, +} + +#[derive(Debug, Serialize, ToSchema)] +pub struct InitProjectResponse { + pub success: bool, + pub project: Option, + pub already_initialized: bool, + pub error: Option, +} + +#[utoipa::path( + post, + path = "/api/projects/init", + request_body = InitProjectRequest, + responses( + (status = 200, description = "Project initialized", body = InitProjectResponse), + (status = 400, description = "Failed to initialize project", body = InitProjectResponse) + ), + tag = "projects" +)] +pub async fn init_project( + State(state): State, + Json(payload): Json, +) -> Result, AppError> { + let path = PathBuf::from(&payload.path); + + match state.project_manager.init(&path, payload.force).await { + Ok(result) => Ok(Json(InitProjectResponse { + success: true, + project: Some(result.project.into()), + already_initialized: result.already_initialized, + error: None, + })), + Err(e) => { + let code = ProjectErrorCode::from(&e); + Ok(Json(InitProjectResponse { + success: false, + project: None, + already_initialized: false, + error: Some(ProjectErrorResponse { + code: format!("{:?}", code), + message: e.to_string(), + }), + })) + } + } +} + +#[derive(Debug, Serialize, ToSchema)] +pub struct CurrentProjectResponse { + pub project: Option, +} + +#[utoipa::path( + get, + path = "/api/projects/current", + responses( + (status = 200, description = "Current project info", body = CurrentProjectResponse) + ), + tag = "projects" +)] +pub async fn get_current_project(State(state): State) -> Json { + let project = match state.project().await { + Ok(ctx) => { + let info = ctx.info().await; + Some(info.into()) + } + Err(_) => None, + }; + + Json(CurrentProjectResponse { project }) +} + +#[derive(Debug, Serialize, ToSchema)] +pub struct RecentProject { + pub path: String, + pub name: String, + pub vcs: String, + pub exists: bool, +} + +#[derive(Debug, Serialize, ToSchema)] +pub struct RecentProjectsResponse { + pub projects: Vec, +} + +#[utoipa::path( + get, + path = "/api/projects/recent", + responses( + (status = 200, description = "List of recent projects", body = RecentProjectsResponse) + ), + tag = "projects" +)] +pub async fn get_recent_projects(State(state): State) -> Json { + let recent_paths = state.global_config.get_recent(); + + // Only return projects that still exist on disk + let projects: Vec = recent_paths + .into_iter() + .filter(|path| path.exists() && path.is_dir()) + .map(|path| { + let name = path + .file_name() + .and_then(|n| n.to_str()) + .unwrap_or("unknown") + .to_string(); + let vcs = detect_vcs(&path).to_string(); + + RecentProject { + path: path.display().to_string(), + name, + vcs, + exists: true, + } + }) + .collect(); + + Json(RecentProjectsResponse { projects }) +} + +#[derive(Debug, Deserialize, ToSchema)] +pub struct RemoveRecentRequest { + pub path: String, +} + +#[derive(Debug, Serialize, ToSchema)] +pub struct RemoveRecentResponse { + pub success: bool, +} + +#[utoipa::path( + post, + path = "/api/projects/recent/remove", + request_body = RemoveRecentRequest, + responses( + (status = 200, description = "Project removed from recent list", body = RemoveRecentResponse) + ), + tag = "projects" +)] +pub async fn remove_recent_project( + State(state): State, + Json(payload): Json, +) -> Result, AppError> { + state.global_config.remove_recent(&PathBuf::from(&payload.path))?; + Ok(Json(RemoveRecentResponse { success: true })) +} + +#[derive(Debug, Serialize, ToSchema)] +pub struct ClearRecentResponse { + pub success: bool, +} + +#[utoipa::path( + post, + path = "/api/projects/recent/clear", + responses( + (status = 200, description = "Recent projects list cleared", body = ClearRecentResponse) + ), + tag = "projects" +)] +pub async fn clear_recent_projects( + State(state): State, +) -> Result, AppError> { + state.global_config.clear_recent()?; + Ok(Json(ClearRecentResponse { success: true })) +} + +#[derive(Debug, Deserialize, ToSchema)] +pub struct ValidatePathRequest { + pub path: String, +} + +#[derive(Debug, Serialize, ToSchema)] +pub struct ValidatePathResponse { + pub valid: bool, + pub exists: bool, + pub is_vcs_repo: bool, + pub vcs: Option, + pub name: Option, + pub error: Option, +} + +#[utoipa::path( + post, + path = "/api/projects/validate", + request_body = ValidatePathRequest, + responses( + (status = 200, description = "Path validation result", body = ValidatePathResponse) + ), + tag = "projects" +)] +pub async fn validate_project_path( + Json(payload): Json, +) -> Json { + let path = PathBuf::from(&payload.path); + + if !path.exists() { + return Json(ValidatePathResponse { + valid: false, + exists: false, + is_vcs_repo: false, + vcs: None, + name: None, + error: Some("Path does not exist".to_string()), + }); + } + + if !path.is_dir() { + return Json(ValidatePathResponse { + valid: false, + exists: true, + is_vcs_repo: false, + vcs: None, + name: None, + error: Some("Path is not a directory".to_string()), + }); + } + + let vcs = detect_vcs(&path); + let is_vcs_repo = vcs != "none"; + + let name = path + .file_name() + .and_then(|n| n.to_str()) + .map(String::from); + + Json(ValidatePathResponse { + valid: is_vcs_repo, + exists: true, + is_vcs_repo, + vcs: if is_vcs_repo { + Some(vcs.to_string()) + } else { + None + }, + name, + error: if !is_vcs_repo { + Some("Not a git or jujutsu repository".to_string()) + } else { + None + }, + }) +} diff --git a/crates/server/src/routes/sessions.rs b/crates/server/src/routes/sessions.rs index c910618..6eb396b 100644 --- a/crates/server/src/routes/sessions.rs +++ b/crates/server/src/routes/sessions.rs @@ -16,7 +16,8 @@ use crate::state::AppState; tag = "sessions" )] pub async fn list_sessions(State(state): State) -> Result>, AppError> { - let sessions = state.session_repository.find_all().await?; + let project = state.project().await?; + let sessions = project.session_repository.find_all().await?; Ok(Json(sessions)) } @@ -36,7 +37,8 @@ pub async fn get_session( State(state): State, Path(id): Path, ) -> Result, AppError> { - let session = state.session_repository.find_by_id(id).await?; + let project = state.project().await?; + let session = project.session_repository.find_by_id(id).await?; match session { Some(s) => Ok(Json(s)), @@ -59,7 +61,8 @@ pub async fn list_sessions_for_task( State(state): State, Path(task_id): Path, ) -> Result>, AppError> { - let sessions = state.session_repository.find_by_task_id(task_id).await?; + let project = state.project().await?; + let sessions = project.session_repository.find_by_task_id(task_id).await?; Ok(Json(sessions)) } @@ -79,7 +82,8 @@ pub async fn delete_session( State(state): State, Path(id): Path, ) -> Result { - let deleted = state.session_repository.delete(id).await?; + let project = state.project().await?; + let deleted = project.session_repository.delete(id).await?; if deleted { Ok(StatusCode::NO_CONTENT) @@ -87,3 +91,5 @@ pub async fn delete_session( Err(AppError::NotFound(format!("Session not found: {}", id))) } } + + diff --git a/crates/server/src/routes/sse.rs b/crates/server/src/routes/sse.rs new file mode 100644 index 0000000..a847a00 --- /dev/null +++ b/crates/server/src/routes/sse.rs @@ -0,0 +1,422 @@ +use std::collections::VecDeque; +use std::convert::Infallible; +use std::sync::{Arc, RwLock}; +use std::time::Duration; + +use axum::extract::{Path, Query, State}; +use axum::response::sse::{Event, KeepAlive, Sse}; +use axum::response::IntoResponse; +use futures::stream::{Stream, StreamExt}; +use serde::Deserialize; +use tokio_stream::wrappers::BroadcastStream; +use uuid::Uuid; + +use crate::error::AppError; +use crate::state::AppState; + +pub const DEFAULT_EVENT_BUFFER_SIZE: usize = 1000; +pub const SSE_KEEP_ALIVE_INTERVAL: Duration = Duration::from_secs(15); + +#[derive(Debug, Deserialize)] +pub struct EventsQuery { + pub task_ids: Option, +} + +pub struct EventBuffer { + events: VecDeque, + max_size: usize, +} + +impl EventBuffer { + pub fn new(max_size: usize) -> Self { + Self { + events: VecDeque::with_capacity(max_size), + max_size, + } + } + + pub fn push(&mut self, envelope: events::EventEnvelope) { + if self.events.len() >= self.max_size { + self.events.pop_front(); + } + self.events.push_back(envelope); + } + + pub fn events_after(&self, event_id: Uuid) -> Vec { + let mut found = false; + self.events + .iter() + .filter_map(|envelope| { + if found { + Some(envelope.clone()) + } else if envelope.id == event_id { + found = true; + None + } else { + None + } + }) + .collect() + } + + #[cfg(test)] + pub fn len(&self) -> usize { + self.events.len() + } +} + +pub type SharedEventBuffer = Arc>; + +fn parse_task_ids(task_ids: Option<&str>) -> Option> { + task_ids.map(|s| { + s.split(',') + .filter_map(|id| id.trim().parse().ok()) + .collect() + }) +} + +fn envelope_to_sse_event(envelope: &events::EventEnvelope) -> Result { + let event_type = match &envelope.event { + events::Event::TaskCreated { .. } => "task.created", + events::Event::TaskUpdated { .. } => "task.updated", + events::Event::TaskStatusChanged { .. } => "task.status_changed", + events::Event::SessionStarted { .. } => "session.started", + events::Event::SessionEnded { .. } => "session.ended", + events::Event::AgentMessage { .. } => "agent.message", + events::Event::ToolExecution { .. } => "tool.execution", + events::Event::WorkspaceCreated { .. } => "workspace.created", + events::Event::WorkspaceMerged { .. } => "workspace.merged", + events::Event::WorkspaceDeleted { .. } => "workspace.deleted", + events::Event::ProjectOpened { .. } => "project.opened", + events::Event::ProjectClosed { .. } => "project.closed", + events::Event::Error { .. } => "error", + }; + + let data = serde_json::to_string(&envelope).unwrap_or_else(|_| "{}".to_string()); + + Ok(Event::default() + .id(envelope.id.to_string()) + .event(event_type) + .data(data)) +} + +fn activity_to_sse_event( + msg: &orchestrator::SessionActivityMsg, + seq: u64, +) -> Result { + let event_type = match msg { + orchestrator::SessionActivityMsg::ToolCall { .. } => "tool_call", + orchestrator::SessionActivityMsg::ToolResult { .. } => "tool_result", + orchestrator::SessionActivityMsg::AgentMessage { .. } => "agent_message", + orchestrator::SessionActivityMsg::Reasoning { .. } => "reasoning", + orchestrator::SessionActivityMsg::StepStart { .. } => "step_start", + orchestrator::SessionActivityMsg::JsonPatch { .. } => "json_patch", + orchestrator::SessionActivityMsg::Finished { .. } => "finished", + }; + + let data = serde_json::to_string(msg).unwrap_or_else(|_| "{}".to_string()); + + Ok(Event::default() + .id(seq.to_string()) + .event(event_type) + .data(data)) +} + +#[utoipa::path( + get, + path = "/api/events", + params( + ("task_ids" = Option, Query, description = "Comma-separated task IDs to filter events"), + ), + responses( + (status = 200, description = "SSE event stream"), + ), + tag = "events" +)] +pub async fn events_stream( + State(state): State, + Query(query): Query, + headers: axum::http::HeaderMap, +) -> Sse>> { + let task_ids = parse_task_ids(query.task_ids.as_deref()); + let last_event_id = headers + .get("Last-Event-ID") + .and_then(|v| v.to_str().ok()) + .and_then(|s| s.parse::().ok()); + + let buffer = Arc::clone(&state.event_buffer); + let buffer_for_live = Arc::clone(&buffer); + + let rx = state.event_bus.subscribe(); + + let missed_events = if let Some(event_id) = last_event_id { + buffer + .read() + .unwrap_or_else(|poisoned| poisoned.into_inner()) + .events_after(event_id) + } else { + vec![] + }; + + let missed_stream = futures::stream::iter( + missed_events + .into_iter() + .map(|e| envelope_to_sse_event(&e)), + ); + + let live_stream = BroadcastStream::new(rx).filter_map(move |result| { + let task_ids = task_ids.clone(); + let buffer = Arc::clone(&buffer_for_live); + + async move { + match result { + Ok(envelope) => { + buffer + .write() + .unwrap_or_else(|poisoned| poisoned.into_inner()) + .push(envelope.clone()); + + if let Some(ref ids) = task_ids { + if let Some(event_task_id) = envelope.event.task_id() { + if !ids.contains(&event_task_id) { + return None; + } + } + } + + Some(envelope_to_sse_event(&envelope)) + } + Err(e) => { + tracing::warn!("SSE broadcast error: {:?}", e); + None + } + } + } + }); + + let stream = missed_stream.chain(live_stream); + + Sse::new(stream).keep_alive( + KeepAlive::new() + .interval(SSE_KEEP_ALIVE_INTERVAL) + .text("keep-alive"), + ) +} + +#[utoipa::path( + get, + path = "/api/sessions/{id}/activity", + params( + ("id" = Uuid, Path, description = "Session ID"), + ), + responses( + (status = 200, description = "SSE activity stream"), + (status = 404, description = "Session not found"), + ), + tag = "sessions" +)] +pub async fn session_activity_stream( + State(state): State, + Path(id): Path, + headers: axum::http::HeaderMap, +) -> Result { + let project = state.project().await?; + + // Check if session exists in DB if no in-memory store + let store = project.activity_registry.get(&id); + if store.is_none() { + let session = project.session_repository.find_by_id(id).await?; + if session.is_none() { + return Err(AppError::NotFound(format!("Session not found: {}", id))); + } + } + + // Use async version that loads historical activities from DB + let store = project.activity_registry.get_or_create_with_history(id).await; + + let last_event_id: Option = headers + .get("Last-Event-ID") + .and_then(|v| v.to_str().ok()) + .and_then(|s| s.parse().ok()); + + let history = store.get_history(); + let rx = store.subscribe(); + + let start_seq = last_event_id.map(|id| id + 1).unwrap_or(0); + + let history_to_send: Vec<_> = history + .into_iter() + .enumerate() + .skip(start_seq as usize) + .collect(); + + let next_seq = start_seq + history_to_send.len() as u64; + let seq_counter = Arc::new(std::sync::atomic::AtomicU64::new(next_seq)); + + let history_stream = futures::stream::iter( + history_to_send + .into_iter() + .map(|(idx, msg)| activity_to_sse_event(&msg, idx as u64)), + ); + + let seq_counter_clone = Arc::clone(&seq_counter); + let live_stream = BroadcastStream::new(rx).filter_map(move |result| { + let seq_counter = Arc::clone(&seq_counter_clone); + async move { + match result { + Ok(msg) => { + let seq = seq_counter.fetch_add(1, std::sync::atomic::Ordering::SeqCst); + Some(activity_to_sse_event(&msg, seq)) + } + Err(e) => { + tracing::warn!("Session activity SSE broadcast error: {:?}", e); + None + } + } + } + }); + + let stream = history_stream.chain(live_stream); + + Ok(Sse::new(stream).keep_alive( + KeepAlive::new() + .interval(SSE_KEEP_ALIVE_INTERVAL) + .text("keep-alive"), + )) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_parse_task_ids_none() { + assert!(parse_task_ids(None).is_none()); + } + + #[test] + fn test_parse_task_ids_empty() { + assert!(parse_task_ids(Some("")).unwrap().is_empty()); + } + + #[test] + fn test_parse_task_ids_single() { + let uuid1 = Uuid::new_v4(); + let result = parse_task_ids(Some(&uuid1.to_string())).unwrap(); + assert_eq!(result.len(), 1); + assert_eq!(result[0], uuid1); + } + + #[test] + fn test_parse_task_ids_multiple() { + let uuid1 = Uuid::new_v4(); + let uuid2 = Uuid::new_v4(); + let uuid3 = Uuid::new_v4(); + let input = format!("{},{},{}", uuid1, uuid2, uuid3); + let result = parse_task_ids(Some(&input)).unwrap(); + assert_eq!(result.len(), 3); + } + + #[test] + fn test_parse_task_ids_with_spaces() { + let uuid1 = Uuid::new_v4(); + let uuid2 = Uuid::new_v4(); + let input = format!("{} , {}", uuid1, uuid2); + let result = parse_task_ids(Some(&input)).unwrap(); + assert_eq!(result.len(), 2); + } + + #[test] + fn test_parse_task_ids_filters_invalid() { + let uuid1 = Uuid::new_v4(); + let uuid2 = Uuid::new_v4(); + let input = format!("{},invalid,{}", uuid1, uuid2); + let result = parse_task_ids(Some(&input)).unwrap(); + assert_eq!(result.len(), 2); + } + + #[test] + fn test_event_buffer_events_after() { + let mut buffer = EventBuffer::new(3); + + let e1 = events::EventEnvelope::new(events::Event::TaskCreated { + task_id: Uuid::new_v4(), + title: "Task 1".to_string(), + }); + let e2 = events::EventEnvelope::new(events::Event::TaskCreated { + task_id: Uuid::new_v4(), + title: "Task 2".to_string(), + }); + let e3 = events::EventEnvelope::new(events::Event::TaskCreated { + task_id: Uuid::new_v4(), + title: "Task 3".to_string(), + }); + + let id1 = e1.id; + let id2 = e2.id; + + buffer.push(e1); + buffer.push(e2); + buffer.push(e3.clone()); + + let after_first = buffer.events_after(id1); + assert_eq!(after_first.len(), 2); + assert_eq!(after_first[0].id, id2); + + let after_second = buffer.events_after(id2); + assert_eq!(after_second.len(), 1); + assert_eq!(after_second[0].id, e3.id); + + let after_nonexistent = buffer.events_after(Uuid::new_v4()); + assert!(after_nonexistent.is_empty()); + } + + #[test] + fn test_event_buffer_evicts_oldest() { + let mut buffer = EventBuffer::new(2); + + let e1 = events::EventEnvelope::new(events::Event::TaskCreated { + task_id: Uuid::new_v4(), + title: "Task 1".to_string(), + }); + let e2 = events::EventEnvelope::new(events::Event::TaskCreated { + task_id: Uuid::new_v4(), + title: "Task 2".to_string(), + }); + let e3 = events::EventEnvelope::new(events::Event::TaskCreated { + task_id: Uuid::new_v4(), + title: "Task 3".to_string(), + }); + + let id1 = e1.id; + let id2 = e2.id; + let id3 = e3.id; + + buffer.push(e1); + buffer.push(e2); + buffer.push(e3); + + assert_eq!(buffer.len(), 2); + let after_e1 = buffer.events_after(id1); + assert!(after_e1.is_empty()); + let after_e2 = buffer.events_after(id2); + assert_eq!(after_e2.len(), 1); + assert_eq!(after_e2[0].id, id3); + } + + #[test] + fn test_envelope_to_sse_event_does_not_panic() { + let envelope = events::EventEnvelope::new(events::Event::TaskCreated { + task_id: Uuid::new_v4(), + title: "Test".to_string(), + }); + + let _event = envelope_to_sse_event(&envelope).unwrap(); + } + + #[test] + fn test_activity_to_sse_event_does_not_panic() { + let msg = orchestrator::SessionActivityMsg::tool_call("tc-1", "bash", None); + let _event = activity_to_sse_event(&msg, 42).unwrap(); + } +} diff --git a/crates/server/src/routes/tasks.rs b/crates/server/src/routes/tasks.rs index 5e83fea..dc9f123 100644 --- a/crates/server/src/routes/tasks.rs +++ b/crates/server/src/routes/tasks.rs @@ -3,8 +3,9 @@ use axum::http::StatusCode; use axum::Json; use events::{Event, EventEnvelope}; use opencode_core::{CreateTaskRequest, Task, TaskStatus, UpdateTaskRequest}; -use orchestrator::PhaseResult; +use orchestrator::ReviewFinding; use serde::{Deserialize, Serialize}; +use tracing::{debug, error, info, instrument, warn}; use utoipa::ToSchema; use uuid::Uuid; @@ -20,7 +21,8 @@ use crate::state::AppState; tag = "tasks" )] pub async fn list_tasks(State(state): State) -> Result>, AppError> { - let tasks = state.task_repository.find_all().await?; + let project = state.project().await?; + let tasks = project.task_repository.find_all().await?; Ok(Json(tasks)) } @@ -38,12 +40,26 @@ pub async fn create_task( State(state): State, Json(payload): Json, ) -> Result<(StatusCode, Json), AppError> { + info!( + title = %payload.title, + has_description = !payload.description.is_empty(), + "API: Creating new task" + ); + if payload.title.trim().is_empty() { + warn!("API: Task creation rejected - empty title"); return Err(AppError::BadRequest("Title cannot be empty".to_string())); } + let project = state.project().await?; let task = Task::new(payload.title.clone(), payload.description); - let created = state.task_repository.create(&task).await?; + let created = project.task_repository.create(&task).await?; + + info!( + task_id = %created.id, + title = %created.title, + "API: Task created successfully" + ); state .event_bus @@ -71,7 +87,8 @@ pub async fn get_task( State(state): State, Path(id): Path, ) -> Result, AppError> { - let task = state.task_repository.find_by_id(id).await?; + let project = state.project().await?; + let task = project.task_repository.find_by_id(id).await?; match task { Some(t) => Ok(Json(t)), @@ -97,7 +114,8 @@ pub async fn update_task( Path(id): Path, Json(payload): Json, ) -> Result, AppError> { - let updated = state.task_repository.update(id, &payload).await?; + let project = state.project().await?; + let updated = project.task_repository.update(id, &payload).await?; match updated { Some(t) => Ok(Json(t)), @@ -121,7 +139,8 @@ pub async fn delete_task( State(state): State, Path(id): Path, ) -> Result { - let deleted = state.task_repository.delete(id).await?; + let project = state.project().await?; + let deleted = project.task_repository.delete(id).await?; if deleted { Ok(StatusCode::NO_CONTENT) @@ -159,36 +178,60 @@ pub struct TransitionResponse { ), tag = "tasks" )] +#[instrument(skip(state), fields(task_id = %id))] pub async fn transition_task( State(state): State, Path(id): Path, Json(payload): Json, ) -> Result, AppError> { - let task = state.task_repository.find_by_id(id).await?; + info!( + task_id = %id, + target_status = %payload.status.as_str(), + "API: Task transition requested" + ); + + let project = state.project().await?; + let task = project.task_repository.find_by_id(id).await?; let Some(mut task) = task else { + warn!(task_id = %id, "API: Task not found for transition"); return Err(AppError::NotFound(format!("Task not found: {}", id))); }; let previous_status = task.status; + debug!( + current_status = %previous_status.as_str(), + target_status = %payload.status.as_str(), + "Attempting state transition" + ); - state + project .task_executor .transition(&mut task, payload.status) - .map_err(|e| AppError::BadRequest(e.to_string()))?; + .map_err(|e| { + warn!( + task_id = %id, + from = %previous_status.as_str(), + to = %payload.status.as_str(), + error = %e, + "API: Task transition failed" + ); + AppError::BadRequest(e.to_string()) + })?; let update = UpdateTaskRequest { status: Some(task.status), ..Default::default() }; - state.task_repository.update(id, &update).await?; + project.task_repository.update(id, &update).await?; - state - .event_bus - .publish(EventEnvelope::new(Event::TaskStatusChanged { - task_id: id, - from_status: format!("{:?}", previous_status), - to_status: format!("{:?}", task.status), - })); + info!( + task_id = %id, + from = %previous_status.as_str(), + to = %task.status.as_str(), + "API: Task transition completed" + ); + + // Note: TaskStatusChanged event is already emitted by task_executor.transition() Ok(Json(TransitionResponse { task, @@ -201,81 +244,390 @@ pub async fn transition_task( #[cfg_attr(feature = "typescript", ts(export))] pub struct ExecuteResponse { pub task: Task, - pub result: PhaseResultDto, + pub session_id: String, + pub opencode_session_id: String, + pub phase: String, +} + +#[utoipa::path( + post, + path = "/api/tasks/{id}/execute", + params( + ("id" = Uuid, Path, description = "Task ID") + ), + responses( + (status = 202, description = "Execution started", body = ExecuteResponse), + (status = 404, description = "Task not found"), + (status = 500, description = "Execution failed to start") + ), + tag = "tasks" +)] +#[instrument(skip(state), fields(task_id = %id))] +pub async fn execute_task( + State(state): State, + Path(id): Path, +) -> Result<(StatusCode, Json), AppError> { + info!(task_id = %id, "API: Task execution requested"); + + let project = state.project().await?; + let task = project.task_repository.find_by_id(id).await?; + let Some(mut task) = task else { + warn!(task_id = %id, "API: Task not found for execution"); + return Err(AppError::NotFound(format!("Task not found: {}", id))); + }; + + info!( + task_id = %id, + task_title = %task.title, + current_status = %task.status.as_str(), + "API: Starting task phase execution" + ); + + let started = project + .task_executor + .start_phase_async(&mut task) + .await + .map_err(|e| { + error!( + task_id = %id, + error = %e, + "API: Task execution failed to start" + ); + AppError::Internal(e.to_string()) + })?; + + let update = UpdateTaskRequest { + status: Some(task.status), + ..Default::default() + }; + project.task_repository.update(id, &update).await?; + + info!( + task_id = %id, + session_id = %started.session_id, + opencode_session_id = %started.opencode_session_id, + phase = %started.phase.as_str(), + "API: Execution started" + ); + + Ok(( + StatusCode::ACCEPTED, + Json(ExecuteResponse { + task, + session_id: started.session_id.to_string(), + opencode_session_id: started.opencode_session_id, + phase: started.phase.as_str().to_string(), + }), + )) } #[derive(Debug, Serialize, ToSchema)] #[cfg_attr(feature = "typescript", derive(ts_rs::TS))] #[cfg_attr(feature = "typescript", ts(export))] -#[serde(tag = "type", rename_all = "snake_case")] -pub enum PhaseResultDto { - SessionCreated { session_id: String }, - PlanCreated { session_id: String, plan_path: String }, - AwaitingApproval { phase: String }, - ReviewPassed { session_id: String }, - ReviewFailed { session_id: String, feedback: String, iteration: u32 }, - MaxIterationsExceeded { iterations: u32 }, - Completed, +pub struct PlanResponse { + pub content: String, + pub exists: bool, } -impl From for PhaseResultDto { - fn from(result: PhaseResult) -> Self { - match result { - PhaseResult::SessionCreated { session_id } => Self::SessionCreated { session_id }, - PhaseResult::PlanCreated { session_id, plan_path } => { - Self::PlanCreated { session_id, plan_path } - } - PhaseResult::AwaitingApproval { phase } => { - Self::AwaitingApproval { phase: phase.as_str().to_string() } - } - PhaseResult::ReviewPassed { session_id } => Self::ReviewPassed { session_id }, - PhaseResult::ReviewFailed { session_id, feedback, iteration } => { - Self::ReviewFailed { session_id, feedback, iteration } - } - PhaseResult::MaxIterationsExceeded { iterations } => { - Self::MaxIterationsExceeded { iterations } +#[utoipa::path( + get, + path = "/api/tasks/{id}/plan", + params( + ("id" = Uuid, Path, description = "Task ID") + ), + responses( + (status = 200, description = "Plan content", body = PlanResponse), + (status = 404, description = "Task not found") + ), + tag = "tasks" +)] +pub async fn get_task_plan( + State(state): State, + Path(id): Path, +) -> Result, AppError> { + let project = state.project().await?; + + // Verify task exists + let task = project.task_repository.find_by_id(id).await?; + if task.is_none() { + return Err(AppError::NotFound(format!("Task not found: {}", id))); + } + + let file_manager = project.task_executor.file_manager(); + if file_manager.plan_exists(id).await { + match file_manager.read_plan(id).await { + Ok(content) => Ok(Json(PlanResponse { + content, + exists: true, + })), + Err(e) => { + error!(task_id = %id, error = %e, "Failed to read plan file"); + Ok(Json(PlanResponse { + content: String::new(), + exists: false, + })) } - PhaseResult::Completed => Self::Completed, + } + } else { + Ok(Json(PlanResponse { + content: String::new(), + exists: false, + })) + } +} + +// ============================================================================ +// Findings API +// ============================================================================ + +#[derive(Debug, Serialize, ToSchema)] +#[cfg_attr(feature = "typescript", derive(ts_rs::TS))] +#[cfg_attr(feature = "typescript", ts(export))] +pub struct FindingsResponse { + pub findings: Vec, + pub summary: String, + pub approved: bool, + pub exists: bool, +} + +#[utoipa::path( + get, + path = "/api/tasks/{id}/findings", + params( + ("id" = Uuid, Path, description = "Task ID") + ), + responses( + (status = 200, description = "Task findings", body = FindingsResponse), + (status = 404, description = "Task not found") + ), + tag = "tasks" +)] +pub async fn get_task_findings( + State(state): State, + Path(id): Path, +) -> Result, AppError> { + let project = state.project().await?; + + // Verify task exists + let task = project.task_repository.find_by_id(id).await?; + if task.is_none() { + return Err(AppError::NotFound(format!("Task not found: {}", id))); + } + + let file_manager = project.task_executor.file_manager(); + match file_manager.read_findings(id).await { + Ok(Some(findings)) => Ok(Json(FindingsResponse { + findings: findings.findings, + summary: findings.summary, + approved: findings.approved, + exists: true, + })), + Ok(None) => Ok(Json(FindingsResponse { + findings: vec![], + summary: String::new(), + approved: false, + exists: false, + })), + Err(e) => { + error!(task_id = %id, error = %e, "Failed to read findings file"); + Ok(Json(FindingsResponse { + findings: vec![], + summary: String::new(), + approved: false, + exists: false, + })) } } } +#[derive(Debug, Deserialize, ToSchema)] +#[cfg_attr(feature = "typescript", derive(ts_rs::TS))] +#[cfg_attr(feature = "typescript", ts(export))] +pub struct FixFindingsRequest { + /// IDs of findings to fix, or empty to fix all + pub finding_ids: Option>, + /// If true, fix all findings regardless of finding_ids + pub fix_all: Option, +} + #[utoipa::path( post, - path = "/api/tasks/{id}/execute", + path = "/api/tasks/{id}/findings/fix", params( ("id" = Uuid, Path, description = "Task ID") ), + request_body = FixFindingsRequest, responses( - (status = 200, description = "Phase executed", body = ExecuteResponse), + (status = 202, description = "Fix started", body = ExecuteResponse), (status = 404, description = "Task not found"), - (status = 500, description = "Execution failed") + (status = 400, description = "Invalid request") ), tag = "tasks" )] -pub async fn execute_task( +#[instrument(skip(state), fields(task_id = %id))] +pub async fn fix_findings( State(state): State, Path(id): Path, -) -> Result, AppError> { - let task = state.task_repository.find_by_id(id).await?; + Json(payload): Json, +) -> Result<(StatusCode, Json), AppError> { + info!(task_id = %id, "API: Fix findings requested"); + + let project = state.project().await?; + let task = project.task_repository.find_by_id(id).await?; let Some(mut task) = task else { return Err(AppError::NotFound(format!("Task not found: {}", id))); }; - let result = state + // Verify task is in ai_review state + if task.status != TaskStatus::AiReview { + return Err(AppError::BadRequest(format!( + "Task must be in ai_review state to fix findings. Current: {}", + task.status.as_str() + ))); + } + + // Read current findings + let file_manager = project.task_executor.file_manager(); + let findings_data = file_manager.read_findings(id).await.map_err(|e| { + error!(task_id = %id, error = %e, "Failed to read findings"); + AppError::Internal(e.to_string()) + })?; + + let Some(findings_data) = findings_data else { + return Err(AppError::NotFound("No findings found for this task".to_string())); + }; + + // Determine which findings to fix + let findings_to_fix: Vec<&ReviewFinding> = if payload.fix_all.unwrap_or(false) { + findings_data + .findings + .iter() + .filter(|f| f.status == orchestrator::FindingStatus::Pending) + .collect() + } else if let Some(ref ids) = payload.finding_ids { + findings_data + .findings + .iter() + .filter(|f| ids.contains(&f.id) && f.status == orchestrator::FindingStatus::Pending) + .collect() + } else { + return Err(AppError::BadRequest( + "Either finding_ids or fix_all must be provided".to_string(), + )); + }; + + if findings_to_fix.is_empty() { + return Err(AppError::BadRequest("No pending findings to fix".to_string())); + } + + info!( + task_id = %id, + finding_count = findings_to_fix.len(), + "API: Fixing selected findings" + ); + + // Transition task to Fix state + project + .task_executor + .transition(&mut task, TaskStatus::Fix) + .map_err(|e| { + error!(task_id = %id, error = %e, "Failed to transition to fix state"); + AppError::BadRequest(e.to_string()) + })?; + + // Start fix execution (this will run fix phase with MCP) + let started = project .task_executor - .execute_phase(&mut task) + .start_phase_async(&mut task) .await - .map_err(|e| AppError::Internal(e.to_string()))?; + .map_err(|e| { + error!( + task_id = %id, + error = %e, + "API: Fix execution failed to start" + ); + AppError::Internal(e.to_string()) + })?; let update = UpdateTaskRequest { status: Some(task.status), ..Default::default() }; - state.task_repository.update(id, &update).await?; + project.task_repository.update(id, &update).await?; - Ok(Json(ExecuteResponse { - task, - result: result.into(), - })) + info!( + task_id = %id, + session_id = %started.session_id, + "API: Fix execution started" + ); + + Ok(( + StatusCode::ACCEPTED, + Json(ExecuteResponse { + task, + session_id: started.session_id.to_string(), + opencode_session_id: started.opencode_session_id, + phase: started.phase.as_str().to_string(), + }), + )) +} + +#[utoipa::path( + post, + path = "/api/tasks/{id}/findings/skip", + params( + ("id" = Uuid, Path, description = "Task ID") + ), + responses( + (status = 200, description = "Findings skipped, task moved to review", body = Task), + (status = 404, description = "Task not found"), + (status = 400, description = "Invalid state") + ), + tag = "tasks" +)] +#[instrument(skip(state), fields(task_id = %id))] +pub async fn skip_findings( + State(state): State, + Path(id): Path, +) -> Result, AppError> { + info!(task_id = %id, "API: Skip findings requested"); + + let project = state.project().await?; + let task = project.task_repository.find_by_id(id).await?; + let Some(mut task) = task else { + return Err(AppError::NotFound(format!("Task not found: {}", id))); + }; + + // Verify task is in ai_review state + if task.status != TaskStatus::AiReview { + return Err(AppError::BadRequest(format!( + "Task must be in ai_review state to skip findings. Current: {}", + task.status.as_str() + ))); + } + + // Mark all pending findings as skipped + let file_manager = project.task_executor.file_manager(); + if let Err(e) = file_manager.skip_all_findings(id).await { + warn!(task_id = %id, error = %e, "Failed to update findings status (continuing anyway)"); + } + + // Transition to review state + project + .task_executor + .transition(&mut task, TaskStatus::Review) + .map_err(|e| { + error!(task_id = %id, error = %e, "Failed to transition to review"); + AppError::Internal(e.to_string()) + })?; + + let update = UpdateTaskRequest { + status: Some(task.status), + ..Default::default() + }; + project.task_repository.update(id, &update).await?; + + info!(task_id = %id, "API: Findings skipped, task moved to review"); + + Ok(Json(task)) } diff --git a/crates/server/src/routes/workspaces.rs b/crates/server/src/routes/workspaces.rs index 1e64f71..8b54786 100644 --- a/crates/server/src/routes/workspaces.rs +++ b/crates/server/src/routes/workspaces.rs @@ -54,13 +54,14 @@ pub async fn create_workspace_for_task( State(state): State, Path(task_id): Path, ) -> Result<(StatusCode, Json), AppError> { - let task = state.task_repository.find_by_id(task_id).await?; + let project = state.project().await?; + let task = project.task_repository.find_by_id(task_id).await?; let Some(_task) = task else { return Err(AppError::NotFound(format!("Task not found: {}", task_id))); }; - let workspace = state + let workspace = project .workspace_manager .setup_workspace(&task_id.to_string()) .await?; @@ -79,7 +80,8 @@ pub async fn create_workspace_for_task( pub async fn list_workspaces( State(state): State, ) -> Result>, AppError> { - let workspaces = state.workspace_manager.list_workspaces().await?; + let project = state.project().await?; + let workspaces = project.workspace_manager.list_workspaces().await?; Ok(Json(workspaces.into_iter().map(Into::into).collect())) } @@ -107,14 +109,15 @@ pub async fn get_workspace_diff( State(state): State, Path(task_id): Path, ) -> Result, AppError> { - let workspaces = state.workspace_manager.list_workspaces().await?; + let project = state.project().await?; + let workspaces = project.workspace_manager.list_workspaces().await?; let workspace = workspaces .into_iter() .find(|ws| ws.task_id == task_id) .ok_or_else(|| AppError::NotFound(format!("Workspace not found: {}", task_id)))?; - let diff = state.workspace_manager.get_diff(&workspace).await?; + let diff = project.workspace_manager.get_diff(&workspace).await?; Ok(Json(DiffResponse { task_id: workspace.task_id, @@ -138,14 +141,15 @@ pub async fn get_workspace_status( State(state): State, Path(task_id): Path, ) -> Result, AppError> { - let workspaces = state.workspace_manager.list_workspaces().await?; + let project = state.project().await?; + let workspaces = project.workspace_manager.list_workspaces().await?; let workspace = workspaces .into_iter() .find(|ws| ws.task_id == task_id) .ok_or_else(|| AppError::NotFound(format!("Workspace not found: {}", task_id)))?; - let status = state.workspace_manager.get_status(&workspace).await?; + let status = project.workspace_manager.get_status(&workspace).await?; Ok(Json(WorkspaceStatusResponse { task_id: workspace.task_id, @@ -201,14 +205,15 @@ pub async fn merge_workspace( Path(task_id): Path, Json(payload): Json, ) -> Result, AppError> { - let workspaces = state.workspace_manager.list_workspaces().await?; + let project = state.project().await?; + let workspaces = project.workspace_manager.list_workspaces().await?; let workspace = workspaces .into_iter() .find(|ws| ws.task_id == task_id) .ok_or_else(|| AppError::NotFound(format!("Workspace not found: {}", task_id)))?; - let result = state + let result = project .workspace_manager .merge_workspace(&workspace, &payload.message) .await?; @@ -232,14 +237,15 @@ pub async fn delete_workspace( State(state): State, Path(task_id): Path, ) -> Result { - let workspaces = state.workspace_manager.list_workspaces().await?; + let project = state.project().await?; + let workspaces = project.workspace_manager.list_workspaces().await?; let workspace = workspaces .into_iter() .find(|ws| ws.task_id == task_id) .ok_or_else(|| AppError::NotFound(format!("Workspace not found: {}", task_id)))?; - state + project .workspace_manager .cleanup_workspace(&workspace) .await?; diff --git a/crates/server/src/routes/ws.rs b/crates/server/src/routes/ws.rs deleted file mode 100644 index 7aae006..0000000 --- a/crates/server/src/routes/ws.rs +++ /dev/null @@ -1,17 +0,0 @@ -use std::sync::Arc; - -use axum::extract::ws::WebSocketUpgrade; -use axum::extract::State; -use axum::response::IntoResponse; - -use websocket::WsState; - -use crate::state::AppState; - -pub async fn websocket_handler( - ws: WebSocketUpgrade, - State(state): State, -) -> impl IntoResponse { - let ws_state = Arc::new(WsState::new(state.event_bus.clone())); - websocket::ws_handler(ws, State(ws_state)).await -} diff --git a/crates/server/src/state.rs b/crates/server/src/state.rs index 9d9cef0..34ed0ec 100644 --- a/crates/server/src/state.rs +++ b/crates/server/src/state.rs @@ -1,70 +1,93 @@ -use db::{SessionRepository, TaskRepository}; +use crate::project_manager::{GlobalConfigManager, ProjectContext, ProjectError, ProjectManager}; +use crate::routes::sse::{EventBuffer, SharedEventBuffer, DEFAULT_EVENT_BUFFER_SIZE}; use events::EventBus; use github::{GitHubClient, RepoConfig}; -use opencode::OpenCodeClient; -use orchestrator::{ExecutorConfig, TaskExecutor}; -use sqlx::SqlitePool; use std::path::{Path, PathBuf}; -use std::sync::Arc; +use std::sync::{Arc, RwLock}; use tokio::sync::OnceCell; -use vcs::{GitVcs, JujutsuVcs, VersionControl, WorkspaceConfig, WorkspaceManager}; #[derive(Clone)] pub struct AppState { - pub task_repository: TaskRepository, - pub session_repository: SessionRepository, - pub task_executor: Arc, - pub workspace_manager: Arc, + pub project_manager: Arc, + pub global_config: GlobalConfigManager, pub event_bus: EventBus, - #[allow(dead_code)] - pub repo_path: PathBuf, - #[allow(dead_code)] + pub event_buffer: SharedEventBuffer, + pub opencode_url: String, + pub app_dir: Option, github_client: Arc>, } impl AppState { - pub fn new(pool: SqlitePool, opencode_url: &str) -> Self { - let opencode_client = Arc::new(OpenCodeClient::new(opencode_url)); + pub fn new(opencode_url: &str) -> Self { + let event_bus = EventBus::new(); + let event_buffer = Arc::new(RwLock::new(EventBuffer::new(DEFAULT_EVENT_BUFFER_SIZE))); + let global_config = GlobalConfigManager::new(); + let project_manager = Arc::new(ProjectManager::new(opencode_url.to_string(), event_bus.clone())); - let repo_path = std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")); - let workspace_base = repo_path - .parent() - .map(|p| p.join(".workspaces")) - .unwrap_or_else(|| PathBuf::from("../.workspaces")); + Self { + project_manager, + global_config, + event_bus, + event_buffer, + opencode_url: opencode_url.to_string(), + app_dir: None, + github_client: Arc::new(OnceCell::new()), + } + } - let vcs = Self::detect_vcs(&repo_path, &workspace_base); - let config = WorkspaceConfig::new(workspace_base.clone()); - let workspace_manager = Arc::new(WorkspaceManager::new(vcs, config, repo_path.clone())); + pub fn with_app_dir(mut self, app_dir: PathBuf) -> Self { + self.app_dir = Some(app_dir); + self + } - let session_repository = SessionRepository::new(pool.clone()); - let event_bus = EventBus::new(); + pub async fn project(&self) -> Result { + self.project_manager + .current() + .await + .ok_or(ProjectError::NoProjectOpen) + } - let config = ExecutorConfig::new(&repo_path) - .with_plan_approval(true) - .with_human_review(true) - .with_max_iterations(3); + pub async fn open_project(&self, path: &Path) -> Result<(), ProjectError> { + let result = self.project_manager.open(path).await?; - let task_executor = TaskExecutor::new(opencode_client, config) - .with_workspace_manager(workspace_manager.clone()) - .with_session_repo(Arc::new(session_repository.clone())) - .with_event_bus(event_bus.clone()); + self.global_config.add_recent(path)?; + self.global_config.set_last(path)?; - Self { - task_repository: TaskRepository::new(pool), - session_repository, - task_executor: Arc::new(task_executor), - workspace_manager, - event_bus, - repo_path, - github_client: Arc::new(OnceCell::new()), + tracing::info!( + "Opened project: {} (initialized: {})", + result.project.name, + result.was_initialized + ); + + Ok(()) + } + + pub async fn auto_open_last_project(&self) -> Result { + if !self.global_config.should_auto_open_last() { + return Ok(false); + } + + if let Some(last_path) = self.global_config.get_last() { + if last_path.exists() && last_path.join(".git").exists() + || last_path.join(".jj").exists() + { + self.open_project(&last_path).await?; + return Ok(true); + } } + + Ok(false) } #[allow(dead_code)] pub async fn github_client(&self) -> Result<&GitHubClient, github::GitHubError> { + let project = self.project().await.map_err(|e| { + github::GitHubError::Config(format!("No project open: {}", e)) + })?; + self.github_client .get_or_try_init(|| async { - let repo_config = RepoConfig::from_git_remote(&self.repo_path) + let repo_config = RepoConfig::from_git_remote(&project.path) .await .ok_or_else(|| { github::GitHubError::Config( @@ -82,20 +105,4 @@ impl AppState { }) .await } - - fn detect_vcs(repo_path: &Path, workspace_base: &Path) -> Arc { - if repo_path.join(".jj").exists() { - tracing::info!("Detected Jujutsu repository"); - Arc::new(JujutsuVcs::new( - repo_path.to_path_buf(), - workspace_base.to_path_buf(), - )) - } else { - tracing::info!("Using Git as VCS backend"); - Arc::new(GitVcs::new( - repo_path.to_path_buf(), - workspace_base.to_path_buf(), - )) - } - } } diff --git a/crates/server/tests/api_tests.rs b/crates/server/tests/api_tests.rs deleted file mode 100644 index 56f59bd..0000000 --- a/crates/server/tests/api_tests.rs +++ /dev/null @@ -1,1080 +0,0 @@ -use axum_test::TestServer; -use serde_json::{json, Value}; -use server::{create_router, state::AppState}; -use std::process::Command; -use std::sync::Mutex; -use tempfile::TempDir; -use wiremock::matchers::{method, path, path_regex}; -use wiremock::{Mock, MockServer, ResponseTemplate}; - -static TEST_MUTEX: Mutex<()> = Mutex::new(()); - -fn create_temp_git_repo() -> TempDir { - let temp_dir = TempDir::new().expect("Failed to create temp dir"); - - // Initialize git repo with main branch (git 2.28+) - Command::new("git") - .args(["init", "--initial-branch=main"]) - .current_dir(temp_dir.path()) - .output() - .expect("Failed to init git repo"); - - Command::new("git") - .args(["config", "user.email", "test@test.com"]) - .current_dir(temp_dir.path()) - .output() - .expect("Failed to set git email"); - - Command::new("git") - .args(["config", "user.name", "Test User"]) - .current_dir(temp_dir.path()) - .output() - .expect("Failed to set git name"); - - std::fs::write(temp_dir.path().join("README.md"), "# Test\n").expect("Failed to write README"); - - Command::new("git") - .args(["add", "."]) - .current_dir(temp_dir.path()) - .output() - .expect("Failed to git add"); - - Command::new("git") - .args(["commit", "-m", "Initial commit"]) - .current_dir(temp_dir.path()) - .output() - .expect("Failed to git commit"); - - temp_dir -} - -async fn setup_test_server() -> (TestServer, TempDir, MockServer, std::sync::MutexGuard<'static, ()>) { - let lock = TEST_MUTEX.lock().unwrap(); - - let temp_dir = create_temp_git_repo(); - let db_path = temp_dir.path().join("test.db"); - let db_url = format!("sqlite:{}", db_path.display()); - - let pool = db::create_pool(&db_url).await.expect("Failed to create pool"); - db::run_migrations(&pool).await.expect("Failed to run migrations"); - - let mock_opencode = MockServer::start().await; - - std::env::set_current_dir(temp_dir.path()).expect("Failed to change dir"); - - let state = AppState::new(pool, &mock_opencode.uri()); - let app = create_router(state); - - let server = TestServer::new(app).expect("Failed to create test server"); - - (server, temp_dir, mock_opencode, lock) -} - -mod health { - use super::*; - - #[tokio::test] - async fn test_health_endpoint() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let response = server.get("/health").await; - - response.assert_status_ok(); - let body: Value = response.json(); - assert_eq!(body["status"], "ok"); - } -} - -mod tasks_crud { - use super::*; - - #[tokio::test] - async fn test_create_task_returns_201_created() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let response = server - .post("/api/tasks") - .json(&json!({ - "title": "Test Task", - "description": "Test Description" - })) - .await; - - response.assert_status(axum::http::StatusCode::CREATED); - let body: Value = response.json(); - assert_eq!(body["title"], "Test Task"); - assert_eq!(body["description"], "Test Description"); - assert_eq!(body["status"], "todo"); - assert!(body["id"].is_string()); - } - - #[tokio::test] - async fn test_list_tasks() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - server - .post("/api/tasks") - .json(&json!({ - "title": "Task 1", - "description": "Desc 1" - })) - .await; - - server - .post("/api/tasks") - .json(&json!({ - "title": "Task 2", - "description": "Desc 2" - })) - .await; - - let response = server.get("/api/tasks").await; - - response.assert_status_ok(); - let body: Value = response.json(); - assert!(body.is_array()); - assert_eq!(body.as_array().unwrap().len(), 2); - } - - #[tokio::test] - async fn test_get_task() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "Get Task Test", - "description": "Description" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - let response = server.get(&format!("/api/tasks/{}", task_id)).await; - - response.assert_status_ok(); - let body: Value = response.json(); - assert_eq!(body["title"], "Get Task Test"); - } - - #[tokio::test] - async fn test_get_task_not_found() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let fake_id = uuid::Uuid::new_v4(); - let response = server.get(&format!("/api/tasks/{}", fake_id)).await; - - response.assert_status_not_found(); - } -} - -mod e2e_jj_workspace { - use super::*; - - fn create_temp_jj_repo() -> TempDir { - let temp_dir = TempDir::new().expect("Failed to create temp dir"); - - Command::new("jj") - .args(["git", "init"]) - .current_dir(temp_dir.path()) - .output() - .expect("Failed to init jj repo"); - - Command::new("jj") - .args(["config", "set", "--repo", "user.email", "test@test.com"]) - .current_dir(temp_dir.path()) - .output() - .expect("Failed to set jj email"); - - Command::new("jj") - .args(["config", "set", "--repo", "user.name", "Test User"]) - .current_dir(temp_dir.path()) - .output() - .expect("Failed to set jj name"); - - std::fs::write(temp_dir.path().join("README.md"), "# Test Project\n") - .expect("Failed to write README"); - - Command::new("jj") - .args(["bookmark", "create", "main", "-r", "@"]) - .current_dir(temp_dir.path()) - .output() - .expect("Failed to create main bookmark"); - - Command::new("jj") - .args(["new"]) - .current_dir(temp_dir.path()) - .output() - .expect("Failed to create new change"); - - temp_dir - } - - async fn setup_e2e_server() -> (TestServer, TempDir, std::sync::MutexGuard<'static, ()>) { - let lock = TEST_MUTEX.lock().unwrap_or_else(|e| e.into_inner()); - - let temp_dir = create_temp_jj_repo(); - let db_path = temp_dir.path().join("test.db"); - let db_url = format!("sqlite:{}", db_path.display()); - - let pool = db::create_pool(&db_url).await.expect("Failed to create pool"); - db::run_migrations(&pool).await.expect("Failed to run migrations"); - - std::env::set_current_dir(temp_dir.path()).expect("Failed to change dir"); - - let state = AppState::new(pool, "http://localhost:9999"); - let app = create_router(state); - - let server = TestServer::new(app).expect("Failed to create test server"); - - (server, temp_dir, lock) - } - - #[tokio::test] - async fn test_e2e_create_jj_workspace() { - let (server, temp_dir, _lock) = setup_e2e_server().await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "E2E JJ Workspace Test", - "description": "Test jj workspace creation" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - let workspace_response = server - .post(&format!("/api/tasks/{}/workspace", task_id)) - .await; - - workspace_response.assert_status(axum::http::StatusCode::CREATED); - let workspace: Value = workspace_response.json(); - - assert_eq!(workspace["task_id"], task_id); - - let workspace_path = workspace["path"].as_str().unwrap(); - assert!( - std::path::Path::new(workspace_path).exists(), - "Workspace directory should exist at {}", - workspace_path - ); - - let jj_output = Command::new("jj") - .args(["workspace", "list"]) - .current_dir(temp_dir.path()) - .output() - .expect("Failed to list jj workspaces"); - - let output = String::from_utf8_lossy(&jj_output.stdout); - assert!( - output.contains(&format!("task-{}", task_id)), - "jj workspace list should contain task workspace: {}", - output - ); - } - - #[tokio::test] - async fn test_e2e_workspace_diff_with_real_changes() { - let (server, _temp_dir, _lock) = setup_e2e_server().await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "E2E Diff Test", - "description": "Test workspace diff with real file changes" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - let workspace_response = server - .post(&format!("/api/tasks/{}/workspace", task_id)) - .await; - - let workspace: Value = workspace_response.json(); - let workspace_path = workspace["path"].as_str().unwrap(); - - let test_file = std::path::Path::new(workspace_path).join("test_change.txt"); - std::fs::write(&test_file, "Hello from E2E test!\n").expect("Failed to write test file"); - - let diff_response = server - .get(&format!("/api/workspaces/{}/diff", task_id)) - .await; - - diff_response.assert_status_ok(); - let diff: Value = diff_response.json(); - - let diff_content = diff["diff"].as_str().unwrap(); - assert!( - diff_content.contains("test_change.txt"), - "Diff should contain the new file name. Got: {}", - diff_content - ); - assert!( - diff_content.contains("Hello from E2E test!"), - "Diff should contain the file content. Got: {}", - diff_content - ); - } - - #[tokio::test] - async fn test_e2e_workspace_status_shows_changes() { - let (server, _temp_dir, _lock) = setup_e2e_server().await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "E2E Status Test", - "description": "Test workspace status with file changes" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - let workspace_response = server - .post(&format!("/api/tasks/{}/workspace", task_id)) - .await; - - let workspace: Value = workspace_response.json(); - let workspace_path = workspace["path"].as_str().unwrap(); - - let test_file = std::path::Path::new(workspace_path).join("new_file.rs"); - std::fs::write(&test_file, "fn main() {}\n").expect("Failed to write test file"); - - let status_response = server - .get(&format!("/api/workspaces/{}", task_id)) - .await; - - status_response.assert_status_ok(); - let status: Value = status_response.json(); - - let status_content = status["status"].as_str().unwrap(); - assert!( - status_content.contains("new_file.rs"), - "Status should show the new file. Got: {}", - status_content - ); - } - - #[tokio::test] - async fn test_e2e_multiple_workspaces() { - let (server, temp_dir, _lock) = setup_e2e_server().await; - - let mut task_ids = Vec::new(); - - for i in 1..=3 { - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": format!("Multi Workspace Task {}", i), - "description": format!("Task {} for multiple workspace test", i) - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap().to_string(); - - server - .post(&format!("/api/tasks/{}/workspace", task_id)) - .await - .assert_status(axum::http::StatusCode::CREATED); - - task_ids.push(task_id); - } - - let list_response = server.get("/api/workspaces").await; - list_response.assert_status_ok(); - - let workspaces: Value = list_response.json(); - let workspaces_arr = workspaces.as_array().unwrap(); - - assert_eq!( - workspaces_arr.len(), - 3, - "Should have 3 workspaces, got {}", - workspaces_arr.len() - ); - - let jj_output = Command::new("jj") - .args(["workspace", "list"]) - .current_dir(temp_dir.path()) - .output() - .expect("Failed to list jj workspaces"); - - let output = String::from_utf8_lossy(&jj_output.stdout); - - for task_id in &task_ids { - assert!( - output.contains(&format!("task-{}", task_id)), - "jj should list workspace for task {}", - task_id - ); - } - } - - #[tokio::test] - async fn test_e2e_workspace_cleanup() { - let (server, temp_dir, _lock) = setup_e2e_server().await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "E2E Cleanup Test", - "description": "Test workspace cleanup" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - let workspace_response = server - .post(&format!("/api/tasks/{}/workspace", task_id)) - .await; - - let workspace: Value = workspace_response.json(); - let workspace_path = workspace["path"].as_str().unwrap().to_string(); - - assert!( - std::path::Path::new(&workspace_path).exists(), - "Workspace should exist before cleanup" - ); - - let delete_response = server - .delete(&format!("/api/workspaces/{}", task_id)) - .await; - - delete_response.assert_status(axum::http::StatusCode::NO_CONTENT); - - assert!( - !std::path::Path::new(&workspace_path).exists(), - "Workspace directory should be removed after cleanup" - ); - - let jj_output = Command::new("jj") - .args(["workspace", "list"]) - .current_dir(temp_dir.path()) - .output() - .expect("Failed to list jj workspaces"); - - let output = String::from_utf8_lossy(&jj_output.stdout); - let workspace_name = format!("task-{}:", task_id); - let workspace_still_exists = output - .lines() - .any(|line| line.starts_with(&workspace_name)); - assert!( - !workspace_still_exists, - "jj workspace list should not contain deleted workspace" - ); - } -} - -mod task_transitions { - use super::*; - - #[tokio::test] - async fn test_transition_todo_to_planning() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "Transition Test", - "description": "Testing transitions" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - let response = server - .post(&format!("/api/tasks/{}/transition", task_id)) - .json(&json!({ - "status": "planning" - })) - .await; - - response.assert_status_ok(); - let body: Value = response.json(); - assert_eq!(body["task"]["status"], "planning"); - assert_eq!(body["previous_status"], "todo"); - } - - #[tokio::test] - async fn test_invalid_transition_todo_to_done() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "Invalid Transition Test", - "description": "Testing invalid transitions" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - let response = server - .post(&format!("/api/tasks/{}/transition", task_id)) - .json(&json!({ - "status": "done" - })) - .await; - - response.assert_status_bad_request(); - } - - #[tokio::test] - async fn test_full_state_machine_path() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "Full Path Test", - "description": "Testing full state machine" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - let transitions = vec![ - "planning", - "planning_review", - "in_progress", - "ai_review", - "review", - "done", - ]; - - for status in transitions { - let response = server - .post(&format!("/api/tasks/{}/transition", task_id)) - .json(&json!({ "status": status })) - .await; - - response.assert_status_ok(); - let body: Value = response.json(); - assert_eq!(body["task"]["status"], status); - } - } -} - -mod task_execute { - use super::*; - - #[tokio::test] - async fn test_execute_planning_phase() { - let (server, _temp_dir, mock_opencode, _lock) = setup_test_server().await; - - Mock::given(method("POST")) - .and(path("/session")) - .respond_with(ResponseTemplate::new(200).set_body_json(json!({ - "id": "mock-session-123", - "title": "Planning: Test Task", - "parent_id": null, - "created_at": "2025-12-30T12:00:00Z" - }))) - .mount(&mock_opencode) - .await; - - Mock::given(method("POST")) - .and(path_regex(r"/session/.*/message")) - .respond_with(ResponseTemplate::new(200).set_body_json(json!({ - "session_id": "mock-session-123", - "message": { - "id": "msg-123", - "role": "assistant", - "content": "# Plan\n\n1. Step one\n2. Step two", - "created_at": "2025-12-30T12:00:00Z" - } - }))) - .mount(&mock_opencode) - .await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "Execute Test", - "description": "Testing execute" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - let transition_response = server - .post(&format!("/api/tasks/{}/transition", task_id)) - .json(&json!({ "status": "planning" })) - .await; - transition_response.assert_status_ok(); - - let execute_response = server - .post(&format!("/api/tasks/{}/execute", task_id)) - .await; - - execute_response.assert_status_ok(); - let body: Value = execute_response.json(); - assert!( - body["result"]["plan_path"].is_string() || body["result"]["session_id"].is_string(), - "Expected plan_path or session_id in response: {:?}", - body - ); - } -} - -mod sessions { - use super::*; - - #[tokio::test] - async fn test_list_sessions_empty() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let response = server.get("/api/sessions").await; - - response.assert_status_ok(); - let body: Value = response.json(); - assert!(body.is_array()); - } - - #[tokio::test] - async fn test_list_sessions_for_task() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "Sessions Test", - "description": "Testing sessions" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - let response = server - .get(&format!("/api/tasks/{}/sessions", task_id)) - .await; - - response.assert_status_ok(); - let body: Value = response.json(); - assert!(body.is_array()); - } -} - -mod workspaces { - use super::*; - - #[tokio::test] - async fn test_list_workspaces_empty() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let response = server.get("/api/workspaces").await; - - response.assert_status_ok(); - let body: Value = response.json(); - assert!(body.is_array()); - assert!(body.as_array().unwrap().is_empty()); - } -} - -mod kanban_flow { - use super::*; - - fn mock_opencode_session_and_message(mock: &MockServer) -> impl std::future::Future + '_ { - async move { - Mock::given(method("POST")) - .and(path("/session")) - .respond_with(ResponseTemplate::new(200).set_body_json(json!({ - "id": "flow-session-123", - "title": "Session", - "parent_id": null, - "created_at": "2025-12-30T12:00:00Z" - }))) - .mount(mock) - .await; - - Mock::given(method("POST")) - .and(path_regex(r"/session/.*/message")) - .respond_with(ResponseTemplate::new(200).set_body_json(json!({ - "session_id": "flow-session-123", - "message": { - "id": "msg-flow-123", - "role": "assistant", - "content": "# Plan\n\n## Steps\n1. Implement feature\n2. Write tests\n3. Document", - "created_at": "2025-12-30T12:00:00Z" - } - }))) - .mount(mock) - .await; - } - } - - #[tokio::test] - async fn test_planning_phase_creates_plan_file() { - let (server, _temp_dir, mock_opencode, _lock) = setup_test_server().await; - mock_opencode_session_and_message(&mock_opencode).await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "Plan File Test", - "description": "Test that planning creates a plan file" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - server - .post(&format!("/api/tasks/{}/transition", task_id)) - .json(&json!({ "status": "planning" })) - .await; - - let execute_response = server - .post(&format!("/api/tasks/{}/execute", task_id)) - .await; - - execute_response.assert_status_ok(); - let body: Value = execute_response.json(); - - assert!(body["result"]["plan_path"].is_string()); - let plan_path = body["result"]["plan_path"].as_str().unwrap(); - - let full_path = std::path::Path::new(plan_path); - assert!(full_path.exists(), "Plan file should exist at {:?}", full_path); - - let task_response = server.get(&format!("/api/tasks/{}", task_id)).await; - let task: Value = task_response.json(); - assert_eq!(task["status"], "planning_review"); - } - - #[tokio::test] - async fn test_planning_phase_creates_session_in_db() { - let (server, _temp_dir, mock_opencode, _lock) = setup_test_server().await; - mock_opencode_session_and_message(&mock_opencode).await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "Session DB Test", - "description": "Test that planning creates a session in DB" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - server - .post(&format!("/api/tasks/{}/transition", task_id)) - .json(&json!({ "status": "planning" })) - .await; - - server - .post(&format!("/api/tasks/{}/execute", task_id)) - .await; - - let sessions_response = server - .get(&format!("/api/tasks/{}/sessions", task_id)) - .await; - - sessions_response.assert_status_ok(); - let sessions: Value = sessions_response.json(); - - assert!(sessions.is_array()); - let sessions_arr = sessions.as_array().unwrap(); - assert!(!sessions_arr.is_empty(), "Should have at least one session"); - - let session = &sessions_arr[0]; - assert_eq!(session["phase"], "planning"); - assert_eq!(session["status"], "completed"); - } - - #[tokio::test] - async fn test_execute_from_todo_auto_transitions_to_planning() { - let (server, _temp_dir, mock_opencode, _lock) = setup_test_server().await; - mock_opencode_session_and_message(&mock_opencode).await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "Auto Transition Test", - "description": "Test execute from TODO auto-transitions" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - assert_eq!(created["status"], "todo"); - - let execute_response = server - .post(&format!("/api/tasks/{}/execute", task_id)) - .await; - - execute_response.assert_status_ok(); - - let task_response = server.get(&format!("/api/tasks/{}", task_id)).await; - let task: Value = task_response.json(); - assert_eq!(task["status"], "planning_review"); - } - - #[tokio::test] - async fn test_planning_review_awaits_approval() { - let (server, _temp_dir, mock_opencode, _lock) = setup_test_server().await; - mock_opencode_session_and_message(&mock_opencode).await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "Approval Test", - "description": "Test that planning_review awaits approval" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - server - .post(&format!("/api/tasks/{}/execute", task_id)) - .await; - - let execute_response = server - .post(&format!("/api/tasks/{}/execute", task_id)) - .await; - - execute_response.assert_status_ok(); - let body: Value = execute_response.json(); - - assert_eq!(body["result"]["type"], "awaiting_approval"); - assert_eq!(body["result"]["phase"], "planning"); - } -} - -mod workspace_flow { - use super::*; - - #[tokio::test] - async fn test_create_workspace_for_task() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "Workspace Test", - "description": "Test workspace creation" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - let workspace_response = server - .post(&format!("/api/tasks/{}/workspace", task_id)) - .await; - - workspace_response.assert_status(axum::http::StatusCode::CREATED); - let workspace: Value = workspace_response.json(); - - assert_eq!(workspace["task_id"], task_id); - assert!(workspace["path"].is_string()); - assert!(workspace["branch_name"].is_string()); - assert!(workspace["status"].is_string()); - } - - #[tokio::test] - async fn test_list_workspaces_after_creation() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "List Workspace Test", - "description": "Test listing workspaces" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - server - .post(&format!("/api/tasks/{}/workspace", task_id)) - .await; - - let list_response = server.get("/api/workspaces").await; - list_response.assert_status_ok(); - - let workspaces: Value = list_response.json(); - assert!(workspaces.is_array()); - let workspaces_arr = workspaces.as_array().unwrap(); - assert!(!workspaces_arr.is_empty()); - - let found = workspaces_arr.iter().any(|ws| ws["task_id"] == task_id); - assert!(found, "Should find workspace with task_id {}", task_id); - } - - #[tokio::test] - async fn test_get_workspace_status() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "Status Test", - "description": "Test workspace status" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - server - .post(&format!("/api/tasks/{}/workspace", task_id)) - .await; - - let status_response = server - .get(&format!("/api/workspaces/{}", task_id)) - .await; - - status_response.assert_status_ok(); - let status: Value = status_response.json(); - assert_eq!(status["task_id"], task_id); - } - - #[tokio::test] - async fn test_get_workspace_diff_empty() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "Diff Test", - "description": "Test workspace diff" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - server - .post(&format!("/api/tasks/{}/workspace", task_id)) - .await; - - let diff_response = server - .get(&format!("/api/workspaces/{}/diff", task_id)) - .await; - - diff_response.assert_status_ok(); - let diff: Value = diff_response.json(); - assert_eq!(diff["task_id"], task_id); - assert!(diff["diff"].is_string()); - } - - #[tokio::test] - async fn test_delete_workspace() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let create_response = server - .post("/api/tasks") - .json(&json!({ - "title": "Delete Workspace Test", - "description": "Test workspace deletion" - })) - .await; - - let created: Value = create_response.json(); - let task_id = created["id"].as_str().unwrap(); - - server - .post(&format!("/api/tasks/{}/workspace", task_id)) - .await; - - let delete_response = server - .delete(&format!("/api/workspaces/{}", task_id)) - .await; - - delete_response.assert_status(axum::http::StatusCode::NO_CONTENT); - - let list_response = server.get("/api/workspaces").await; - let workspaces: Value = list_response.json(); - let workspaces_arr = workspaces.as_array().unwrap(); - let found = workspaces_arr.iter().any(|ws| ws["task_id"] == task_id); - assert!(!found, "Workspace should be deleted"); - } - - #[tokio::test] - async fn test_workspace_not_found_for_nonexistent_task() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let fake_id = uuid::Uuid::new_v4(); - let response = server - .post(&format!("/api/tasks/{}/workspace", fake_id)) - .await; - - response.assert_status_not_found(); - } -} - -mod validation { - use super::*; - - #[tokio::test] - async fn test_create_task_with_empty_title_fails() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let response = server - .post("/api/tasks") - .json(&json!({ - "title": "", - "description": "Valid description" - })) - .await; - - response.assert_status_bad_request(); - } - - #[tokio::test] - async fn test_create_task_with_whitespace_title_fails() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let response = server - .post("/api/tasks") - .json(&json!({ - "title": " ", - "description": "Valid description" - })) - .await; - - response.assert_status_bad_request(); - } - - #[tokio::test] - async fn test_transition_nonexistent_task_returns_404() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let fake_id = uuid::Uuid::new_v4(); - let response = server - .post(&format!("/api/tasks/{}/transition", fake_id)) - .json(&json!({ "status": "planning" })) - .await; - - response.assert_status_not_found(); - } - - #[tokio::test] - async fn test_execute_nonexistent_task_returns_404() { - let (server, _temp_dir, _mock, _lock) = setup_test_server().await; - - let fake_id = uuid::Uuid::new_v4(); - let response = server - .post(&format!("/api/tasks/{}/execute", fake_id)) - .await; - - response.assert_status_not_found(); - } -} diff --git a/crates/websocket/Cargo.toml b/crates/websocket/Cargo.toml deleted file mode 100644 index a5d20dd..0000000 --- a/crates/websocket/Cargo.toml +++ /dev/null @@ -1,23 +0,0 @@ -[package] -name = "websocket" -version.workspace = true -edition.workspace = true - -[features] -default = [] -typescript = ["ts-rs", "events/typescript"] - -[dependencies] -events = { path = "../events" } - -axum = { workspace = true } -tokio = { workspace = true } -serde = { workspace = true } -serde_json = { workspace = true } -uuid = { workspace = true } -tracing = { workspace = true } -futures-util = "0.3" -ts-rs = { workspace = true, optional = true } - -[dev-dependencies] -tokio = { workspace = true, features = ["full", "test-util"] } diff --git a/crates/websocket/src/handler.rs b/crates/websocket/src/handler.rs deleted file mode 100644 index 1b69fee..0000000 --- a/crates/websocket/src/handler.rs +++ /dev/null @@ -1,165 +0,0 @@ -use std::sync::Arc; -use std::time::Duration; - -use axum::extract::ws::{Message, WebSocket, WebSocketUpgrade}; -use axum::extract::State; -use axum::response::IntoResponse; -use futures_util::{SinkExt, StreamExt}; -use tokio::sync::broadcast; -use tokio::time::interval; - -use events::EventBus; - -use crate::messages::{ClientMessage, ServerMessage, SubscriptionFilter}; - -const HEARTBEAT_INTERVAL: Duration = Duration::from_secs(30); -const CLIENT_TIMEOUT: Duration = Duration::from_secs(10); - -#[derive(Clone)] -pub struct WsState { - pub event_bus: EventBus, -} - -impl WsState { - pub fn new(event_bus: EventBus) -> Self { - Self { event_bus } - } -} - -pub async fn ws_handler( - ws: WebSocketUpgrade, - State(state): State>, -) -> impl IntoResponse { - ws.on_upgrade(move |socket| handle_socket(socket, state)) -} - -async fn handle_socket(socket: WebSocket, state: Arc) { - let (mut sender, mut receiver) = socket.split(); - - let mut event_rx = state.event_bus.subscribe(); - let mut filter: Option = None; - let mut subscribed = false; - - let mut heartbeat = interval(HEARTBEAT_INTERVAL); - heartbeat.reset(); - - loop { - tokio::select! { - _ = heartbeat.tick() => { - let ping_msg = serde_json::to_string(&ServerMessage::Pong).unwrap(); - if sender.send(Message::Text(ping_msg.into())).await.is_err() { - break; - } - } - - event_result = event_rx.recv() => { - match event_result { - Ok(envelope) => { - if subscribed { - let should_send = filter.as_ref() - .map(|f| f.matches(&envelope)) - .unwrap_or(true); - - if should_send { - let msg = ServerMessage::Event { envelope }; - let json = serde_json::to_string(&msg).unwrap(); - if sender.send(Message::Text(json.into())).await.is_err() { - break; - } - } - } - } - Err(broadcast::error::RecvError::Lagged(n)) => { - tracing::warn!("WebSocket client lagged, missed {} events", n); - } - Err(broadcast::error::RecvError::Closed) => { - break; - } - } - } - - msg = tokio::time::timeout(CLIENT_TIMEOUT + HEARTBEAT_INTERVAL, receiver.next()) => { - match msg { - Ok(Some(Ok(Message::Text(text)))) => { - match serde_json::from_str::(&text) { - Ok(ClientMessage::Subscribe { filter: new_filter }) => { - filter = new_filter.clone(); - subscribed = true; - let response = ServerMessage::Subscribed { filter: new_filter }; - let json = serde_json::to_string(&response).unwrap(); - if sender.send(Message::Text(json.into())).await.is_err() { - break; - } - } - Ok(ClientMessage::Unsubscribe) => { - subscribed = false; - filter = None; - let response = ServerMessage::Unsubscribed; - let json = serde_json::to_string(&response).unwrap(); - if sender.send(Message::Text(json.into())).await.is_err() { - break; - } - } - Ok(ClientMessage::Ping) => { - let response = ServerMessage::Pong; - let json = serde_json::to_string(&response).unwrap(); - if sender.send(Message::Text(json.into())).await.is_err() { - break; - } - } - Err(e) => { - let response = ServerMessage::Error { - message: format!("Invalid message: {}", e), - }; - let json = serde_json::to_string(&response).unwrap(); - let _ = sender.send(Message::Text(json.into())).await; - } - } - } - Ok(Some(Ok(Message::Close(_)))) => { - break; - } - Ok(Some(Ok(Message::Ping(data)))) => { - if sender.send(Message::Pong(data)).await.is_err() { - break; - } - } - Ok(Some(Ok(_))) => {} - Ok(Some(Err(_))) => { - break; - } - Ok(None) => { - break; - } - Err(_) => { - tracing::debug!("WebSocket client timeout, sending ping"); - } - } - } - } - } - - tracing::debug!("WebSocket connection closed"); -} - -#[cfg(test)] -mod tests { - use super::*; - - #[tokio::test] - async fn test_ws_state_creation() { - let bus = EventBus::new(); - let state = WsState::new(bus); - assert_eq!(state.event_bus.subscriber_count(), 0); - } - - #[test] - fn test_heartbeat_interval() { - assert_eq!(HEARTBEAT_INTERVAL, Duration::from_secs(30)); - } - - #[test] - fn test_client_timeout() { - assert_eq!(CLIENT_TIMEOUT, Duration::from_secs(10)); - } -} diff --git a/crates/websocket/src/lib.rs b/crates/websocket/src/lib.rs deleted file mode 100644 index d931f26..0000000 --- a/crates/websocket/src/lib.rs +++ /dev/null @@ -1,5 +0,0 @@ -mod handler; -mod messages; - -pub use handler::{ws_handler, WsState}; -pub use messages::{ClientMessage, ServerMessage, SubscriptionFilter}; diff --git a/crates/websocket/src/messages.rs b/crates/websocket/src/messages.rs deleted file mode 100644 index 9d54713..0000000 --- a/crates/websocket/src/messages.rs +++ /dev/null @@ -1,131 +0,0 @@ -use serde::{Deserialize, Serialize}; -use uuid::Uuid; - -use events::EventEnvelope; - -#[derive(Debug, Clone, Serialize, Deserialize)] -#[cfg_attr(feature = "typescript", derive(ts_rs::TS))] -#[cfg_attr(feature = "typescript", ts(export))] -#[serde(tag = "type", rename_all = "snake_case")] -pub enum ClientMessage { - Subscribe { filter: Option }, - Unsubscribe, - Ping, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -#[cfg_attr(feature = "typescript", derive(ts_rs::TS))] -#[cfg_attr(feature = "typescript", ts(export))] -#[serde(tag = "type", rename_all = "snake_case")] -pub enum ServerMessage { - Event { envelope: EventEnvelope }, - Subscribed { filter: Option }, - Unsubscribed, - Pong, - Error { message: String }, -} - -#[derive(Debug, Clone, Serialize, Deserialize)] -#[cfg_attr(feature = "typescript", derive(ts_rs::TS))] -#[cfg_attr(feature = "typescript", ts(export))] -pub struct SubscriptionFilter { - pub task_ids: Option>, -} - -impl SubscriptionFilter { - pub fn for_task(task_id: Uuid) -> Self { - Self { - task_ids: Some(vec![task_id]), - } - } - - pub fn for_tasks(task_ids: Vec) -> Self { - Self { - task_ids: Some(task_ids), - } - } - - pub fn matches(&self, envelope: &EventEnvelope) -> bool { - match &self.task_ids { - Some(ids) => { - if let Some(event_task_id) = envelope.event.task_id() { - ids.contains(&event_task_id) - } else { - true - } - } - None => true, - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - use events::Event; - - #[test] - fn test_client_message_serialize() { - let msg = ClientMessage::Subscribe { filter: None }; - let json = serde_json::to_string(&msg).unwrap(); - assert!(json.contains("subscribe")); - } - - #[test] - fn test_client_message_deserialize() { - let json = r#"{"type":"ping"}"#; - let msg: ClientMessage = serde_json::from_str(json).unwrap(); - assert!(matches!(msg, ClientMessage::Ping)); - } - - #[test] - fn test_server_message_serialize() { - let msg = ServerMessage::Pong; - let json = serde_json::to_string(&msg).unwrap(); - assert!(json.contains("pong")); - } - - #[test] - fn test_subscription_filter_matches_all() { - let filter = SubscriptionFilter { task_ids: None }; - let task_id = Uuid::new_v4(); - let envelope = EventEnvelope::new(Event::TaskCreated { - task_id, - title: "Test".to_string(), - }); - - assert!(filter.matches(&envelope)); - } - - #[test] - fn test_subscription_filter_matches_specific_task() { - let task_id = Uuid::new_v4(); - let other_task_id = Uuid::new_v4(); - - let filter = SubscriptionFilter::for_task(task_id); - - let matching_envelope = EventEnvelope::new(Event::TaskCreated { - task_id, - title: "Test".to_string(), - }); - - let non_matching_envelope = EventEnvelope::new(Event::TaskCreated { - task_id: other_task_id, - title: "Other".to_string(), - }); - - assert!(filter.matches(&matching_envelope)); - assert!(!filter.matches(&non_matching_envelope)); - } - - #[test] - fn test_subscription_filter_allows_events_without_task_id() { - let filter = SubscriptionFilter::for_task(Uuid::new_v4()); - let envelope = EventEnvelope::new(Event::Error { - message: "test".to_string(), - context: None, - }); - - assert!(filter.matches(&envelope)); - } -} diff --git a/docs/architecture/multi-project-design.md b/docs/architecture/multi-project-design.md new file mode 100644 index 0000000..4d3d165 --- /dev/null +++ b/docs/architecture/multi-project-design.md @@ -0,0 +1,421 @@ +# Multi-Project Workspace Selection - Backend Design + +## Overview + +Enable users to select and switch between multiple projects at runtime, with automatic initialization of `.opencode-studio/` structure when opening a new project. + +## User Flow + +1. User opens opencode-studio +2. Frontend shows project picker (recent projects + folder selector) +3. User selects a folder (must be git/jj repo) +4. Backend validates, auto-inits if needed, switches context +5. User can switch projects at any time without restarting + +## Architecture Decision + +**Approach: Hot-swap AppState with Arc>** + +The server maintains a single `AppState` but with a swappable `ProjectContext` that holds project-specific resources (DB pool, repositories, executor, workspace manager). + +``` +AppState (immutable shell) +├── project_context: Arc>> // Swappable +├── opencode_url: String // Shared +├── global_config: GlobalConfigManager // Shared +└── event_bus: EventBus // Shared (broadcast project changes) + +ProjectContext (per-project) +├── path: PathBuf +├── pool: SqlitePool +├── task_repository: TaskRepository +├── session_repository: SessionRepository +├── task_executor: Arc +├── workspace_manager: Arc +└── vcs: Arc +``` + +### Why This Approach? + +1. **No server restart** - Seamless project switching +2. **Clean isolation** - Each project has its own DB and resources +3. **Graceful cleanup** - Can close old DB connections before switching +4. **WebSocket continuity** - Existing connections stay alive, receive project change events + +## API Design + +### New Endpoints + +``` +POST /api/projects/open +POST /api/projects/init +GET /api/projects/current +GET /api/projects/recent (exists, rename from /api/project/recent) +POST /api/projects/validate (exists, rename from /api/project/validate) +``` + +### POST /api/projects/open + +Opens a project, auto-initializing if needed. + +**Request:** +```json +{ + "path": "/Users/dev/my-project" +} +``` + +**Response (success):** +```json +{ + "success": true, + "project": { + "name": "my-project", + "path": "/Users/dev/my-project", + "vcs": "git", + "tasks_count": 12, + "initialized": true, + "was_initialized": false // true if we just created .opencode-studio/ + } +} +``` + +**Response (error):** +```json +{ + "success": false, + "error": { + "code": "NOT_VCS_REPO", + "message": "Path is not a git or jujutsu repository" + } +} +``` + +**Error codes:** +- `PATH_NOT_FOUND` - Path doesn't exist +- `NOT_DIRECTORY` - Path is not a directory +- `NOT_VCS_REPO` - Not a git/jj repository +- `INIT_FAILED` - Failed to create .opencode-studio structure +- `DB_CONNECT_FAILED` - Failed to connect to project database + +### POST /api/projects/init + +Explicitly initializes a project without switching to it. Useful for "init in background" scenarios. + +**Request:** +```json +{ + "path": "/Users/dev/my-project", + "force": false // if true, reinitialize even if exists +} +``` + +**Response:** +```json +{ + "success": true, + "already_initialized": false, + "project": { ... } +} +``` + +### GET /api/projects/current + +Returns currently active project, or null if none. + +**Response:** +```json +{ + "project": { + "name": "my-project", + "path": "/Users/dev/my-project", + "vcs": "git", + "tasks_count": 12, + "initialized": true + } +} +``` + +**Response (no project):** +```json +{ + "project": null +} +``` + +## Implementation Plan + +### 1. New Module: `crates/server/src/project_manager.rs` + +```rust +use std::path::{Path, PathBuf}; +use std::sync::Arc; +use tokio::sync::RwLock; + +pub struct ProjectManager { + context: Arc>>, + opencode_url: String, + global_config: GlobalConfigManager, +} + +pub struct ProjectContext { + pub path: PathBuf, + pub pool: SqlitePool, + pub task_repository: TaskRepository, + pub session_repository: SessionRepository, + pub task_executor: Arc, + pub workspace_manager: Arc, +} + +impl ProjectManager { + /// Open a project, initializing if needed + pub async fn open(&self, path: &Path) -> Result; + + /// Initialize project structure without opening + pub async fn init(&self, path: &Path, force: bool) -> Result; + + /// Get current project context + pub async fn current(&self) -> Option; + + /// Close current project (cleanup) + pub async fn close(&self) -> Result<(), ProjectError>; +} + +impl ProjectContext { + /// Create from path (connects to DB, sets up executor) + pub async fn new(path: PathBuf, opencode_url: &str) -> Result; +} +``` + +### 2. Update: `crates/server/src/state.rs` + +```rust +#[derive(Clone)] +pub struct AppState { + pub project_manager: Arc, + pub event_bus: EventBus, + pub opencode_url: String, +} + +impl AppState { + pub async fn new(opencode_url: &str) -> Self { + let event_bus = EventBus::new(); + let global_config = GlobalConfigManager::new(); + let project_manager = Arc::new(ProjectManager::new( + opencode_url.to_string(), + global_config, + )); + + Self { + project_manager, + event_bus, + opencode_url: opencode_url.to_string(), + } + } + + /// Convenience: get current project context or error + pub async fn project(&self) -> Result { + self.project_manager.current().await.ok_or(NoProjectError) + } +} +``` + +### 3. Update Route Handlers + +Existing task/session routes need to handle "no project" state: + +```rust +pub async fn list_tasks(State(state): State) -> Result, AppError> { + let project = state.project().await?; // Returns 400 if no project + let tasks = project.task_repository.find_all().await?; + Ok(Json(tasks)) +} +``` + +### 4. Global Config Manager + +```rust +// ~/.opencode-studio/global.toml +[projects] +recent = [ + "/Users/dev/project-a", + "/Users/dev/project-b", +] +last = "/Users/dev/project-a" + +[preferences] +auto_open_last = true +max_recent = 10 +``` + +```rust +pub struct GlobalConfigManager { + path: PathBuf, // ~/.opencode-studio/global.toml +} + +impl GlobalConfigManager { + pub fn add_recent(&self, path: &Path) -> Result<(), ConfigError>; + pub fn get_recent(&self) -> Vec; + pub fn set_last(&self, path: &Path) -> Result<(), ConfigError>; + pub fn get_last(&self) -> Option; +} +``` + +### 5. Project Initialization + +When opening a project that lacks `.opencode-studio/`: + +```rust +async fn init_project_structure(path: &Path) -> Result<(), InitError> { + let studio_dir = path.join(".opencode-studio"); + + // Create directory structure + fs::create_dir_all(&studio_dir)?; + fs::create_dir_all(studio_dir.join("kanban/plans"))?; + fs::create_dir_all(studio_dir.join("kanban/reviews"))?; + + // Create config.toml with defaults + let config = ProjectConfig::default(); + fs::write( + studio_dir.join("config.toml"), + toml::to_string_pretty(&config)? + )?; + + // Database will be created by sqlx on first connect + // (create_if_missing: true) + + Ok(()) +} +``` + +### 6. WebSocket Events + +Broadcast project changes to connected clients: + +```rust +#[derive(Serialize, Clone)] +#[serde(tag = "type")] +pub enum ServerMessage { + // ... existing variants + + #[serde(rename = "project_changed")] + ProjectChanged { + project: Option, + }, + + #[serde(rename = "project_closed")] + ProjectClosed, +} +``` + +## Migration Path + +### Phase 1: Add ProjectManager (backward compatible) + +1. Create `project_manager.rs` with `ProjectContext` +2. Refactor `AppState` to use `ProjectManager` internally +3. Keep existing `DATABASE_URL` env var working +4. Auto-open project from `DATABASE_URL` path on startup + +### Phase 2: Add new endpoints + +1. Add `/api/projects/open` endpoint +2. Add `/api/projects/current` endpoint +3. Add `/api/projects/init` endpoint +4. Update existing `/api/project/*` routes to `/api/projects/*` + +### Phase 3: Handle no-project state + +1. Update all route handlers to require `state.project()` +2. Return proper error when no project is open +3. Frontend handles "select project" flow + +### Phase 4: Cleanup + +1. Remove hardcoded `DATABASE_URL` dependency +2. Add startup option to auto-open last project +3. Add CLI support for project selection + +## Error Handling + +```rust +#[derive(Debug, thiserror::Error)] +pub enum ProjectError { + #[error("Path not found: {0}")] + PathNotFound(PathBuf), + + #[error("Path is not a directory: {0}")] + NotDirectory(PathBuf), + + #[error("Not a git or jujutsu repository: {0}")] + NotVcsRepo(PathBuf), + + #[error("Failed to initialize project: {0}")] + InitFailed(String), + + #[error("Database connection failed: {0}")] + DbConnectFailed(#[from] sqlx::Error), + + #[error("No project is currently open")] + NoProjectOpen, + + #[error("IO error: {0}")] + Io(#[from] std::io::Error), +} +``` + +## Directory Structure + +``` +~/.opencode-studio/ # Global config +├── global.toml # Recent projects, preferences + +/path/to/project/ # User's project +├── .opencode-studio/ # Project-specific +│ ├── config.toml # Project config +│ ├── studio.db # SQLite database +│ ├── studio.db-wal # WAL file +│ ├── studio.db-shm # Shared memory +│ └── kanban/ +│ ├── plans/ # AI-generated plans +│ └── reviews/ # AI-generated reviews +├── .git/ or .jj/ # VCS +└── ... # Project files +``` + +## Frontend Integration + +The frontend needs to: + +1. **On load**: Call `GET /api/projects/current` + - If project → show main UI + - If null → show project picker + +2. **Project picker UI**: + - List recent projects from `GET /api/projects/recent` + - Folder picker button (uses native file dialog via Tauri or similar) + - Call `POST /api/projects/open` on selection + +3. **Project switch**: + - Show loading state during switch + - Invalidate all React Query caches on project change + - Re-subscribe WebSocket with new context + +4. **Handle WebSocket `project_changed` event**: + - Refresh all data + - Update UI to reflect new project + +## Testing Strategy + +1. **Unit tests**: `ProjectManager` with mock filesystem +2. **Integration tests**: Full open/switch/close cycle +3. **Concurrency tests**: Multiple rapid switches +4. **Cleanup tests**: Verify DB connections closed properly + +## Open Questions + +1. **Multiple simultaneous projects?** - Current design is single-project. Multi-project would need separate task executor instances per project, more complex. + +2. **Remote projects?** - Git clone from URL? Future enhancement. + +3. **Project templates?** - Pre-configured `.opencode-studio/` structures? Future enhancement. diff --git a/frontend/.env.example b/frontend/.env.example deleted file mode 100644 index db1c402..0000000 --- a/frontend/.env.example +++ /dev/null @@ -1,14 +0,0 @@ -# Since the ".env" file is gitignored, you can use the ".env.example" file to -# build a new ".env" file when you clone the repo. Keep this file up-to-date -# when you add new variables to `.env`. - -# This file will be committed to version control, so make sure not to have any -# secrets in it. If you are cloning this repo, create a copy of this file named -# ".env" and populate it with your secrets. - -# When adding additional environment variables, the schema in "/src/env.js" -# should be updated accordingly. - -# Prisma -# https://www.prisma.io/docs/reference/database-reference/connection-urls#env -DATABASE_URL="file:./db.sqlite" diff --git a/frontend/.gitignore b/frontend/.gitignore deleted file mode 100644 index c24a835..0000000 --- a/frontend/.gitignore +++ /dev/null @@ -1,46 +0,0 @@ -# See https://help.github.com/articles/ignoring-files/ for more about ignoring files. - -# dependencies -/node_modules -/.pnp -.pnp.js - -# testing -/coverage - -# database -/prisma/db.sqlite -/prisma/db.sqlite-journal -db.sqlite - -# next.js -/.next/ -/out/ -next-env.d.ts - -# production -/build - -# misc -.DS_Store -*.pem - -# debug -npm-debug.log* -yarn-debug.log* -yarn-error.log* -.pnpm-debug.log* - -# local env files -# do not commit any .env files to git, except for the .env.example file. https://create.t3.gg/en/usage/env-variables#using-environment-variables -.env -.env*.local - -# vercel -.vercel - -# typescript -*.tsbuildinfo - -# idea files -.idea \ No newline at end of file diff --git a/frontend/AGENTS.md b/frontend/AGENTS.md new file mode 100644 index 0000000..d9acf8b --- /dev/null +++ b/frontend/AGENTS.md @@ -0,0 +1,102 @@ +# OpenCode Studio: Frontend + +## OVERVIEW + +React + Vite SPA. React Query for server state, Zustand for client state, Orval-generated API hooks. + +## STRUCTURE + +``` +frontend/src/ +├── api/generated/ # Orval-generated React Query hooks (DO NOT EDIT) +├── components/ # Feature-based organization +│ ├── ui/ # Shared primitives (shadcn/ui) +│ ├── kanban/ # KanbanView, KanbanColumn, TaskCard +│ ├── sessions/ # SessionCard, SessionsList +│ ├── task-detail/ # TaskDetailPanel +│ ├── activity/ # ActivityFeed, ActivityItem +│ └── dialogs/ # CreateTaskDialog, ProjectPickerDialog +├── hooks/ # Custom hooks (SSE, real-time) +├── stores/ # Zustand stores (project, sidebar) +├── lib/ # Utilities (api-fetcher, modals) +└── types/generated/ # ts-rs generated types (DO NOT EDIT) +``` + +## WHERE TO LOOK + +| Task | Location | +|:-----|:---------| +| Add UI component | `components/ui/` (shadcn pattern) | +| Add feature component | `components/{feature}/` | +| Add API hook | Regenerate: `pnpm generate:api` | +| Add client state | `stores/use{Name}Store.ts` | +| Add SSE hook | `hooks/useEventStream.ts` pattern | + +## PATTERNS + +**State Management:** +- Server state → React Query (via Orval hooks) +- Client state → Zustand stores +- SSE events → Custom hooks with auto-reconnect + +**Component Pattern:** +```tsx +// Feature component +export function TaskCard({ task }: { task: Task }) { + const { data, isLoading } = useGetTask(task.id); + const mutation = useUpdateTask(); + // ... +} +``` + +**SSE Pattern:** +```tsx +const { isConnected } = useEventStream({ + onEvent: (event) => { + if (event.type === "TaskStatusChanged") { + queryClient.invalidateQueries({ queryKey: ["tasks"] }); + } + } +}); +``` + +## CONVENTIONS + +- Biome: Tabs, 100 chars, double quotes, trailing commas +- Named exports only (no default except pages/configs) +- `useImportType` / `useExportType` enforced +- No barrel files (direct imports only) + +## ANTI-PATTERNS + +- `as any`, `@ts-ignore`, `@ts-expect-error` → NEVER +- `console.log` → use proper logging or remove +- Empty catch blocks → handle errors explicitly +- Floating promises → always await or void +- Editing `api/generated/` or `types/generated/` → regenerate instead + +## GENERATED CODE + +Two sources of generated code (never edit directly): + +| Source | Output | Regenerate | +|:-------|:-------|:-----------| +| OpenAPI spec | `api/generated/` | `pnpm generate:api` | +| Rust types (ts-rs) | `types/generated/` | Backend build | + +## COMMANDS + +```bash +pnpm dev # Vite dev server +pnpm build # Production build +pnpm generate:api # Regenerate API hooks from OpenAPI +pnpm lint # Biome check +``` + +## DEPS + +- `@tanstack/react-query` - Server state +- `zustand` - Client state +- `@nice-modal-react` - Modal management +- `tailwindcss` - Styling +- `shadcn/ui` - Component primitives diff --git a/frontend/README.md b/frontend/README.md deleted file mode 100644 index 67943c7..0000000 --- a/frontend/README.md +++ /dev/null @@ -1,29 +0,0 @@ -# Create T3 App - -This is a [T3 Stack](https://create.t3.gg/) project bootstrapped with `create-t3-app`. - -## What's next? How do I make an app with this? - -We try to keep this project as simple as possible, so you can start with just the scaffolding we set up for you, and add additional things later when they become necessary. - -If you are not familiar with the different technologies used in this project, please refer to the respective docs. If you still are in the wind, please join our [Discord](https://t3.gg/discord) and ask for help. - -- [Next.js](https://nextjs.org) -- [NextAuth.js](https://next-auth.js.org) -- [Prisma](https://prisma.io) -- [Drizzle](https://orm.drizzle.team) -- [Tailwind CSS](https://tailwindcss.com) -- [tRPC](https://trpc.io) - -## Learn More - -To learn more about the [T3 Stack](https://create.t3.gg/), take a look at the following resources: - -- [Documentation](https://create.t3.gg/) -- [Learn the T3 Stack](https://create.t3.gg/en/faq#what-learning-resources-are-currently-available) — Check out these awesome tutorials - -You can check out the [create-t3-app GitHub repository](https://github.com/t3-oss/create-t3-app) — your feedback and contributions are welcome! - -## How do I deploy this? - -Follow our deployment guides for [Vercel](https://create.t3.gg/en/deployment/vercel), [Netlify](https://create.t3.gg/en/deployment/netlify) and [Docker](https://create.t3.gg/en/deployment/docker) for more information. diff --git a/frontend/app/globals.css b/frontend/app/globals.css deleted file mode 100644 index 4230384..0000000 --- a/frontend/app/globals.css +++ /dev/null @@ -1,101 +0,0 @@ -@import "tailwindcss"; -@import "tw-animate-css"; - -@custom-variant dark (&:is(.dark *)); - -@theme inline { - --font-sans: "Inter", sans-serif; - --font-mono: "JetBrains Mono", monospace; - --color-background: var(--background); - --color-foreground: var(--foreground); - --color-card: var(--card); - --color-card-foreground: var(--card-foreground); - --color-popover: var(--popover); - --color-popover-foreground: var(--popover-foreground); - --color-primary: var(--primary); - --color-primary-foreground: var(--primary-foreground); - --color-secondary: var(--secondary); - --color-secondary-foreground: var(--secondary-foreground); - --color-muted: var(--muted); - --color-muted-foreground: var(--muted-foreground); - --color-accent: var(--accent); - --color-accent-foreground: var(--accent-foreground); - --color-destructive: var(--destructive); - --color-destructive-foreground: var(--destructive-foreground); - --color-border: var(--border); - --color-input: var(--input); - --color-ring: var(--ring); - --color-chart-1: var(--chart-1); - --color-chart-2: var(--chart-2); - --color-chart-3: var(--chart-3); - --color-chart-4: var(--chart-4); - --color-chart-5: var(--chart-5); - --color-sidebar: var(--sidebar); - --color-sidebar-foreground: var(--sidebar-foreground); - --color-sidebar-primary: var(--sidebar-primary); - --color-sidebar-primary-foreground: var(--sidebar-primary-foreground); - --color-sidebar-accent: var(--sidebar-accent); - --color-sidebar-accent-foreground: var(--sidebar-accent-foreground); - --color-sidebar-border: var(--sidebar-border); - --color-sidebar-ring: var(--sidebar-ring); - --color-success: var(--success); - --color-success-foreground: var(--success-foreground); - --color-warning: var(--warning); - --color-warning-foreground: var(--warning-foreground); - --radius-sm: calc(var(--radius) - 4px); - --radius-md: calc(var(--radius) - 2px); - --radius-lg: var(--radius); - --radius-xl: calc(var(--radius) + 4px); - --radius-2xl: calc(var(--radius) + 8px); - --radius-3xl: calc(var(--radius) + 12px); - --radius-4xl: calc(var(--radius) + 16px); -} - -:root { - --background: oklch(0.09 0 0); - --foreground: oklch(0.95 0 0); - --card: oklch(0.13 0 0); - --card-foreground: oklch(0.95 0 0); - --popover: oklch(0.13 0 0); - --popover-foreground: oklch(0.95 0 0); - --primary: oklch(0.75 0.18 145); - --primary-foreground: oklch(0.09 0 0); - --secondary: oklch(0.18 0 0); - --secondary-foreground: oklch(0.95 0 0); - --muted: oklch(0.18 0 0); - --muted-foreground: oklch(0.55 0 0); - --accent: oklch(0.22 0 0); - --accent-foreground: oklch(0.95 0 0); - --destructive: oklch(0.65 0.2 25); - --destructive-foreground: oklch(0.95 0 0); - --success: oklch(0.75 0.18 145); - --success-foreground: oklch(0.09 0 0); - --warning: oklch(0.8 0.15 85); - --warning-foreground: oklch(0.09 0 0); - --border: oklch(0.22 0 0); - --input: oklch(0.18 0 0); - --ring: oklch(0.75 0.18 145); - --chart-1: oklch(0.75 0.18 145); - --chart-2: oklch(0.7 0.15 250); - --chart-3: oklch(0.8 0.15 85); - --chart-4: oklch(0.65 0.2 25); - --chart-5: oklch(0.7 0.15 300); - --radius: 0.5rem; - --sidebar: oklch(0.11 0 0); - --sidebar-foreground: oklch(0.95 0 0); - --sidebar-primary: oklch(0.75 0.18 145); - --sidebar-primary-foreground: oklch(0.09 0 0); - --sidebar-accent: oklch(0.18 0 0); - --sidebar-accent-foreground: oklch(0.95 0 0); - --sidebar-border: oklch(0.22 0 0); - --sidebar-ring: oklch(0.75 0.18 145); -} - -@layer base { - * { - @apply border-border outline-ring/50; - } - body { - @apply bg-background text-foreground; - } -} diff --git a/frontend/components.json b/frontend/components.json deleted file mode 100644 index 506c339..0000000 --- a/frontend/components.json +++ /dev/null @@ -1 +0,0 @@ -{"$schema":"https://ui.shadcn.com/schema.json","style":"new-york","rsc":true,"tsx":true,"tailwind":{"config":"","css":"src/styles/globals.css","baseColor":"neutral","cssVariables":true},"aliases":{"components":"~/components","utils":"~/lib/utils","ui":"~/components/ui","lib":"~/lib","hooks":"~/hooks"},"iconLibrary":"lucide"} diff --git a/frontend/frontend/src/types/generated/AgentMessageData.ts b/frontend/frontend/src/types/generated/AgentMessageData.ts new file mode 100644 index 0000000..42d2fd3 --- /dev/null +++ b/frontend/frontend/src/types/generated/AgentMessageData.ts @@ -0,0 +1,15 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. + +export type AgentMessageData = { +/** + * The message content + */ +content: string, +/** + * Message role (assistant, user, system) + */ +role: string, +/** + * Whether this is a partial/streaming message + */ +is_partial: boolean, }; diff --git a/frontend/frontend/src/types/generated/ConflictFile.ts b/frontend/frontend/src/types/generated/ConflictFile.ts new file mode 100644 index 0000000..3e5feb2 --- /dev/null +++ b/frontend/frontend/src/types/generated/ConflictFile.ts @@ -0,0 +1,4 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. +import type { ConflictType } from "./ConflictType"; + +export type ConflictFile = { path: string, conflict_type: ConflictType, }; diff --git a/frontend/frontend/src/types/generated/ConflictType.ts b/frontend/frontend/src/types/generated/ConflictType.ts new file mode 100644 index 0000000..643c81d --- /dev/null +++ b/frontend/frontend/src/types/generated/ConflictType.ts @@ -0,0 +1,3 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. + +export type ConflictType = "content" | "add_add" | "modify_delete" | "delete_modify" | "rename"; diff --git a/frontend/frontend/src/types/generated/CreateTaskRequest.ts b/frontend/frontend/src/types/generated/CreateTaskRequest.ts new file mode 100644 index 0000000..a4aa840 --- /dev/null +++ b/frontend/frontend/src/types/generated/CreateTaskRequest.ts @@ -0,0 +1,3 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. + +export type CreateTaskRequest = { title: string, description: string, roadmap_item_id: string | null, }; diff --git a/frontend/src/types/generated/SubscriptionFilter.ts b/frontend/frontend/src/types/generated/DiffResponse.ts similarity index 61% rename from frontend/src/types/generated/SubscriptionFilter.ts rename to frontend/frontend/src/types/generated/DiffResponse.ts index bbc1d67..41790c4 100644 --- a/frontend/src/types/generated/SubscriptionFilter.ts +++ b/frontend/frontend/src/types/generated/DiffResponse.ts @@ -1,3 +1,3 @@ // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. -export type SubscriptionFilter = { task_ids: Array | null, }; +export type DiffResponse = { task_id: string, diff: string, }; diff --git a/frontend/frontend/src/types/generated/Event.ts b/frontend/frontend/src/types/generated/Event.ts new file mode 100644 index 0000000..ff923c7 --- /dev/null +++ b/frontend/frontend/src/types/generated/Event.ts @@ -0,0 +1,5 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. +import type { AgentMessageData } from "./AgentMessageData"; +import type { ToolExecutionData } from "./ToolExecutionData"; + +export type Event = { "type": "task.created", task_id: string, title: string, } | { "type": "task.updated", task_id: string, } | { "type": "task.status_changed", task_id: string, from_status: string, to_status: string, } | { "type": "session.started", session_id: string, task_id: string, } | { "type": "session.ended", session_id: string, task_id: string, success: boolean, } | { "type": "agent.message", session_id: string, task_id: string, message: AgentMessageData, } | { "type": "tool.execution", session_id: string, task_id: string, tool: ToolExecutionData, } | { "type": "workspace.created", task_id: string, path: string, } | { "type": "workspace.merged", task_id: string, success: boolean, } | { "type": "workspace.deleted", task_id: string, } | { "type": "project.opened", path: string, name: string, was_initialized: boolean, } | { "type": "project.closed", path: string, } | { "type": "error", message: string, context: string | null, }; diff --git a/frontend/frontend/src/types/generated/EventEnvelope.ts b/frontend/frontend/src/types/generated/EventEnvelope.ts new file mode 100644 index 0000000..2df75cf --- /dev/null +++ b/frontend/frontend/src/types/generated/EventEnvelope.ts @@ -0,0 +1,16 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. +import type { Event } from "./Event"; + +export type EventEnvelope = { +/** + * Unique event ID + */ +id: string, +/** + * When the event occurred + */ +timestamp: string, +/** + * The actual event + */ +event: Event, }; diff --git a/frontend/frontend/src/types/generated/ExecuteResponse.ts b/frontend/frontend/src/types/generated/ExecuteResponse.ts new file mode 100644 index 0000000..b81a6ec --- /dev/null +++ b/frontend/frontend/src/types/generated/ExecuteResponse.ts @@ -0,0 +1,5 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. +import type { PhaseResultDto } from "./PhaseResultDto"; +import type { Task } from "./Task"; + +export type ExecuteResponse = { task: Task, result: PhaseResultDto, }; diff --git a/frontend/frontend/src/types/generated/MergeRequest.ts b/frontend/frontend/src/types/generated/MergeRequest.ts new file mode 100644 index 0000000..ba1398e --- /dev/null +++ b/frontend/frontend/src/types/generated/MergeRequest.ts @@ -0,0 +1,3 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. + +export type MergeRequest = { message: string, }; diff --git a/frontend/frontend/src/types/generated/MergeResponse.ts b/frontend/frontend/src/types/generated/MergeResponse.ts new file mode 100644 index 0000000..5a4462e --- /dev/null +++ b/frontend/frontend/src/types/generated/MergeResponse.ts @@ -0,0 +1,3 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. + +export type MergeResponse = { "result": "success" } | { "result": "conflicts", files: Array, }; diff --git a/frontend/frontend/src/types/generated/MergeResult.ts b/frontend/frontend/src/types/generated/MergeResult.ts new file mode 100644 index 0000000..2dc1605 --- /dev/null +++ b/frontend/frontend/src/types/generated/MergeResult.ts @@ -0,0 +1,4 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. +import type { ConflictFile } from "./ConflictFile"; + +export type MergeResult = { "status": "success" } | { "status": "conflicts", files: Array, }; diff --git a/frontend/frontend/src/types/generated/PhaseResultDto.ts b/frontend/frontend/src/types/generated/PhaseResultDto.ts new file mode 100644 index 0000000..45d6e47 --- /dev/null +++ b/frontend/frontend/src/types/generated/PhaseResultDto.ts @@ -0,0 +1,3 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. + +export type PhaseResultDto = { "type": "session_created", session_id: string, } | { "type": "plan_created", session_id: string, plan_path: string, } | { "type": "awaiting_approval", phase: string, } | { "type": "review_passed", session_id: string, } | { "type": "review_failed", session_id: string, feedback: string, iteration: number, } | { "type": "max_iterations_exceeded", iterations: number, } | { "type": "completed" }; diff --git a/frontend/frontend/src/types/generated/Session.ts b/frontend/frontend/src/types/generated/Session.ts new file mode 100644 index 0000000..da5c9fd --- /dev/null +++ b/frontend/frontend/src/types/generated/Session.ts @@ -0,0 +1,5 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. +import type { SessionPhase } from "./SessionPhase"; +import type { SessionStatus } from "./SessionStatus"; + +export type Session = { id: string, task_id: string, opencode_session_id: string | null, phase: SessionPhase, status: SessionStatus, started_at: string | null, completed_at: string | null, created_at: string, }; diff --git a/frontend/frontend/src/types/generated/SessionActivityMsg.ts b/frontend/frontend/src/types/generated/SessionActivityMsg.ts new file mode 100644 index 0000000..ca90c04 --- /dev/null +++ b/frontend/frontend/src/types/generated/SessionActivityMsg.ts @@ -0,0 +1,3 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. + +export type SessionActivityMsg = { "type": "tool_call", id: string, tool_name: string, args: Record | null, timestamp: string, } | { "type": "tool_result", id: string, tool_name: string, args: Record | null, result: string, success: boolean, timestamp: string, } | { "type": "agent_message", id: string, content: string, is_partial: boolean, timestamp: string, } | { "type": "reasoning", id: string, content: string, timestamp: string, } | { "type": "step_start", id: string, step_name: string | null, timestamp: string, } | { "type": "json_patch", patch: unknown[], timestamp: string, } | { "type": "finished", success: boolean, error: string | null, timestamp: string, }; diff --git a/frontend/frontend/src/types/generated/SessionPhase.ts b/frontend/frontend/src/types/generated/SessionPhase.ts new file mode 100644 index 0000000..3ac6f50 --- /dev/null +++ b/frontend/frontend/src/types/generated/SessionPhase.ts @@ -0,0 +1,3 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. + +export type SessionPhase = "planning" | "implementation" | "review"; diff --git a/frontend/frontend/src/types/generated/SessionStatus.ts b/frontend/frontend/src/types/generated/SessionStatus.ts new file mode 100644 index 0000000..5509c39 --- /dev/null +++ b/frontend/frontend/src/types/generated/SessionStatus.ts @@ -0,0 +1,3 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. + +export type SessionStatus = "pending" | "running" | "completed" | "failed" | "aborted"; diff --git a/frontend/frontend/src/types/generated/Task.ts b/frontend/frontend/src/types/generated/Task.ts new file mode 100644 index 0000000..f228ed4 --- /dev/null +++ b/frontend/frontend/src/types/generated/Task.ts @@ -0,0 +1,4 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. +import type { TaskStatus } from "./TaskStatus"; + +export type Task = { id: string, title: string, description: string, status: TaskStatus, roadmap_item_id: string | null, workspace_path: string | null, created_at: string, updated_at: string, }; diff --git a/frontend/frontend/src/types/generated/TaskStatus.ts b/frontend/frontend/src/types/generated/TaskStatus.ts new file mode 100644 index 0000000..d2190e2 --- /dev/null +++ b/frontend/frontend/src/types/generated/TaskStatus.ts @@ -0,0 +1,3 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. + +export type TaskStatus = "todo" | "planning" | "planning_review" | "in_progress" | "ai_review" | "review" | "done"; diff --git a/frontend/frontend/src/types/generated/ToolExecutionData.ts b/frontend/frontend/src/types/generated/ToolExecutionData.ts new file mode 100644 index 0000000..ccd63f3 --- /dev/null +++ b/frontend/frontend/src/types/generated/ToolExecutionData.ts @@ -0,0 +1,19 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. + +export type ToolExecutionData = { +/** + * Tool name + */ +name: string, +/** + * Tool input (JSON string or summary) + */ +input: string | null, +/** + * Tool output (truncated if large) + */ +output: string | null, +/** + * Whether the tool succeeded + */ +success: boolean, }; diff --git a/frontend/frontend/src/types/generated/TransitionRequest.ts b/frontend/frontend/src/types/generated/TransitionRequest.ts new file mode 100644 index 0000000..a258441 --- /dev/null +++ b/frontend/frontend/src/types/generated/TransitionRequest.ts @@ -0,0 +1,4 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. +import type { TaskStatus } from "./TaskStatus"; + +export type TransitionRequest = { status: TaskStatus, }; diff --git a/frontend/frontend/src/types/generated/TransitionResponse.ts b/frontend/frontend/src/types/generated/TransitionResponse.ts new file mode 100644 index 0000000..cb341ba --- /dev/null +++ b/frontend/frontend/src/types/generated/TransitionResponse.ts @@ -0,0 +1,5 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. +import type { Task } from "./Task"; +import type { TaskStatus } from "./TaskStatus"; + +export type TransitionResponse = { task: Task, previous_status: TaskStatus, }; diff --git a/frontend/frontend/src/types/generated/UpdateTaskRequest.ts b/frontend/frontend/src/types/generated/UpdateTaskRequest.ts new file mode 100644 index 0000000..8864df2 --- /dev/null +++ b/frontend/frontend/src/types/generated/UpdateTaskRequest.ts @@ -0,0 +1,4 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. +import type { TaskStatus } from "./TaskStatus"; + +export type UpdateTaskRequest = { title: string | null, description: string | null, status: TaskStatus | null, workspace_path: string | null, }; diff --git a/frontend/frontend/src/types/generated/Workspace.ts b/frontend/frontend/src/types/generated/Workspace.ts new file mode 100644 index 0000000..c0cdfe4 --- /dev/null +++ b/frontend/frontend/src/types/generated/Workspace.ts @@ -0,0 +1,4 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. +import type { WorkspaceStatus } from "./WorkspaceStatus"; + +export type Workspace = { task_id: string, path: string, branch_name: string, status: WorkspaceStatus, created_at: string, }; diff --git a/frontend/frontend/src/types/generated/WorkspaceResponse.ts b/frontend/frontend/src/types/generated/WorkspaceResponse.ts new file mode 100644 index 0000000..3644109 --- /dev/null +++ b/frontend/frontend/src/types/generated/WorkspaceResponse.ts @@ -0,0 +1,3 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. + +export type WorkspaceResponse = { task_id: string, path: string, branch_name: string, status: string, created_at: string, }; diff --git a/frontend/frontend/src/types/generated/WorkspaceStatus.ts b/frontend/frontend/src/types/generated/WorkspaceStatus.ts new file mode 100644 index 0000000..0bbbac9 --- /dev/null +++ b/frontend/frontend/src/types/generated/WorkspaceStatus.ts @@ -0,0 +1,3 @@ +// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually. + +export type WorkspaceStatus = "active" | "merged" | "abandoned"; diff --git a/frontend/frontend/src/types/generated/index.ts b/frontend/frontend/src/types/generated/index.ts new file mode 100644 index 0000000..9ae24e7 --- /dev/null +++ b/frontend/frontend/src/types/generated/index.ts @@ -0,0 +1,31 @@ +// Auto-generated - regenerate with: cargo run --package server --bin generate-types --features typescript + +export * from './Task'; +export * from './TaskStatus'; +export * from './CreateTaskRequest'; +export * from './UpdateTaskRequest'; +export * from './Session'; +export * from './SessionPhase'; +export * from './SessionStatus'; + +export * from './EventEnvelope'; +export * from './Event'; +export * from './AgentMessageData'; +export * from './ToolExecutionData'; + +export * from './Workspace'; +export * from './WorkspaceStatus'; +export * from './MergeResult'; +export * from './ConflictFile'; +export * from './ConflictType'; + +export * from './TransitionRequest'; +export * from './TransitionResponse'; +export * from './ExecuteResponse'; +export * from './PhaseResultDto'; +export * from './WorkspaceResponse'; +export * from './DiffResponse'; +export * from './MergeRequest'; +export * from './MergeResponse'; + +export * from './SessionActivityMsg'; diff --git a/frontend/generated/prisma/client.d.ts b/frontend/generated/prisma/client.d.ts deleted file mode 100644 index bc20c6c..0000000 --- a/frontend/generated/prisma/client.d.ts +++ /dev/null @@ -1 +0,0 @@ -export * from "./index" \ No newline at end of file diff --git a/frontend/generated/prisma/client.js b/frontend/generated/prisma/client.js deleted file mode 100644 index 6ac8a81..0000000 --- a/frontend/generated/prisma/client.js +++ /dev/null @@ -1,5 +0,0 @@ - -/* !!! This is code generated by Prisma. Do not edit directly. !!! -/* eslint-disable */ -// biome-ignore-all lint: generated file -module.exports = { ...require('.') } \ No newline at end of file diff --git a/frontend/generated/prisma/default.d.ts b/frontend/generated/prisma/default.d.ts deleted file mode 100644 index bc20c6c..0000000 --- a/frontend/generated/prisma/default.d.ts +++ /dev/null @@ -1 +0,0 @@ -export * from "./index" \ No newline at end of file diff --git a/frontend/generated/prisma/default.js b/frontend/generated/prisma/default.js deleted file mode 100644 index eb55675..0000000 --- a/frontend/generated/prisma/default.js +++ /dev/null @@ -1,5 +0,0 @@ - -/* !!! This is code generated by Prisma. Do not edit directly. !!! -/* eslint-disable */ -// biome-ignore-all lint: generated file -module.exports = { ...require('#main-entry-point') } \ No newline at end of file diff --git a/frontend/generated/prisma/edge.d.ts b/frontend/generated/prisma/edge.d.ts deleted file mode 100644 index 274b8fa..0000000 --- a/frontend/generated/prisma/edge.d.ts +++ /dev/null @@ -1 +0,0 @@ -export * from "./default" \ No newline at end of file diff --git a/frontend/generated/prisma/edge.js b/frontend/generated/prisma/edge.js deleted file mode 100644 index 77b01bf..0000000 --- a/frontend/generated/prisma/edge.js +++ /dev/null @@ -1,181 +0,0 @@ - -/* !!! This is code generated by Prisma. Do not edit directly. !!! -/* eslint-disable */ -// biome-ignore-all lint: generated file - -Object.defineProperty(exports, "__esModule", { value: true }); - -const { - PrismaClientKnownRequestError, - PrismaClientUnknownRequestError, - PrismaClientRustPanicError, - PrismaClientInitializationError, - PrismaClientValidationError, - getPrismaClient, - sqltag, - empty, - join, - raw, - skip, - Decimal, - Debug, - objectEnumValues, - makeStrictEnum, - Extensions, - warnOnce, - defineDmmfProperty, - Public, - getRuntime, - createParam, -} = require('./runtime/edge.js') - - -const Prisma = {} - -exports.Prisma = Prisma -exports.$Enums = {} - -/** - * Prisma Client JS version: 6.19.1 - * Query Engine version: c2990dca591cba766e3b7ef5d9e8a84796e47ab7 - */ -Prisma.prismaVersion = { - client: "6.19.1", - engine: "c2990dca591cba766e3b7ef5d9e8a84796e47ab7" -} - -Prisma.PrismaClientKnownRequestError = PrismaClientKnownRequestError; -Prisma.PrismaClientUnknownRequestError = PrismaClientUnknownRequestError -Prisma.PrismaClientRustPanicError = PrismaClientRustPanicError -Prisma.PrismaClientInitializationError = PrismaClientInitializationError -Prisma.PrismaClientValidationError = PrismaClientValidationError -Prisma.Decimal = Decimal - -/** - * Re-export of sql-template-tag - */ -Prisma.sql = sqltag -Prisma.empty = empty -Prisma.join = join -Prisma.raw = raw -Prisma.validator = Public.validator - -/** -* Extensions -*/ -Prisma.getExtensionContext = Extensions.getExtensionContext -Prisma.defineExtension = Extensions.defineExtension - -/** - * Shorthand utilities for JSON filtering - */ -Prisma.DbNull = objectEnumValues.instances.DbNull -Prisma.JsonNull = objectEnumValues.instances.JsonNull -Prisma.AnyNull = objectEnumValues.instances.AnyNull - -Prisma.NullTypes = { - DbNull: objectEnumValues.classes.DbNull, - JsonNull: objectEnumValues.classes.JsonNull, - AnyNull: objectEnumValues.classes.AnyNull -} - - - - - -/** - * Enums - */ -exports.Prisma.TransactionIsolationLevel = makeStrictEnum({ - Serializable: 'Serializable' -}); - -exports.Prisma.PostScalarFieldEnum = { - id: 'id', - name: 'name', - createdAt: 'createdAt', - updatedAt: 'updatedAt' -}; - -exports.Prisma.SortOrder = { - asc: 'asc', - desc: 'desc' -}; - - -exports.Prisma.ModelName = { - Post: 'Post' -}; -/** - * Create the Client - */ -const config = { - "generator": { - "name": "client", - "provider": { - "fromEnvVar": null, - "value": "prisma-client-js" - }, - "output": { - "value": "/Users/pavelsoukup/DEV/opencode-os/frontend/generated/prisma", - "fromEnvVar": null - }, - "config": { - "engineType": "library" - }, - "binaryTargets": [ - { - "fromEnvVar": null, - "value": "darwin-arm64", - "native": true - } - ], - "previewFeatures": [], - "sourceFilePath": "/Users/pavelsoukup/DEV/opencode-os/frontend/prisma/schema.prisma", - "isCustomOutput": true - }, - "relativeEnvPaths": { - "rootEnvPath": null, - "schemaEnvPath": "../../.env" - }, - "relativePath": "../../prisma", - "clientVersion": "6.19.1", - "engineVersion": "c2990dca591cba766e3b7ef5d9e8a84796e47ab7", - "datasourceNames": [ - "db" - ], - "activeProvider": "sqlite", - "postinstall": false, - "inlineDatasources": { - "db": { - "url": { - "fromEnvVar": "DATABASE_URL", - "value": null - } - } - }, - "inlineSchema": "// This is your Prisma schema file,\n// learn more about it in the docs: https://pris.ly/d/prisma-schema\n\ngenerator client {\n provider = \"prisma-client-js\"\n output = \"../generated/prisma\"\n}\n\ndatasource db {\n provider = \"sqlite\"\n url = env(\"DATABASE_URL\")\n}\n\nmodel Post {\n id Int @id @default(autoincrement())\n name String\n createdAt DateTime @default(now())\n updatedAt DateTime @updatedAt\n\n @@index([name])\n}\n", - "inlineSchemaHash": "6173f79f1f1e8cae300b91aa9403ded205a6c79085b2f8c48fed8dd26c8c16cc", - "copyEngine": true -} -config.dirname = '/' - -config.runtimeDataModel = JSON.parse("{\"models\":{\"Post\":{\"dbName\":null,\"schema\":null,\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"isList\":false,\"isRequired\":true,\"isUnique\":false,\"isId\":true,\"isReadOnly\":false,\"hasDefaultValue\":true,\"type\":\"Int\",\"nativeType\":null,\"default\":{\"name\":\"autoincrement\",\"args\":[]},\"isGenerated\":false,\"isUpdatedAt\":false},{\"name\":\"name\",\"kind\":\"scalar\",\"isList\":false,\"isRequired\":true,\"isUnique\":false,\"isId\":false,\"isReadOnly\":false,\"hasDefaultValue\":false,\"type\":\"String\",\"nativeType\":null,\"isGenerated\":false,\"isUpdatedAt\":false},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"isList\":false,\"isRequired\":true,\"isUnique\":false,\"isId\":false,\"isReadOnly\":false,\"hasDefaultValue\":true,\"type\":\"DateTime\",\"nativeType\":null,\"default\":{\"name\":\"now\",\"args\":[]},\"isGenerated\":false,\"isUpdatedAt\":false},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"isList\":false,\"isRequired\":true,\"isUnique\":false,\"isId\":false,\"isReadOnly\":false,\"hasDefaultValue\":false,\"type\":\"DateTime\",\"nativeType\":null,\"isGenerated\":false,\"isUpdatedAt\":true}],\"primaryKey\":null,\"uniqueFields\":[],\"uniqueIndexes\":[],\"isGenerated\":false}},\"enums\":{},\"types\":{}}") -defineDmmfProperty(exports.Prisma, config.runtimeDataModel) -config.engineWasm = undefined -config.compilerWasm = undefined - -config.injectableEdgeEnv = () => ({ - parsed: { - DATABASE_URL: typeof globalThis !== 'undefined' && globalThis['DATABASE_URL'] || typeof process !== 'undefined' && process.env && process.env.DATABASE_URL || undefined - } -}) - -if (typeof globalThis !== 'undefined' && globalThis['DEBUG'] || typeof process !== 'undefined' && process.env && process.env.DEBUG || undefined) { - Debug.enable(typeof globalThis !== 'undefined' && globalThis['DEBUG'] || typeof process !== 'undefined' && process.env && process.env.DEBUG || undefined) -} - -const PrismaClient = getPrismaClient(config) -exports.PrismaClient = PrismaClient -Object.assign(exports, Prisma) - diff --git a/frontend/generated/prisma/index-browser.js b/frontend/generated/prisma/index-browser.js deleted file mode 100644 index 5f9b981..0000000 --- a/frontend/generated/prisma/index-browser.js +++ /dev/null @@ -1,167 +0,0 @@ - -/* !!! This is code generated by Prisma. Do not edit directly. !!! -/* eslint-disable */ -// biome-ignore-all lint: generated file - -Object.defineProperty(exports, "__esModule", { value: true }); - -const { - Decimal, - objectEnumValues, - makeStrictEnum, - Public, - getRuntime, - skip -} = require('./runtime/index-browser.js') - - -const Prisma = {} - -exports.Prisma = Prisma -exports.$Enums = {} - -/** - * Prisma Client JS version: 6.19.1 - * Query Engine version: c2990dca591cba766e3b7ef5d9e8a84796e47ab7 - */ -Prisma.prismaVersion = { - client: "6.19.1", - engine: "c2990dca591cba766e3b7ef5d9e8a84796e47ab7" -} - -Prisma.PrismaClientKnownRequestError = () => { - const runtimeName = getRuntime().prettyName; - throw new Error(`PrismaClientKnownRequestError is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}). -In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`, -)}; -Prisma.PrismaClientUnknownRequestError = () => { - const runtimeName = getRuntime().prettyName; - throw new Error(`PrismaClientUnknownRequestError is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}). -In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`, -)} -Prisma.PrismaClientRustPanicError = () => { - const runtimeName = getRuntime().prettyName; - throw new Error(`PrismaClientRustPanicError is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}). -In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`, -)} -Prisma.PrismaClientInitializationError = () => { - const runtimeName = getRuntime().prettyName; - throw new Error(`PrismaClientInitializationError is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}). -In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`, -)} -Prisma.PrismaClientValidationError = () => { - const runtimeName = getRuntime().prettyName; - throw new Error(`PrismaClientValidationError is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}). -In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`, -)} -Prisma.Decimal = Decimal - -/** - * Re-export of sql-template-tag - */ -Prisma.sql = () => { - const runtimeName = getRuntime().prettyName; - throw new Error(`sqltag is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}). -In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`, -)} -Prisma.empty = () => { - const runtimeName = getRuntime().prettyName; - throw new Error(`empty is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}). -In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`, -)} -Prisma.join = () => { - const runtimeName = getRuntime().prettyName; - throw new Error(`join is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}). -In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`, -)} -Prisma.raw = () => { - const runtimeName = getRuntime().prettyName; - throw new Error(`raw is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}). -In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`, -)} -Prisma.validator = Public.validator - -/** -* Extensions -*/ -Prisma.getExtensionContext = () => { - const runtimeName = getRuntime().prettyName; - throw new Error(`Extensions.getExtensionContext is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}). -In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`, -)} -Prisma.defineExtension = () => { - const runtimeName = getRuntime().prettyName; - throw new Error(`Extensions.defineExtension is unable to run in this browser environment, or has been bundled for the browser (running in ${runtimeName}). -In case this error is unexpected for you, please report it in https://pris.ly/prisma-prisma-bug-report`, -)} - -/** - * Shorthand utilities for JSON filtering - */ -Prisma.DbNull = objectEnumValues.instances.DbNull -Prisma.JsonNull = objectEnumValues.instances.JsonNull -Prisma.AnyNull = objectEnumValues.instances.AnyNull - -Prisma.NullTypes = { - DbNull: objectEnumValues.classes.DbNull, - JsonNull: objectEnumValues.classes.JsonNull, - AnyNull: objectEnumValues.classes.AnyNull -} - - - -/** - * Enums - */ - -exports.Prisma.TransactionIsolationLevel = makeStrictEnum({ - Serializable: 'Serializable' -}); - -exports.Prisma.PostScalarFieldEnum = { - id: 'id', - name: 'name', - createdAt: 'createdAt', - updatedAt: 'updatedAt' -}; - -exports.Prisma.SortOrder = { - asc: 'asc', - desc: 'desc' -}; - - -exports.Prisma.ModelName = { - Post: 'Post' -}; - -/** - * This is a stub Prisma Client that will error at runtime if called. - */ -class PrismaClient { - constructor() { - return new Proxy(this, { - get(target, prop) { - let message - const runtime = getRuntime() - if (runtime.isEdge) { - message = `PrismaClient is not configured to run in ${runtime.prettyName}. In order to run Prisma Client on edge runtime, either: -- Use Prisma Accelerate: https://pris.ly/d/accelerate -- Use Driver Adapters: https://pris.ly/d/driver-adapters -`; - } else { - message = 'PrismaClient is unable to run in this browser environment, or has been bundled for the browser (running in `' + runtime.prettyName + '`).' - } - - message += ` -If this is unexpected, please open an issue: https://pris.ly/prisma-prisma-bug-report` - - throw new Error(message) - } - }) - } -} - -exports.PrismaClient = PrismaClient - -Object.assign(exports, Prisma) diff --git a/frontend/generated/prisma/index.d.ts b/frontend/generated/prisma/index.d.ts deleted file mode 100644 index 19fe735..0000000 --- a/frontend/generated/prisma/index.d.ts +++ /dev/null @@ -1,2274 +0,0 @@ - -/** - * Client -**/ - -import * as runtime from './runtime/library.js'; -import $Types = runtime.Types // general types -import $Public = runtime.Types.Public -import $Utils = runtime.Types.Utils -import $Extensions = runtime.Types.Extensions -import $Result = runtime.Types.Result - -export type PrismaPromise = $Public.PrismaPromise - - -/** - * Model Post - * - */ -export type Post = $Result.DefaultSelection - -/** - * ## Prisma Client ʲˢ - * - * Type-safe database client for TypeScript & Node.js - * @example - * ``` - * const prisma = new PrismaClient() - * // Fetch zero or more Posts - * const posts = await prisma.post.findMany() - * ``` - * - * - * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client). - */ -export class PrismaClient< - ClientOptions extends Prisma.PrismaClientOptions = Prisma.PrismaClientOptions, - const U = 'log' extends keyof ClientOptions ? ClientOptions['log'] extends Array ? Prisma.GetEvents : never : never, - ExtArgs extends $Extensions.InternalArgs = $Extensions.DefaultArgs -> { - [K: symbol]: { types: Prisma.TypeMap['other'] } - - /** - * ## Prisma Client ʲˢ - * - * Type-safe database client for TypeScript & Node.js - * @example - * ``` - * const prisma = new PrismaClient() - * // Fetch zero or more Posts - * const posts = await prisma.post.findMany() - * ``` - * - * - * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client). - */ - - constructor(optionsArg ?: Prisma.Subset); - $on(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): PrismaClient; - - /** - * Connect with the database - */ - $connect(): $Utils.JsPromise; - - /** - * Disconnect from the database - */ - $disconnect(): $Utils.JsPromise; - -/** - * Executes a prepared raw query and returns the number of affected rows. - * @example - * ``` - * const result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};` - * ``` - * - * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access). - */ - $executeRaw(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise; - - /** - * Executes a raw query and returns the number of affected rows. - * Susceptible to SQL injections, see documentation. - * @example - * ``` - * const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com') - * ``` - * - * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access). - */ - $executeRawUnsafe(query: string, ...values: any[]): Prisma.PrismaPromise; - - /** - * Performs a prepared raw query and returns the `SELECT` data. - * @example - * ``` - * const result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};` - * ``` - * - * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access). - */ - $queryRaw(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise; - - /** - * Performs a raw query and returns the `SELECT` data. - * Susceptible to SQL injections, see documentation. - * @example - * ``` - * const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com') - * ``` - * - * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access). - */ - $queryRawUnsafe(query: string, ...values: any[]): Prisma.PrismaPromise; - - - /** - * Allows the running of a sequence of read/write operations that are guaranteed to either succeed or fail as a whole. - * @example - * ``` - * const [george, bob, alice] = await prisma.$transaction([ - * prisma.user.create({ data: { name: 'George' } }), - * prisma.user.create({ data: { name: 'Bob' } }), - * prisma.user.create({ data: { name: 'Alice' } }), - * ]) - * ``` - * - * Read more in our [docs](https://www.prisma.io/docs/concepts/components/prisma-client/transactions). - */ - $transaction

[]>(arg: [...P], options?: { isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise> - - $transaction(fn: (prisma: Omit) => $Utils.JsPromise, options?: { maxWait?: number, timeout?: number, isolationLevel?: Prisma.TransactionIsolationLevel }): $Utils.JsPromise - - - $extends: $Extensions.ExtendsHook<"extends", Prisma.TypeMapCb, ExtArgs, $Utils.Call, { - extArgs: ExtArgs - }>> - - /** - * `prisma.post`: Exposes CRUD operations for the **Post** model. - * Example usage: - * ```ts - * // Fetch zero or more Posts - * const posts = await prisma.post.findMany() - * ``` - */ - get post(): Prisma.PostDelegate; -} - -export namespace Prisma { - export import DMMF = runtime.DMMF - - export type PrismaPromise = $Public.PrismaPromise - - /** - * Validator - */ - export import validator = runtime.Public.validator - - /** - * Prisma Errors - */ - export import PrismaClientKnownRequestError = runtime.PrismaClientKnownRequestError - export import PrismaClientUnknownRequestError = runtime.PrismaClientUnknownRequestError - export import PrismaClientRustPanicError = runtime.PrismaClientRustPanicError - export import PrismaClientInitializationError = runtime.PrismaClientInitializationError - export import PrismaClientValidationError = runtime.PrismaClientValidationError - - /** - * Re-export of sql-template-tag - */ - export import sql = runtime.sqltag - export import empty = runtime.empty - export import join = runtime.join - export import raw = runtime.raw - export import Sql = runtime.Sql - - - - /** - * Decimal.js - */ - export import Decimal = runtime.Decimal - - export type DecimalJsLike = runtime.DecimalJsLike - - /** - * Metrics - */ - export type Metrics = runtime.Metrics - export type Metric = runtime.Metric - export type MetricHistogram = runtime.MetricHistogram - export type MetricHistogramBucket = runtime.MetricHistogramBucket - - /** - * Extensions - */ - export import Extension = $Extensions.UserArgs - export import getExtensionContext = runtime.Extensions.getExtensionContext - export import Args = $Public.Args - export import Payload = $Public.Payload - export import Result = $Public.Result - export import Exact = $Public.Exact - - /** - * Prisma Client JS version: 6.19.1 - * Query Engine version: c2990dca591cba766e3b7ef5d9e8a84796e47ab7 - */ - export type PrismaVersion = { - client: string - } - - export const prismaVersion: PrismaVersion - - /** - * Utility Types - */ - - - export import Bytes = runtime.Bytes - export import JsonObject = runtime.JsonObject - export import JsonArray = runtime.JsonArray - export import JsonValue = runtime.JsonValue - export import InputJsonObject = runtime.InputJsonObject - export import InputJsonArray = runtime.InputJsonArray - export import InputJsonValue = runtime.InputJsonValue - - /** - * Types of the values used to represent different kinds of `null` values when working with JSON fields. - * - * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field - */ - namespace NullTypes { - /** - * Type of `Prisma.DbNull`. - * - * You cannot use other instances of this class. Please use the `Prisma.DbNull` value. - * - * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field - */ - class DbNull { - private DbNull: never - private constructor() - } - - /** - * Type of `Prisma.JsonNull`. - * - * You cannot use other instances of this class. Please use the `Prisma.JsonNull` value. - * - * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field - */ - class JsonNull { - private JsonNull: never - private constructor() - } - - /** - * Type of `Prisma.AnyNull`. - * - * You cannot use other instances of this class. Please use the `Prisma.AnyNull` value. - * - * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field - */ - class AnyNull { - private AnyNull: never - private constructor() - } - } - - /** - * Helper for filtering JSON entries that have `null` on the database (empty on the db) - * - * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field - */ - export const DbNull: NullTypes.DbNull - - /** - * Helper for filtering JSON entries that have JSON `null` values (not empty on the db) - * - * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field - */ - export const JsonNull: NullTypes.JsonNull - - /** - * Helper for filtering JSON entries that are `Prisma.DbNull` or `Prisma.JsonNull` - * - * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-on-a-json-field - */ - export const AnyNull: NullTypes.AnyNull - - type SelectAndInclude = { - select: any - include: any - } - - type SelectAndOmit = { - select: any - omit: any - } - - /** - * Get the type of the value, that the Promise holds. - */ - export type PromiseType> = T extends PromiseLike ? U : T; - - /** - * Get the return type of a function which returns a Promise. - */ - export type PromiseReturnType $Utils.JsPromise> = PromiseType> - - /** - * From T, pick a set of properties whose keys are in the union K - */ - type Prisma__Pick = { - [P in K]: T[P]; - }; - - - export type Enumerable = T | Array; - - export type RequiredKeys = { - [K in keyof T]-?: {} extends Prisma__Pick ? never : K - }[keyof T] - - export type TruthyKeys = keyof { - [K in keyof T as T[K] extends false | undefined | null ? never : K]: K - } - - export type TrueKeys = TruthyKeys>> - - /** - * Subset - * @desc From `T` pick properties that exist in `U`. Simple version of Intersection - */ - export type Subset = { - [key in keyof T]: key extends keyof U ? T[key] : never; - }; - - /** - * SelectSubset - * @desc From `T` pick properties that exist in `U`. Simple version of Intersection. - * Additionally, it validates, if both select and include are present. If the case, it errors. - */ - export type SelectSubset = { - [key in keyof T]: key extends keyof U ? T[key] : never - } & - (T extends SelectAndInclude - ? 'Please either choose `select` or `include`.' - : T extends SelectAndOmit - ? 'Please either choose `select` or `omit`.' - : {}) - - /** - * Subset + Intersection - * @desc From `T` pick properties that exist in `U` and intersect `K` - */ - export type SubsetIntersection = { - [key in keyof T]: key extends keyof U ? T[key] : never - } & - K - - type Without = { [P in Exclude]?: never }; - - /** - * XOR is needed to have a real mutually exclusive union type - * https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types - */ - type XOR = - T extends object ? - U extends object ? - (Without & U) | (Without & T) - : U : T - - - /** - * Is T a Record? - */ - type IsObject = T extends Array - ? False - : T extends Date - ? False - : T extends Uint8Array - ? False - : T extends BigInt - ? False - : T extends object - ? True - : False - - - /** - * If it's T[], return T - */ - export type UnEnumerate = T extends Array ? U : T - - /** - * From ts-toolbelt - */ - - type __Either = Omit & - { - // Merge all but K - [P in K]: Prisma__Pick // With K possibilities - }[K] - - type EitherStrict = Strict<__Either> - - type EitherLoose = ComputeRaw<__Either> - - type _Either< - O extends object, - K extends Key, - strict extends Boolean - > = { - 1: EitherStrict - 0: EitherLoose - }[strict] - - type Either< - O extends object, - K extends Key, - strict extends Boolean = 1 - > = O extends unknown ? _Either : never - - export type Union = any - - type PatchUndefined = { - [K in keyof O]: O[K] extends undefined ? At : O[K] - } & {} - - /** Helper Types for "Merge" **/ - export type IntersectOf = ( - U extends unknown ? (k: U) => void : never - ) extends (k: infer I) => void - ? I - : never - - export type Overwrite = { - [K in keyof O]: K extends keyof O1 ? O1[K] : O[K]; - } & {}; - - type _Merge = IntersectOf; - }>>; - - type Key = string | number | symbol; - type AtBasic = K extends keyof O ? O[K] : never; - type AtStrict = O[K & keyof O]; - type AtLoose = O extends unknown ? AtStrict : never; - export type At = { - 1: AtStrict; - 0: AtLoose; - }[strict]; - - export type ComputeRaw = A extends Function ? A : { - [K in keyof A]: A[K]; - } & {}; - - export type OptionalFlat = { - [K in keyof O]?: O[K]; - } & {}; - - type _Record = { - [P in K]: T; - }; - - // cause typescript not to expand types and preserve names - type NoExpand = T extends unknown ? T : never; - - // this type assumes the passed object is entirely optional - type AtLeast = NoExpand< - O extends unknown - ? | (K extends keyof O ? { [P in K]: O[P] } & O : O) - | {[P in keyof O as P extends K ? P : never]-?: O[P]} & O - : never>; - - type _Strict = U extends unknown ? U & OptionalFlat<_Record, keyof U>, never>> : never; - - export type Strict = ComputeRaw<_Strict>; - /** End Helper Types for "Merge" **/ - - export type Merge = ComputeRaw<_Merge>>; - - /** - A [[Boolean]] - */ - export type Boolean = True | False - - // /** - // 1 - // */ - export type True = 1 - - /** - 0 - */ - export type False = 0 - - export type Not = { - 0: 1 - 1: 0 - }[B] - - export type Extends = [A1] extends [never] - ? 0 // anything `never` is false - : A1 extends A2 - ? 1 - : 0 - - export type Has = Not< - Extends, U1> - > - - export type Or = { - 0: { - 0: 0 - 1: 1 - } - 1: { - 0: 1 - 1: 1 - } - }[B1][B2] - - export type Keys = U extends unknown ? keyof U : never - - type Cast = A extends B ? A : B; - - export const type: unique symbol; - - - - /** - * Used by group by - */ - - export type GetScalarType = O extends object ? { - [P in keyof T]: P extends keyof O - ? O[P] - : never - } : never - - type FieldPaths< - T, - U = Omit - > = IsObject extends True ? U : T - - type GetHavingFields = { - [K in keyof T]: Or< - Or, Extends<'AND', K>>, - Extends<'NOT', K> - > extends True - ? // infer is only needed to not hit TS limit - // based on the brilliant idea of Pierre-Antoine Mills - // https://github.com/microsoft/TypeScript/issues/30188#issuecomment-478938437 - T[K] extends infer TK - ? GetHavingFields extends object ? Merge> : never> - : never - : {} extends FieldPaths - ? never - : K - }[keyof T] - - /** - * Convert tuple to union - */ - type _TupleToUnion = T extends (infer E)[] ? E : never - type TupleToUnion = _TupleToUnion - type MaybeTupleToUnion = T extends any[] ? TupleToUnion : T - - /** - * Like `Pick`, but additionally can also accept an array of keys - */ - type PickEnumerable | keyof T> = Prisma__Pick> - - /** - * Exclude all keys with underscores - */ - type ExcludeUnderscoreKeys = T extends `_${string}` ? never : T - - - export type FieldRef = runtime.FieldRef - - type FieldRefInputType = Model extends never ? never : FieldRef - - - export const ModelName: { - Post: 'Post' - }; - - export type ModelName = (typeof ModelName)[keyof typeof ModelName] - - - export type Datasources = { - db?: Datasource - } - - interface TypeMapCb extends $Utils.Fn<{extArgs: $Extensions.InternalArgs }, $Utils.Record> { - returns: Prisma.TypeMap - } - - export type TypeMap = { - globalOmitOptions: { - omit: GlobalOmitOptions - } - meta: { - modelProps: "post" - txIsolationLevel: Prisma.TransactionIsolationLevel - } - model: { - Post: { - payload: Prisma.$PostPayload - fields: Prisma.PostFieldRefs - operations: { - findUnique: { - args: Prisma.PostFindUniqueArgs - result: $Utils.PayloadToResult | null - } - findUniqueOrThrow: { - args: Prisma.PostFindUniqueOrThrowArgs - result: $Utils.PayloadToResult - } - findFirst: { - args: Prisma.PostFindFirstArgs - result: $Utils.PayloadToResult | null - } - findFirstOrThrow: { - args: Prisma.PostFindFirstOrThrowArgs - result: $Utils.PayloadToResult - } - findMany: { - args: Prisma.PostFindManyArgs - result: $Utils.PayloadToResult[] - } - create: { - args: Prisma.PostCreateArgs - result: $Utils.PayloadToResult - } - createMany: { - args: Prisma.PostCreateManyArgs - result: BatchPayload - } - createManyAndReturn: { - args: Prisma.PostCreateManyAndReturnArgs - result: $Utils.PayloadToResult[] - } - delete: { - args: Prisma.PostDeleteArgs - result: $Utils.PayloadToResult - } - update: { - args: Prisma.PostUpdateArgs - result: $Utils.PayloadToResult - } - deleteMany: { - args: Prisma.PostDeleteManyArgs - result: BatchPayload - } - updateMany: { - args: Prisma.PostUpdateManyArgs - result: BatchPayload - } - updateManyAndReturn: { - args: Prisma.PostUpdateManyAndReturnArgs - result: $Utils.PayloadToResult[] - } - upsert: { - args: Prisma.PostUpsertArgs - result: $Utils.PayloadToResult - } - aggregate: { - args: Prisma.PostAggregateArgs - result: $Utils.Optional - } - groupBy: { - args: Prisma.PostGroupByArgs - result: $Utils.Optional[] - } - count: { - args: Prisma.PostCountArgs - result: $Utils.Optional | number - } - } - } - } - } & { - other: { - payload: any - operations: { - $executeRaw: { - args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]], - result: any - } - $executeRawUnsafe: { - args: [query: string, ...values: any[]], - result: any - } - $queryRaw: { - args: [query: TemplateStringsArray | Prisma.Sql, ...values: any[]], - result: any - } - $queryRawUnsafe: { - args: [query: string, ...values: any[]], - result: any - } - } - } - } - export const defineExtension: $Extensions.ExtendsHook<"define", Prisma.TypeMapCb, $Extensions.DefaultArgs> - export type DefaultPrismaClient = PrismaClient - export type ErrorFormat = 'pretty' | 'colorless' | 'minimal' - export interface PrismaClientOptions { - /** - * Overwrites the datasource url from your schema.prisma file - */ - datasources?: Datasources - /** - * Overwrites the datasource url from your schema.prisma file - */ - datasourceUrl?: string - /** - * @default "colorless" - */ - errorFormat?: ErrorFormat - /** - * @example - * ``` - * // Shorthand for `emit: 'stdout'` - * log: ['query', 'info', 'warn', 'error'] - * - * // Emit as events only - * log: [ - * { emit: 'event', level: 'query' }, - * { emit: 'event', level: 'info' }, - * { emit: 'event', level: 'warn' } - * { emit: 'event', level: 'error' } - * ] - * - * / Emit as events and log to stdout - * og: [ - * { emit: 'stdout', level: 'query' }, - * { emit: 'stdout', level: 'info' }, - * { emit: 'stdout', level: 'warn' } - * { emit: 'stdout', level: 'error' } - * - * ``` - * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option). - */ - log?: (LogLevel | LogDefinition)[] - /** - * The default values for transactionOptions - * maxWait ?= 2000 - * timeout ?= 5000 - */ - transactionOptions?: { - maxWait?: number - timeout?: number - isolationLevel?: Prisma.TransactionIsolationLevel - } - /** - * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale` - */ - adapter?: runtime.SqlDriverAdapterFactory | null - /** - * Global configuration for omitting model fields by default. - * - * @example - * ``` - * const prisma = new PrismaClient({ - * omit: { - * user: { - * password: true - * } - * } - * }) - * ``` - */ - omit?: Prisma.GlobalOmitConfig - } - export type GlobalOmitConfig = { - post?: PostOmit - } - - /* Types for Logging */ - export type LogLevel = 'info' | 'query' | 'warn' | 'error' - export type LogDefinition = { - level: LogLevel - emit: 'stdout' | 'event' - } - - export type CheckIsLogLevel = T extends LogLevel ? T : never; - - export type GetLogType = CheckIsLogLevel< - T extends LogDefinition ? T['level'] : T - >; - - export type GetEvents = T extends Array - ? GetLogType - : never; - - export type QueryEvent = { - timestamp: Date - query: string - params: string - duration: number - target: string - } - - export type LogEvent = { - timestamp: Date - message: string - target: string - } - /* End Types for Logging */ - - - export type PrismaAction = - | 'findUnique' - | 'findUniqueOrThrow' - | 'findMany' - | 'findFirst' - | 'findFirstOrThrow' - | 'create' - | 'createMany' - | 'createManyAndReturn' - | 'update' - | 'updateMany' - | 'updateManyAndReturn' - | 'upsert' - | 'delete' - | 'deleteMany' - | 'executeRaw' - | 'queryRaw' - | 'aggregate' - | 'count' - | 'runCommandRaw' - | 'findRaw' - | 'groupBy' - - // tested in getLogLevel.test.ts - export function getLogLevel(log: Array): LogLevel | undefined; - - /** - * `PrismaClient` proxy available in interactive transactions. - */ - export type TransactionClient = Omit - - export type Datasource = { - url?: string - } - - /** - * Count Types - */ - - - - /** - * Models - */ - - /** - * Model Post - */ - - export type AggregatePost = { - _count: PostCountAggregateOutputType | null - _avg: PostAvgAggregateOutputType | null - _sum: PostSumAggregateOutputType | null - _min: PostMinAggregateOutputType | null - _max: PostMaxAggregateOutputType | null - } - - export type PostAvgAggregateOutputType = { - id: number | null - } - - export type PostSumAggregateOutputType = { - id: number | null - } - - export type PostMinAggregateOutputType = { - id: number | null - name: string | null - createdAt: Date | null - updatedAt: Date | null - } - - export type PostMaxAggregateOutputType = { - id: number | null - name: string | null - createdAt: Date | null - updatedAt: Date | null - } - - export type PostCountAggregateOutputType = { - id: number - name: number - createdAt: number - updatedAt: number - _all: number - } - - - export type PostAvgAggregateInputType = { - id?: true - } - - export type PostSumAggregateInputType = { - id?: true - } - - export type PostMinAggregateInputType = { - id?: true - name?: true - createdAt?: true - updatedAt?: true - } - - export type PostMaxAggregateInputType = { - id?: true - name?: true - createdAt?: true - updatedAt?: true - } - - export type PostCountAggregateInputType = { - id?: true - name?: true - createdAt?: true - updatedAt?: true - _all?: true - } - - export type PostAggregateArgs = { - /** - * Filter which Post to aggregate. - */ - where?: PostWhereInput - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} - * - * Determine the order of Posts to fetch. - */ - orderBy?: PostOrderByWithRelationInput | PostOrderByWithRelationInput[] - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} - * - * Sets the start position - */ - cursor?: PostWhereUniqueInput - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} - * - * Take `±n` Posts from the position of the cursor. - */ - take?: number - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} - * - * Skip the first `n` Posts. - */ - skip?: number - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} - * - * Count returned Posts - **/ - _count?: true | PostCountAggregateInputType - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} - * - * Select which fields to average - **/ - _avg?: PostAvgAggregateInputType - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} - * - * Select which fields to sum - **/ - _sum?: PostSumAggregateInputType - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} - * - * Select which fields to find the minimum value - **/ - _min?: PostMinAggregateInputType - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/aggregations Aggregation Docs} - * - * Select which fields to find the maximum value - **/ - _max?: PostMaxAggregateInputType - } - - export type GetPostAggregateType = { - [P in keyof T & keyof AggregatePost]: P extends '_count' | 'count' - ? T[P] extends true - ? number - : GetScalarType - : GetScalarType - } - - - - - export type PostGroupByArgs = { - where?: PostWhereInput - orderBy?: PostOrderByWithAggregationInput | PostOrderByWithAggregationInput[] - by: PostScalarFieldEnum[] | PostScalarFieldEnum - having?: PostScalarWhereWithAggregatesInput - take?: number - skip?: number - _count?: PostCountAggregateInputType | true - _avg?: PostAvgAggregateInputType - _sum?: PostSumAggregateInputType - _min?: PostMinAggregateInputType - _max?: PostMaxAggregateInputType - } - - export type PostGroupByOutputType = { - id: number - name: string - createdAt: Date - updatedAt: Date - _count: PostCountAggregateOutputType | null - _avg: PostAvgAggregateOutputType | null - _sum: PostSumAggregateOutputType | null - _min: PostMinAggregateOutputType | null - _max: PostMaxAggregateOutputType | null - } - - type GetPostGroupByPayload = Prisma.PrismaPromise< - Array< - PickEnumerable & - { - [P in ((keyof T) & (keyof PostGroupByOutputType))]: P extends '_count' - ? T[P] extends boolean - ? number - : GetScalarType - : GetScalarType - } - > - > - - - export type PostSelect = $Extensions.GetSelect<{ - id?: boolean - name?: boolean - createdAt?: boolean - updatedAt?: boolean - }, ExtArgs["result"]["post"]> - - export type PostSelectCreateManyAndReturn = $Extensions.GetSelect<{ - id?: boolean - name?: boolean - createdAt?: boolean - updatedAt?: boolean - }, ExtArgs["result"]["post"]> - - export type PostSelectUpdateManyAndReturn = $Extensions.GetSelect<{ - id?: boolean - name?: boolean - createdAt?: boolean - updatedAt?: boolean - }, ExtArgs["result"]["post"]> - - export type PostSelectScalar = { - id?: boolean - name?: boolean - createdAt?: boolean - updatedAt?: boolean - } - - export type PostOmit = $Extensions.GetOmit<"id" | "name" | "createdAt" | "updatedAt", ExtArgs["result"]["post"]> - - export type $PostPayload = { - name: "Post" - objects: {} - scalars: $Extensions.GetPayloadResult<{ - id: number - name: string - createdAt: Date - updatedAt: Date - }, ExtArgs["result"]["post"]> - composites: {} - } - - type PostGetPayload = $Result.GetResult - - type PostCountArgs = - Omit & { - select?: PostCountAggregateInputType | true - } - - export interface PostDelegate { - [K: symbol]: { types: Prisma.TypeMap['model']['Post'], meta: { name: 'Post' } } - /** - * Find zero or one Post that matches the filter. - * @param {PostFindUniqueArgs} args - Arguments to find a Post - * @example - * // Get one Post - * const post = await prisma.post.findUnique({ - * where: { - * // ... provide filter here - * } - * }) - */ - findUnique(args: SelectSubset>): Prisma__PostClient<$Result.GetResult, T, "findUnique", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> - - /** - * Find one Post that matches the filter or throw an error with `error.code='P2025'` - * if no matches were found. - * @param {PostFindUniqueOrThrowArgs} args - Arguments to find a Post - * @example - * // Get one Post - * const post = await prisma.post.findUniqueOrThrow({ - * where: { - * // ... provide filter here - * } - * }) - */ - findUniqueOrThrow(args: SelectSubset>): Prisma__PostClient<$Result.GetResult, T, "findUniqueOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> - - /** - * Find the first Post that matches the filter. - * Note, that providing `undefined` is treated as the value not being there. - * Read more here: https://pris.ly/d/null-undefined - * @param {PostFindFirstArgs} args - Arguments to find a Post - * @example - * // Get one Post - * const post = await prisma.post.findFirst({ - * where: { - * // ... provide filter here - * } - * }) - */ - findFirst(args?: SelectSubset>): Prisma__PostClient<$Result.GetResult, T, "findFirst", GlobalOmitOptions> | null, null, ExtArgs, GlobalOmitOptions> - - /** - * Find the first Post that matches the filter or - * throw `PrismaKnownClientError` with `P2025` code if no matches were found. - * Note, that providing `undefined` is treated as the value not being there. - * Read more here: https://pris.ly/d/null-undefined - * @param {PostFindFirstOrThrowArgs} args - Arguments to find a Post - * @example - * // Get one Post - * const post = await prisma.post.findFirstOrThrow({ - * where: { - * // ... provide filter here - * } - * }) - */ - findFirstOrThrow(args?: SelectSubset>): Prisma__PostClient<$Result.GetResult, T, "findFirstOrThrow", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> - - /** - * Find zero or more Posts that matches the filter. - * Note, that providing `undefined` is treated as the value not being there. - * Read more here: https://pris.ly/d/null-undefined - * @param {PostFindManyArgs} args - Arguments to filter and select certain fields only. - * @example - * // Get all Posts - * const posts = await prisma.post.findMany() - * - * // Get first 10 Posts - * const posts = await prisma.post.findMany({ take: 10 }) - * - * // Only select the `id` - * const postWithIdOnly = await prisma.post.findMany({ select: { id: true } }) - * - */ - findMany(args?: SelectSubset>): Prisma.PrismaPromise<$Result.GetResult, T, "findMany", GlobalOmitOptions>> - - /** - * Create a Post. - * @param {PostCreateArgs} args - Arguments to create a Post. - * @example - * // Create one Post - * const Post = await prisma.post.create({ - * data: { - * // ... data to create a Post - * } - * }) - * - */ - create(args: SelectSubset>): Prisma__PostClient<$Result.GetResult, T, "create", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> - - /** - * Create many Posts. - * @param {PostCreateManyArgs} args - Arguments to create many Posts. - * @example - * // Create many Posts - * const post = await prisma.post.createMany({ - * data: [ - * // ... provide data here - * ] - * }) - * - */ - createMany(args?: SelectSubset>): Prisma.PrismaPromise - - /** - * Create many Posts and returns the data saved in the database. - * @param {PostCreateManyAndReturnArgs} args - Arguments to create many Posts. - * @example - * // Create many Posts - * const post = await prisma.post.createManyAndReturn({ - * data: [ - * // ... provide data here - * ] - * }) - * - * // Create many Posts and only return the `id` - * const postWithIdOnly = await prisma.post.createManyAndReturn({ - * select: { id: true }, - * data: [ - * // ... provide data here - * ] - * }) - * Note, that providing `undefined` is treated as the value not being there. - * Read more here: https://pris.ly/d/null-undefined - * - */ - createManyAndReturn(args?: SelectSubset>): Prisma.PrismaPromise<$Result.GetResult, T, "createManyAndReturn", GlobalOmitOptions>> - - /** - * Delete a Post. - * @param {PostDeleteArgs} args - Arguments to delete one Post. - * @example - * // Delete one Post - * const Post = await prisma.post.delete({ - * where: { - * // ... filter to delete one Post - * } - * }) - * - */ - delete(args: SelectSubset>): Prisma__PostClient<$Result.GetResult, T, "delete", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> - - /** - * Update one Post. - * @param {PostUpdateArgs} args - Arguments to update one Post. - * @example - * // Update one Post - * const post = await prisma.post.update({ - * where: { - * // ... provide filter here - * }, - * data: { - * // ... provide data here - * } - * }) - * - */ - update(args: SelectSubset>): Prisma__PostClient<$Result.GetResult, T, "update", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> - - /** - * Delete zero or more Posts. - * @param {PostDeleteManyArgs} args - Arguments to filter Posts to delete. - * @example - * // Delete a few Posts - * const { count } = await prisma.post.deleteMany({ - * where: { - * // ... provide filter here - * } - * }) - * - */ - deleteMany(args?: SelectSubset>): Prisma.PrismaPromise - - /** - * Update zero or more Posts. - * Note, that providing `undefined` is treated as the value not being there. - * Read more here: https://pris.ly/d/null-undefined - * @param {PostUpdateManyArgs} args - Arguments to update one or more rows. - * @example - * // Update many Posts - * const post = await prisma.post.updateMany({ - * where: { - * // ... provide filter here - * }, - * data: { - * // ... provide data here - * } - * }) - * - */ - updateMany(args: SelectSubset>): Prisma.PrismaPromise - - /** - * Update zero or more Posts and returns the data updated in the database. - * @param {PostUpdateManyAndReturnArgs} args - Arguments to update many Posts. - * @example - * // Update many Posts - * const post = await prisma.post.updateManyAndReturn({ - * where: { - * // ... provide filter here - * }, - * data: [ - * // ... provide data here - * ] - * }) - * - * // Update zero or more Posts and only return the `id` - * const postWithIdOnly = await prisma.post.updateManyAndReturn({ - * select: { id: true }, - * where: { - * // ... provide filter here - * }, - * data: [ - * // ... provide data here - * ] - * }) - * Note, that providing `undefined` is treated as the value not being there. - * Read more here: https://pris.ly/d/null-undefined - * - */ - updateManyAndReturn(args: SelectSubset>): Prisma.PrismaPromise<$Result.GetResult, T, "updateManyAndReturn", GlobalOmitOptions>> - - /** - * Create or update one Post. - * @param {PostUpsertArgs} args - Arguments to update or create a Post. - * @example - * // Update or create a Post - * const post = await prisma.post.upsert({ - * create: { - * // ... data to create a Post - * }, - * update: { - * // ... in case it already exists, update - * }, - * where: { - * // ... the filter for the Post we want to update - * } - * }) - */ - upsert(args: SelectSubset>): Prisma__PostClient<$Result.GetResult, T, "upsert", GlobalOmitOptions>, never, ExtArgs, GlobalOmitOptions> - - - /** - * Count the number of Posts. - * Note, that providing `undefined` is treated as the value not being there. - * Read more here: https://pris.ly/d/null-undefined - * @param {PostCountArgs} args - Arguments to filter Posts to count. - * @example - * // Count the number of Posts - * const count = await prisma.post.count({ - * where: { - * // ... the filter for the Posts we want to count - * } - * }) - **/ - count( - args?: Subset, - ): Prisma.PrismaPromise< - T extends $Utils.Record<'select', any> - ? T['select'] extends true - ? number - : GetScalarType - : number - > - - /** - * Allows you to perform aggregations operations on a Post. - * Note, that providing `undefined` is treated as the value not being there. - * Read more here: https://pris.ly/d/null-undefined - * @param {PostAggregateArgs} args - Select which aggregations you would like to apply and on what fields. - * @example - * // Ordered by age ascending - * // Where email contains prisma.io - * // Limited to the 10 users - * const aggregations = await prisma.user.aggregate({ - * _avg: { - * age: true, - * }, - * where: { - * email: { - * contains: "prisma.io", - * }, - * }, - * orderBy: { - * age: "asc", - * }, - * take: 10, - * }) - **/ - aggregate(args: Subset): Prisma.PrismaPromise> - - /** - * Group by Post. - * Note, that providing `undefined` is treated as the value not being there. - * Read more here: https://pris.ly/d/null-undefined - * @param {PostGroupByArgs} args - Group by arguments. - * @example - * // Group by city, order by createdAt, get count - * const result = await prisma.user.groupBy({ - * by: ['city', 'createdAt'], - * orderBy: { - * createdAt: true - * }, - * _count: { - * _all: true - * }, - * }) - * - **/ - groupBy< - T extends PostGroupByArgs, - HasSelectOrTake extends Or< - Extends<'skip', Keys>, - Extends<'take', Keys> - >, - OrderByArg extends True extends HasSelectOrTake - ? { orderBy: PostGroupByArgs['orderBy'] } - : { orderBy?: PostGroupByArgs['orderBy'] }, - OrderFields extends ExcludeUnderscoreKeys>>, - ByFields extends MaybeTupleToUnion, - ByValid extends Has, - HavingFields extends GetHavingFields, - HavingValid extends Has, - ByEmpty extends T['by'] extends never[] ? True : False, - InputErrors extends ByEmpty extends True - ? `Error: "by" must not be empty.` - : HavingValid extends False - ? { - [P in HavingFields]: P extends ByFields - ? never - : P extends string - ? `Error: Field "${P}" used in "having" needs to be provided in "by".` - : [ - Error, - 'Field ', - P, - ` in "having" needs to be provided in "by"`, - ] - }[HavingFields] - : 'take' extends Keys - ? 'orderBy' extends Keys - ? ByValid extends True - ? {} - : { - [P in OrderFields]: P extends ByFields - ? never - : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` - }[OrderFields] - : 'Error: If you provide "take", you also need to provide "orderBy"' - : 'skip' extends Keys - ? 'orderBy' extends Keys - ? ByValid extends True - ? {} - : { - [P in OrderFields]: P extends ByFields - ? never - : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` - }[OrderFields] - : 'Error: If you provide "skip", you also need to provide "orderBy"' - : ByValid extends True - ? {} - : { - [P in OrderFields]: P extends ByFields - ? never - : `Error: Field "${P}" in "orderBy" needs to be provided in "by"` - }[OrderFields] - >(args: SubsetIntersection & InputErrors): {} extends InputErrors ? GetPostGroupByPayload : Prisma.PrismaPromise - /** - * Fields of the Post model - */ - readonly fields: PostFieldRefs; - } - - /** - * The delegate class that acts as a "Promise-like" for Post. - * Why is this prefixed with `Prisma__`? - * Because we want to prevent naming conflicts as mentioned in - * https://github.com/prisma/prisma-client-js/issues/707 - */ - export interface Prisma__PostClient extends Prisma.PrismaPromise { - readonly [Symbol.toStringTag]: "PrismaPromise" - /** - * Attaches callbacks for the resolution and/or rejection of the Promise. - * @param onfulfilled The callback to execute when the Promise is resolved. - * @param onrejected The callback to execute when the Promise is rejected. - * @returns A Promise for the completion of which ever callback is executed. - */ - then(onfulfilled?: ((value: T) => TResult1 | PromiseLike) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike) | undefined | null): $Utils.JsPromise - /** - * Attaches a callback for only the rejection of the Promise. - * @param onrejected The callback to execute when the Promise is rejected. - * @returns A Promise for the completion of the callback. - */ - catch(onrejected?: ((reason: any) => TResult | PromiseLike) | undefined | null): $Utils.JsPromise - /** - * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The - * resolved value cannot be modified from the callback. - * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected). - * @returns A Promise for the completion of the callback. - */ - finally(onfinally?: (() => void) | undefined | null): $Utils.JsPromise - } - - - - - /** - * Fields of the Post model - */ - interface PostFieldRefs { - readonly id: FieldRef<"Post", 'Int'> - readonly name: FieldRef<"Post", 'String'> - readonly createdAt: FieldRef<"Post", 'DateTime'> - readonly updatedAt: FieldRef<"Post", 'DateTime'> - } - - - // Custom InputTypes - /** - * Post findUnique - */ - export type PostFindUniqueArgs = { - /** - * Select specific fields to fetch from the Post - */ - select?: PostSelect | null - /** - * Omit specific fields from the Post - */ - omit?: PostOmit | null - /** - * Filter, which Post to fetch. - */ - where: PostWhereUniqueInput - } - - /** - * Post findUniqueOrThrow - */ - export type PostFindUniqueOrThrowArgs = { - /** - * Select specific fields to fetch from the Post - */ - select?: PostSelect | null - /** - * Omit specific fields from the Post - */ - omit?: PostOmit | null - /** - * Filter, which Post to fetch. - */ - where: PostWhereUniqueInput - } - - /** - * Post findFirst - */ - export type PostFindFirstArgs = { - /** - * Select specific fields to fetch from the Post - */ - select?: PostSelect | null - /** - * Omit specific fields from the Post - */ - omit?: PostOmit | null - /** - * Filter, which Post to fetch. - */ - where?: PostWhereInput - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} - * - * Determine the order of Posts to fetch. - */ - orderBy?: PostOrderByWithRelationInput | PostOrderByWithRelationInput[] - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} - * - * Sets the position for searching for Posts. - */ - cursor?: PostWhereUniqueInput - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} - * - * Take `±n` Posts from the position of the cursor. - */ - take?: number - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} - * - * Skip the first `n` Posts. - */ - skip?: number - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} - * - * Filter by unique combinations of Posts. - */ - distinct?: PostScalarFieldEnum | PostScalarFieldEnum[] - } - - /** - * Post findFirstOrThrow - */ - export type PostFindFirstOrThrowArgs = { - /** - * Select specific fields to fetch from the Post - */ - select?: PostSelect | null - /** - * Omit specific fields from the Post - */ - omit?: PostOmit | null - /** - * Filter, which Post to fetch. - */ - where?: PostWhereInput - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} - * - * Determine the order of Posts to fetch. - */ - orderBy?: PostOrderByWithRelationInput | PostOrderByWithRelationInput[] - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} - * - * Sets the position for searching for Posts. - */ - cursor?: PostWhereUniqueInput - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} - * - * Take `±n` Posts from the position of the cursor. - */ - take?: number - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} - * - * Skip the first `n` Posts. - */ - skip?: number - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/distinct Distinct Docs} - * - * Filter by unique combinations of Posts. - */ - distinct?: PostScalarFieldEnum | PostScalarFieldEnum[] - } - - /** - * Post findMany - */ - export type PostFindManyArgs = { - /** - * Select specific fields to fetch from the Post - */ - select?: PostSelect | null - /** - * Omit specific fields from the Post - */ - omit?: PostOmit | null - /** - * Filter, which Posts to fetch. - */ - where?: PostWhereInput - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/sorting Sorting Docs} - * - * Determine the order of Posts to fetch. - */ - orderBy?: PostOrderByWithRelationInput | PostOrderByWithRelationInput[] - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs} - * - * Sets the position for listing Posts. - */ - cursor?: PostWhereUniqueInput - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} - * - * Take `±n` Posts from the position of the cursor. - */ - take?: number - /** - * {@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs} - * - * Skip the first `n` Posts. - */ - skip?: number - distinct?: PostScalarFieldEnum | PostScalarFieldEnum[] - } - - /** - * Post create - */ - export type PostCreateArgs = { - /** - * Select specific fields to fetch from the Post - */ - select?: PostSelect | null - /** - * Omit specific fields from the Post - */ - omit?: PostOmit | null - /** - * The data needed to create a Post. - */ - data: XOR - } - - /** - * Post createMany - */ - export type PostCreateManyArgs = { - /** - * The data used to create many Posts. - */ - data: PostCreateManyInput | PostCreateManyInput[] - } - - /** - * Post createManyAndReturn - */ - export type PostCreateManyAndReturnArgs = { - /** - * Select specific fields to fetch from the Post - */ - select?: PostSelectCreateManyAndReturn | null - /** - * Omit specific fields from the Post - */ - omit?: PostOmit | null - /** - * The data used to create many Posts. - */ - data: PostCreateManyInput | PostCreateManyInput[] - } - - /** - * Post update - */ - export type PostUpdateArgs = { - /** - * Select specific fields to fetch from the Post - */ - select?: PostSelect | null - /** - * Omit specific fields from the Post - */ - omit?: PostOmit | null - /** - * The data needed to update a Post. - */ - data: XOR - /** - * Choose, which Post to update. - */ - where: PostWhereUniqueInput - } - - /** - * Post updateMany - */ - export type PostUpdateManyArgs = { - /** - * The data used to update Posts. - */ - data: XOR - /** - * Filter which Posts to update - */ - where?: PostWhereInput - /** - * Limit how many Posts to update. - */ - limit?: number - } - - /** - * Post updateManyAndReturn - */ - export type PostUpdateManyAndReturnArgs = { - /** - * Select specific fields to fetch from the Post - */ - select?: PostSelectUpdateManyAndReturn | null - /** - * Omit specific fields from the Post - */ - omit?: PostOmit | null - /** - * The data used to update Posts. - */ - data: XOR - /** - * Filter which Posts to update - */ - where?: PostWhereInput - /** - * Limit how many Posts to update. - */ - limit?: number - } - - /** - * Post upsert - */ - export type PostUpsertArgs = { - /** - * Select specific fields to fetch from the Post - */ - select?: PostSelect | null - /** - * Omit specific fields from the Post - */ - omit?: PostOmit | null - /** - * The filter to search for the Post to update in case it exists. - */ - where: PostWhereUniqueInput - /** - * In case the Post found by the `where` argument doesn't exist, create a new Post with this data. - */ - create: XOR - /** - * In case the Post was found with the provided `where` argument, update it with this data. - */ - update: XOR - } - - /** - * Post delete - */ - export type PostDeleteArgs = { - /** - * Select specific fields to fetch from the Post - */ - select?: PostSelect | null - /** - * Omit specific fields from the Post - */ - omit?: PostOmit | null - /** - * Filter which Post to delete. - */ - where: PostWhereUniqueInput - } - - /** - * Post deleteMany - */ - export type PostDeleteManyArgs = { - /** - * Filter which Posts to delete - */ - where?: PostWhereInput - /** - * Limit how many Posts to delete. - */ - limit?: number - } - - /** - * Post without action - */ - export type PostDefaultArgs = { - /** - * Select specific fields to fetch from the Post - */ - select?: PostSelect | null - /** - * Omit specific fields from the Post - */ - omit?: PostOmit | null - } - - - /** - * Enums - */ - - export const TransactionIsolationLevel: { - Serializable: 'Serializable' - }; - - export type TransactionIsolationLevel = (typeof TransactionIsolationLevel)[keyof typeof TransactionIsolationLevel] - - - export const PostScalarFieldEnum: { - id: 'id', - name: 'name', - createdAt: 'createdAt', - updatedAt: 'updatedAt' - }; - - export type PostScalarFieldEnum = (typeof PostScalarFieldEnum)[keyof typeof PostScalarFieldEnum] - - - export const SortOrder: { - asc: 'asc', - desc: 'desc' - }; - - export type SortOrder = (typeof SortOrder)[keyof typeof SortOrder] - - - /** - * Field references - */ - - - /** - * Reference to a field of type 'Int' - */ - export type IntFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Int'> - - - - /** - * Reference to a field of type 'String' - */ - export type StringFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'String'> - - - - /** - * Reference to a field of type 'DateTime' - */ - export type DateTimeFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'DateTime'> - - - - /** - * Reference to a field of type 'Float' - */ - export type FloatFieldRefInput<$PrismaModel> = FieldRefInputType<$PrismaModel, 'Float'> - - /** - * Deep Input Types - */ - - - export type PostWhereInput = { - AND?: PostWhereInput | PostWhereInput[] - OR?: PostWhereInput[] - NOT?: PostWhereInput | PostWhereInput[] - id?: IntFilter<"Post"> | number - name?: StringFilter<"Post"> | string - createdAt?: DateTimeFilter<"Post"> | Date | string - updatedAt?: DateTimeFilter<"Post"> | Date | string - } - - export type PostOrderByWithRelationInput = { - id?: SortOrder - name?: SortOrder - createdAt?: SortOrder - updatedAt?: SortOrder - } - - export type PostWhereUniqueInput = Prisma.AtLeast<{ - id?: number - AND?: PostWhereInput | PostWhereInput[] - OR?: PostWhereInput[] - NOT?: PostWhereInput | PostWhereInput[] - name?: StringFilter<"Post"> | string - createdAt?: DateTimeFilter<"Post"> | Date | string - updatedAt?: DateTimeFilter<"Post"> | Date | string - }, "id"> - - export type PostOrderByWithAggregationInput = { - id?: SortOrder - name?: SortOrder - createdAt?: SortOrder - updatedAt?: SortOrder - _count?: PostCountOrderByAggregateInput - _avg?: PostAvgOrderByAggregateInput - _max?: PostMaxOrderByAggregateInput - _min?: PostMinOrderByAggregateInput - _sum?: PostSumOrderByAggregateInput - } - - export type PostScalarWhereWithAggregatesInput = { - AND?: PostScalarWhereWithAggregatesInput | PostScalarWhereWithAggregatesInput[] - OR?: PostScalarWhereWithAggregatesInput[] - NOT?: PostScalarWhereWithAggregatesInput | PostScalarWhereWithAggregatesInput[] - id?: IntWithAggregatesFilter<"Post"> | number - name?: StringWithAggregatesFilter<"Post"> | string - createdAt?: DateTimeWithAggregatesFilter<"Post"> | Date | string - updatedAt?: DateTimeWithAggregatesFilter<"Post"> | Date | string - } - - export type PostCreateInput = { - name: string - createdAt?: Date | string - updatedAt?: Date | string - } - - export type PostUncheckedCreateInput = { - id?: number - name: string - createdAt?: Date | string - updatedAt?: Date | string - } - - export type PostUpdateInput = { - name?: StringFieldUpdateOperationsInput | string - createdAt?: DateTimeFieldUpdateOperationsInput | Date | string - updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string - } - - export type PostUncheckedUpdateInput = { - id?: IntFieldUpdateOperationsInput | number - name?: StringFieldUpdateOperationsInput | string - createdAt?: DateTimeFieldUpdateOperationsInput | Date | string - updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string - } - - export type PostCreateManyInput = { - id?: number - name: string - createdAt?: Date | string - updatedAt?: Date | string - } - - export type PostUpdateManyMutationInput = { - name?: StringFieldUpdateOperationsInput | string - createdAt?: DateTimeFieldUpdateOperationsInput | Date | string - updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string - } - - export type PostUncheckedUpdateManyInput = { - id?: IntFieldUpdateOperationsInput | number - name?: StringFieldUpdateOperationsInput | string - createdAt?: DateTimeFieldUpdateOperationsInput | Date | string - updatedAt?: DateTimeFieldUpdateOperationsInput | Date | string - } - - export type IntFilter<$PrismaModel = never> = { - equals?: number | IntFieldRefInput<$PrismaModel> - in?: number[] - notIn?: number[] - lt?: number | IntFieldRefInput<$PrismaModel> - lte?: number | IntFieldRefInput<$PrismaModel> - gt?: number | IntFieldRefInput<$PrismaModel> - gte?: number | IntFieldRefInput<$PrismaModel> - not?: NestedIntFilter<$PrismaModel> | number - } - - export type StringFilter<$PrismaModel = never> = { - equals?: string | StringFieldRefInput<$PrismaModel> - in?: string[] - notIn?: string[] - lt?: string | StringFieldRefInput<$PrismaModel> - lte?: string | StringFieldRefInput<$PrismaModel> - gt?: string | StringFieldRefInput<$PrismaModel> - gte?: string | StringFieldRefInput<$PrismaModel> - contains?: string | StringFieldRefInput<$PrismaModel> - startsWith?: string | StringFieldRefInput<$PrismaModel> - endsWith?: string | StringFieldRefInput<$PrismaModel> - not?: NestedStringFilter<$PrismaModel> | string - } - - export type DateTimeFilter<$PrismaModel = never> = { - equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> - in?: Date[] | string[] - notIn?: Date[] | string[] - lt?: Date | string | DateTimeFieldRefInput<$PrismaModel> - lte?: Date | string | DateTimeFieldRefInput<$PrismaModel> - gt?: Date | string | DateTimeFieldRefInput<$PrismaModel> - gte?: Date | string | DateTimeFieldRefInput<$PrismaModel> - not?: NestedDateTimeFilter<$PrismaModel> | Date | string - } - - export type PostCountOrderByAggregateInput = { - id?: SortOrder - name?: SortOrder - createdAt?: SortOrder - updatedAt?: SortOrder - } - - export type PostAvgOrderByAggregateInput = { - id?: SortOrder - } - - export type PostMaxOrderByAggregateInput = { - id?: SortOrder - name?: SortOrder - createdAt?: SortOrder - updatedAt?: SortOrder - } - - export type PostMinOrderByAggregateInput = { - id?: SortOrder - name?: SortOrder - createdAt?: SortOrder - updatedAt?: SortOrder - } - - export type PostSumOrderByAggregateInput = { - id?: SortOrder - } - - export type IntWithAggregatesFilter<$PrismaModel = never> = { - equals?: number | IntFieldRefInput<$PrismaModel> - in?: number[] - notIn?: number[] - lt?: number | IntFieldRefInput<$PrismaModel> - lte?: number | IntFieldRefInput<$PrismaModel> - gt?: number | IntFieldRefInput<$PrismaModel> - gte?: number | IntFieldRefInput<$PrismaModel> - not?: NestedIntWithAggregatesFilter<$PrismaModel> | number - _count?: NestedIntFilter<$PrismaModel> - _avg?: NestedFloatFilter<$PrismaModel> - _sum?: NestedIntFilter<$PrismaModel> - _min?: NestedIntFilter<$PrismaModel> - _max?: NestedIntFilter<$PrismaModel> - } - - export type StringWithAggregatesFilter<$PrismaModel = never> = { - equals?: string | StringFieldRefInput<$PrismaModel> - in?: string[] - notIn?: string[] - lt?: string | StringFieldRefInput<$PrismaModel> - lte?: string | StringFieldRefInput<$PrismaModel> - gt?: string | StringFieldRefInput<$PrismaModel> - gte?: string | StringFieldRefInput<$PrismaModel> - contains?: string | StringFieldRefInput<$PrismaModel> - startsWith?: string | StringFieldRefInput<$PrismaModel> - endsWith?: string | StringFieldRefInput<$PrismaModel> - not?: NestedStringWithAggregatesFilter<$PrismaModel> | string - _count?: NestedIntFilter<$PrismaModel> - _min?: NestedStringFilter<$PrismaModel> - _max?: NestedStringFilter<$PrismaModel> - } - - export type DateTimeWithAggregatesFilter<$PrismaModel = never> = { - equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> - in?: Date[] | string[] - notIn?: Date[] | string[] - lt?: Date | string | DateTimeFieldRefInput<$PrismaModel> - lte?: Date | string | DateTimeFieldRefInput<$PrismaModel> - gt?: Date | string | DateTimeFieldRefInput<$PrismaModel> - gte?: Date | string | DateTimeFieldRefInput<$PrismaModel> - not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string - _count?: NestedIntFilter<$PrismaModel> - _min?: NestedDateTimeFilter<$PrismaModel> - _max?: NestedDateTimeFilter<$PrismaModel> - } - - export type StringFieldUpdateOperationsInput = { - set?: string - } - - export type DateTimeFieldUpdateOperationsInput = { - set?: Date | string - } - - export type IntFieldUpdateOperationsInput = { - set?: number - increment?: number - decrement?: number - multiply?: number - divide?: number - } - - export type NestedIntFilter<$PrismaModel = never> = { - equals?: number | IntFieldRefInput<$PrismaModel> - in?: number[] - notIn?: number[] - lt?: number | IntFieldRefInput<$PrismaModel> - lte?: number | IntFieldRefInput<$PrismaModel> - gt?: number | IntFieldRefInput<$PrismaModel> - gte?: number | IntFieldRefInput<$PrismaModel> - not?: NestedIntFilter<$PrismaModel> | number - } - - export type NestedStringFilter<$PrismaModel = never> = { - equals?: string | StringFieldRefInput<$PrismaModel> - in?: string[] - notIn?: string[] - lt?: string | StringFieldRefInput<$PrismaModel> - lte?: string | StringFieldRefInput<$PrismaModel> - gt?: string | StringFieldRefInput<$PrismaModel> - gte?: string | StringFieldRefInput<$PrismaModel> - contains?: string | StringFieldRefInput<$PrismaModel> - startsWith?: string | StringFieldRefInput<$PrismaModel> - endsWith?: string | StringFieldRefInput<$PrismaModel> - not?: NestedStringFilter<$PrismaModel> | string - } - - export type NestedDateTimeFilter<$PrismaModel = never> = { - equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> - in?: Date[] | string[] - notIn?: Date[] | string[] - lt?: Date | string | DateTimeFieldRefInput<$PrismaModel> - lte?: Date | string | DateTimeFieldRefInput<$PrismaModel> - gt?: Date | string | DateTimeFieldRefInput<$PrismaModel> - gte?: Date | string | DateTimeFieldRefInput<$PrismaModel> - not?: NestedDateTimeFilter<$PrismaModel> | Date | string - } - - export type NestedIntWithAggregatesFilter<$PrismaModel = never> = { - equals?: number | IntFieldRefInput<$PrismaModel> - in?: number[] - notIn?: number[] - lt?: number | IntFieldRefInput<$PrismaModel> - lte?: number | IntFieldRefInput<$PrismaModel> - gt?: number | IntFieldRefInput<$PrismaModel> - gte?: number | IntFieldRefInput<$PrismaModel> - not?: NestedIntWithAggregatesFilter<$PrismaModel> | number - _count?: NestedIntFilter<$PrismaModel> - _avg?: NestedFloatFilter<$PrismaModel> - _sum?: NestedIntFilter<$PrismaModel> - _min?: NestedIntFilter<$PrismaModel> - _max?: NestedIntFilter<$PrismaModel> - } - - export type NestedFloatFilter<$PrismaModel = never> = { - equals?: number | FloatFieldRefInput<$PrismaModel> - in?: number[] - notIn?: number[] - lt?: number | FloatFieldRefInput<$PrismaModel> - lte?: number | FloatFieldRefInput<$PrismaModel> - gt?: number | FloatFieldRefInput<$PrismaModel> - gte?: number | FloatFieldRefInput<$PrismaModel> - not?: NestedFloatFilter<$PrismaModel> | number - } - - export type NestedStringWithAggregatesFilter<$PrismaModel = never> = { - equals?: string | StringFieldRefInput<$PrismaModel> - in?: string[] - notIn?: string[] - lt?: string | StringFieldRefInput<$PrismaModel> - lte?: string | StringFieldRefInput<$PrismaModel> - gt?: string | StringFieldRefInput<$PrismaModel> - gte?: string | StringFieldRefInput<$PrismaModel> - contains?: string | StringFieldRefInput<$PrismaModel> - startsWith?: string | StringFieldRefInput<$PrismaModel> - endsWith?: string | StringFieldRefInput<$PrismaModel> - not?: NestedStringWithAggregatesFilter<$PrismaModel> | string - _count?: NestedIntFilter<$PrismaModel> - _min?: NestedStringFilter<$PrismaModel> - _max?: NestedStringFilter<$PrismaModel> - } - - export type NestedDateTimeWithAggregatesFilter<$PrismaModel = never> = { - equals?: Date | string | DateTimeFieldRefInput<$PrismaModel> - in?: Date[] | string[] - notIn?: Date[] | string[] - lt?: Date | string | DateTimeFieldRefInput<$PrismaModel> - lte?: Date | string | DateTimeFieldRefInput<$PrismaModel> - gt?: Date | string | DateTimeFieldRefInput<$PrismaModel> - gte?: Date | string | DateTimeFieldRefInput<$PrismaModel> - not?: NestedDateTimeWithAggregatesFilter<$PrismaModel> | Date | string - _count?: NestedIntFilter<$PrismaModel> - _min?: NestedDateTimeFilter<$PrismaModel> - _max?: NestedDateTimeFilter<$PrismaModel> - } - - - - /** - * Batch Payload for updateMany & deleteMany & createMany - */ - - export type BatchPayload = { - count: number - } - - /** - * DMMF - */ - export const dmmf: runtime.BaseDMMF -} \ No newline at end of file diff --git a/frontend/generated/prisma/index.js b/frontend/generated/prisma/index.js deleted file mode 100644 index 75653c4..0000000 --- a/frontend/generated/prisma/index.js +++ /dev/null @@ -1,202 +0,0 @@ - -/* !!! This is code generated by Prisma. Do not edit directly. !!! -/* eslint-disable */ -// biome-ignore-all lint: generated file - -Object.defineProperty(exports, "__esModule", { value: true }); - -const { - PrismaClientKnownRequestError, - PrismaClientUnknownRequestError, - PrismaClientRustPanicError, - PrismaClientInitializationError, - PrismaClientValidationError, - getPrismaClient, - sqltag, - empty, - join, - raw, - skip, - Decimal, - Debug, - objectEnumValues, - makeStrictEnum, - Extensions, - warnOnce, - defineDmmfProperty, - Public, - getRuntime, - createParam, -} = require('./runtime/library.js') - - -const Prisma = {} - -exports.Prisma = Prisma -exports.$Enums = {} - -/** - * Prisma Client JS version: 6.19.1 - * Query Engine version: c2990dca591cba766e3b7ef5d9e8a84796e47ab7 - */ -Prisma.prismaVersion = { - client: "6.19.1", - engine: "c2990dca591cba766e3b7ef5d9e8a84796e47ab7" -} - -Prisma.PrismaClientKnownRequestError = PrismaClientKnownRequestError; -Prisma.PrismaClientUnknownRequestError = PrismaClientUnknownRequestError -Prisma.PrismaClientRustPanicError = PrismaClientRustPanicError -Prisma.PrismaClientInitializationError = PrismaClientInitializationError -Prisma.PrismaClientValidationError = PrismaClientValidationError -Prisma.Decimal = Decimal - -/** - * Re-export of sql-template-tag - */ -Prisma.sql = sqltag -Prisma.empty = empty -Prisma.join = join -Prisma.raw = raw -Prisma.validator = Public.validator - -/** -* Extensions -*/ -Prisma.getExtensionContext = Extensions.getExtensionContext -Prisma.defineExtension = Extensions.defineExtension - -/** - * Shorthand utilities for JSON filtering - */ -Prisma.DbNull = objectEnumValues.instances.DbNull -Prisma.JsonNull = objectEnumValues.instances.JsonNull -Prisma.AnyNull = objectEnumValues.instances.AnyNull - -Prisma.NullTypes = { - DbNull: objectEnumValues.classes.DbNull, - JsonNull: objectEnumValues.classes.JsonNull, - AnyNull: objectEnumValues.classes.AnyNull -} - - - - - const path = require('path') - -/** - * Enums - */ -exports.Prisma.TransactionIsolationLevel = makeStrictEnum({ - Serializable: 'Serializable' -}); - -exports.Prisma.PostScalarFieldEnum = { - id: 'id', - name: 'name', - createdAt: 'createdAt', - updatedAt: 'updatedAt' -}; - -exports.Prisma.SortOrder = { - asc: 'asc', - desc: 'desc' -}; - - -exports.Prisma.ModelName = { - Post: 'Post' -}; -/** - * Create the Client - */ -const config = { - "generator": { - "name": "client", - "provider": { - "fromEnvVar": null, - "value": "prisma-client-js" - }, - "output": { - "value": "/Users/pavelsoukup/DEV/opencode-os/frontend/generated/prisma", - "fromEnvVar": null - }, - "config": { - "engineType": "library" - }, - "binaryTargets": [ - { - "fromEnvVar": null, - "value": "darwin-arm64", - "native": true - } - ], - "previewFeatures": [], - "sourceFilePath": "/Users/pavelsoukup/DEV/opencode-os/frontend/prisma/schema.prisma", - "isCustomOutput": true - }, - "relativeEnvPaths": { - "rootEnvPath": null, - "schemaEnvPath": "../../.env" - }, - "relativePath": "../../prisma", - "clientVersion": "6.19.1", - "engineVersion": "c2990dca591cba766e3b7ef5d9e8a84796e47ab7", - "datasourceNames": [ - "db" - ], - "activeProvider": "sqlite", - "postinstall": false, - "inlineDatasources": { - "db": { - "url": { - "fromEnvVar": "DATABASE_URL", - "value": null - } - } - }, - "inlineSchema": "// This is your Prisma schema file,\n// learn more about it in the docs: https://pris.ly/d/prisma-schema\n\ngenerator client {\n provider = \"prisma-client-js\"\n output = \"../generated/prisma\"\n}\n\ndatasource db {\n provider = \"sqlite\"\n url = env(\"DATABASE_URL\")\n}\n\nmodel Post {\n id Int @id @default(autoincrement())\n name String\n createdAt DateTime @default(now())\n updatedAt DateTime @updatedAt\n\n @@index([name])\n}\n", - "inlineSchemaHash": "6173f79f1f1e8cae300b91aa9403ded205a6c79085b2f8c48fed8dd26c8c16cc", - "copyEngine": true -} - -const fs = require('fs') - -config.dirname = __dirname -if (!fs.existsSync(path.join(__dirname, 'schema.prisma'))) { - const alternativePaths = [ - "generated/prisma", - "prisma", - ] - - const alternativePath = alternativePaths.find((altPath) => { - return fs.existsSync(path.join(process.cwd(), altPath, 'schema.prisma')) - }) ?? alternativePaths[0] - - config.dirname = path.join(process.cwd(), alternativePath) - config.isBundled = true -} - -config.runtimeDataModel = JSON.parse("{\"models\":{\"Post\":{\"dbName\":null,\"schema\":null,\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"isList\":false,\"isRequired\":true,\"isUnique\":false,\"isId\":true,\"isReadOnly\":false,\"hasDefaultValue\":true,\"type\":\"Int\",\"nativeType\":null,\"default\":{\"name\":\"autoincrement\",\"args\":[]},\"isGenerated\":false,\"isUpdatedAt\":false},{\"name\":\"name\",\"kind\":\"scalar\",\"isList\":false,\"isRequired\":true,\"isUnique\":false,\"isId\":false,\"isReadOnly\":false,\"hasDefaultValue\":false,\"type\":\"String\",\"nativeType\":null,\"isGenerated\":false,\"isUpdatedAt\":false},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"isList\":false,\"isRequired\":true,\"isUnique\":false,\"isId\":false,\"isReadOnly\":false,\"hasDefaultValue\":true,\"type\":\"DateTime\",\"nativeType\":null,\"default\":{\"name\":\"now\",\"args\":[]},\"isGenerated\":false,\"isUpdatedAt\":false},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"isList\":false,\"isRequired\":true,\"isUnique\":false,\"isId\":false,\"isReadOnly\":false,\"hasDefaultValue\":false,\"type\":\"DateTime\",\"nativeType\":null,\"isGenerated\":false,\"isUpdatedAt\":true}],\"primaryKey\":null,\"uniqueFields\":[],\"uniqueIndexes\":[],\"isGenerated\":false}},\"enums\":{},\"types\":{}}") -defineDmmfProperty(exports.Prisma, config.runtimeDataModel) -config.engineWasm = undefined -config.compilerWasm = undefined - - -const { warnEnvConflicts } = require('./runtime/library.js') - -warnEnvConflicts({ - rootEnvPath: config.relativeEnvPaths.rootEnvPath && path.resolve(config.dirname, config.relativeEnvPaths.rootEnvPath), - schemaEnvPath: config.relativeEnvPaths.schemaEnvPath && path.resolve(config.dirname, config.relativeEnvPaths.schemaEnvPath) -}) - -const PrismaClient = getPrismaClient(config) -exports.PrismaClient = PrismaClient -Object.assign(exports, Prisma) - -// file annotations for bundling tools to include these files -path.join(__dirname, "libquery_engine-darwin-arm64.dylib.node"); -path.join(process.cwd(), "generated/prisma/libquery_engine-darwin-arm64.dylib.node") -// file annotations for bundling tools to include these files -path.join(__dirname, "schema.prisma"); -path.join(process.cwd(), "generated/prisma/schema.prisma") diff --git a/frontend/generated/prisma/libquery_engine-darwin-arm64.dylib.node b/frontend/generated/prisma/libquery_engine-darwin-arm64.dylib.node deleted file mode 100755 index d0fa4cb..0000000 Binary files a/frontend/generated/prisma/libquery_engine-darwin-arm64.dylib.node and /dev/null differ diff --git a/frontend/generated/prisma/package.json b/frontend/generated/prisma/package.json deleted file mode 100644 index f892068..0000000 --- a/frontend/generated/prisma/package.json +++ /dev/null @@ -1,183 +0,0 @@ -{ - "name": "prisma-client-1fc46a7a7b2be9dea58ab6744c916674838bda77f3f8d088304fe10e40eb883e", - "main": "index.js", - "types": "index.d.ts", - "browser": "default.js", - "exports": { - "./client": { - "require": { - "node": "./index.js", - "edge-light": "./wasm.js", - "workerd": "./wasm.js", - "worker": "./wasm.js", - "browser": "./index-browser.js", - "default": "./index.js" - }, - "import": { - "node": "./index.js", - "edge-light": "./wasm.js", - "workerd": "./wasm.js", - "worker": "./wasm.js", - "browser": "./index-browser.js", - "default": "./index.js" - }, - "default": "./index.js" - }, - "./package.json": "./package.json", - ".": { - "require": { - "node": "./index.js", - "edge-light": "./wasm.js", - "workerd": "./wasm.js", - "worker": "./wasm.js", - "browser": "./index-browser.js", - "default": "./index.js" - }, - "import": { - "node": "./index.js", - "edge-light": "./wasm.js", - "workerd": "./wasm.js", - "worker": "./wasm.js", - "browser": "./index-browser.js", - "default": "./index.js" - }, - "default": "./index.js" - }, - "./edge": { - "types": "./edge.d.ts", - "require": "./edge.js", - "import": "./edge.js", - "default": "./edge.js" - }, - "./react-native": { - "types": "./react-native.d.ts", - "require": "./react-native.js", - "import": "./react-native.js", - "default": "./react-native.js" - }, - "./extension": { - "types": "./extension.d.ts", - "require": "./extension.js", - "import": "./extension.js", - "default": "./extension.js" - }, - "./index-browser": { - "types": "./index.d.ts", - "require": "./index-browser.js", - "import": "./index-browser.js", - "default": "./index-browser.js" - }, - "./index": { - "types": "./index.d.ts", - "require": "./index.js", - "import": "./index.js", - "default": "./index.js" - }, - "./wasm": { - "types": "./wasm.d.ts", - "require": "./wasm.js", - "import": "./wasm.mjs", - "default": "./wasm.mjs" - }, - "./runtime/client": { - "types": "./runtime/client.d.ts", - "node": { - "require": "./runtime/client.js", - "default": "./runtime/client.js" - }, - "require": "./runtime/client.js", - "import": "./runtime/client.mjs", - "default": "./runtime/client.mjs" - }, - "./runtime/library": { - "types": "./runtime/library.d.ts", - "require": "./runtime/library.js", - "import": "./runtime/library.mjs", - "default": "./runtime/library.mjs" - }, - "./runtime/binary": { - "types": "./runtime/binary.d.ts", - "require": "./runtime/binary.js", - "import": "./runtime/binary.mjs", - "default": "./runtime/binary.mjs" - }, - "./runtime/wasm-engine-edge": { - "types": "./runtime/wasm-engine-edge.d.ts", - "require": "./runtime/wasm-engine-edge.js", - "import": "./runtime/wasm-engine-edge.mjs", - "default": "./runtime/wasm-engine-edge.mjs" - }, - "./runtime/wasm-compiler-edge": { - "types": "./runtime/wasm-compiler-edge.d.ts", - "require": "./runtime/wasm-compiler-edge.js", - "import": "./runtime/wasm-compiler-edge.mjs", - "default": "./runtime/wasm-compiler-edge.mjs" - }, - "./runtime/edge": { - "types": "./runtime/edge.d.ts", - "require": "./runtime/edge.js", - "import": "./runtime/edge-esm.js", - "default": "./runtime/edge-esm.js" - }, - "./runtime/react-native": { - "types": "./runtime/react-native.d.ts", - "require": "./runtime/react-native.js", - "import": "./runtime/react-native.js", - "default": "./runtime/react-native.js" - }, - "./runtime/index-browser": { - "types": "./runtime/index-browser.d.ts", - "require": "./runtime/index-browser.js", - "import": "./runtime/index-browser.mjs", - "default": "./runtime/index-browser.mjs" - }, - "./generator-build": { - "require": "./generator-build/index.js", - "import": "./generator-build/index.js", - "default": "./generator-build/index.js" - }, - "./sql": { - "require": { - "types": "./sql.d.ts", - "node": "./sql.js", - "default": "./sql.js" - }, - "import": { - "types": "./sql.d.ts", - "node": "./sql.mjs", - "default": "./sql.mjs" - }, - "default": "./sql.js" - }, - "./*": "./*" - }, - "version": "6.19.1", - "sideEffects": false, - "imports": { - "#wasm-engine-loader": { - "edge-light": "./wasm-edge-light-loader.mjs", - "workerd": "./wasm-worker-loader.mjs", - "worker": "./wasm-worker-loader.mjs", - "default": "./wasm-worker-loader.mjs" - }, - "#main-entry-point": { - "require": { - "node": "./index.js", - "edge-light": "./wasm.js", - "workerd": "./wasm.js", - "worker": "./wasm.js", - "browser": "./index-browser.js", - "default": "./index.js" - }, - "import": { - "node": "./index.js", - "edge-light": "./wasm.js", - "workerd": "./wasm.js", - "worker": "./wasm.js", - "browser": "./index-browser.js", - "default": "./index.js" - }, - "default": "./index.js" - } - } -} \ No newline at end of file diff --git a/frontend/generated/prisma/query_engine_bg.js b/frontend/generated/prisma/query_engine_bg.js deleted file mode 100644 index 4ade61f..0000000 --- a/frontend/generated/prisma/query_engine_bg.js +++ /dev/null @@ -1,2 +0,0 @@ -"use strict";var F=Object.defineProperty;var B=Object.getOwnPropertyDescriptor;var R=Object.getOwnPropertyNames;var U=Object.prototype.hasOwnProperty;var L=(e,t)=>{for(var n in t)F(e,n,{get:t[n],enumerable:!0})},N=(e,t,n,_)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of R(t))!U.call(e,o)&&o!==n&&F(e,o,{get:()=>t[o],enumerable:!(_=B(t,o))||_.enumerable});return e};var C=e=>N(F({},"__esModule",{value:!0}),e);var qt={};L(qt,{QueryEngine:()=>E,__wbg_Error_e83987f665cf5504:()=>J,__wbg_Number_bb48ca12f395cd08:()=>X,__wbg_String_8f0eb39a4a4c2f66:()=>Y,__wbg___wbindgen_bigint_get_as_i64_f3ebc5a755000afd:()=>K,__wbg___wbindgen_boolean_get_6d5a1ee65bab5f68:()=>Z,__wbg___wbindgen_debug_string_df47ffb5e35e6763:()=>ee,__wbg___wbindgen_in_bb933bd9e1b3bc0f:()=>te,__wbg___wbindgen_is_bigint_cb320707dcd35f0b:()=>ne,__wbg___wbindgen_is_function_ee8a6c5833c90377:()=>re,__wbg___wbindgen_is_object_c818261d21f283a4:()=>_e,__wbg___wbindgen_is_string_fbb76cb2940daafd:()=>oe,__wbg___wbindgen_is_undefined_2d472862bd29a478:()=>ce,__wbg___wbindgen_jsval_eq_6b13ab83478b1c50:()=>ie,__wbg___wbindgen_jsval_loose_eq_b664b38a2f582147:()=>se,__wbg___wbindgen_number_get_a20bf9b85341449d:()=>ue,__wbg___wbindgen_string_get_e4f06c90489ad01b:()=>be,__wbg___wbindgen_throw_b855445ff6a94295:()=>fe,__wbg__wbg_cb_unref_2454a539ea5790d9:()=>ae,__wbg_call_525440f72fbfc0ea:()=>ge,__wbg_call_e762c39fa8ea36bf:()=>le,__wbg_crypto_805be4ce92f1e370:()=>de,__wbg_done_2042aa2670fb1db1:()=>we,__wbg_entries_e171b586f8f6bdbf:()=>pe,__wbg_getRandomValues_f6a868620c8bab49:()=>xe,__wbg_getTime_14776bfb48a1bff9:()=>ye,__wbg_get_7bed016f185add81:()=>me,__wbg_get_ece95cf6585650d9:()=>he,__wbg_get_efcb449f58ec27c2:()=>Te,__wbg_get_with_ref_key_1dc361bd10053bfe:()=>Ae,__wbg_has_787fafc980c3ccdb:()=>Se,__wbg_instanceof_ArrayBuffer_70beb1189ca63b38:()=>Fe,__wbg_instanceof_Map_8579b5e2ab5437c7:()=>Ie,__wbg_instanceof_Promise_001fdd42afa1b7ef:()=>qe,__wbg_instanceof_Uint8Array_20c8e73002f7af98:()=>ke,__wbg_isArray_96e0af9891d0945d:()=>Ee,__wbg_isSafeInteger_d216eda7911dde36:()=>Oe,__wbg_iterator_e5822695327a3c39:()=>Me,__wbg_keys_b4d27b02ad14f4be:()=>ve,__wbg_length_69bca3cb64fc8748:()=>De,__wbg_length_cdd215e10d9dd507:()=>je,__wbg_msCrypto_2ac4d17c4748234a:()=>Be,__wbg_new_0_f9740686d739025c:()=>Re,__wbg_new_1acc0b6eea89d040:()=>Ue,__wbg_new_3c3d849046688a66:()=>Le,__wbg_new_5a79be3ab53b8aa5:()=>Ne,__wbg_new_68651c719dcda04e:()=>Ce,__wbg_new_e17d9f43105b08be:()=>$e,__wbg_new_from_slice_92f4d78ca282a2d2:()=>Ve,__wbg_new_no_args_ee98eee5275000a4:()=>We,__wbg_new_with_length_01aa0dc35aa13543:()=>ze,__wbg_next_020810e0ae8ebcb0:()=>Pe,__wbg_next_2c826fe5dfec6b6a:()=>Ge,__wbg_node_ecc8306b9857f33d:()=>Qe,__wbg_now_793306c526e2e3b6:()=>He,__wbg_now_7fd00a794a07d388:()=>Je,__wbg_now_b3f7572f6ef3d3a9:()=>Xe,__wbg_process_5cff2739921be718:()=>Ye,__wbg_prototypesetcall_2a6620b6922694b2:()=>Ke,__wbg_push_df81a39d04db858c:()=>Ze,__wbg_queueMicrotask_5a8a9131f3f0b37b:()=>et,__wbg_queueMicrotask_6d79674585219521:()=>tt,__wbg_randomFillSync_d3c85af7e31cf1f8:()=>nt,__wbg_require_0c566c6f2eef6c79:()=>rt,__wbg_resolve_caf97c30b83f7053:()=>_t,__wbg_setTimeout_5d6a1d4fc51ea450:()=>ot,__wbg_set_3f1d0b984ed272ed:()=>ct,__wbg_set_907fb406c34a251d:()=>it,__wbg_set_c213c871859d6500:()=>st,__wbg_set_c2abbebe8b9ebee1:()=>ut,__wbg_set_wasm:()=>$,__wbg_static_accessor_GLOBAL_89e1d9ac6a1b250e:()=>bt,__wbg_static_accessor_GLOBAL_THIS_8b530f326a9e48ac:()=>ft,__wbg_static_accessor_SELF_6fdf4b64710cc91b:()=>at,__wbg_static_accessor_WINDOW_b45bfc5a37f6cfa2:()=>gt,__wbg_subarray_480600f3d6a9f26c:()=>lt,__wbg_then_4f46f6544e6b4a28:()=>dt,__wbg_then_70d05cf780a18d77:()=>wt,__wbg_valueOf_9eee4828c11458ca:()=>pt,__wbg_value_692627309814bb8c:()=>xt,__wbg_versions_a8e5a362e1f16442:()=>yt,__wbindgen_cast_126e48f66237b479:()=>mt,__wbindgen_cast_2241b6af4c4b2941:()=>ht,__wbindgen_cast_4625c577ab2ec9ee:()=>Tt,__wbindgen_cast_9ae0607507abb057:()=>At,__wbindgen_cast_cb9088102bce6b30:()=>St,__wbindgen_cast_d6cd19b81560fd6e:()=>Ft,__wbindgen_init_externref_table:()=>It,debug_panic:()=>P,getBuildTimeInfo:()=>G});module.exports=C(qt);var h=()=>{};h.prototype=h;let r;function $(e){r=e}let T=null;function p(){return(T===null||T.byteLength===0)&&(T=new Uint8Array(r.memory.buffer)),T}let A=new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0});A.decode();const V=2146435072;let I=0;function W(e,t){return I+=t,I>=V&&(A=new TextDecoder("utf-8",{ignoreBOM:!0,fatal:!0}),A.decode(),I=t),A.decode(p().subarray(e,e+t))}function S(e,t){return e=e>>>0,W(e,t)}let u=0;const x=new TextEncoder;"encodeInto"in x||(x.encodeInto=function(e,t){const n=x.encode(e);return t.set(n),{read:e.length,written:n.length}});function b(e,t,n){if(n===void 0){const s=x.encode(e),f=t(s.length,1)>>>0;return p().subarray(f,f+s.length).set(s),u=s.length,f}let _=e.length,o=t(_,1)>>>0;const i=p();let c=0;for(;c<_;c++){const s=e.charCodeAt(c);if(s>127)break;i[o+c]=s}if(c!==_){c!==0&&(e=e.slice(c)),o=n(o,_,_=c+e.length*3,1)>>>0;const s=p().subarray(o+c,o+_),f=x.encodeInto(e,s);c+=f.written,o=n(o,_,c,1)>>>0}return u=c,o}let w=null;function l(){return(w===null||w.buffer.detached===!0||w.buffer.detached===void 0&&w.buffer!==r.memory.buffer)&&(w=new DataView(r.memory.buffer)),w}function a(e){return e==null}function q(e){const t=typeof e;if(t=="number"||t=="boolean"||e==null)return`${e}`;if(t=="string")return`"${e}"`;if(t=="symbol"){const o=e.description;return o==null?"Symbol":`Symbol(${o})`}if(t=="function"){const o=e.name;return typeof o=="string"&&o.length>0?`Function(${o})`:"Function"}if(Array.isArray(e)){const o=e.length;let i="[";o>0&&(i+=q(e[0]));for(let c=1;c1)_=n[1];else return toString.call(e);if(_=="Object")try{return"Object("+JSON.stringify(e)+")"}catch{return"Object"}return e instanceof Error?`${e.name}: ${e.message} -${e.stack}`:_}function y(e){const t=r.__externref_table_alloc();return r.__wbindgen_externrefs.set(t,e),t}function g(e,t){try{return e.apply(this,t)}catch(n){const _=y(n);r.__wbindgen_exn_store(_)}}function k(e,t){return e=e>>>0,p().subarray(e/1,e/1+t)}const O=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(e=>e.dtor(e.a,e.b));function z(e,t,n,_){const o={a:e,b:t,cnt:1,dtor:n},i=(...c)=>{o.cnt++;const s=o.a;o.a=0;try{return _(s,o.b,...c)}finally{o.a=s,i._wbg_cb_unref()}};return i._wbg_cb_unref=()=>{--o.cnt===0&&(o.dtor(o.a,o.b),o.a=0,O.unregister(o))},O.register(i,o,o),i}function M(e){const t=r.__wbindgen_externrefs.get(e);return r.__externref_table_dealloc(e),t}function P(e){var t=a(e)?0:b(e,r.__wbindgen_malloc,r.__wbindgen_realloc),n=u;const _=r.debug_panic(t,n);if(_[1])throw M(_[0])}function G(){return r.getBuildTimeInfo()}function Q(e,t,n){r.wasm_bindgen__convert__closures_____invoke__ha235f3ea55a06a09(e,t,n)}function H(e,t,n,_){r.wasm_bindgen__convert__closures_____invoke__h1a2f20be69ab8911(e,t,n,_)}const v=typeof FinalizationRegistry>"u"?{register:()=>{},unregister:()=>{}}:new FinalizationRegistry(e=>r.__wbg_queryengine_free(e>>>0,1));class E{__destroy_into_raw(){const t=this.__wbg_ptr;return this.__wbg_ptr=0,v.unregister(this),t}free(){const t=this.__destroy_into_raw();r.__wbg_queryengine_free(t,0)}disconnect(t,n){const _=b(t,r.__wbindgen_malloc,r.__wbindgen_realloc),o=u,i=b(n,r.__wbindgen_malloc,r.__wbindgen_realloc),c=u;return r.queryengine_disconnect(this.__wbg_ptr,_,o,i,c)}startTransaction(t,n,_){const o=b(t,r.__wbindgen_malloc,r.__wbindgen_realloc),i=u,c=b(n,r.__wbindgen_malloc,r.__wbindgen_realloc),s=u,f=b(_,r.__wbindgen_malloc,r.__wbindgen_realloc),d=u;return r.queryengine_startTransaction(this.__wbg_ptr,o,i,c,s,f,d)}commitTransaction(t,n,_){const o=b(t,r.__wbindgen_malloc,r.__wbindgen_realloc),i=u,c=b(n,r.__wbindgen_malloc,r.__wbindgen_realloc),s=u,f=b(_,r.__wbindgen_malloc,r.__wbindgen_realloc),d=u;return r.queryengine_commitTransaction(this.__wbg_ptr,o,i,c,s,f,d)}rollbackTransaction(t,n,_){const o=b(t,r.__wbindgen_malloc,r.__wbindgen_realloc),i=u,c=b(n,r.__wbindgen_malloc,r.__wbindgen_realloc),s=u,f=b(_,r.__wbindgen_malloc,r.__wbindgen_realloc),d=u;return r.queryengine_rollbackTransaction(this.__wbg_ptr,o,i,c,s,f,d)}constructor(t,n,_){const o=r.queryengine_new(t,n,_);if(o[2])throw M(o[1]);return this.__wbg_ptr=o[0]>>>0,v.register(this,this.__wbg_ptr,this),this}query(t,n,_,o){const i=b(t,r.__wbindgen_malloc,r.__wbindgen_realloc),c=u,s=b(n,r.__wbindgen_malloc,r.__wbindgen_realloc),f=u;var d=a(_)?0:b(_,r.__wbindgen_malloc,r.__wbindgen_realloc),m=u;const D=b(o,r.__wbindgen_malloc,r.__wbindgen_realloc),j=u;return r.queryengine_query(this.__wbg_ptr,i,c,s,f,d,m,D,j)}trace(t){const n=b(t,r.__wbindgen_malloc,r.__wbindgen_realloc),_=u;return r.queryengine_trace(this.__wbg_ptr,n,_)}connect(t,n){const _=b(t,r.__wbindgen_malloc,r.__wbindgen_realloc),o=u,i=b(n,r.__wbindgen_malloc,r.__wbindgen_realloc),c=u;return r.queryengine_connect(this.__wbg_ptr,_,o,i,c)}metrics(t){const n=b(t,r.__wbindgen_malloc,r.__wbindgen_realloc),_=u;return r.queryengine_metrics(this.__wbg_ptr,n,_)}}Symbol.dispose&&(E.prototype[Symbol.dispose]=E.prototype.free);function J(e,t){return Error(S(e,t))}function X(e){return Number(e)}function Y(e,t){const n=String(t),_=b(n,r.__wbindgen_malloc,r.__wbindgen_realloc),o=u;l().setInt32(e+4*1,o,!0),l().setInt32(e+4*0,_,!0)}function K(e,t){const n=t,_=typeof n=="bigint"?n:void 0;l().setBigInt64(e+8*1,a(_)?BigInt(0):_,!0),l().setInt32(e+4*0,!a(_),!0)}function Z(e){const t=e,n=typeof t=="boolean"?t:void 0;return a(n)?16777215:n?1:0}function ee(e,t){const n=q(t),_=b(n,r.__wbindgen_malloc,r.__wbindgen_realloc),o=u;l().setInt32(e+4*1,o,!0),l().setInt32(e+4*0,_,!0)}function te(e,t){return e in t}function ne(e){return typeof e=="bigint"}function re(e){return typeof e=="function"}function _e(e){const t=e;return typeof t=="object"&&t!==null}function oe(e){return typeof e=="string"}function ce(e){return e===void 0}function ie(e,t){return e===t}function se(e,t){return e==t}function ue(e,t){const n=t,_=typeof n=="number"?n:void 0;l().setFloat64(e+8*1,a(_)?0:_,!0),l().setInt32(e+4*0,!a(_),!0)}function be(e,t){const n=t,_=typeof n=="string"?n:void 0;var o=a(_)?0:b(_,r.__wbindgen_malloc,r.__wbindgen_realloc),i=u;l().setInt32(e+4*1,i,!0),l().setInt32(e+4*0,o,!0)}function fe(e,t){throw new Error(S(e,t))}function ae(e){e._wbg_cb_unref()}function ge(){return g(function(e,t,n){return e.call(t,n)},arguments)}function le(){return g(function(e,t){return e.call(t)},arguments)}function de(e){return e.crypto}function we(e){return e.done}function pe(e){return Object.entries(e)}function xe(){return g(function(e,t){e.getRandomValues(t)},arguments)}function ye(e){return e.getTime()}function me(e,t){return e[t>>>0]}function he(){return g(function(e,t){return e[t]},arguments)}function Te(){return g(function(e,t){return Reflect.get(e,t)},arguments)}function Ae(e,t){return e[t]}function Se(){return g(function(e,t){return Reflect.has(e,t)},arguments)}function Fe(e){let t;try{t=e instanceof ArrayBuffer}catch{t=!1}return t}function Ie(e){let t;try{t=e instanceof Map}catch{t=!1}return t}function qe(e){let t;try{t=e instanceof Promise}catch{t=!1}return t}function ke(e){let t;try{t=e instanceof Uint8Array}catch{t=!1}return t}function Ee(e){return Array.isArray(e)}function Oe(e){return Number.isSafeInteger(e)}function Me(){return Symbol.iterator}function ve(e){return Object.keys(e)}function De(e){return e.length}function je(e){return e.length}function Be(e){return e.msCrypto}function Re(){return new Date}function Ue(){return new Object}function Le(e,t){try{var n={a:e,b:t},_=(i,c)=>{const s=n.a;n.a=0;try{return H(s,n.b,i,c)}finally{n.a=s}};return new Promise(_)}finally{n.a=n.b=0}}function Ne(e){return new Uint8Array(e)}function Ce(){return new Map}function $e(){return new Array}function Ve(e,t){return new Uint8Array(k(e,t))}function We(e,t){return new h(S(e,t))}function ze(e){return new Uint8Array(e>>>0)}function Pe(){return g(function(e){return e.next()},arguments)}function Ge(e){return e.next}function Qe(e){return e.node}function He(){return Date.now()}function Je(e){return e.now()}function Xe(){return g(function(){return Date.now()},arguments)}function Ye(e){return e.process}function Ke(e,t,n){Uint8Array.prototype.set.call(k(e,t),n)}function Ze(e,t){return e.push(t)}function et(e){return e.queueMicrotask}function tt(e){queueMicrotask(e)}function nt(){return g(function(e,t){e.randomFillSync(t)},arguments)}function rt(){return g(function(){return module.require},arguments)}function _t(e){return Promise.resolve(e)}function ot(e,t){return setTimeout(e,t>>>0)}function ct(e,t,n){e[t]=n}function it(e,t,n){return e.set(t,n)}function st(e,t,n){e[t>>>0]=n}function ut(){return g(function(e,t,n){return Reflect.set(e,t,n)},arguments)}function bt(){const e=typeof global>"u"?null:global;return a(e)?0:y(e)}function ft(){const e=typeof globalThis>"u"?null:globalThis;return a(e)?0:y(e)}function at(){const e=typeof self>"u"?null:self;return a(e)?0:y(e)}function gt(){const e=typeof window>"u"?null:window;return a(e)?0:y(e)}function lt(e,t,n){return e.subarray(t>>>0,n>>>0)}function dt(e,t){return e.then(t)}function wt(e,t,n){return e.then(t,n)}function pt(e){return e.valueOf()}function xt(e){return e.value}function yt(e){return e.versions}function mt(e,t){return z(e,t,r.wasm_bindgen__closure__destroy__hf9ae564cf31e91c2,Q)}function ht(e,t){return S(e,t)}function Tt(e){return BigInt.asUintN(64,e)}function At(e){return e}function St(e,t){return k(e,t)}function Ft(e){return e}function It(){const e=r.__wbindgen_externrefs,t=e.grow(4);e.set(0,void 0),e.set(t+0,void 0),e.set(t+1,null),e.set(t+2,!0),e.set(t+3,!1)}0&&(module.exports={QueryEngine,__wbg_Error_e83987f665cf5504,__wbg_Number_bb48ca12f395cd08,__wbg_String_8f0eb39a4a4c2f66,__wbg___wbindgen_bigint_get_as_i64_f3ebc5a755000afd,__wbg___wbindgen_boolean_get_6d5a1ee65bab5f68,__wbg___wbindgen_debug_string_df47ffb5e35e6763,__wbg___wbindgen_in_bb933bd9e1b3bc0f,__wbg___wbindgen_is_bigint_cb320707dcd35f0b,__wbg___wbindgen_is_function_ee8a6c5833c90377,__wbg___wbindgen_is_object_c818261d21f283a4,__wbg___wbindgen_is_string_fbb76cb2940daafd,__wbg___wbindgen_is_undefined_2d472862bd29a478,__wbg___wbindgen_jsval_eq_6b13ab83478b1c50,__wbg___wbindgen_jsval_loose_eq_b664b38a2f582147,__wbg___wbindgen_number_get_a20bf9b85341449d,__wbg___wbindgen_string_get_e4f06c90489ad01b,__wbg___wbindgen_throw_b855445ff6a94295,__wbg__wbg_cb_unref_2454a539ea5790d9,__wbg_call_525440f72fbfc0ea,__wbg_call_e762c39fa8ea36bf,__wbg_crypto_805be4ce92f1e370,__wbg_done_2042aa2670fb1db1,__wbg_entries_e171b586f8f6bdbf,__wbg_getRandomValues_f6a868620c8bab49,__wbg_getTime_14776bfb48a1bff9,__wbg_get_7bed016f185add81,__wbg_get_ece95cf6585650d9,__wbg_get_efcb449f58ec27c2,__wbg_get_with_ref_key_1dc361bd10053bfe,__wbg_has_787fafc980c3ccdb,__wbg_instanceof_ArrayBuffer_70beb1189ca63b38,__wbg_instanceof_Map_8579b5e2ab5437c7,__wbg_instanceof_Promise_001fdd42afa1b7ef,__wbg_instanceof_Uint8Array_20c8e73002f7af98,__wbg_isArray_96e0af9891d0945d,__wbg_isSafeInteger_d216eda7911dde36,__wbg_iterator_e5822695327a3c39,__wbg_keys_b4d27b02ad14f4be,__wbg_length_69bca3cb64fc8748,__wbg_length_cdd215e10d9dd507,__wbg_msCrypto_2ac4d17c4748234a,__wbg_new_0_f9740686d739025c,__wbg_new_1acc0b6eea89d040,__wbg_new_3c3d849046688a66,__wbg_new_5a79be3ab53b8aa5,__wbg_new_68651c719dcda04e,__wbg_new_e17d9f43105b08be,__wbg_new_from_slice_92f4d78ca282a2d2,__wbg_new_no_args_ee98eee5275000a4,__wbg_new_with_length_01aa0dc35aa13543,__wbg_next_020810e0ae8ebcb0,__wbg_next_2c826fe5dfec6b6a,__wbg_node_ecc8306b9857f33d,__wbg_now_793306c526e2e3b6,__wbg_now_7fd00a794a07d388,__wbg_now_b3f7572f6ef3d3a9,__wbg_process_5cff2739921be718,__wbg_prototypesetcall_2a6620b6922694b2,__wbg_push_df81a39d04db858c,__wbg_queueMicrotask_5a8a9131f3f0b37b,__wbg_queueMicrotask_6d79674585219521,__wbg_randomFillSync_d3c85af7e31cf1f8,__wbg_require_0c566c6f2eef6c79,__wbg_resolve_caf97c30b83f7053,__wbg_setTimeout_5d6a1d4fc51ea450,__wbg_set_3f1d0b984ed272ed,__wbg_set_907fb406c34a251d,__wbg_set_c213c871859d6500,__wbg_set_c2abbebe8b9ebee1,__wbg_set_wasm,__wbg_static_accessor_GLOBAL_89e1d9ac6a1b250e,__wbg_static_accessor_GLOBAL_THIS_8b530f326a9e48ac,__wbg_static_accessor_SELF_6fdf4b64710cc91b,__wbg_static_accessor_WINDOW_b45bfc5a37f6cfa2,__wbg_subarray_480600f3d6a9f26c,__wbg_then_4f46f6544e6b4a28,__wbg_then_70d05cf780a18d77,__wbg_valueOf_9eee4828c11458ca,__wbg_value_692627309814bb8c,__wbg_versions_a8e5a362e1f16442,__wbindgen_cast_126e48f66237b479,__wbindgen_cast_2241b6af4c4b2941,__wbindgen_cast_4625c577ab2ec9ee,__wbindgen_cast_9ae0607507abb057,__wbindgen_cast_cb9088102bce6b30,__wbindgen_cast_d6cd19b81560fd6e,__wbindgen_init_externref_table,debug_panic,getBuildTimeInfo}); diff --git a/frontend/generated/prisma/query_engine_bg.wasm b/frontend/generated/prisma/query_engine_bg.wasm deleted file mode 100644 index 82eba79..0000000 Binary files a/frontend/generated/prisma/query_engine_bg.wasm and /dev/null differ diff --git a/frontend/generated/prisma/runtime/edge-esm.js b/frontend/generated/prisma/runtime/edge-esm.js deleted file mode 100644 index 060644c..0000000 --- a/frontend/generated/prisma/runtime/edge-esm.js +++ /dev/null @@ -1,35 +0,0 @@ - -/* !!! This is code generated by Prisma. Do not edit directly. !!! -/* eslint-disable */ -// biome-ignore-all lint: generated file -var ca=Object.create;var rn=Object.defineProperty;var pa=Object.getOwnPropertyDescriptor;var ma=Object.getOwnPropertyNames;var fa=Object.getPrototypeOf,da=Object.prototype.hasOwnProperty;var fe=(e,t)=>()=>(e&&(t=e(e=0)),t);var Je=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),or=(e,t)=>{for(var r in t)rn(e,r,{get:t[r],enumerable:!0})},ga=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of ma(t))!da.call(e,i)&&i!==r&&rn(e,i,{get:()=>t[i],enumerable:!(n=pa(t,i))||n.enumerable});return e};var Qe=(e,t,r)=>(r=e!=null?ca(fa(e)):{},ga(t||!e||!e.__esModule?rn(r,"default",{value:e,enumerable:!0}):r,e));var y,b,u=fe(()=>{"use strict";y={nextTick:(e,...t)=>{setTimeout(()=>{e(...t)},0)},env:{},version:"",cwd:()=>"/",stderr:{},argv:["/bin/node"],pid:1e4},{cwd:b}=y});var x,c=fe(()=>{"use strict";x=globalThis.performance??(()=>{let e=Date.now();return{now:()=>Date.now()-e}})()});var E,p=fe(()=>{"use strict";E=()=>{};E.prototype=E});var m=fe(()=>{"use strict"});var Ti=Je(ze=>{"use strict";f();u();c();p();m();var ci=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),ha=ci(e=>{"use strict";e.byteLength=l,e.toByteArray=g,e.fromByteArray=I;var t=[],r=[],n=typeof Uint8Array<"u"?Uint8Array:Array,i="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";for(o=0,s=i.length;o0)throw new Error("Invalid string. Length must be a multiple of 4");var M=S.indexOf("=");M===-1&&(M=C);var F=M===C?0:4-M%4;return[M,F]}function l(S){var C=a(S),M=C[0],F=C[1];return(M+F)*3/4-F}function d(S,C,M){return(C+M)*3/4-M}function g(S){var C,M=a(S),F=M[0],B=M[1],O=new n(d(S,F,B)),L=0,oe=B>0?F-4:F,J;for(J=0;J>16&255,O[L++]=C>>8&255,O[L++]=C&255;return B===2&&(C=r[S.charCodeAt(J)]<<2|r[S.charCodeAt(J+1)]>>4,O[L++]=C&255),B===1&&(C=r[S.charCodeAt(J)]<<10|r[S.charCodeAt(J+1)]<<4|r[S.charCodeAt(J+2)]>>2,O[L++]=C>>8&255,O[L++]=C&255),O}function h(S){return t[S>>18&63]+t[S>>12&63]+t[S>>6&63]+t[S&63]}function T(S,C,M){for(var F,B=[],O=C;Ooe?oe:L+O));return F===1?(C=S[M-1],B.push(t[C>>2]+t[C<<4&63]+"==")):F===2&&(C=(S[M-2]<<8)+S[M-1],B.push(t[C>>10]+t[C>>4&63]+t[C<<2&63]+"=")),B.join("")}}),ya=ci(e=>{e.read=function(t,r,n,i,o){var s,a,l=o*8-i-1,d=(1<>1,h=-7,T=n?o-1:0,I=n?-1:1,S=t[r+T];for(T+=I,s=S&(1<<-h)-1,S>>=-h,h+=l;h>0;s=s*256+t[r+T],T+=I,h-=8);for(a=s&(1<<-h)-1,s>>=-h,h+=i;h>0;a=a*256+t[r+T],T+=I,h-=8);if(s===0)s=1-g;else{if(s===d)return a?NaN:(S?-1:1)*(1/0);a=a+Math.pow(2,i),s=s-g}return(S?-1:1)*a*Math.pow(2,s-i)},e.write=function(t,r,n,i,o,s){var a,l,d,g=s*8-o-1,h=(1<>1,I=o===23?Math.pow(2,-24)-Math.pow(2,-77):0,S=i?0:s-1,C=i?1:-1,M=r<0||r===0&&1/r<0?1:0;for(r=Math.abs(r),isNaN(r)||r===1/0?(l=isNaN(r)?1:0,a=h):(a=Math.floor(Math.log(r)/Math.LN2),r*(d=Math.pow(2,-a))<1&&(a--,d*=2),a+T>=1?r+=I/d:r+=I*Math.pow(2,1-T),r*d>=2&&(a++,d/=2),a+T>=h?(l=0,a=h):a+T>=1?(l=(r*d-1)*Math.pow(2,o),a=a+T):(l=r*Math.pow(2,T-1)*Math.pow(2,o),a=0));o>=8;t[n+S]=l&255,S+=C,l/=256,o-=8);for(a=a<0;t[n+S]=a&255,S+=C,a/=256,g-=8);t[n+S-C]|=M*128}}),nn=ha(),We=ya(),si=typeof Symbol=="function"&&typeof Symbol.for=="function"?Symbol.for("nodejs.util.inspect.custom"):null;ze.Buffer=A;ze.SlowBuffer=va;ze.INSPECT_MAX_BYTES=50;var sr=2147483647;ze.kMaxLength=sr;A.TYPED_ARRAY_SUPPORT=wa();!A.TYPED_ARRAY_SUPPORT&&typeof console<"u"&&typeof console.error=="function"&&console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");function wa(){try{let e=new Uint8Array(1),t={foo:function(){return 42}};return Object.setPrototypeOf(t,Uint8Array.prototype),Object.setPrototypeOf(e,t),e.foo()===42}catch{return!1}}Object.defineProperty(A.prototype,"parent",{enumerable:!0,get:function(){if(A.isBuffer(this))return this.buffer}});Object.defineProperty(A.prototype,"offset",{enumerable:!0,get:function(){if(A.isBuffer(this))return this.byteOffset}});function xe(e){if(e>sr)throw new RangeError('The value "'+e+'" is invalid for option "size"');let t=new Uint8Array(e);return Object.setPrototypeOf(t,A.prototype),t}function A(e,t,r){if(typeof e=="number"){if(typeof t=="string")throw new TypeError('The "string" argument must be of type string. Received type number');return an(e)}return pi(e,t,r)}A.poolSize=8192;function pi(e,t,r){if(typeof e=="string")return ba(e,t);if(ArrayBuffer.isView(e))return xa(e);if(e==null)throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type "+typeof e);if(de(e,ArrayBuffer)||e&&de(e.buffer,ArrayBuffer)||typeof SharedArrayBuffer<"u"&&(de(e,SharedArrayBuffer)||e&&de(e.buffer,SharedArrayBuffer)))return fi(e,t,r);if(typeof e=="number")throw new TypeError('The "value" argument must not be of type number. Received type number');let n=e.valueOf&&e.valueOf();if(n!=null&&n!==e)return A.from(n,t,r);let i=Pa(e);if(i)return i;if(typeof Symbol<"u"&&Symbol.toPrimitive!=null&&typeof e[Symbol.toPrimitive]=="function")return A.from(e[Symbol.toPrimitive]("string"),t,r);throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type "+typeof e)}A.from=function(e,t,r){return pi(e,t,r)};Object.setPrototypeOf(A.prototype,Uint8Array.prototype);Object.setPrototypeOf(A,Uint8Array);function mi(e){if(typeof e!="number")throw new TypeError('"size" argument must be of type number');if(e<0)throw new RangeError('The value "'+e+'" is invalid for option "size"')}function Ea(e,t,r){return mi(e),e<=0?xe(e):t!==void 0?typeof r=="string"?xe(e).fill(t,r):xe(e).fill(t):xe(e)}A.alloc=function(e,t,r){return Ea(e,t,r)};function an(e){return mi(e),xe(e<0?0:ln(e)|0)}A.allocUnsafe=function(e){return an(e)};A.allocUnsafeSlow=function(e){return an(e)};function ba(e,t){if((typeof t!="string"||t==="")&&(t="utf8"),!A.isEncoding(t))throw new TypeError("Unknown encoding: "+t);let r=di(e,t)|0,n=xe(r),i=n.write(e,t);return i!==r&&(n=n.slice(0,i)),n}function on(e){let t=e.length<0?0:ln(e.length)|0,r=xe(t);for(let n=0;n=sr)throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+sr.toString(16)+" bytes");return e|0}function va(e){return+e!=e&&(e=0),A.alloc(+e)}A.isBuffer=function(e){return e!=null&&e._isBuffer===!0&&e!==A.prototype};A.compare=function(e,t){if(de(e,Uint8Array)&&(e=A.from(e,e.offset,e.byteLength)),de(t,Uint8Array)&&(t=A.from(t,t.offset,t.byteLength)),!A.isBuffer(e)||!A.isBuffer(t))throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');if(e===t)return 0;let r=e.length,n=t.length;for(let i=0,o=Math.min(r,n);in.length?(A.isBuffer(o)||(o=A.from(o)),o.copy(n,i)):Uint8Array.prototype.set.call(n,o,i);else if(A.isBuffer(o))o.copy(n,i);else throw new TypeError('"list" argument must be an Array of Buffers');i+=o.length}return n};function di(e,t){if(A.isBuffer(e))return e.length;if(ArrayBuffer.isView(e)||de(e,ArrayBuffer))return e.byteLength;if(typeof e!="string")throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type '+typeof e);let r=e.length,n=arguments.length>2&&arguments[2]===!0;if(!n&&r===0)return 0;let i=!1;for(;;)switch(t){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":return sn(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return r*2;case"hex":return r>>>1;case"base64":return vi(e).length;default:if(i)return n?-1:sn(e).length;t=(""+t).toLowerCase(),i=!0}}A.byteLength=di;function Ta(e,t,r){let n=!1;if((t===void 0||t<0)&&(t=0),t>this.length||((r===void 0||r>this.length)&&(r=this.length),r<=0)||(r>>>=0,t>>>=0,r<=t))return"";for(e||(e="utf8");;)switch(e){case"hex":return _a(this,t,r);case"utf8":case"utf-8":return hi(this,t,r);case"ascii":return Da(this,t,r);case"latin1":case"binary":return Ma(this,t,r);case"base64":return Oa(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return Na(this,t,r);default:if(n)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),n=!0}}A.prototype._isBuffer=!0;function Le(e,t,r){let n=e[t];e[t]=e[r],e[r]=n}A.prototype.swap16=function(){let e=this.length;if(e%2!==0)throw new RangeError("Buffer size must be a multiple of 16-bits");for(let t=0;tt&&(e+=" ... "),""};si&&(A.prototype[si]=A.prototype.inspect);A.prototype.compare=function(e,t,r,n,i){if(de(e,Uint8Array)&&(e=A.from(e,e.offset,e.byteLength)),!A.isBuffer(e))throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type '+typeof e);if(t===void 0&&(t=0),r===void 0&&(r=e?e.length:0),n===void 0&&(n=0),i===void 0&&(i=this.length),t<0||r>e.length||n<0||i>this.length)throw new RangeError("out of range index");if(n>=i&&t>=r)return 0;if(n>=i)return-1;if(t>=r)return 1;if(t>>>=0,r>>>=0,n>>>=0,i>>>=0,this===e)return 0;let o=i-n,s=r-t,a=Math.min(o,s),l=this.slice(n,i),d=e.slice(t,r);for(let g=0;g2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),r=+r,cn(r)&&(r=i?0:e.length-1),r<0&&(r=e.length+r),r>=e.length){if(i)return-1;r=e.length-1}else if(r<0)if(i)r=0;else return-1;if(typeof t=="string"&&(t=A.from(t,n)),A.isBuffer(t))return t.length===0?-1:ai(e,t,r,n,i);if(typeof t=="number")return t=t&255,typeof Uint8Array.prototype.indexOf=="function"?i?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):ai(e,[t],r,n,i);throw new TypeError("val must be string, number or Buffer")}function ai(e,t,r,n,i){let o=1,s=e.length,a=t.length;if(n!==void 0&&(n=String(n).toLowerCase(),n==="ucs2"||n==="ucs-2"||n==="utf16le"||n==="utf-16le")){if(e.length<2||t.length<2)return-1;o=2,s/=2,a/=2,r/=2}function l(g,h){return o===1?g[h]:g.readUInt16BE(h*o)}let d;if(i){let g=-1;for(d=r;ds&&(r=s-a),d=r;d>=0;d--){let g=!0;for(let h=0;hi&&(n=i)):n=i;let o=t.length;n>o/2&&(n=o/2);let s;for(s=0;s>>0,isFinite(r)?(r=r>>>0,n===void 0&&(n="utf8")):(n=r,r=void 0);else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");let i=this.length-t;if((r===void 0||r>i)&&(r=i),e.length>0&&(r<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");let o=!1;for(;;)switch(n){case"hex":return Aa(this,e,t,r);case"utf8":case"utf-8":return Ra(this,e,t,r);case"ascii":case"latin1":case"binary":return Ca(this,e,t,r);case"base64":return Sa(this,e,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return Ia(this,e,t,r);default:if(o)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),o=!0}};A.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};function Oa(e,t,r){return t===0&&r===e.length?nn.fromByteArray(e):nn.fromByteArray(e.slice(t,r))}function hi(e,t,r){r=Math.min(e.length,r);let n=[],i=t;for(;i239?4:o>223?3:o>191?2:1;if(i+a<=r){let l,d,g,h;switch(a){case 1:o<128&&(s=o);break;case 2:l=e[i+1],(l&192)===128&&(h=(o&31)<<6|l&63,h>127&&(s=h));break;case 3:l=e[i+1],d=e[i+2],(l&192)===128&&(d&192)===128&&(h=(o&15)<<12|(l&63)<<6|d&63,h>2047&&(h<55296||h>57343)&&(s=h));break;case 4:l=e[i+1],d=e[i+2],g=e[i+3],(l&192)===128&&(d&192)===128&&(g&192)===128&&(h=(o&15)<<18|(l&63)<<12|(d&63)<<6|g&63,h>65535&&h<1114112&&(s=h))}}s===null?(s=65533,a=1):s>65535&&(s-=65536,n.push(s>>>10&1023|55296),s=56320|s&1023),n.push(s),i+=a}return ka(n)}var li=4096;function ka(e){let t=e.length;if(t<=li)return String.fromCharCode.apply(String,e);let r="",n=0;for(;nn)&&(r=n);let i="";for(let o=t;or&&(e=r),t<0?(t+=r,t<0&&(t=0)):t>r&&(t=r),tr)throw new RangeError("Trying to access beyond buffer length")}A.prototype.readUintLE=A.prototype.readUIntLE=function(e,t,r){e=e>>>0,t=t>>>0,r||W(e,t,this.length);let n=this[e],i=1,o=0;for(;++o>>0,t=t>>>0,r||W(e,t,this.length);let n=this[e+--t],i=1;for(;t>0&&(i*=256);)n+=this[e+--t]*i;return n};A.prototype.readUint8=A.prototype.readUInt8=function(e,t){return e=e>>>0,t||W(e,1,this.length),this[e]};A.prototype.readUint16LE=A.prototype.readUInt16LE=function(e,t){return e=e>>>0,t||W(e,2,this.length),this[e]|this[e+1]<<8};A.prototype.readUint16BE=A.prototype.readUInt16BE=function(e,t){return e=e>>>0,t||W(e,2,this.length),this[e]<<8|this[e+1]};A.prototype.readUint32LE=A.prototype.readUInt32LE=function(e,t){return e=e>>>0,t||W(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+this[e+3]*16777216};A.prototype.readUint32BE=A.prototype.readUInt32BE=function(e,t){return e=e>>>0,t||W(e,4,this.length),this[e]*16777216+(this[e+1]<<16|this[e+2]<<8|this[e+3])};A.prototype.readBigUInt64LE=Re(function(e){e=e>>>0,He(e,"offset");let t=this[e],r=this[e+7];(t===void 0||r===void 0)&&xt(e,this.length-8);let n=t+this[++e]*2**8+this[++e]*2**16+this[++e]*2**24,i=this[++e]+this[++e]*2**8+this[++e]*2**16+r*2**24;return BigInt(n)+(BigInt(i)<>>0,He(e,"offset");let t=this[e],r=this[e+7];(t===void 0||r===void 0)&&xt(e,this.length-8);let n=t*2**24+this[++e]*2**16+this[++e]*2**8+this[++e],i=this[++e]*2**24+this[++e]*2**16+this[++e]*2**8+r;return(BigInt(n)<>>0,t=t>>>0,r||W(e,t,this.length);let n=this[e],i=1,o=0;for(;++o=i&&(n-=Math.pow(2,8*t)),n};A.prototype.readIntBE=function(e,t,r){e=e>>>0,t=t>>>0,r||W(e,t,this.length);let n=t,i=1,o=this[e+--n];for(;n>0&&(i*=256);)o+=this[e+--n]*i;return i*=128,o>=i&&(o-=Math.pow(2,8*t)),o};A.prototype.readInt8=function(e,t){return e=e>>>0,t||W(e,1,this.length),this[e]&128?(255-this[e]+1)*-1:this[e]};A.prototype.readInt16LE=function(e,t){e=e>>>0,t||W(e,2,this.length);let r=this[e]|this[e+1]<<8;return r&32768?r|4294901760:r};A.prototype.readInt16BE=function(e,t){e=e>>>0,t||W(e,2,this.length);let r=this[e+1]|this[e]<<8;return r&32768?r|4294901760:r};A.prototype.readInt32LE=function(e,t){return e=e>>>0,t||W(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24};A.prototype.readInt32BE=function(e,t){return e=e>>>0,t||W(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]};A.prototype.readBigInt64LE=Re(function(e){e=e>>>0,He(e,"offset");let t=this[e],r=this[e+7];(t===void 0||r===void 0)&&xt(e,this.length-8);let n=this[e+4]+this[e+5]*2**8+this[e+6]*2**16+(r<<24);return(BigInt(n)<>>0,He(e,"offset");let t=this[e],r=this[e+7];(t===void 0||r===void 0)&&xt(e,this.length-8);let n=(t<<24)+this[++e]*2**16+this[++e]*2**8+this[++e];return(BigInt(n)<>>0,t||W(e,4,this.length),We.read(this,e,!0,23,4)};A.prototype.readFloatBE=function(e,t){return e=e>>>0,t||W(e,4,this.length),We.read(this,e,!1,23,4)};A.prototype.readDoubleLE=function(e,t){return e=e>>>0,t||W(e,8,this.length),We.read(this,e,!0,52,8)};A.prototype.readDoubleBE=function(e,t){return e=e>>>0,t||W(e,8,this.length),We.read(this,e,!1,52,8)};function re(e,t,r,n,i,o){if(!A.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>i||te.length)throw new RangeError("Index out of range")}A.prototype.writeUintLE=A.prototype.writeUIntLE=function(e,t,r,n){if(e=+e,t=t>>>0,r=r>>>0,!n){let s=Math.pow(2,8*r)-1;re(this,e,t,r,s,0)}let i=1,o=0;for(this[t]=e&255;++o>>0,r=r>>>0,!n){let s=Math.pow(2,8*r)-1;re(this,e,t,r,s,0)}let i=r-1,o=1;for(this[t+i]=e&255;--i>=0&&(o*=256);)this[t+i]=e/o&255;return t+r};A.prototype.writeUint8=A.prototype.writeUInt8=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,1,255,0),this[t]=e&255,t+1};A.prototype.writeUint16LE=A.prototype.writeUInt16LE=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,2,65535,0),this[t]=e&255,this[t+1]=e>>>8,t+2};A.prototype.writeUint16BE=A.prototype.writeUInt16BE=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,2,65535,0),this[t]=e>>>8,this[t+1]=e&255,t+2};A.prototype.writeUint32LE=A.prototype.writeUInt32LE=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,4,4294967295,0),this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=e&255,t+4};A.prototype.writeUint32BE=A.prototype.writeUInt32BE=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,4,4294967295,0),this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=e&255,t+4};function yi(e,t,r,n,i){Pi(t,n,i,e,r,7);let o=Number(t&BigInt(4294967295));e[r++]=o,o=o>>8,e[r++]=o,o=o>>8,e[r++]=o,o=o>>8,e[r++]=o;let s=Number(t>>BigInt(32)&BigInt(4294967295));return e[r++]=s,s=s>>8,e[r++]=s,s=s>>8,e[r++]=s,s=s>>8,e[r++]=s,r}function wi(e,t,r,n,i){Pi(t,n,i,e,r,7);let o=Number(t&BigInt(4294967295));e[r+7]=o,o=o>>8,e[r+6]=o,o=o>>8,e[r+5]=o,o=o>>8,e[r+4]=o;let s=Number(t>>BigInt(32)&BigInt(4294967295));return e[r+3]=s,s=s>>8,e[r+2]=s,s=s>>8,e[r+1]=s,s=s>>8,e[r]=s,r+8}A.prototype.writeBigUInt64LE=Re(function(e,t=0){return yi(this,e,t,BigInt(0),BigInt("0xffffffffffffffff"))});A.prototype.writeBigUInt64BE=Re(function(e,t=0){return wi(this,e,t,BigInt(0),BigInt("0xffffffffffffffff"))});A.prototype.writeIntLE=function(e,t,r,n){if(e=+e,t=t>>>0,!n){let a=Math.pow(2,8*r-1);re(this,e,t,r,a-1,-a)}let i=0,o=1,s=0;for(this[t]=e&255;++i>0)-s&255;return t+r};A.prototype.writeIntBE=function(e,t,r,n){if(e=+e,t=t>>>0,!n){let a=Math.pow(2,8*r-1);re(this,e,t,r,a-1,-a)}let i=r-1,o=1,s=0;for(this[t+i]=e&255;--i>=0&&(o*=256);)e<0&&s===0&&this[t+i+1]!==0&&(s=1),this[t+i]=(e/o>>0)-s&255;return t+r};A.prototype.writeInt8=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,1,127,-128),e<0&&(e=255+e+1),this[t]=e&255,t+1};A.prototype.writeInt16LE=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,2,32767,-32768),this[t]=e&255,this[t+1]=e>>>8,t+2};A.prototype.writeInt16BE=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,2,32767,-32768),this[t]=e>>>8,this[t+1]=e&255,t+2};A.prototype.writeInt32LE=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,4,2147483647,-2147483648),this[t]=e&255,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24,t+4};A.prototype.writeInt32BE=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=e&255,t+4};A.prototype.writeBigInt64LE=Re(function(e,t=0){return yi(this,e,t,-BigInt("0x8000000000000000"),BigInt("0x7fffffffffffffff"))});A.prototype.writeBigInt64BE=Re(function(e,t=0){return wi(this,e,t,-BigInt("0x8000000000000000"),BigInt("0x7fffffffffffffff"))});function Ei(e,t,r,n,i,o){if(r+n>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function bi(e,t,r,n,i){return t=+t,r=r>>>0,i||Ei(e,t,r,4,34028234663852886e22,-34028234663852886e22),We.write(e,t,r,n,23,4),r+4}A.prototype.writeFloatLE=function(e,t,r){return bi(this,e,t,!0,r)};A.prototype.writeFloatBE=function(e,t,r){return bi(this,e,t,!1,r)};function xi(e,t,r,n,i){return t=+t,r=r>>>0,i||Ei(e,t,r,8,17976931348623157e292,-17976931348623157e292),We.write(e,t,r,n,52,8),r+8}A.prototype.writeDoubleLE=function(e,t,r){return xi(this,e,t,!0,r)};A.prototype.writeDoubleBE=function(e,t,r){return xi(this,e,t,!1,r)};A.prototype.copy=function(e,t,r,n){if(!A.isBuffer(e))throw new TypeError("argument should be a Buffer");if(r||(r=0),!n&&n!==0&&(n=this.length),t>=e.length&&(t=e.length),t||(t=0),n>0&&n=this.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),e.length-t>>0,r=r===void 0?this.length:r>>>0,e||(e=0);let i;if(typeof e=="number")for(i=t;i2**32?i=ui(String(r)):typeof r=="bigint"&&(i=String(r),(r>BigInt(2)**BigInt(32)||r<-(BigInt(2)**BigInt(32)))&&(i=ui(i)),i+="n"),n+=` It must be ${t}. Received ${i}`,n},RangeError);function ui(e){let t="",r=e.length,n=e[0]==="-"?1:0;for(;r>=n+4;r-=3)t=`_${e.slice(r-3,r)}${t}`;return`${e.slice(0,r)}${t}`}function Fa(e,t,r){He(t,"offset"),(e[t]===void 0||e[t+r]===void 0)&&xt(t,e.length-(r+1))}function Pi(e,t,r,n,i,o){if(e>r||e3?t===0||t===BigInt(0)?a=`>= 0${s} and < 2${s} ** ${(o+1)*8}${s}`:a=`>= -(2${s} ** ${(o+1)*8-1}${s}) and < 2 ** ${(o+1)*8-1}${s}`:a=`>= ${t}${s} and <= ${r}${s}`,new Ke.ERR_OUT_OF_RANGE("value",a,e)}Fa(n,i,o)}function He(e,t){if(typeof e!="number")throw new Ke.ERR_INVALID_ARG_TYPE(t,"number",e)}function xt(e,t,r){throw Math.floor(e)!==e?(He(e,r),new Ke.ERR_OUT_OF_RANGE(r||"offset","an integer",e)):t<0?new Ke.ERR_BUFFER_OUT_OF_BOUNDS:new Ke.ERR_OUT_OF_RANGE(r||"offset",`>= ${r?1:0} and <= ${t}`,e)}var La=/[^+/0-9A-Za-z-_]/g;function Ua(e){if(e=e.split("=")[0],e=e.trim().replace(La,""),e.length<2)return"";for(;e.length%4!==0;)e=e+"=";return e}function sn(e,t){t=t||1/0;let r,n=e.length,i=null,o=[];for(let s=0;s55295&&r<57344){if(!i){if(r>56319){(t-=3)>-1&&o.push(239,191,189);continue}else if(s+1===n){(t-=3)>-1&&o.push(239,191,189);continue}i=r;continue}if(r<56320){(t-=3)>-1&&o.push(239,191,189),i=r;continue}r=(i-55296<<10|r-56320)+65536}else i&&(t-=3)>-1&&o.push(239,191,189);if(i=null,r<128){if((t-=1)<0)break;o.push(r)}else if(r<2048){if((t-=2)<0)break;o.push(r>>6|192,r&63|128)}else if(r<65536){if((t-=3)<0)break;o.push(r>>12|224,r>>6&63|128,r&63|128)}else if(r<1114112){if((t-=4)<0)break;o.push(r>>18|240,r>>12&63|128,r>>6&63|128,r&63|128)}else throw new Error("Invalid code point")}return o}function Ba(e){let t=[];for(let r=0;r>8,i=r%256,o.push(i),o.push(n);return o}function vi(e){return nn.toByteArray(Ua(e))}function ar(e,t,r,n){let i;for(i=0;i=t.length||i>=e.length);++i)t[i+r]=e[i];return i}function de(e,t){return e instanceof t||e!=null&&e.constructor!=null&&e.constructor.name!=null&&e.constructor.name===t.name}function cn(e){return e!==e}var Va=function(){let e="0123456789abcdef",t=new Array(256);for(let r=0;r<16;++r){let n=r*16;for(let i=0;i<16;++i)t[n+i]=e[r]+e[i]}return t}();function Re(e){return typeof BigInt>"u"?$a:e}function $a(){throw new Error("BigInt not supported")}});var w,f=fe(()=>{"use strict";w=Qe(Ti())});function Wa(){return!1}function fn(){return{dev:0,ino:0,mode:0,nlink:0,uid:0,gid:0,rdev:0,size:0,blksize:0,blocks:0,atimeMs:0,mtimeMs:0,ctimeMs:0,birthtimeMs:0,atime:new Date,mtime:new Date,ctime:new Date,birthtime:new Date}}function Ha(){return fn()}function za(){return[]}function Ya(e){e(null,[])}function Za(){return""}function Xa(){return""}function el(){}function tl(){}function rl(){}function nl(){}function il(){}function ol(){}function sl(){}function al(){}function ll(){return{close:()=>{},on:()=>{},removeAllListeners:()=>{}}}function ul(e,t){t(null,fn())}var cl,pl,ji,Gi=fe(()=>{"use strict";f();u();c();p();m();cl={},pl={existsSync:Wa,lstatSync:fn,stat:ul,statSync:Ha,readdirSync:za,readdir:Ya,readlinkSync:Za,realpathSync:Xa,chmodSync:el,renameSync:tl,mkdirSync:rl,rmdirSync:nl,rmSync:il,unlinkSync:ol,watchFile:sl,unwatchFile:al,watch:ll,promises:cl},ji=pl});var Ji=Je((mf,ml)=>{ml.exports={name:"@prisma/internals",version:"6.19.1",description:"This package is intended for Prisma's internal use",main:"dist/index.js",types:"dist/index.d.ts",repository:{type:"git",url:"https://github.com/prisma/prisma.git",directory:"packages/internals"},homepage:"https://www.prisma.io",author:"Tim Suchanek ",bugs:"https://github.com/prisma/prisma/issues",license:"Apache-2.0",scripts:{dev:"DEV=true tsx helpers/build.ts",build:"tsx helpers/build.ts",test:"dotenv -e ../../.db.env -- jest --silent",prepublishOnly:"pnpm run build"},files:["README.md","dist","!**/libquery_engine*","!dist/get-generators/engines/*","scripts"],devDependencies:{"@babel/helper-validator-identifier":"7.25.9","@opentelemetry/api":"1.9.0","@swc/core":"1.11.5","@swc/jest":"0.2.37","@types/babel__helper-validator-identifier":"7.15.2","@types/jest":"29.5.14","@types/node":"18.19.76","@types/resolve":"1.20.6",archiver:"6.0.2","checkpoint-client":"1.1.33","cli-truncate":"4.0.0",dotenv:"16.5.0",empathic:"2.0.0","escape-string-regexp":"5.0.0",execa:"8.0.1","fast-glob":"3.3.3","find-up":"7.0.0","fp-ts":"2.16.9","fs-extra":"11.3.0","global-directory":"4.0.0",globby:"11.1.0","identifier-regex":"1.0.0","indent-string":"4.0.0","is-windows":"1.0.2","is-wsl":"3.1.0",jest:"29.7.0","jest-junit":"16.0.0",kleur:"4.1.5","mock-stdin":"1.0.0","new-github-issue-url":"0.2.1","node-fetch":"3.3.2","npm-packlist":"5.1.3",open:"7.4.2","p-map":"4.0.0",resolve:"1.22.10","string-width":"7.2.0","strip-indent":"4.0.0","temp-dir":"2.0.0",tempy:"1.0.1","terminal-link":"4.0.0",tmp:"0.2.3","ts-pattern":"5.6.2","ts-toolbelt":"9.6.0",typescript:"5.4.5",yarn:"1.22.22"},dependencies:{"@prisma/config":"workspace:*","@prisma/debug":"workspace:*","@prisma/dmmf":"workspace:*","@prisma/driver-adapter-utils":"workspace:*","@prisma/engines":"workspace:*","@prisma/fetch-engine":"workspace:*","@prisma/generator":"workspace:*","@prisma/generator-helper":"workspace:*","@prisma/get-platform":"workspace:*","@prisma/prisma-schema-wasm":"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7","@prisma/schema-engine-wasm":"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7","@prisma/schema-files-loader":"workspace:*",arg:"5.0.2",prompts:"2.4.2"},peerDependencies:{typescript:">=5.1.0"},peerDependenciesMeta:{typescript:{optional:!0}},sideEffects:!1}});function dl(...e){return e.join("/")}function gl(...e){return e.join("/")}function hl(e){let t=Qi(e),r=Ki(e),[n,i]=t.split(".");return{root:"/",dir:r,base:t,ext:i,name:n}}function Qi(e){let t=e.split("/");return t[t.length-1]}function Ki(e){return e.split("/").slice(0,-1).join("/")}function wl(e){let t=e.split("/").filter(i=>i!==""&&i!=="."),r=[];for(let i of t)i===".."?r.pop():r.push(i);let n=r.join("/");return e.startsWith("/")?"/"+n:n}var Wi,yl,El,bl,pr,Hi=fe(()=>{"use strict";f();u();c();p();m();Wi="/",yl=":";El={sep:Wi},bl={basename:Qi,delimiter:yl,dirname:Ki,join:gl,normalize:wl,parse:hl,posix:El,resolve:dl,sep:Wi},pr=bl});var gn=Je((kf,vl)=>{vl.exports={name:"@prisma/engines-version",version:"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7",main:"index.js",types:"index.d.ts",license:"Apache-2.0",author:"Tim Suchanek ",prisma:{enginesVersion:"c2990dca591cba766e3b7ef5d9e8a84796e47ab7"},repository:{type:"git",url:"https://github.com/prisma/engines-wrapper.git",directory:"packages/engines-version"},devDependencies:{"@types/node":"18.19.76",typescript:"4.9.5"},files:["index.js","index.d.ts"],scripts:{build:"tsc -d"}}});var zi=Je(mr=>{"use strict";f();u();c();p();m();Object.defineProperty(mr,"__esModule",{value:!0});mr.enginesVersion=void 0;mr.enginesVersion=gn().prisma.enginesVersion});var Xi=Je((Gf,Zi)=>{"use strict";f();u();c();p();m();Zi.exports=(e,t=1,r)=>{if(r={indent:" ",includeEmptyLines:!1,...r},typeof e!="string")throw new TypeError(`Expected \`input\` to be a \`string\`, got \`${typeof e}\``);if(typeof t!="number")throw new TypeError(`Expected \`count\` to be a \`number\`, got \`${typeof t}\``);if(typeof r.indent!="string")throw new TypeError(`Expected \`options.indent\` to be a \`string\`, got \`${typeof r.indent}\``);if(t===0)return e;let n=r.includeEmptyLines?/^/gm:/^(?!\s*$)/gm;return e.replace(n,r.indent.repeat(t))}});var Sn=Je((jy,Eo)=>{"use strict";f();u();c();p();m();Eo.exports=function(){function e(t,r,n,i,o){return tn?n+1:t+1:i===o?r:r+1}return function(t,r){if(t===r)return 0;if(t.length>r.length){var n=t;t=r,r=n}for(var i=t.length,o=r.length;i>0&&t.charCodeAt(i-1)===r.charCodeAt(o-1);)i--,o--;for(var s=0;s{"use strict";f();u();c();p();m()});var Ao=fe(()=>{"use strict";f();u();c();p();m()});var Vr,Qo=fe(()=>{"use strict";f();u();c();p();m();Vr=class{events={};on(t,r){return this.events[t]||(this.events[t]=[]),this.events[t].push(r),this}emit(t,...r){return this.events[t]?(this.events[t].forEach(n=>{n(...r)}),!0):!1}}});f();u();c();p();m();var Ci={};or(Ci,{defineExtension:()=>Ai,getExtensionContext:()=>Ri});f();u();c();p();m();f();u();c();p();m();function Ai(e){return typeof e=="function"?e:t=>t.$extends(e)}f();u();c();p();m();function Ri(e){return e}var Ii={};or(Ii,{validator:()=>Si});f();u();c();p();m();f();u();c();p();m();function Si(...e){return t=>t}f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();var pn,Oi,ki,Di,Mi=!0;typeof y<"u"&&({FORCE_COLOR:pn,NODE_DISABLE_COLORS:Oi,NO_COLOR:ki,TERM:Di}=y.env||{},Mi=y.stdout&&y.stdout.isTTY);var ja={enabled:!Oi&&ki==null&&Di!=="dumb"&&(pn!=null&&pn!=="0"||Mi)};function j(e,t){let r=new RegExp(`\\x1b\\[${t}m`,"g"),n=`\x1B[${e}m`,i=`\x1B[${t}m`;return function(o){return!ja.enabled||o==null?o:n+(~(""+o).indexOf(i)?o.replace(r,i+n):o)+i}}var bm=j(0,0),lr=j(1,22),ur=j(2,22),xm=j(3,23),_i=j(4,24),Pm=j(7,27),vm=j(8,28),Tm=j(9,29),Am=j(30,39),Ye=j(31,39),Ni=j(32,39),Fi=j(33,39),Li=j(34,39),Rm=j(35,39),Ui=j(36,39),Cm=j(37,39),Bi=j(90,39),Sm=j(90,39),Im=j(40,49),Om=j(41,49),km=j(42,49),Dm=j(43,49),Mm=j(44,49),_m=j(45,49),Nm=j(46,49),Fm=j(47,49);f();u();c();p();m();var Ga=100,qi=["green","yellow","blue","magenta","cyan","red"],cr=[],Vi=Date.now(),Ja=0,mn=typeof y<"u"?y.env:{};globalThis.DEBUG??=mn.DEBUG??"";globalThis.DEBUG_COLORS??=mn.DEBUG_COLORS?mn.DEBUG_COLORS==="true":!0;var Pt={enable(e){typeof e=="string"&&(globalThis.DEBUG=e)},disable(){let e=globalThis.DEBUG;return globalThis.DEBUG="",e},enabled(e){let t=globalThis.DEBUG.split(",").map(i=>i.replace(/[.+?^${}()|[\]\\]/g,"\\$&")),r=t.some(i=>i===""||i[0]==="-"?!1:e.match(RegExp(i.split("*").join(".*")+"$"))),n=t.some(i=>i===""||i[0]!=="-"?!1:e.match(RegExp(i.slice(1).split("*").join(".*")+"$")));return r&&!n},log:(...e)=>{let[t,r,...n]=e;(console.warn??console.log)(`${t} ${r}`,...n)},formatters:{}};function Qa(e){let t={color:qi[Ja++%qi.length],enabled:Pt.enabled(e),namespace:e,log:Pt.log,extend:()=>{}},r=(...n)=>{let{enabled:i,namespace:o,color:s,log:a}=t;if(n.length!==0&&cr.push([o,...n]),cr.length>Ga&&cr.shift(),Pt.enabled(o)||i){let l=n.map(g=>typeof g=="string"?g:Ka(g)),d=`+${Date.now()-Vi}ms`;Vi=Date.now(),a(o,...l,d)}};return new Proxy(r,{get:(n,i)=>t[i],set:(n,i,o)=>t[i]=o})}var Z=new Proxy(Qa,{get:(e,t)=>Pt[t],set:(e,t,r)=>Pt[t]=r});function Ka(e,t=2){let r=new Set;return JSON.stringify(e,(n,i)=>{if(typeof i=="object"&&i!==null){if(r.has(i))return"[Circular *]";r.add(i)}else if(typeof i=="bigint")return i.toString();return i},t)}function $i(){cr.length=0}f();u();c();p();m();f();u();c();p();m();var fl=Ji(),dn=fl.version;f();u();c();p();m();function Ze(e){let t=xl();return t||(e?.config.engineType==="library"?"library":e?.config.engineType==="binary"?"binary":e?.config.engineType==="client"?"client":Pl())}function xl(){let e=y.env.PRISMA_CLIENT_ENGINE_TYPE;return e==="library"?"library":e==="binary"?"binary":e==="client"?"client":void 0}function Pl(){return"library"}f();u();c();p();m();var Yi="prisma+postgres",fr=`${Yi}:`;function dr(e){return e?.toString().startsWith(`${fr}//`)??!1}function hn(e){if(!dr(e))return!1;let{host:t}=new URL(e);return t.includes("localhost")||t.includes("127.0.0.1")||t.includes("[::1]")}var Tt={};or(Tt,{error:()=>Rl,info:()=>Al,log:()=>Tl,query:()=>Cl,should:()=>eo,tags:()=>vt,warn:()=>yn});f();u();c();p();m();var vt={error:Ye("prisma:error"),warn:Fi("prisma:warn"),info:Ui("prisma:info"),query:Li("prisma:query")},eo={warn:()=>!y.env.PRISMA_DISABLE_WARNINGS};function Tl(...e){console.log(...e)}function yn(e,...t){eo.warn()&&console.warn(`${vt.warn} ${e}`,...t)}function Al(e,...t){console.info(`${vt.info} ${e}`,...t)}function Rl(e,...t){console.error(`${vt.error} ${e}`,...t)}function Cl(e,...t){console.log(`${vt.query} ${e}`,...t)}f();u();c();p();m();function Ue(e,t){throw new Error(t)}f();u();c();p();m();f();u();c();p();m();function wn({onlyFirst:e=!1}={}){let r=["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?(?:\\u0007|\\u001B\\u005C|\\u009C))","(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"].join("|");return new RegExp(r,e?void 0:"g")}var Sl=wn();function En(e){if(typeof e!="string")throw new TypeError(`Expected a \`string\`, got \`${typeof e}\``);return e.replace(Sl,"")}f();u();c();p();m();function bn(e,t){return Object.prototype.hasOwnProperty.call(e,t)}f();u();c();p();m();function gr(e,t){let r={};for(let n of Object.keys(e))r[n]=t(e[n],n);return r}f();u();c();p();m();function xn(e,t){if(e.length===0)return;let r=e[0];for(let n=1;n{to.has(e)||(to.add(e),yn(t,...r))};var Q=class e extends Error{clientVersion;errorCode;retryable;constructor(t,r,n){super(t),this.name="PrismaClientInitializationError",this.clientVersion=r,this.errorCode=n,Error.captureStackTrace(e)}get[Symbol.toStringTag](){return"PrismaClientInitializationError"}};N(Q,"PrismaClientInitializationError");f();u();c();p();m();var se=class extends Error{code;meta;clientVersion;batchRequestIdx;constructor(t,{code:r,clientVersion:n,meta:i,batchRequestIdx:o}){super(t),this.name="PrismaClientKnownRequestError",this.code=r,this.clientVersion=n,this.meta=i,Object.defineProperty(this,"batchRequestIdx",{value:o,enumerable:!1,writable:!0})}get[Symbol.toStringTag](){return"PrismaClientKnownRequestError"}};N(se,"PrismaClientKnownRequestError");f();u();c();p();m();var Ce=class extends Error{clientVersion;constructor(t,r){super(t),this.name="PrismaClientRustPanicError",this.clientVersion=r}get[Symbol.toStringTag](){return"PrismaClientRustPanicError"}};N(Ce,"PrismaClientRustPanicError");f();u();c();p();m();var ae=class extends Error{clientVersion;batchRequestIdx;constructor(t,{clientVersion:r,batchRequestIdx:n}){super(t),this.name="PrismaClientUnknownRequestError",this.clientVersion=r,Object.defineProperty(this,"batchRequestIdx",{value:n,writable:!0,enumerable:!1})}get[Symbol.toStringTag](){return"PrismaClientUnknownRequestError"}};N(ae,"PrismaClientUnknownRequestError");f();u();c();p();m();var ee=class extends Error{name="PrismaClientValidationError";clientVersion;constructor(t,{clientVersion:r}){super(t),this.clientVersion=r}get[Symbol.toStringTag](){return"PrismaClientValidationError"}};N(ee,"PrismaClientValidationError");f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();var ge=class{_map=new Map;get(t){return this._map.get(t)?.value}set(t,r){this._map.set(t,{value:r})}getOrCreate(t,r){let n=this._map.get(t);if(n)return n.value;let i=r();return this.set(t,i),i}};f();u();c();p();m();function Se(e){return e.substring(0,1).toLowerCase()+e.substring(1)}f();u();c();p();m();function no(e,t){let r={};for(let n of e){let i=n[t];r[i]=n}return r}f();u();c();p();m();function At(e){let t;return{get(){return t||(t={value:e()}),t.value}}}f();u();c();p();m();function Il(e){return{models:Pn(e.models),enums:Pn(e.enums),types:Pn(e.types)}}function Pn(e){let t={};for(let{name:r,...n}of e)t[r]=n;return t}f();u();c();p();m();function Xe(e){return e instanceof Date||Object.prototype.toString.call(e)==="[object Date]"}function yr(e){return e.toString()!=="Invalid Date"}f();u();c();p();m();f();u();c();p();m();var et=9e15,De=1e9,vn="0123456789abcdef",br="2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058",xr="3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789",Tn={precision:20,rounding:4,modulo:1,toExpNeg:-7,toExpPos:21,minE:-et,maxE:et,crypto:!1},ao,Pe,_=!0,vr="[DecimalError] ",ke=vr+"Invalid argument: ",lo=vr+"Precision limit exceeded",uo=vr+"crypto unavailable",co="[object Decimal]",X=Math.floor,K=Math.pow,Ol=/^0b([01]+(\.[01]*)?|\.[01]+)(p[+-]?\d+)?$/i,kl=/^0x([0-9a-f]+(\.[0-9a-f]*)?|\.[0-9a-f]+)(p[+-]?\d+)?$/i,Dl=/^0o([0-7]+(\.[0-7]*)?|\.[0-7]+)(p[+-]?\d+)?$/i,po=/^(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i,pe=1e7,D=7,Ml=9007199254740991,_l=br.length-1,An=xr.length-1,R={toStringTag:co};R.absoluteValue=R.abs=function(){var e=new this.constructor(this);return e.s<0&&(e.s=1),k(e)};R.ceil=function(){return k(new this.constructor(this),this.e+1,2)};R.clampedTo=R.clamp=function(e,t){var r,n=this,i=n.constructor;if(e=new i(e),t=new i(t),!e.s||!t.s)return new i(NaN);if(e.gt(t))throw Error(ke+t);return r=n.cmp(e),r<0?e:n.cmp(t)>0?t:new i(n)};R.comparedTo=R.cmp=function(e){var t,r,n,i,o=this,s=o.d,a=(e=new o.constructor(e)).d,l=o.s,d=e.s;if(!s||!a)return!l||!d?NaN:l!==d?l:s===a?0:!s^l<0?1:-1;if(!s[0]||!a[0])return s[0]?l:a[0]?-d:0;if(l!==d)return l;if(o.e!==e.e)return o.e>e.e^l<0?1:-1;for(n=s.length,i=a.length,t=0,r=na[t]^l<0?1:-1;return n===i?0:n>i^l<0?1:-1};R.cosine=R.cos=function(){var e,t,r=this,n=r.constructor;return r.d?r.d[0]?(e=n.precision,t=n.rounding,n.precision=e+Math.max(r.e,r.sd())+D,n.rounding=1,r=Nl(n,yo(n,r)),n.precision=e,n.rounding=t,k(Pe==2||Pe==3?r.neg():r,e,t,!0)):new n(1):new n(NaN)};R.cubeRoot=R.cbrt=function(){var e,t,r,n,i,o,s,a,l,d,g=this,h=g.constructor;if(!g.isFinite()||g.isZero())return new h(g);for(_=!1,o=g.s*K(g.s*g,1/3),!o||Math.abs(o)==1/0?(r=z(g.d),e=g.e,(o=(e-r.length+1)%3)&&(r+=o==1||o==-2?"0":"00"),o=K(r,1/3),e=X((e+1)/3)-(e%3==(e<0?-1:2)),o==1/0?r="5e"+e:(r=o.toExponential(),r=r.slice(0,r.indexOf("e")+1)+e),n=new h(r),n.s=g.s):n=new h(o.toString()),s=(e=h.precision)+3;;)if(a=n,l=a.times(a).times(a),d=l.plus(g),n=V(d.plus(g).times(a),d.plus(l),s+2,1),z(a.d).slice(0,s)===(r=z(n.d)).slice(0,s))if(r=r.slice(s-3,s+1),r=="9999"||!i&&r=="4999"){if(!i&&(k(a,e+1,0),a.times(a).times(a).eq(g))){n=a;break}s+=4,i=1}else{(!+r||!+r.slice(1)&&r.charAt(0)=="5")&&(k(n,e+1,1),t=!n.times(n).times(n).eq(g));break}return _=!0,k(n,e,h.rounding,t)};R.decimalPlaces=R.dp=function(){var e,t=this.d,r=NaN;if(t){if(e=t.length-1,r=(e-X(this.e/D))*D,e=t[e],e)for(;e%10==0;e/=10)r--;r<0&&(r=0)}return r};R.dividedBy=R.div=function(e){return V(this,new this.constructor(e))};R.dividedToIntegerBy=R.divToInt=function(e){var t=this,r=t.constructor;return k(V(t,new r(e),0,1,1),r.precision,r.rounding)};R.equals=R.eq=function(e){return this.cmp(e)===0};R.floor=function(){return k(new this.constructor(this),this.e+1,3)};R.greaterThan=R.gt=function(e){return this.cmp(e)>0};R.greaterThanOrEqualTo=R.gte=function(e){var t=this.cmp(e);return t==1||t===0};R.hyperbolicCosine=R.cosh=function(){var e,t,r,n,i,o=this,s=o.constructor,a=new s(1);if(!o.isFinite())return new s(o.s?1/0:NaN);if(o.isZero())return a;r=s.precision,n=s.rounding,s.precision=r+Math.max(o.e,o.sd())+4,s.rounding=1,i=o.d.length,i<32?(e=Math.ceil(i/3),t=(1/Ar(4,e)).toString()):(e=16,t="2.3283064365386962890625e-10"),o=tt(s,1,o.times(t),new s(1),!0);for(var l,d=e,g=new s(8);d--;)l=o.times(o),o=a.minus(l.times(g.minus(l.times(g))));return k(o,s.precision=r,s.rounding=n,!0)};R.hyperbolicSine=R.sinh=function(){var e,t,r,n,i=this,o=i.constructor;if(!i.isFinite()||i.isZero())return new o(i);if(t=o.precision,r=o.rounding,o.precision=t+Math.max(i.e,i.sd())+4,o.rounding=1,n=i.d.length,n<3)i=tt(o,2,i,i,!0);else{e=1.4*Math.sqrt(n),e=e>16?16:e|0,i=i.times(1/Ar(5,e)),i=tt(o,2,i,i,!0);for(var s,a=new o(5),l=new o(16),d=new o(20);e--;)s=i.times(i),i=i.times(a.plus(s.times(l.times(s).plus(d))))}return o.precision=t,o.rounding=r,k(i,t,r,!0)};R.hyperbolicTangent=R.tanh=function(){var e,t,r=this,n=r.constructor;return r.isFinite()?r.isZero()?new n(r):(e=n.precision,t=n.rounding,n.precision=e+7,n.rounding=1,V(r.sinh(),r.cosh(),n.precision=e,n.rounding=t)):new n(r.s)};R.inverseCosine=R.acos=function(){var e=this,t=e.constructor,r=e.abs().cmp(1),n=t.precision,i=t.rounding;return r!==-1?r===0?e.isNeg()?he(t,n,i):new t(0):new t(NaN):e.isZero()?he(t,n+4,i).times(.5):(t.precision=n+6,t.rounding=1,e=new t(1).minus(e).div(e.plus(1)).sqrt().atan(),t.precision=n,t.rounding=i,e.times(2))};R.inverseHyperbolicCosine=R.acosh=function(){var e,t,r=this,n=r.constructor;return r.lte(1)?new n(r.eq(1)?0:NaN):r.isFinite()?(e=n.precision,t=n.rounding,n.precision=e+Math.max(Math.abs(r.e),r.sd())+4,n.rounding=1,_=!1,r=r.times(r).minus(1).sqrt().plus(r),_=!0,n.precision=e,n.rounding=t,r.ln()):new n(r)};R.inverseHyperbolicSine=R.asinh=function(){var e,t,r=this,n=r.constructor;return!r.isFinite()||r.isZero()?new n(r):(e=n.precision,t=n.rounding,n.precision=e+2*Math.max(Math.abs(r.e),r.sd())+6,n.rounding=1,_=!1,r=r.times(r).plus(1).sqrt().plus(r),_=!0,n.precision=e,n.rounding=t,r.ln())};R.inverseHyperbolicTangent=R.atanh=function(){var e,t,r,n,i=this,o=i.constructor;return i.isFinite()?i.e>=0?new o(i.abs().eq(1)?i.s/0:i.isZero()?i:NaN):(e=o.precision,t=o.rounding,n=i.sd(),Math.max(n,e)<2*-i.e-1?k(new o(i),e,t,!0):(o.precision=r=n-i.e,i=V(i.plus(1),new o(1).minus(i),r+e,1),o.precision=e+4,o.rounding=1,i=i.ln(),o.precision=e,o.rounding=t,i.times(.5))):new o(NaN)};R.inverseSine=R.asin=function(){var e,t,r,n,i=this,o=i.constructor;return i.isZero()?new o(i):(t=i.abs().cmp(1),r=o.precision,n=o.rounding,t!==-1?t===0?(e=he(o,r+4,n).times(.5),e.s=i.s,e):new o(NaN):(o.precision=r+6,o.rounding=1,i=i.div(new o(1).minus(i.times(i)).sqrt().plus(1)).atan(),o.precision=r,o.rounding=n,i.times(2)))};R.inverseTangent=R.atan=function(){var e,t,r,n,i,o,s,a,l,d=this,g=d.constructor,h=g.precision,T=g.rounding;if(d.isFinite()){if(d.isZero())return new g(d);if(d.abs().eq(1)&&h+4<=An)return s=he(g,h+4,T).times(.25),s.s=d.s,s}else{if(!d.s)return new g(NaN);if(h+4<=An)return s=he(g,h+4,T).times(.5),s.s=d.s,s}for(g.precision=a=h+10,g.rounding=1,r=Math.min(28,a/D+2|0),e=r;e;--e)d=d.div(d.times(d).plus(1).sqrt().plus(1));for(_=!1,t=Math.ceil(a/D),n=1,l=d.times(d),s=new g(d),i=d;e!==-1;)if(i=i.times(l),o=s.minus(i.div(n+=2)),i=i.times(l),s=o.plus(i.div(n+=2)),s.d[t]!==void 0)for(e=t;s.d[e]===o.d[e]&&e--;);return r&&(s=s.times(2<this.d.length-2};R.isNaN=function(){return!this.s};R.isNegative=R.isNeg=function(){return this.s<0};R.isPositive=R.isPos=function(){return this.s>0};R.isZero=function(){return!!this.d&&this.d[0]===0};R.lessThan=R.lt=function(e){return this.cmp(e)<0};R.lessThanOrEqualTo=R.lte=function(e){return this.cmp(e)<1};R.logarithm=R.log=function(e){var t,r,n,i,o,s,a,l,d=this,g=d.constructor,h=g.precision,T=g.rounding,I=5;if(e==null)e=new g(10),t=!0;else{if(e=new g(e),r=e.d,e.s<0||!r||!r[0]||e.eq(1))return new g(NaN);t=e.eq(10)}if(r=d.d,d.s<0||!r||!r[0]||d.eq(1))return new g(r&&!r[0]?-1/0:d.s!=1?NaN:r?0:1/0);if(t)if(r.length>1)o=!0;else{for(i=r[0];i%10===0;)i/=10;o=i!==1}if(_=!1,a=h+I,s=Oe(d,a),n=t?Pr(g,a+10):Oe(e,a),l=V(s,n,a,1),Rt(l.d,i=h,T))do if(a+=10,s=Oe(d,a),n=t?Pr(g,a+10):Oe(e,a),l=V(s,n,a,1),!o){+z(l.d).slice(i+1,i+15)+1==1e14&&(l=k(l,h+1,0));break}while(Rt(l.d,i+=10,T));return _=!0,k(l,h,T)};R.minus=R.sub=function(e){var t,r,n,i,o,s,a,l,d,g,h,T,I=this,S=I.constructor;if(e=new S(e),!I.d||!e.d)return!I.s||!e.s?e=new S(NaN):I.d?e.s=-e.s:e=new S(e.d||I.s!==e.s?I:NaN),e;if(I.s!=e.s)return e.s=-e.s,I.plus(e);if(d=I.d,T=e.d,a=S.precision,l=S.rounding,!d[0]||!T[0]){if(T[0])e.s=-e.s;else if(d[0])e=new S(I);else return new S(l===3?-0:0);return _?k(e,a,l):e}if(r=X(e.e/D),g=X(I.e/D),d=d.slice(),o=g-r,o){for(h=o<0,h?(t=d,o=-o,s=T.length):(t=T,r=g,s=d.length),n=Math.max(Math.ceil(a/D),s)+2,o>n&&(o=n,t.length=1),t.reverse(),n=o;n--;)t.push(0);t.reverse()}else{for(n=d.length,s=T.length,h=n0;--n)d[s++]=0;for(n=T.length;n>o;){if(d[--n]s?o+1:s+1,i>s&&(i=s,r.length=1),r.reverse();i--;)r.push(0);r.reverse()}for(s=d.length,i=g.length,s-i<0&&(i=s,r=g,g=d,d=r),t=0;i;)t=(d[--i]=d[i]+g[i]+t)/pe|0,d[i]%=pe;for(t&&(d.unshift(t),++n),s=d.length;d[--s]==0;)d.pop();return e.d=d,e.e=Tr(d,n),_?k(e,a,l):e};R.precision=R.sd=function(e){var t,r=this;if(e!==void 0&&e!==!!e&&e!==1&&e!==0)throw Error(ke+e);return r.d?(t=mo(r.d),e&&r.e+1>t&&(t=r.e+1)):t=NaN,t};R.round=function(){var e=this,t=e.constructor;return k(new t(e),e.e+1,t.rounding)};R.sine=R.sin=function(){var e,t,r=this,n=r.constructor;return r.isFinite()?r.isZero()?new n(r):(e=n.precision,t=n.rounding,n.precision=e+Math.max(r.e,r.sd())+D,n.rounding=1,r=Ll(n,yo(n,r)),n.precision=e,n.rounding=t,k(Pe>2?r.neg():r,e,t,!0)):new n(NaN)};R.squareRoot=R.sqrt=function(){var e,t,r,n,i,o,s=this,a=s.d,l=s.e,d=s.s,g=s.constructor;if(d!==1||!a||!a[0])return new g(!d||d<0&&(!a||a[0])?NaN:a?s:1/0);for(_=!1,d=Math.sqrt(+s),d==0||d==1/0?(t=z(a),(t.length+l)%2==0&&(t+="0"),d=Math.sqrt(t),l=X((l+1)/2)-(l<0||l%2),d==1/0?t="5e"+l:(t=d.toExponential(),t=t.slice(0,t.indexOf("e")+1)+l),n=new g(t)):n=new g(d.toString()),r=(l=g.precision)+3;;)if(o=n,n=o.plus(V(s,o,r+2,1)).times(.5),z(o.d).slice(0,r)===(t=z(n.d)).slice(0,r))if(t=t.slice(r-3,r+1),t=="9999"||!i&&t=="4999"){if(!i&&(k(o,l+1,0),o.times(o).eq(s))){n=o;break}r+=4,i=1}else{(!+t||!+t.slice(1)&&t.charAt(0)=="5")&&(k(n,l+1,1),e=!n.times(n).eq(s));break}return _=!0,k(n,l,g.rounding,e)};R.tangent=R.tan=function(){var e,t,r=this,n=r.constructor;return r.isFinite()?r.isZero()?new n(r):(e=n.precision,t=n.rounding,n.precision=e+10,n.rounding=1,r=r.sin(),r.s=1,r=V(r,new n(1).minus(r.times(r)).sqrt(),e+10,0),n.precision=e,n.rounding=t,k(Pe==2||Pe==4?r.neg():r,e,t,!0)):new n(NaN)};R.times=R.mul=function(e){var t,r,n,i,o,s,a,l,d,g=this,h=g.constructor,T=g.d,I=(e=new h(e)).d;if(e.s*=g.s,!T||!T[0]||!I||!I[0])return new h(!e.s||T&&!T[0]&&!I||I&&!I[0]&&!T?NaN:!T||!I?e.s/0:e.s*0);for(r=X(g.e/D)+X(e.e/D),l=T.length,d=I.length,l=0;){for(t=0,i=l+n;i>n;)a=o[i]+I[n]*T[i-n-1]+t,o[i--]=a%pe|0,t=a/pe|0;o[i]=(o[i]+t)%pe|0}for(;!o[--s];)o.pop();return t?++r:o.shift(),e.d=o,e.e=Tr(o,r),_?k(e,h.precision,h.rounding):e};R.toBinary=function(e,t){return Cn(this,2,e,t)};R.toDecimalPlaces=R.toDP=function(e,t){var r=this,n=r.constructor;return r=new n(r),e===void 0?r:(ne(e,0,De),t===void 0?t=n.rounding:ne(t,0,8),k(r,e+r.e+1,t))};R.toExponential=function(e,t){var r,n=this,i=n.constructor;return e===void 0?r=ye(n,!0):(ne(e,0,De),t===void 0?t=i.rounding:ne(t,0,8),n=k(new i(n),e+1,t),r=ye(n,!0,e+1)),n.isNeg()&&!n.isZero()?"-"+r:r};R.toFixed=function(e,t){var r,n,i=this,o=i.constructor;return e===void 0?r=ye(i):(ne(e,0,De),t===void 0?t=o.rounding:ne(t,0,8),n=k(new o(i),e+i.e+1,t),r=ye(n,!1,e+n.e+1)),i.isNeg()&&!i.isZero()?"-"+r:r};R.toFraction=function(e){var t,r,n,i,o,s,a,l,d,g,h,T,I=this,S=I.d,C=I.constructor;if(!S)return new C(I);if(d=r=new C(1),n=l=new C(0),t=new C(n),o=t.e=mo(S)-I.e-1,s=o%D,t.d[0]=K(10,s<0?D+s:s),e==null)e=o>0?t:d;else{if(a=new C(e),!a.isInt()||a.lt(d))throw Error(ke+a);e=a.gt(t)?o>0?t:d:a}for(_=!1,a=new C(z(S)),g=C.precision,C.precision=o=S.length*D*2;h=V(a,t,0,1,1),i=r.plus(h.times(n)),i.cmp(e)!=1;)r=n,n=i,i=d,d=l.plus(h.times(i)),l=i,i=t,t=a.minus(h.times(i)),a=i;return i=V(e.minus(r),n,0,1,1),l=l.plus(i.times(d)),r=r.plus(i.times(n)),l.s=d.s=I.s,T=V(d,n,o,1).minus(I).abs().cmp(V(l,r,o,1).minus(I).abs())<1?[d,n]:[l,r],C.precision=g,_=!0,T};R.toHexadecimal=R.toHex=function(e,t){return Cn(this,16,e,t)};R.toNearest=function(e,t){var r=this,n=r.constructor;if(r=new n(r),e==null){if(!r.d)return r;e=new n(1),t=n.rounding}else{if(e=new n(e),t===void 0?t=n.rounding:ne(t,0,8),!r.d)return e.s?r:e;if(!e.d)return e.s&&(e.s=r.s),e}return e.d[0]?(_=!1,r=V(r,e,0,t,1).times(e),_=!0,k(r)):(e.s=r.s,r=e),r};R.toNumber=function(){return+this};R.toOctal=function(e,t){return Cn(this,8,e,t)};R.toPower=R.pow=function(e){var t,r,n,i,o,s,a=this,l=a.constructor,d=+(e=new l(e));if(!a.d||!e.d||!a.d[0]||!e.d[0])return new l(K(+a,d));if(a=new l(a),a.eq(1))return a;if(n=l.precision,o=l.rounding,e.eq(1))return k(a,n,o);if(t=X(e.e/D),t>=e.d.length-1&&(r=d<0?-d:d)<=Ml)return i=fo(l,a,r,n),e.s<0?new l(1).div(i):k(i,n,o);if(s=a.s,s<0){if(tl.maxE+1||t0?s/0:0):(_=!1,l.rounding=a.s=1,r=Math.min(12,(t+"").length),i=Rn(e.times(Oe(a,n+r)),n),i.d&&(i=k(i,n+5,1),Rt(i.d,n,o)&&(t=n+10,i=k(Rn(e.times(Oe(a,t+r)),t),t+5,1),+z(i.d).slice(n+1,n+15)+1==1e14&&(i=k(i,n+1,0)))),i.s=s,_=!0,l.rounding=o,k(i,n,o))};R.toPrecision=function(e,t){var r,n=this,i=n.constructor;return e===void 0?r=ye(n,n.e<=i.toExpNeg||n.e>=i.toExpPos):(ne(e,1,De),t===void 0?t=i.rounding:ne(t,0,8),n=k(new i(n),e,t),r=ye(n,e<=n.e||n.e<=i.toExpNeg,e)),n.isNeg()&&!n.isZero()?"-"+r:r};R.toSignificantDigits=R.toSD=function(e,t){var r=this,n=r.constructor;return e===void 0?(e=n.precision,t=n.rounding):(ne(e,1,De),t===void 0?t=n.rounding:ne(t,0,8)),k(new n(r),e,t)};R.toString=function(){var e=this,t=e.constructor,r=ye(e,e.e<=t.toExpNeg||e.e>=t.toExpPos);return e.isNeg()&&!e.isZero()?"-"+r:r};R.truncated=R.trunc=function(){return k(new this.constructor(this),this.e+1,1)};R.valueOf=R.toJSON=function(){var e=this,t=e.constructor,r=ye(e,e.e<=t.toExpNeg||e.e>=t.toExpPos);return e.isNeg()?"-"+r:r};function z(e){var t,r,n,i=e.length-1,o="",s=e[0];if(i>0){for(o+=s,t=1;tr)throw Error(ke+e)}function Rt(e,t,r,n){var i,o,s,a;for(o=e[0];o>=10;o/=10)--t;return--t<0?(t+=D,i=0):(i=Math.ceil((t+1)/D),t%=D),o=K(10,D-t),a=e[i]%o|0,n==null?t<3?(t==0?a=a/100|0:t==1&&(a=a/10|0),s=r<4&&a==99999||r>3&&a==49999||a==5e4||a==0):s=(r<4&&a+1==o||r>3&&a+1==o/2)&&(e[i+1]/o/100|0)==K(10,t-2)-1||(a==o/2||a==0)&&(e[i+1]/o/100|0)==0:t<4?(t==0?a=a/1e3|0:t==1?a=a/100|0:t==2&&(a=a/10|0),s=(n||r<4)&&a==9999||!n&&r>3&&a==4999):s=((n||r<4)&&a+1==o||!n&&r>3&&a+1==o/2)&&(e[i+1]/o/1e3|0)==K(10,t-3)-1,s}function wr(e,t,r){for(var n,i=[0],o,s=0,a=e.length;sr-1&&(i[n+1]===void 0&&(i[n+1]=0),i[n+1]+=i[n]/r|0,i[n]%=r)}return i.reverse()}function Nl(e,t){var r,n,i;if(t.isZero())return t;n=t.d.length,n<32?(r=Math.ceil(n/3),i=(1/Ar(4,r)).toString()):(r=16,i="2.3283064365386962890625e-10"),e.precision+=r,t=tt(e,1,t.times(i),new e(1));for(var o=r;o--;){var s=t.times(t);t=s.times(s).minus(s).times(8).plus(1)}return e.precision-=r,t}var V=function(){function e(n,i,o){var s,a=0,l=n.length;for(n=n.slice();l--;)s=n[l]*i+a,n[l]=s%o|0,a=s/o|0;return a&&n.unshift(a),n}function t(n,i,o,s){var a,l;if(o!=s)l=o>s?1:-1;else for(a=l=0;ai[a]?1:-1;break}return l}function r(n,i,o,s){for(var a=0;o--;)n[o]-=a,a=n[o]1;)n.shift()}return function(n,i,o,s,a,l){var d,g,h,T,I,S,C,M,F,B,O,L,oe,J,Xr,rr,bt,en,ce,nr,ir=n.constructor,tn=n.s==i.s?1:-1,Y=n.d,$=i.d;if(!Y||!Y[0]||!$||!$[0])return new ir(!n.s||!i.s||(Y?$&&Y[0]==$[0]:!$)?NaN:Y&&Y[0]==0||!$?tn*0:tn/0);for(l?(I=1,g=n.e-i.e):(l=pe,I=D,g=X(n.e/I)-X(i.e/I)),ce=$.length,bt=Y.length,F=new ir(tn),B=F.d=[],h=0;$[h]==(Y[h]||0);h++);if($[h]>(Y[h]||0)&&g--,o==null?(J=o=ir.precision,s=ir.rounding):a?J=o+(n.e-i.e)+1:J=o,J<0)B.push(1),S=!0;else{if(J=J/I+2|0,h=0,ce==1){for(T=0,$=$[0],J++;(h1&&($=e($,T,l),Y=e(Y,T,l),ce=$.length,bt=Y.length),rr=ce,O=Y.slice(0,ce),L=O.length;L=l/2&&++en;do T=0,d=t($,O,ce,L),d<0?(oe=O[0],ce!=L&&(oe=oe*l+(O[1]||0)),T=oe/en|0,T>1?(T>=l&&(T=l-1),C=e($,T,l),M=C.length,L=O.length,d=t(C,O,M,L),d==1&&(T--,r(C,ce=10;T/=10)h++;F.e=h+g*I-1,k(F,a?o+F.e+1:o,s,S)}return F}}();function k(e,t,r,n){var i,o,s,a,l,d,g,h,T,I=e.constructor;e:if(t!=null){if(h=e.d,!h)return e;for(i=1,a=h[0];a>=10;a/=10)i++;if(o=t-i,o<0)o+=D,s=t,g=h[T=0],l=g/K(10,i-s-1)%10|0;else if(T=Math.ceil((o+1)/D),a=h.length,T>=a)if(n){for(;a++<=T;)h.push(0);g=l=0,i=1,o%=D,s=o-D+1}else break e;else{for(g=a=h[T],i=1;a>=10;a/=10)i++;o%=D,s=o-D+i,l=s<0?0:g/K(10,i-s-1)%10|0}if(n=n||t<0||h[T+1]!==void 0||(s<0?g:g%K(10,i-s-1)),d=r<4?(l||n)&&(r==0||r==(e.s<0?3:2)):l>5||l==5&&(r==4||n||r==6&&(o>0?s>0?g/K(10,i-s):0:h[T-1])%10&1||r==(e.s<0?8:7)),t<1||!h[0])return h.length=0,d?(t-=e.e+1,h[0]=K(10,(D-t%D)%D),e.e=-t||0):h[0]=e.e=0,e;if(o==0?(h.length=T,a=1,T--):(h.length=T+1,a=K(10,D-o),h[T]=s>0?(g/K(10,i-s)%K(10,s)|0)*a:0),d)for(;;)if(T==0){for(o=1,s=h[0];s>=10;s/=10)o++;for(s=h[0]+=a,a=1;s>=10;s/=10)a++;o!=a&&(e.e++,h[0]==pe&&(h[0]=1));break}else{if(h[T]+=a,h[T]!=pe)break;h[T--]=0,a=1}for(o=h.length;h[--o]===0;)h.pop()}return _&&(e.e>I.maxE?(e.d=null,e.e=NaN):e.e0?o=o.charAt(0)+"."+o.slice(1)+Ie(n):s>1&&(o=o.charAt(0)+"."+o.slice(1)),o=o+(e.e<0?"e":"e+")+e.e):i<0?(o="0."+Ie(-i-1)+o,r&&(n=r-s)>0&&(o+=Ie(n))):i>=s?(o+=Ie(i+1-s),r&&(n=r-i-1)>0&&(o=o+"."+Ie(n))):((n=i+1)0&&(i+1===s&&(o+="."),o+=Ie(n))),o}function Tr(e,t){var r=e[0];for(t*=D;r>=10;r/=10)t++;return t}function Pr(e,t,r){if(t>_l)throw _=!0,r&&(e.precision=r),Error(lo);return k(new e(br),t,1,!0)}function he(e,t,r){if(t>An)throw Error(lo);return k(new e(xr),t,r,!0)}function mo(e){var t=e.length-1,r=t*D+1;if(t=e[t],t){for(;t%10==0;t/=10)r--;for(t=e[0];t>=10;t/=10)r++}return r}function Ie(e){for(var t="";e--;)t+="0";return t}function fo(e,t,r,n){var i,o=new e(1),s=Math.ceil(n/D+4);for(_=!1;;){if(r%2&&(o=o.times(t),oo(o.d,s)&&(i=!0)),r=X(r/2),r===0){r=o.d.length-1,i&&o.d[r]===0&&++o.d[r];break}t=t.times(t),oo(t.d,s)}return _=!0,o}function io(e){return e.d[e.d.length-1]&1}function go(e,t,r){for(var n,i,o=new e(t[0]),s=0;++s17)return new T(e.d?e.d[0]?e.s<0?0:1/0:1:e.s?e.s<0?0:e:NaN);for(t==null?(_=!1,l=S):l=t,a=new T(.03125);e.e>-2;)e=e.times(a),h+=5;for(n=Math.log(K(2,h))/Math.LN10*2+5|0,l+=n,r=o=s=new T(1),T.precision=l;;){if(o=k(o.times(e),l,1),r=r.times(++g),a=s.plus(V(o,r,l,1)),z(a.d).slice(0,l)===z(s.d).slice(0,l)){for(i=h;i--;)s=k(s.times(s),l,1);if(t==null)if(d<3&&Rt(s.d,l-n,I,d))T.precision=l+=10,r=o=a=new T(1),g=0,d++;else return k(s,T.precision=S,I,_=!0);else return T.precision=S,s}s=a}}function Oe(e,t){var r,n,i,o,s,a,l,d,g,h,T,I=1,S=10,C=e,M=C.d,F=C.constructor,B=F.rounding,O=F.precision;if(C.s<0||!M||!M[0]||!C.e&&M[0]==1&&M.length==1)return new F(M&&!M[0]?-1/0:C.s!=1?NaN:M?0:C);if(t==null?(_=!1,g=O):g=t,F.precision=g+=S,r=z(M),n=r.charAt(0),Math.abs(o=C.e)<15e14){for(;n<7&&n!=1||n==1&&r.charAt(1)>3;)C=C.times(e),r=z(C.d),n=r.charAt(0),I++;o=C.e,n>1?(C=new F("0."+r),o++):C=new F(n+"."+r.slice(1))}else return d=Pr(F,g+2,O).times(o+""),C=Oe(new F(n+"."+r.slice(1)),g-S).plus(d),F.precision=O,t==null?k(C,O,B,_=!0):C;for(h=C,l=s=C=V(C.minus(1),C.plus(1),g,1),T=k(C.times(C),g,1),i=3;;){if(s=k(s.times(T),g,1),d=l.plus(V(s,new F(i),g,1)),z(d.d).slice(0,g)===z(l.d).slice(0,g))if(l=l.times(2),o!==0&&(l=l.plus(Pr(F,g+2,O).times(o+""))),l=V(l,new F(I),g,1),t==null)if(Rt(l.d,g-S,B,a))F.precision=g+=S,d=s=C=V(h.minus(1),h.plus(1),g,1),T=k(C.times(C),g,1),i=a=1;else return k(l,F.precision=O,B,_=!0);else return F.precision=O,l;l=d,i+=2}}function ho(e){return String(e.s*e.s/0)}function Er(e,t){var r,n,i;for((r=t.indexOf("."))>-1&&(t=t.replace(".","")),(n=t.search(/e/i))>0?(r<0&&(r=n),r+=+t.slice(n+1),t=t.substring(0,n)):r<0&&(r=t.length),n=0;t.charCodeAt(n)===48;n++);for(i=t.length;t.charCodeAt(i-1)===48;--i);if(t=t.slice(n,i),t){if(i-=n,e.e=r=r-n-1,e.d=[],n=(r+1)%D,r<0&&(n+=D),ne.constructor.maxE?(e.d=null,e.e=NaN):e.e-1){if(t=t.replace(/(\d)_(?=\d)/g,"$1"),po.test(t))return Er(e,t)}else if(t==="Infinity"||t==="NaN")return+t||(e.s=NaN),e.e=NaN,e.d=null,e;if(kl.test(t))r=16,t=t.toLowerCase();else if(Ol.test(t))r=2;else if(Dl.test(t))r=8;else throw Error(ke+t);for(o=t.search(/p/i),o>0?(l=+t.slice(o+1),t=t.substring(2,o)):t=t.slice(2),o=t.indexOf("."),s=o>=0,n=e.constructor,s&&(t=t.replace(".",""),a=t.length,o=a-o,i=fo(n,new n(r),o,o*2)),d=wr(t,r,pe),g=d.length-1,o=g;d[o]===0;--o)d.pop();return o<0?new n(e.s*0):(e.e=Tr(d,g),e.d=d,_=!1,s&&(e=V(e,i,a*4)),l&&(e=e.times(Math.abs(l)<54?K(2,l):ve.pow(2,l))),_=!0,e)}function Ll(e,t){var r,n=t.d.length;if(n<3)return t.isZero()?t:tt(e,2,t,t);r=1.4*Math.sqrt(n),r=r>16?16:r|0,t=t.times(1/Ar(5,r)),t=tt(e,2,t,t);for(var i,o=new e(5),s=new e(16),a=new e(20);r--;)i=t.times(t),t=t.times(o.plus(i.times(s.times(i).minus(a))));return t}function tt(e,t,r,n,i){var o,s,a,l,d=1,g=e.precision,h=Math.ceil(g/D);for(_=!1,l=r.times(r),a=new e(n);;){if(s=V(a.times(l),new e(t++*t++),g,1),a=i?n.plus(s):n.minus(s),n=V(s.times(l),new e(t++*t++),g,1),s=a.plus(n),s.d[h]!==void 0){for(o=h;s.d[o]===a.d[o]&&o--;);if(o==-1)break}o=a,a=n,n=s,s=o,d++}return _=!0,s.d.length=h+1,s}function Ar(e,t){for(var r=e;--t;)r*=e;return r}function yo(e,t){var r,n=t.s<0,i=he(e,e.precision,1),o=i.times(.5);if(t=t.abs(),t.lte(o))return Pe=n?4:1,t;if(r=t.divToInt(i),r.isZero())Pe=n?3:2;else{if(t=t.minus(r.times(i)),t.lte(o))return Pe=io(r)?n?2:3:n?4:1,t;Pe=io(r)?n?1:4:n?3:2}return t.minus(i).abs()}function Cn(e,t,r,n){var i,o,s,a,l,d,g,h,T,I=e.constructor,S=r!==void 0;if(S?(ne(r,1,De),n===void 0?n=I.rounding:ne(n,0,8)):(r=I.precision,n=I.rounding),!e.isFinite())g=ho(e);else{for(g=ye(e),s=g.indexOf("."),S?(i=2,t==16?r=r*4-3:t==8&&(r=r*3-2)):i=t,s>=0&&(g=g.replace(".",""),T=new I(1),T.e=g.length-s,T.d=wr(ye(T),10,i),T.e=T.d.length),h=wr(g,10,i),o=l=h.length;h[--l]==0;)h.pop();if(!h[0])g=S?"0p+0":"0";else{if(s<0?o--:(e=new I(e),e.d=h,e.e=o,e=V(e,T,r,n,0,i),h=e.d,o=e.e,d=ao),s=h[r],a=i/2,d=d||h[r+1]!==void 0,d=n<4?(s!==void 0||d)&&(n===0||n===(e.s<0?3:2)):s>a||s===a&&(n===4||d||n===6&&h[r-1]&1||n===(e.s<0?8:7)),h.length=r,d)for(;++h[--r]>i-1;)h[r]=0,r||(++o,h.unshift(1));for(l=h.length;!h[l-1];--l);for(s=0,g="";s1)if(t==16||t==8){for(s=t==16?4:3,--l;l%s;l++)g+="0";for(h=wr(g,i,t),l=h.length;!h[l-1];--l);for(s=1,g="1.";sl)for(o-=l;o--;)g+="0";else ot)return e.length=t,!0}function Ul(e){return new this(e).abs()}function Bl(e){return new this(e).acos()}function ql(e){return new this(e).acosh()}function Vl(e,t){return new this(e).plus(t)}function $l(e){return new this(e).asin()}function jl(e){return new this(e).asinh()}function Gl(e){return new this(e).atan()}function Jl(e){return new this(e).atanh()}function Ql(e,t){e=new this(e),t=new this(t);var r,n=this.precision,i=this.rounding,o=n+4;return!e.s||!t.s?r=new this(NaN):!e.d&&!t.d?(r=he(this,o,1).times(t.s>0?.25:.75),r.s=e.s):!t.d||e.isZero()?(r=t.s<0?he(this,n,i):new this(0),r.s=e.s):!e.d||t.isZero()?(r=he(this,o,1).times(.5),r.s=e.s):t.s<0?(this.precision=o,this.rounding=1,r=this.atan(V(e,t,o,1)),t=he(this,o,1),this.precision=n,this.rounding=i,r=e.s<0?r.minus(t):r.plus(t)):r=this.atan(V(e,t,o,1)),r}function Kl(e){return new this(e).cbrt()}function Wl(e){return k(e=new this(e),e.e+1,2)}function Hl(e,t,r){return new this(e).clamp(t,r)}function zl(e){if(!e||typeof e!="object")throw Error(vr+"Object expected");var t,r,n,i=e.defaults===!0,o=["precision",1,De,"rounding",0,8,"toExpNeg",-et,0,"toExpPos",0,et,"maxE",0,et,"minE",-et,0,"modulo",0,9];for(t=0;t=o[t+1]&&n<=o[t+2])this[r]=n;else throw Error(ke+r+": "+n);if(r="crypto",i&&(this[r]=Tn[r]),(n=e[r])!==void 0)if(n===!0||n===!1||n===0||n===1)if(n)if(typeof crypto<"u"&&crypto&&(crypto.getRandomValues||crypto.randomBytes))this[r]=!0;else throw Error(uo);else this[r]=!1;else throw Error(ke+r+": "+n);return this}function Yl(e){return new this(e).cos()}function Zl(e){return new this(e).cosh()}function wo(e){var t,r,n;function i(o){var s,a,l,d=this;if(!(d instanceof i))return new i(o);if(d.constructor=i,so(o)){d.s=o.s,_?!o.d||o.e>i.maxE?(d.e=NaN,d.d=null):o.e=10;a/=10)s++;_?s>i.maxE?(d.e=NaN,d.d=null):s=429e7?t[o]=crypto.getRandomValues(new Uint32Array(1))[0]:a[o++]=i%1e7;else if(crypto.randomBytes){for(t=crypto.randomBytes(n*=4);o=214e7?crypto.randomBytes(4).copy(t,o):(a.push(i%1e7),o+=4);o=n/4}else throw Error(uo);else for(;o=10;i/=10)n++;nCt,datamodelEnumToSchemaEnum:()=>vu});f();u();c();p();m();f();u();c();p();m();function vu(e){return{name:e.name,values:e.values.map(t=>t.name)}}f();u();c();p();m();var Ct=(O=>(O.findUnique="findUnique",O.findUniqueOrThrow="findUniqueOrThrow",O.findFirst="findFirst",O.findFirstOrThrow="findFirstOrThrow",O.findMany="findMany",O.create="create",O.createMany="createMany",O.createManyAndReturn="createManyAndReturn",O.update="update",O.updateMany="updateMany",O.updateManyAndReturn="updateManyAndReturn",O.upsert="upsert",O.delete="delete",O.deleteMany="deleteMany",O.groupBy="groupBy",O.count="count",O.aggregate="aggregate",O.findRaw="findRaw",O.aggregateRaw="aggregateRaw",O))(Ct||{});var Tu=Qe(Xi());var Au={red:Ye,gray:Bi,dim:ur,bold:lr,underline:_i,highlightSource:e=>e.highlight()},Ru={red:e=>e,gray:e=>e,dim:e=>e,bold:e=>e,underline:e=>e,highlightSource:e=>e};function Cu({message:e,originalMethod:t,isPanic:r,callArguments:n}){return{functionName:`prisma.${t}()`,message:e,isPanic:r??!1,callArguments:n}}function Su({functionName:e,location:t,message:r,isPanic:n,contextLines:i,callArguments:o},s){let a=[""],l=t?" in":":";if(n?(a.push(s.red(`Oops, an unknown error occurred! This is ${s.bold("on us")}, you did nothing wrong.`)),a.push(s.red(`It occurred in the ${s.bold(`\`${e}\``)} invocation${l}`))):a.push(s.red(`Invalid ${s.bold(`\`${e}\``)} invocation${l}`)),t&&a.push(s.underline(Iu(t))),i){a.push("");let d=[i.toString()];o&&(d.push(o),d.push(s.dim(")"))),a.push(d.join("")),o&&a.push("")}else a.push(""),o&&a.push(o),a.push("");return a.push(r),a.join(` -`)}function Iu(e){let t=[e.fileName];return e.lineNumber&&t.push(String(e.lineNumber)),e.columnNumber&&t.push(String(e.columnNumber)),t.join(":")}function Cr(e){let t=e.showColors?Au:Ru,r;return typeof $getTemplateParameters<"u"?r=$getTemplateParameters(e,t):r=Cu(e),Su(r,t)}f();u();c();p();m();var Co=Qe(Sn());f();u();c();p();m();function Po(e,t,r){let n=vo(e),i=Ou(n),o=Du(i);o?Sr(o,t,r):t.addErrorMessage(()=>"Unknown error")}function vo(e){return e.errors.flatMap(t=>t.kind==="Union"?vo(t):[t])}function Ou(e){let t=new Map,r=[];for(let n of e){if(n.kind!=="InvalidArgumentType"){r.push(n);continue}let i=`${n.selectionPath.join(".")}:${n.argumentPath.join(".")}`,o=t.get(i);o?t.set(i,{...n,argument:{...n.argument,typeNames:ku(o.argument.typeNames,n.argument.typeNames)}}):t.set(i,n)}return r.push(...t.values()),r}function ku(e,t){return[...new Set(e.concat(t))]}function Du(e){return xn(e,(t,r)=>{let n=bo(t),i=bo(r);return n!==i?n-i:xo(t)-xo(r)})}function bo(e){let t=0;return Array.isArray(e.selectionPath)&&(t+=e.selectionPath.length),Array.isArray(e.argumentPath)&&(t+=e.argumentPath.length),t}function xo(e){switch(e.kind){case"InvalidArgumentValue":case"ValueTooLarge":return 20;case"InvalidArgumentType":return 10;case"RequiredArgumentMissing":return-10;default:return 0}}f();u();c();p();m();var le=class{constructor(t,r){this.name=t;this.value=r}isRequired=!1;makeRequired(){return this.isRequired=!0,this}write(t){let{colors:{green:r}}=t.context;t.addMarginSymbol(r(this.isRequired?"+":"?")),t.write(r(this.name)),this.isRequired||t.write(r("?")),t.write(r(": ")),typeof this.value=="string"?t.write(r(this.value)):t.write(this.value)}};f();u();c();p();m();f();u();c();p();m();Ao();f();u();c();p();m();var nt=class{constructor(t=0,r){this.context=r;this.currentIndent=t}lines=[];currentLine="";currentIndent=0;marginSymbol;afterNextNewLineCallback;write(t){return typeof t=="string"?this.currentLine+=t:t.write(this),this}writeJoined(t,r,n=(i,o)=>o.write(i)){let i=r.length-1;for(let o=0;o0&&this.currentIndent--,this}addMarginSymbol(t){return this.marginSymbol=t,this}toString(){return this.lines.concat(this.indentedCurrentLine()).join(` -`)}getCurrentLineLength(){return this.currentLine.length}indentedCurrentLine(){let t=this.currentLine.padStart(this.currentLine.length+2*this.currentIndent);return this.marginSymbol?this.marginSymbol+t.slice(1):t}};To();f();u();c();p();m();f();u();c();p();m();var Ir=class{constructor(t){this.value=t}write(t){t.write(this.value)}markAsError(){this.value.markAsError()}};f();u();c();p();m();var Or=e=>e,kr={bold:Or,red:Or,green:Or,dim:Or,enabled:!1},Ro={bold:lr,red:Ye,green:Ni,dim:ur,enabled:!0},it={write(e){e.writeLine(",")}};f();u();c();p();m();var we=class{constructor(t){this.contents=t}isUnderlined=!1;color=t=>t;underline(){return this.isUnderlined=!0,this}setColor(t){return this.color=t,this}write(t){let r=t.getCurrentLineLength();t.write(this.color(this.contents)),this.isUnderlined&&t.afterNextNewline(()=>{t.write(" ".repeat(r)).writeLine(this.color("~".repeat(this.contents.length)))})}};f();u();c();p();m();var _e=class{hasError=!1;markAsError(){return this.hasError=!0,this}};var ot=class extends _e{items=[];addItem(t){return this.items.push(new Ir(t)),this}getField(t){return this.items[t]}getPrintWidth(){return this.items.length===0?2:Math.max(...this.items.map(r=>r.value.getPrintWidth()))+2}write(t){if(this.items.length===0){this.writeEmpty(t);return}this.writeWithItems(t)}writeEmpty(t){let r=new we("[]");this.hasError&&r.setColor(t.context.colors.red).underline(),t.write(r)}writeWithItems(t){let{colors:r}=t.context;t.writeLine("[").withIndent(()=>t.writeJoined(it,this.items).newLine()).write("]"),this.hasError&&t.afterNextNewline(()=>{t.writeLine(r.red("~".repeat(this.getPrintWidth())))})}asObject(){}};var st=class e extends _e{fields={};suggestions=[];addField(t){this.fields[t.name]=t}addSuggestion(t){this.suggestions.push(t)}getField(t){return this.fields[t]}getDeepField(t){let[r,...n]=t,i=this.getField(r);if(!i)return;let o=i;for(let s of n){let a;if(o.value instanceof e?a=o.value.getField(s):o.value instanceof ot&&(a=o.value.getField(Number(s))),!a)return;o=a}return o}getDeepFieldValue(t){return t.length===0?this:this.getDeepField(t)?.value}hasField(t){return!!this.getField(t)}removeAllFields(){this.fields={}}removeField(t){delete this.fields[t]}getFields(){return this.fields}isEmpty(){return Object.keys(this.fields).length===0}getFieldValue(t){return this.getField(t)?.value}getDeepSubSelectionValue(t){let r=this;for(let n of t){if(!(r instanceof e))return;let i=r.getSubSelectionValue(n);if(!i)return;r=i}return r}getDeepSelectionParent(t){let r=this.getSelectionParent();if(!r)return;let n=r;for(let i of t){let o=n.value.getFieldValue(i);if(!o||!(o instanceof e))return;let s=o.getSelectionParent();if(!s)return;n=s}return n}getSelectionParent(){let t=this.getField("select")?.value.asObject();if(t)return{kind:"select",value:t};let r=this.getField("include")?.value.asObject();if(r)return{kind:"include",value:r}}getSubSelectionValue(t){return this.getSelectionParent()?.value.fields[t].value}getPrintWidth(){let t=Object.values(this.fields);return t.length==0?2:Math.max(...t.map(n=>n.getPrintWidth()))+2}write(t){let r=Object.values(this.fields);if(r.length===0&&this.suggestions.length===0){this.writeEmpty(t);return}this.writeWithContents(t,r)}asObject(){return this}writeEmpty(t){let r=new we("{}");this.hasError&&r.setColor(t.context.colors.red).underline(),t.write(r)}writeWithContents(t,r){t.writeLine("{").withIndent(()=>{t.writeJoined(it,[...r,...this.suggestions]).newLine()}),t.write("}"),this.hasError&&t.afterNextNewline(()=>{t.writeLine(t.context.colors.red("~".repeat(this.getPrintWidth())))})}};f();u();c();p();m();var H=class extends _e{constructor(r){super();this.text=r}getPrintWidth(){return this.text.length}write(r){let n=new we(this.text);this.hasError&&n.underline().setColor(r.context.colors.red),r.write(n)}asObject(){}};f();u();c();p();m();var St=class{fields=[];addField(t,r){return this.fields.push({write(n){let{green:i,dim:o}=n.context.colors;n.write(i(o(`${t}: ${r}`))).addMarginSymbol(i(o("+")))}}),this}write(t){let{colors:{green:r}}=t.context;t.writeLine(r("{")).withIndent(()=>{t.writeJoined(it,this.fields).newLine()}).write(r("}")).addMarginSymbol(r("+"))}};function Sr(e,t,r){switch(e.kind){case"MutuallyExclusiveFields":Mu(e,t);break;case"IncludeOnScalar":_u(e,t);break;case"EmptySelection":Nu(e,t,r);break;case"UnknownSelectionField":Bu(e,t);break;case"InvalidSelectionValue":qu(e,t);break;case"UnknownArgument":Vu(e,t);break;case"UnknownInputField":$u(e,t);break;case"RequiredArgumentMissing":ju(e,t);break;case"InvalidArgumentType":Gu(e,t);break;case"InvalidArgumentValue":Ju(e,t);break;case"ValueTooLarge":Qu(e,t);break;case"SomeFieldsMissing":Ku(e,t);break;case"TooManyFieldsGiven":Wu(e,t);break;case"Union":Po(e,t,r);break;default:throw new Error("not implemented: "+e.kind)}}function Mu(e,t){let r=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();r&&(r.getField(e.firstField)?.markAsError(),r.getField(e.secondField)?.markAsError()),t.addErrorMessage(n=>`Please ${n.bold("either")} use ${n.green(`\`${e.firstField}\``)} or ${n.green(`\`${e.secondField}\``)}, but ${n.red("not both")} at the same time.`)}function _u(e,t){let[r,n]=at(e.selectionPath),i=e.outputType,o=t.arguments.getDeepSelectionParent(r)?.value;if(o&&(o.getField(n)?.markAsError(),i))for(let s of i.fields)s.isRelation&&o.addSuggestion(new le(s.name,"true"));t.addErrorMessage(s=>{let a=`Invalid scalar field ${s.red(`\`${n}\``)} for ${s.bold("include")} statement`;return i?a+=` on model ${s.bold(i.name)}. ${It(s)}`:a+=".",a+=` -Note that ${s.bold("include")} statements only accept relation fields.`,a})}function Nu(e,t,r){let n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(n){let i=n.getField("omit")?.value.asObject();if(i){Fu(e,t,i);return}if(n.hasField("select")){Lu(e,t);return}}if(r?.[Se(e.outputType.name)]){Uu(e,t);return}t.addErrorMessage(()=>`Unknown field at "${e.selectionPath.join(".")} selection"`)}function Fu(e,t,r){r.removeAllFields();for(let n of e.outputType.fields)r.addSuggestion(new le(n.name,"false"));t.addErrorMessage(n=>`The ${n.red("omit")} statement includes every field of the model ${n.bold(e.outputType.name)}. At least one field must be included in the result`)}function Lu(e,t){let r=e.outputType,n=t.arguments.getDeepSelectionParent(e.selectionPath)?.value,i=n?.isEmpty()??!1;n&&(n.removeAllFields(),Oo(n,r)),t.addErrorMessage(o=>i?`The ${o.red("`select`")} statement for type ${o.bold(r.name)} must not be empty. ${It(o)}`:`The ${o.red("`select`")} statement for type ${o.bold(r.name)} needs ${o.bold("at least one truthy value")}.`)}function Uu(e,t){let r=new St;for(let i of e.outputType.fields)i.isRelation||r.addField(i.name,"false");let n=new le("omit",r).makeRequired();if(e.selectionPath.length===0)t.arguments.addSuggestion(n);else{let[i,o]=at(e.selectionPath),a=t.arguments.getDeepSelectionParent(i)?.value.asObject()?.getField(o);if(a){let l=a?.value.asObject()??new st;l.addSuggestion(n),a.value=l}}t.addErrorMessage(i=>`The global ${i.red("omit")} configuration excludes every field of the model ${i.bold(e.outputType.name)}. At least one field must be included in the result`)}function Bu(e,t){let r=ko(e.selectionPath,t);if(r.parentKind!=="unknown"){r.field.markAsError();let n=r.parent;switch(r.parentKind){case"select":Oo(n,e.outputType);break;case"include":Hu(n,e.outputType);break;case"omit":zu(n,e.outputType);break}}t.addErrorMessage(n=>{let i=[`Unknown field ${n.red(`\`${r.fieldName}\``)}`];return r.parentKind!=="unknown"&&i.push(`for ${n.bold(r.parentKind)} statement`),i.push(`on model ${n.bold(`\`${e.outputType.name}\``)}.`),i.push(It(n)),i.join(" ")})}function qu(e,t){let r=ko(e.selectionPath,t);r.parentKind!=="unknown"&&r.field.value.markAsError(),t.addErrorMessage(n=>`Invalid value for selection field \`${n.red(r.fieldName)}\`: ${e.underlyingError}`)}function Vu(e,t){let r=e.argumentPath[0],n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();n&&(n.getField(r)?.markAsError(),Yu(n,e.arguments)),t.addErrorMessage(i=>So(i,r,e.arguments.map(o=>o.name)))}function $u(e,t){let[r,n]=at(e.argumentPath),i=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(i){i.getDeepField(e.argumentPath)?.markAsError();let o=i.getDeepFieldValue(r)?.asObject();o&&Do(o,e.inputType)}t.addErrorMessage(o=>So(o,n,e.inputType.fields.map(s=>s.name)))}function So(e,t,r){let n=[`Unknown argument \`${e.red(t)}\`.`],i=Xu(t,r);return i&&n.push(`Did you mean \`${e.green(i)}\`?`),r.length>0&&n.push(It(e)),n.join(" ")}function ju(e,t){let r;t.addErrorMessage(l=>r?.value instanceof H&&r.value.text==="null"?`Argument \`${l.green(o)}\` must not be ${l.red("null")}.`:`Argument \`${l.green(o)}\` is missing.`);let n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(!n)return;let[i,o]=at(e.argumentPath),s=new St,a=n.getDeepFieldValue(i)?.asObject();if(a){if(r=a.getField(o),r&&a.removeField(o),e.inputTypes.length===1&&e.inputTypes[0].kind==="object"){for(let l of e.inputTypes[0].fields)s.addField(l.name,l.typeNames.join(" | "));a.addSuggestion(new le(o,s).makeRequired())}else{let l=e.inputTypes.map(Io).join(" | ");a.addSuggestion(new le(o,l).makeRequired())}if(e.dependentArgumentPath){n.getDeepField(e.dependentArgumentPath)?.markAsError();let[,l]=at(e.dependentArgumentPath);t.addErrorMessage(d=>`Argument \`${d.green(o)}\` is required because argument \`${d.green(l)}\` was provided.`)}}}function Io(e){return e.kind==="list"?`${Io(e.elementType)}[]`:e.name}function Gu(e,t){let r=e.argument.name,n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();n&&n.getDeepFieldValue(e.argumentPath)?.markAsError(),t.addErrorMessage(i=>{let o=Dr("or",e.argument.typeNames.map(s=>i.green(s)));return`Argument \`${i.bold(r)}\`: Invalid value provided. Expected ${o}, provided ${i.red(e.inferredType)}.`})}function Ju(e,t){let r=e.argument.name,n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();n&&n.getDeepFieldValue(e.argumentPath)?.markAsError(),t.addErrorMessage(i=>{let o=[`Invalid value for argument \`${i.bold(r)}\``];if(e.underlyingError&&o.push(`: ${e.underlyingError}`),o.push("."),e.argument.typeNames.length>0){let s=Dr("or",e.argument.typeNames.map(a=>i.green(a)));o.push(` Expected ${s}.`)}return o.join("")})}function Qu(e,t){let r=e.argument.name,n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject(),i;if(n){let s=n.getDeepField(e.argumentPath)?.value;s?.markAsError(),s instanceof H&&(i=s.text)}t.addErrorMessage(o=>{let s=["Unable to fit value"];return i&&s.push(o.red(i)),s.push(`into a 64-bit signed integer for field \`${o.bold(r)}\``),s.join(" ")})}function Ku(e,t){let r=e.argumentPath[e.argumentPath.length-1],n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(n){let i=n.getDeepFieldValue(e.argumentPath)?.asObject();i&&Do(i,e.inputType)}t.addErrorMessage(i=>{let o=[`Argument \`${i.bold(r)}\` of type ${i.bold(e.inputType.name)} needs`];return e.constraints.minFieldCount===1?e.constraints.requiredFields?o.push(`${i.green("at least one of")} ${Dr("or",e.constraints.requiredFields.map(s=>`\`${i.bold(s)}\``))} arguments.`):o.push(`${i.green("at least one")} argument.`):o.push(`${i.green(`at least ${e.constraints.minFieldCount}`)} arguments.`),o.push(It(i)),o.join(" ")})}function Wu(e,t){let r=e.argumentPath[e.argumentPath.length-1],n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject(),i=[];if(n){let o=n.getDeepFieldValue(e.argumentPath)?.asObject();o&&(o.markAsError(),i=Object.keys(o.getFields()))}t.addErrorMessage(o=>{let s=[`Argument \`${o.bold(r)}\` of type ${o.bold(e.inputType.name)} needs`];return e.constraints.minFieldCount===1&&e.constraints.maxFieldCount==1?s.push(`${o.green("exactly one")} argument,`):e.constraints.maxFieldCount==1?s.push(`${o.green("at most one")} argument,`):s.push(`${o.green(`at most ${e.constraints.maxFieldCount}`)} arguments,`),s.push(`but you provided ${Dr("and",i.map(a=>o.red(a)))}. Please choose`),e.constraints.maxFieldCount===1?s.push("one."):s.push(`${e.constraints.maxFieldCount}.`),s.join(" ")})}function Oo(e,t){for(let r of t.fields)e.hasField(r.name)||e.addSuggestion(new le(r.name,"true"))}function Hu(e,t){for(let r of t.fields)r.isRelation&&!e.hasField(r.name)&&e.addSuggestion(new le(r.name,"true"))}function zu(e,t){for(let r of t.fields)!e.hasField(r.name)&&!r.isRelation&&e.addSuggestion(new le(r.name,"true"))}function Yu(e,t){for(let r of t)e.hasField(r.name)||e.addSuggestion(new le(r.name,r.typeNames.join(" | ")))}function ko(e,t){let[r,n]=at(e),i=t.arguments.getDeepSubSelectionValue(r)?.asObject();if(!i)return{parentKind:"unknown",fieldName:n};let o=i.getFieldValue("select")?.asObject(),s=i.getFieldValue("include")?.asObject(),a=i.getFieldValue("omit")?.asObject(),l=o?.getField(n);return o&&l?{parentKind:"select",parent:o,field:l,fieldName:n}:(l=s?.getField(n),s&&l?{parentKind:"include",field:l,parent:s,fieldName:n}:(l=a?.getField(n),a&&l?{parentKind:"omit",field:l,parent:a,fieldName:n}:{parentKind:"unknown",fieldName:n}))}function Do(e,t){if(t.kind==="object")for(let r of t.fields)e.hasField(r.name)||e.addSuggestion(new le(r.name,r.typeNames.join(" | ")))}function at(e){let t=[...e],r=t.pop();if(!r)throw new Error("unexpected empty path");return[t,r]}function It({green:e,enabled:t}){return"Available options are "+(t?`listed in ${e("green")}`:"marked with ?")+"."}function Dr(e,t){if(t.length===1)return t[0];let r=[...t],n=r.pop();return`${r.join(", ")} ${e} ${n}`}var Zu=3;function Xu(e,t){let r=1/0,n;for(let i of t){let o=(0,Co.default)(e,i);o>Zu||o`}};function lt(e){return e instanceof Ot}f();u();c();p();m();var Mr=Symbol(),On=new WeakMap,Te=class{constructor(t){t===Mr?On.set(this,`Prisma.${this._getName()}`):On.set(this,`new Prisma.${this._getNamespace()}.${this._getName()}()`)}_getName(){return this.constructor.name}toString(){return On.get(this)}},kt=class extends Te{_getNamespace(){return"NullTypes"}},Dt=class extends kt{#e};Dn(Dt,"DbNull");var Mt=class extends kt{#e};Dn(Mt,"JsonNull");var _t=class extends kt{#e};Dn(_t,"AnyNull");var kn={classes:{DbNull:Dt,JsonNull:Mt,AnyNull:_t},instances:{DbNull:new Dt(Mr),JsonNull:new Mt(Mr),AnyNull:new _t(Mr)}};function Dn(e,t){Object.defineProperty(e,"name",{value:t,configurable:!0})}f();u();c();p();m();var Mo=": ",_r=class{constructor(t,r){this.name=t;this.value=r}hasError=!1;markAsError(){this.hasError=!0}getPrintWidth(){return this.name.length+this.value.getPrintWidth()+Mo.length}write(t){let r=new we(this.name);this.hasError&&r.underline().setColor(t.context.colors.red),t.write(r).write(Mo).write(this.value)}};var Mn=class{arguments;errorMessages=[];constructor(t){this.arguments=t}write(t){t.write(this.arguments)}addErrorMessage(t){this.errorMessages.push(t)}renderAllMessages(t){return this.errorMessages.map(r=>r(t)).join(` -`)}};function ut(e){return new Mn(_o(e))}function _o(e){let t=new st;for(let[r,n]of Object.entries(e)){let i=new _r(r,No(n));t.addField(i)}return t}function No(e){if(typeof e=="string")return new H(JSON.stringify(e));if(typeof e=="number"||typeof e=="boolean")return new H(String(e));if(typeof e=="bigint")return new H(`${e}n`);if(e===null)return new H("null");if(e===void 0)return new H("undefined");if(rt(e))return new H(`new Prisma.Decimal("${e.toFixed()}")`);if(e instanceof Uint8Array)return w.Buffer.isBuffer(e)?new H(`Buffer.alloc(${e.byteLength})`):new H(`new Uint8Array(${e.byteLength})`);if(e instanceof Date){let t=yr(e)?e.toISOString():"Invalid Date";return new H(`new Date("${t}")`)}return e instanceof Te?new H(`Prisma.${e._getName()}`):lt(e)?new H(`prisma.${Se(e.modelName)}.$fields.${e.name}`):Array.isArray(e)?ec(e):typeof e=="object"?_o(e):new H(Object.prototype.toString.call(e))}function ec(e){let t=new ot;for(let r of e)t.addItem(No(r));return t}function Nr(e,t){let r=t==="pretty"?Ro:kr,n=e.renderAllMessages(r),i=new nt(0,{colors:r}).write(e).toString();return{message:n,args:i}}function Fr({args:e,errors:t,errorFormat:r,callsite:n,originalMethod:i,clientVersion:o,globalOmit:s}){let a=ut(e);for(let h of t)Sr(h,a,s);let{message:l,args:d}=Nr(a,r),g=Cr({message:l,callsite:n,originalMethod:i,showColors:r==="pretty",callArguments:d});throw new ee(g,{clientVersion:o})}f();u();c();p();m();f();u();c();p();m();function Ee(e){return e.replace(/^./,t=>t.toLowerCase())}f();u();c();p();m();function Lo(e,t,r){let n=Ee(r);return!t.result||!(t.result.$allModels||t.result[n])?e:tc({...e,...Fo(t.name,e,t.result.$allModels),...Fo(t.name,e,t.result[n])})}function tc(e){let t=new ge,r=(n,i)=>t.getOrCreate(n,()=>i.has(n)?[n]:(i.add(n),e[n]?e[n].needs.flatMap(o=>r(o,i)):[n]));return gr(e,n=>({...n,needs:r(n.name,new Set)}))}function Fo(e,t,r){return r?gr(r,({needs:n,compute:i},o)=>({name:o,needs:n?Object.keys(n).filter(s=>n[s]):[],compute:rc(t,o,i)})):{}}function rc(e,t,r){let n=e?.[t]?.compute;return n?i=>r({...i,[t]:n(i)}):r}function Uo(e,t){if(!t)return e;let r={...e};for(let n of Object.values(t))if(e[n.name])for(let i of n.needs)r[i]=!0;return r}function Bo(e,t){if(!t)return e;let r={...e};for(let n of Object.values(t))if(!e[n.name])for(let i of n.needs)delete r[i];return r}var Lr=class{constructor(t,r){this.extension=t;this.previous=r}computedFieldsCache=new ge;modelExtensionsCache=new ge;queryCallbacksCache=new ge;clientExtensions=At(()=>this.extension.client?{...this.previous?.getAllClientExtensions(),...this.extension.client}:this.previous?.getAllClientExtensions());batchCallbacks=At(()=>{let t=this.previous?.getAllBatchQueryCallbacks()??[],r=this.extension.query?.$__internalBatch;return r?t.concat(r):t});getAllComputedFields(t){return this.computedFieldsCache.getOrCreate(t,()=>Lo(this.previous?.getAllComputedFields(t),this.extension,t))}getAllClientExtensions(){return this.clientExtensions.get()}getAllModelExtensions(t){return this.modelExtensionsCache.getOrCreate(t,()=>{let r=Ee(t);return!this.extension.model||!(this.extension.model[r]||this.extension.model.$allModels)?this.previous?.getAllModelExtensions(t):{...this.previous?.getAllModelExtensions(t),...this.extension.model.$allModels,...this.extension.model[r]}})}getAllQueryCallbacks(t,r){return this.queryCallbacksCache.getOrCreate(`${t}:${r}`,()=>{let n=this.previous?.getAllQueryCallbacks(t,r)??[],i=[],o=this.extension.query;return!o||!(o[t]||o.$allModels||o[r]||o.$allOperations)?n:(o[t]!==void 0&&(o[t][r]!==void 0&&i.push(o[t][r]),o[t].$allOperations!==void 0&&i.push(o[t].$allOperations)),t!=="$none"&&o.$allModels!==void 0&&(o.$allModels[r]!==void 0&&i.push(o.$allModels[r]),o.$allModels.$allOperations!==void 0&&i.push(o.$allModels.$allOperations)),o[r]!==void 0&&i.push(o[r]),o.$allOperations!==void 0&&i.push(o.$allOperations),n.concat(i))})}getAllBatchQueryCallbacks(){return this.batchCallbacks.get()}},ct=class e{constructor(t){this.head=t}static empty(){return new e}static single(t){return new e(new Lr(t))}isEmpty(){return this.head===void 0}append(t){return new e(new Lr(t,this.head))}getAllComputedFields(t){return this.head?.getAllComputedFields(t)}getAllClientExtensions(){return this.head?.getAllClientExtensions()}getAllModelExtensions(t){return this.head?.getAllModelExtensions(t)}getAllQueryCallbacks(t,r){return this.head?.getAllQueryCallbacks(t,r)??[]}getAllBatchQueryCallbacks(){return this.head?.getAllBatchQueryCallbacks()??[]}};f();u();c();p();m();var Ur=class{constructor(t){this.name=t}};function qo(e){return e instanceof Ur}function nc(e){return new Ur(e)}f();u();c();p();m();f();u();c();p();m();var Vo=Symbol(),Nt=class{constructor(t){if(t!==Vo)throw new Error("Skip instance can not be constructed directly")}ifUndefined(t){return t===void 0?_n:t}},_n=new Nt(Vo);function be(e){return e instanceof Nt}var ic={findUnique:"findUnique",findUniqueOrThrow:"findUniqueOrThrow",findFirst:"findFirst",findFirstOrThrow:"findFirstOrThrow",findMany:"findMany",count:"aggregate",create:"createOne",createMany:"createMany",createManyAndReturn:"createManyAndReturn",update:"updateOne",updateMany:"updateMany",updateManyAndReturn:"updateManyAndReturn",upsert:"upsertOne",delete:"deleteOne",deleteMany:"deleteMany",executeRaw:"executeRaw",queryRaw:"queryRaw",aggregate:"aggregate",groupBy:"groupBy",runCommandRaw:"runCommandRaw",findRaw:"findRaw",aggregateRaw:"aggregateRaw"},$o="explicitly `undefined` values are not allowed";function Fn({modelName:e,action:t,args:r,runtimeDataModel:n,extensions:i=ct.empty(),callsite:o,clientMethod:s,errorFormat:a,clientVersion:l,previewFeatures:d,globalOmit:g}){let h=new Nn({runtimeDataModel:n,modelName:e,action:t,rootArgs:r,callsite:o,extensions:i,selectionPath:[],argumentPath:[],originalMethod:s,errorFormat:a,clientVersion:l,previewFeatures:d,globalOmit:g});return{modelName:e,action:ic[t],query:Ft(r,h)}}function Ft({select:e,include:t,...r}={},n){let i=r.omit;return delete r.omit,{arguments:Go(r,n),selection:oc(e,t,i,n)}}function oc(e,t,r,n){return e?(t?n.throwValidationError({kind:"MutuallyExclusiveFields",firstField:"include",secondField:"select",selectionPath:n.getSelectionPath()}):r&&n.throwValidationError({kind:"MutuallyExclusiveFields",firstField:"omit",secondField:"select",selectionPath:n.getSelectionPath()}),uc(e,n)):sc(n,t,r)}function sc(e,t,r){let n={};return e.modelOrType&&!e.isRawAction()&&(n.$composites=!0,n.$scalars=!0),t&&ac(n,t,e),lc(n,r,e),n}function ac(e,t,r){for(let[n,i]of Object.entries(t)){if(be(i))continue;let o=r.nestSelection(n);if(Ln(i,o),i===!1||i===void 0){e[n]=!1;continue}let s=r.findField(n);if(s&&s.kind!=="object"&&r.throwValidationError({kind:"IncludeOnScalar",selectionPath:r.getSelectionPath().concat(n),outputType:r.getOutputTypeDescription()}),s){e[n]=Ft(i===!0?{}:i,o);continue}if(i===!0){e[n]=!0;continue}e[n]=Ft(i,o)}}function lc(e,t,r){let n=r.getComputedFields(),i={...r.getGlobalOmit(),...t},o=Bo(i,n);for(let[s,a]of Object.entries(o)){if(be(a))continue;Ln(a,r.nestSelection(s));let l=r.findField(s);n?.[s]&&!l||(e[s]=!a)}}function uc(e,t){let r={},n=t.getComputedFields(),i=Uo(e,n);for(let[o,s]of Object.entries(i)){if(be(s))continue;let a=t.nestSelection(o);Ln(s,a);let l=t.findField(o);if(!(n?.[o]&&!l)){if(s===!1||s===void 0||be(s)){r[o]=!1;continue}if(s===!0){l?.kind==="object"?r[o]=Ft({},a):r[o]=!0;continue}r[o]=Ft(s,a)}}return r}function jo(e,t){if(e===null)return null;if(typeof e=="string"||typeof e=="number"||typeof e=="boolean")return e;if(typeof e=="bigint")return{$type:"BigInt",value:String(e)};if(Xe(e)){if(yr(e))return{$type:"DateTime",value:e.toISOString()};t.throwValidationError({kind:"InvalidArgumentValue",selectionPath:t.getSelectionPath(),argumentPath:t.getArgumentPath(),argument:{name:t.getArgumentName(),typeNames:["Date"]},underlyingError:"Provided Date object is invalid"})}if(qo(e))return{$type:"Param",value:e.name};if(lt(e))return{$type:"FieldRef",value:{_ref:e.name,_container:e.modelName}};if(Array.isArray(e))return cc(e,t);if(ArrayBuffer.isView(e)){let{buffer:r,byteOffset:n,byteLength:i}=e;return{$type:"Bytes",value:w.Buffer.from(r,n,i).toString("base64")}}if(pc(e))return e.values;if(rt(e))return{$type:"Decimal",value:e.toFixed()};if(e instanceof Te){if(e!==kn.instances[e._getName()])throw new Error("Invalid ObjectEnumValue");return{$type:"Enum",value:e._getName()}}if(mc(e))return e.toJSON();if(typeof e=="object")return Go(e,t);t.throwValidationError({kind:"InvalidArgumentValue",selectionPath:t.getSelectionPath(),argumentPath:t.getArgumentPath(),argument:{name:t.getArgumentName(),typeNames:[]},underlyingError:`We could not serialize ${Object.prototype.toString.call(e)} value. Serialize the object to JSON or implement a ".toJSON()" method on it`})}function Go(e,t){if(e.$type)return{$type:"Raw",value:e};let r={};for(let n in e){let i=e[n],o=t.nestArgument(n);be(i)||(i!==void 0?r[n]=jo(i,o):t.isPreviewFeatureOn("strictUndefinedChecks")&&t.throwValidationError({kind:"InvalidArgumentValue",argumentPath:o.getArgumentPath(),selectionPath:t.getSelectionPath(),argument:{name:t.getArgumentName(),typeNames:[]},underlyingError:$o}))}return r}function cc(e,t){let r=[];for(let n=0;n({name:t.name,typeName:"boolean",isRelation:t.kind==="object"}))}}isRawAction(){return["executeRaw","queryRaw","runCommandRaw","findRaw","aggregateRaw"].includes(this.params.action)}isPreviewFeatureOn(t){return this.params.previewFeatures.includes(t)}getComputedFields(){if(this.params.modelName)return this.params.extensions.getAllComputedFields(this.params.modelName)}findField(t){return this.modelOrType?.fields.find(r=>r.name===t)}nestSelection(t){let r=this.findField(t),n=r?.kind==="object"?r.type:void 0;return new e({...this.params,modelName:n,selectionPath:this.params.selectionPath.concat(t)})}getGlobalOmit(){return this.params.modelName&&this.shouldApplyGlobalOmit()?this.params.globalOmit?.[Se(this.params.modelName)]??{}:{}}shouldApplyGlobalOmit(){switch(this.params.action){case"findFirst":case"findFirstOrThrow":case"findUniqueOrThrow":case"findMany":case"upsert":case"findUnique":case"createManyAndReturn":case"create":case"update":case"updateManyAndReturn":case"delete":return!0;case"executeRaw":case"aggregateRaw":case"runCommandRaw":case"findRaw":case"createMany":case"deleteMany":case"groupBy":case"updateMany":case"count":case"aggregate":case"queryRaw":return!1;default:Ue(this.params.action,"Unknown action")}}nestArgument(t){return new e({...this.params,argumentPath:this.params.argumentPath.concat(t)})}};f();u();c();p();m();function Jo(e){if(!e._hasPreviewFlag("metrics"))throw new ee("`metrics` preview feature must be enabled in order to access metrics API",{clientVersion:e._clientVersion})}var Lt=class{_client;constructor(t){this._client=t}prometheus(t){return Jo(this._client),this._client._engine.metrics({format:"prometheus",...t})}json(t){return Jo(this._client),this._client._engine.metrics({format:"json",...t})}};f();u();c();p();m();function fc(e,t){let r=At(()=>dc(t));Object.defineProperty(e,"dmmf",{get:()=>r.get()})}function dc(e){return{datamodel:{models:Un(e.models),enums:Un(e.enums),types:Un(e.types)}}}function Un(e){return Object.entries(e).map(([t,r])=>({name:t,...r}))}f();u();c();p();m();var Bn=new WeakMap,Br="$$PrismaTypedSql",Ut=class{constructor(t,r){Bn.set(this,{sql:t,values:r}),Object.defineProperty(this,Br,{value:Br})}get sql(){return Bn.get(this).sql}get values(){return Bn.get(this).values}};function gc(e){return(...t)=>new Ut(e,t)}function qr(e){return e!=null&&e[Br]===Br}f();u();c();p();m();var ua=Qe(gn());f();u();c();p();m();Qo();Gi();Hi();f();u();c();p();m();var ue=class e{constructor(t,r){if(t.length-1!==r.length)throw t.length===0?new TypeError("Expected at least 1 string"):new TypeError(`Expected ${t.length} strings to have ${t.length-1} values`);let n=r.reduce((s,a)=>s+(a instanceof e?a.values.length:1),0);this.values=new Array(n),this.strings=new Array(n+1),this.strings[0]=t[0];let i=0,o=0;for(;ie.getPropertyValue(r))},getPropertyDescriptor(r){return e.getPropertyDescriptor?.(r)}}}f();u();c();p();m();f();u();c();p();m();var $r={enumerable:!0,configurable:!0,writable:!0};function jr(e){let t=new Set(e);return{getPrototypeOf:()=>Object.prototype,getOwnPropertyDescriptor:()=>$r,has:(r,n)=>t.has(n),set:(r,n,i)=>t.add(n)&&Reflect.set(r,n,i),ownKeys:()=>[...t]}}var Ho=Symbol.for("nodejs.util.inspect.custom");function me(e,t){let r=wc(t),n=new Set,i=new Proxy(e,{get(o,s){if(n.has(s))return o[s];let a=r.get(s);return a?a.getPropertyValue(s):o[s]},has(o,s){if(n.has(s))return!0;let a=r.get(s);return a?a.has?.(s)??!0:Reflect.has(o,s)},ownKeys(o){let s=zo(Reflect.ownKeys(o),r),a=zo(Array.from(r.keys()),r);return[...new Set([...s,...a,...n])]},set(o,s,a){return r.get(s)?.getPropertyDescriptor?.(s)?.writable===!1?!1:(n.add(s),Reflect.set(o,s,a))},getOwnPropertyDescriptor(o,s){let a=Reflect.getOwnPropertyDescriptor(o,s);if(a&&!a.configurable)return a;let l=r.get(s);return l?l.getPropertyDescriptor?{...$r,...l?.getPropertyDescriptor(s)}:$r:a},defineProperty(o,s,a){return n.add(s),Reflect.defineProperty(o,s,a)},getPrototypeOf:()=>Object.prototype});return i[Ho]=function(){let o={...this};return delete o[Ho],o},i}function wc(e){let t=new Map;for(let r of e){let n=r.getKeys();for(let i of n)t.set(i,r)}return t}function zo(e,t){return e.filter(r=>t.get(r)?.has?.(r)??!0)}f();u();c();p();m();function pt(e){return{getKeys(){return e},has(){return!1},getPropertyValue(){}}}f();u();c();p();m();function Gr(e,t){return{batch:e,transaction:t?.kind==="batch"?{isolationLevel:t.options.isolationLevel}:void 0}}f();u();c();p();m();function Yo(e){if(e===void 0)return"";let t=ut(e);return new nt(0,{colors:kr}).write(t).toString()}f();u();c();p();m();var Ec="P2037";function Jr({error:e,user_facing_error:t},r,n){return t.error_code?new se(bc(t,n),{code:t.error_code,clientVersion:r,meta:t.meta,batchRequestIdx:t.batch_request_idx}):new ae(e,{clientVersion:r,batchRequestIdx:t.batch_request_idx})}function bc(e,t){let r=e.message;return(t==="postgresql"||t==="postgres"||t==="mysql")&&e.error_code===Ec&&(r+=` -Prisma Accelerate has built-in connection pooling to prevent such errors: https://pris.ly/client/error-accelerate`),r}f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();var qn=class{getLocation(){return null}};function Ne(e){return typeof $EnabledCallSite=="function"&&e!=="minimal"?new $EnabledCallSite:new qn}f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();var Zo={_avg:!0,_count:!0,_sum:!0,_min:!0,_max:!0};function mt(e={}){let t=Pc(e);return Object.entries(t).reduce((n,[i,o])=>(Zo[i]!==void 0?n.select[i]={select:o}:n[i]=o,n),{select:{}})}function Pc(e={}){return typeof e._count=="boolean"?{...e,_count:{_all:e._count}}:e}function Qr(e={}){return t=>(typeof e._count=="boolean"&&(t._count=t._count._all),t)}function Xo(e,t){let r=Qr(e);return t({action:"aggregate",unpacker:r,argsMapper:mt})(e)}f();u();c();p();m();function vc(e={}){let{select:t,...r}=e;return typeof t=="object"?mt({...r,_count:t}):mt({...r,_count:{_all:!0}})}function Tc(e={}){return typeof e.select=="object"?t=>Qr(e)(t)._count:t=>Qr(e)(t)._count._all}function es(e,t){return t({action:"count",unpacker:Tc(e),argsMapper:vc})(e)}f();u();c();p();m();function Ac(e={}){let t=mt(e);if(Array.isArray(t.by))for(let r of t.by)typeof r=="string"&&(t.select[r]=!0);else typeof t.by=="string"&&(t.select[t.by]=!0);return t}function Rc(e={}){return t=>(typeof e?._count=="boolean"&&t.forEach(r=>{r._count=r._count._all}),t)}function ts(e,t){return t({action:"groupBy",unpacker:Rc(e),argsMapper:Ac})(e)}function rs(e,t,r){if(t==="aggregate")return n=>Xo(n,r);if(t==="count")return n=>es(n,r);if(t==="groupBy")return n=>ts(n,r)}f();u();c();p();m();function ns(e,t){let r=t.fields.filter(i=>!i.relationName),n=no(r,"name");return new Proxy({},{get(i,o){if(o in i||typeof o=="symbol")return i[o];let s=n[o];if(s)return new Ot(e,o,s.type,s.isList,s.kind==="enum")},...jr(Object.keys(n))})}f();u();c();p();m();f();u();c();p();m();var is=e=>Array.isArray(e)?e:e.split("."),Vn=(e,t)=>is(t).reduce((r,n)=>r&&r[n],e),os=(e,t,r)=>is(t).reduceRight((n,i,o,s)=>Object.assign({},Vn(e,s.slice(0,o)),{[i]:n}),r);function Cc(e,t){return e===void 0||t===void 0?[]:[...t,"select",e]}function Sc(e,t,r){return t===void 0?e??{}:os(t,r,e||!0)}function $n(e,t,r,n,i,o){let a=e._runtimeDataModel.models[t].fields.reduce((l,d)=>({...l,[d.name]:d}),{});return l=>{let d=Ne(e._errorFormat),g=Cc(n,i),h=Sc(l,o,g),T=r({dataPath:g,callsite:d})(h),I=Ic(e,t);return new Proxy(T,{get(S,C){if(!I.includes(C))return S[C];let F=[a[C].type,r,C],B=[g,h];return $n(e,...F,...B)},...jr([...I,...Object.getOwnPropertyNames(T)])})}}function Ic(e,t){return e._runtimeDataModel.models[t].fields.filter(r=>r.kind==="object").map(r=>r.name)}var Oc=["findUnique","findUniqueOrThrow","findFirst","findFirstOrThrow","create","update","upsert","delete"],kc=["aggregate","count","groupBy"];function jn(e,t){let r=e._extensions.getAllModelExtensions(t)??{},n=[Dc(e,t),_c(e,t),Bt(r),te("name",()=>t),te("$name",()=>t),te("$parent",()=>e._appliedParent)];return me({},n)}function Dc(e,t){let r=Ee(t),n=Object.keys(Ct).concat("count");return{getKeys(){return n},getPropertyValue(i){let o=i,s=a=>l=>{let d=Ne(e._errorFormat);return e._createPrismaPromise(g=>{let h={args:l,dataPath:[],action:o,model:t,clientMethod:`${r}.${i}`,jsModelName:r,transaction:g,callsite:d};return e._request({...h,...a})},{action:o,args:l,model:t})};return Oc.includes(o)?$n(e,t,s):Mc(i)?rs(e,i,s):s({})}}}function Mc(e){return kc.includes(e)}function _c(e,t){return Be(te("fields",()=>{let r=e._runtimeDataModel.models[t];return ns(t,r)}))}f();u();c();p();m();function ss(e){return e.replace(/^./,t=>t.toUpperCase())}var Gn=Symbol();function qt(e){let t=[Nc(e),Fc(e),te(Gn,()=>e),te("$parent",()=>e._appliedParent)],r=e._extensions.getAllClientExtensions();return r&&t.push(Bt(r)),me(e,t)}function Nc(e){let t=Object.getPrototypeOf(e._originalClient),r=[...new Set(Object.getOwnPropertyNames(t))];return{getKeys(){return r},getPropertyValue(n){return e[n]}}}function Fc(e){let t=Object.keys(e._runtimeDataModel.models),r=t.map(Ee),n=[...new Set(t.concat(r))];return Be({getKeys(){return n},getPropertyValue(i){let o=ss(i);if(e._runtimeDataModel.models[o]!==void 0)return jn(e,o);if(e._runtimeDataModel.models[i]!==void 0)return jn(e,i)},getPropertyDescriptor(i){if(!r.includes(i))return{enumerable:!1}}})}function as(e){return e[Gn]?e[Gn]:e}function ls(e){if(typeof e=="function")return e(this);if(e.client?.__AccelerateEngine){let r=e.client.__AccelerateEngine;this._originalClient._engine=new r(this._originalClient._accelerateEngineConfig)}let t=Object.create(this._originalClient,{_extensions:{value:this._extensions.append(e)},_appliedParent:{value:this,configurable:!0},$on:{value:void 0}});return qt(t)}f();u();c();p();m();f();u();c();p();m();function us({result:e,modelName:t,select:r,omit:n,extensions:i}){let o=i.getAllComputedFields(t);if(!o)return e;let s=[],a=[];for(let l of Object.values(o)){if(n){if(n[l.name])continue;let d=l.needs.filter(g=>n[g]);d.length>0&&a.push(pt(d))}else if(r){if(!r[l.name])continue;let d=l.needs.filter(g=>!r[g]);d.length>0&&a.push(pt(d))}Lc(e,l.needs)&&s.push(Uc(l,me(e,s)))}return s.length>0||a.length>0?me(e,[...s,...a]):e}function Lc(e,t){return t.every(r=>bn(e,r))}function Uc(e,t){return Be(te(e.name,()=>e.compute(t)))}f();u();c();p();m();function Kr({visitor:e,result:t,args:r,runtimeDataModel:n,modelName:i}){if(Array.isArray(t)){for(let s=0;sg.name===o);if(!l||l.kind!=="object"||!l.relationName)continue;let d=typeof s=="object"?s:{};t[o]=Kr({visitor:i,result:t[o],args:d,modelName:l.type,runtimeDataModel:n})}}function ps({result:e,modelName:t,args:r,extensions:n,runtimeDataModel:i,globalOmit:o}){return n.isEmpty()||e==null||typeof e!="object"||!i.models[t]?e:Kr({result:e,args:r??{},modelName:t,runtimeDataModel:i,visitor:(a,l,d)=>{let g=Ee(l);return us({result:a,modelName:g,select:d.select,omit:d.select?void 0:{...o?.[g],...d.omit},extensions:n})}})}f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();var Bc=["$connect","$disconnect","$on","$transaction","$extends"],ms=Bc;function fs(e){if(e instanceof ue)return qc(e);if(qr(e))return Vc(e);if(Array.isArray(e)){let r=[e[0]];for(let n=1;n{let o=t.customDataProxyFetch;return"transaction"in t&&i!==void 0&&(t.transaction?.kind==="batch"&&t.transaction.lock.then(),t.transaction=i),n===r.length?e._executeRequest(t):r[n]({model:t.model,operation:t.model?t.action:t.clientMethod,args:fs(t.args??{}),__internalParams:t,query:(s,a=t)=>{let l=a.customDataProxyFetch;return a.customDataProxyFetch=Es(o,l),a.args=s,gs(e,a,r,n+1)}})})}function hs(e,t){let{jsModelName:r,action:n,clientMethod:i}=t,o=r?n:i;if(e._extensions.isEmpty())return e._executeRequest(t);let s=e._extensions.getAllQueryCallbacks(r??"$none",o);return gs(e,t,s)}function ys(e){return t=>{let r={requests:t},n=t[0].extensions.getAllBatchQueryCallbacks();return n.length?ws(r,n,0,e):e(r)}}function ws(e,t,r,n){if(r===t.length)return n(e);let i=e.customDataProxyFetch,o=e.requests[0].transaction;return t[r]({args:{queries:e.requests.map(s=>({model:s.modelName,operation:s.action,args:s.args})),transaction:o?{isolationLevel:o.kind==="batch"?o.isolationLevel:void 0}:void 0},__internalParams:e,query(s,a=e){let l=a.customDataProxyFetch;return a.customDataProxyFetch=Es(i,l),ws(a,t,r+1,n)}})}var ds=e=>e;function Es(e=ds,t=ds){return r=>e(t(r))}f();u();c();p();m();var bs=Z("prisma:client"),xs={Vercel:"vercel","Netlify CI":"netlify"};function Ps({postinstall:e,ciName:t,clientVersion:r,generator:n}){if(bs("checkPlatformCaching:postinstall",e),bs("checkPlatformCaching:ciName",t),e===!0&&!(n?.output&&typeof(n.output.fromEnvVar??n.output.value)=="string")&&t&&t in xs){let i=`Prisma has detected that this project was built on ${t}, which caches dependencies. This leads to an outdated Prisma Client because Prisma's auto-generation isn't triggered. To fix this, make sure to run the \`prisma generate\` command during the build process. - -Learn how: https://pris.ly/d/${xs[t]}-build`;throw console.error(i),new Q(i,r)}}f();u();c();p();m();function vs(e,t){return e?e.datasources?e.datasources:e.datasourceUrl?{[t[0]]:{url:e.datasourceUrl}}:{}:{}}f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();function Ts(e,t){throw new Error(t)}function $c(e){return e!==null&&typeof e=="object"&&typeof e.$type=="string"}function jc(e,t){let r={};for(let n of Object.keys(e))r[n]=t(e[n],n);return r}function $t(e){return e===null?e:Array.isArray(e)?e.map($t):typeof e=="object"?$c(e)?Gc(e):e.constructor!==null&&e.constructor.name!=="Object"?e:jc(e,$t):e}function Gc({$type:e,value:t}){switch(e){case"BigInt":return BigInt(t);case"Bytes":{let{buffer:r,byteOffset:n,byteLength:i}=w.Buffer.from(t,"base64");return new Uint8Array(r,n,i)}case"DateTime":return new Date(t);case"Decimal":return new ve(t);case"Json":return JSON.parse(t);default:Ts(t,"Unknown tagged value")}}var As="6.19.1";f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();var Qc=()=>globalThis.process?.release?.name==="node",Kc=()=>!!globalThis.Bun||!!globalThis.process?.versions?.bun,Wc=()=>!!globalThis.Deno,Hc=()=>typeof globalThis.Netlify=="object",zc=()=>typeof globalThis.EdgeRuntime=="object",Yc=()=>globalThis.navigator?.userAgent==="Cloudflare-Workers";function Zc(){return[[Hc,"netlify"],[zc,"edge-light"],[Yc,"workerd"],[Wc,"deno"],[Kc,"bun"],[Qc,"node"]].flatMap(r=>r[0]()?[r[1]]:[]).at(0)??""}var Xc={node:"Node.js",workerd:"Cloudflare Workers",deno:"Deno and Deno Deploy",netlify:"Netlify Edge Functions","edge-light":"Edge Runtime (Vercel Edge Functions, Vercel Edge Middleware, Next.js (Pages Router) Edge API Routes, Next.js (App Router) Edge Route Handlers or Next.js Middleware)"};function Jn(){let e=Zc();return{id:e,prettyName:Xc[e]||e,isEdge:["workerd","deno","netlify","edge-light"].includes(e)}}function ft({inlineDatasources:e,overrideDatasources:t,env:r,clientVersion:n}){let i,o=Object.keys(e)[0],s=e[o]?.url,a=t[o]?.url;if(o===void 0?i=void 0:a?i=a:s?.value?i=s.value:s?.fromEnvVar&&(i=r[s.fromEnvVar]),s?.fromEnvVar!==void 0&&i===void 0)throw Jn().id==="workerd"?new Q(`error: Environment variable not found: ${s.fromEnvVar}. - -In Cloudflare module Workers, environment variables are available only in the Worker's \`env\` parameter of \`fetch\`. -To solve this, provide the connection string directly: https://pris.ly/d/cloudflare-datasource-url`,n):new Q(`error: Environment variable not found: ${s.fromEnvVar}.`,n);if(i===void 0)throw new Q("error: Missing URL environment variable, value, or override.",n);return i}f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();var Wr=class extends Error{clientVersion;cause;constructor(t,r){super(t),this.clientVersion=r.clientVersion,this.cause=r.cause}get[Symbol.toStringTag](){return this.name}};var ie=class extends Wr{isRetryable;constructor(t,r){super(t,r),this.isRetryable=r.isRetryable??!0}};f();u();c();p();m();function U(e,t){return{...e,isRetryable:t}}var qe=class extends ie{name="InvalidDatasourceError";code="P6001";constructor(t,r){super(t,U(r,!1))}};N(qe,"InvalidDatasourceError");function Rs(e){let t={clientVersion:e.clientVersion},r=Object.keys(e.inlineDatasources)[0],n=ft({inlineDatasources:e.inlineDatasources,overrideDatasources:e.overrideDatasources,clientVersion:e.clientVersion,env:{...e.env,...typeof y<"u"?y.env:{}}}),i;try{i=new URL(n)}catch{throw new qe(`Error validating datasource \`${r}\`: the URL must start with the protocol \`prisma://\``,t)}let{protocol:o,searchParams:s}=i;if(o!=="prisma:"&&o!==fr)throw new qe(`Error validating datasource \`${r}\`: the URL must start with the protocol \`prisma://\` or \`prisma+postgres://\``,t);let a=s.get("api_key");if(a===null||a.length<1)throw new qe(`Error validating datasource \`${r}\`: the URL must contain a valid API key`,t);let l=hn(i)?"http:":"https:";y.env.TEST_CLIENT_ENGINE_REMOTE_EXECUTOR&&i.searchParams.has("use_http")&&(l="http:");let d=new URL(i.href.replace(o,l));return{apiKey:a,url:d}}f();u();c();p();m();var Cs=Qe(zi()),Hr=class{apiKey;tracingHelper;logLevel;logQueries;engineHash;constructor({apiKey:t,tracingHelper:r,logLevel:n,logQueries:i,engineHash:o}){this.apiKey=t,this.tracingHelper=r,this.logLevel=n,this.logQueries=i,this.engineHash=o}build({traceparent:t,transactionId:r}={}){let n={Accept:"application/json",Authorization:`Bearer ${this.apiKey}`,"Content-Type":"application/json","Prisma-Engine-Hash":this.engineHash,"Prisma-Engine-Version":Cs.enginesVersion};this.tracingHelper.isEnabled()&&(n.traceparent=t??this.tracingHelper.getTraceParent()),r&&(n["X-Transaction-Id"]=r);let i=this.#e();return i.length>0&&(n["X-Capture-Telemetry"]=i.join(", ")),n}#e(){let t=[];return this.tracingHelper.isEnabled()&&t.push("tracing"),this.logLevel&&t.push(this.logLevel),this.logQueries&&t.push("query"),t}};f();u();c();p();m();function ep(e){return e[0]*1e3+e[1]/1e6}function Qn(e){return new Date(ep(e))}f();u();c();p();m();f();u();c();p();m();var dt=class extends ie{name="ForcedRetryError";code="P5001";constructor(t){super("This request must be retried",U(t,!0))}};N(dt,"ForcedRetryError");f();u();c();p();m();var Ve=class extends ie{name="NotImplementedYetError";code="P5004";constructor(t,r){super(t,U(r,!1))}};N(Ve,"NotImplementedYetError");f();u();c();p();m();f();u();c();p();m();var G=class extends ie{response;constructor(t,r){super(t,r),this.response=r.response;let n=this.response.headers.get("prisma-request-id");if(n){let i=`(The request id was: ${n})`;this.message=this.message+" "+i}}};var $e=class extends G{name="SchemaMissingError";code="P5005";constructor(t){super("Schema needs to be uploaded",U(t,!0))}};N($e,"SchemaMissingError");f();u();c();p();m();f();u();c();p();m();var Kn="This request could not be understood by the server",jt=class extends G{name="BadRequestError";code="P5000";constructor(t,r,n){super(r||Kn,U(t,!1)),n&&(this.code=n)}};N(jt,"BadRequestError");f();u();c();p();m();var Gt=class extends G{name="HealthcheckTimeoutError";code="P5013";logs;constructor(t,r){super("Engine not started: healthcheck timeout",U(t,!0)),this.logs=r}};N(Gt,"HealthcheckTimeoutError");f();u();c();p();m();var Jt=class extends G{name="EngineStartupError";code="P5014";logs;constructor(t,r,n){super(r,U(t,!0)),this.logs=n}};N(Jt,"EngineStartupError");f();u();c();p();m();var Qt=class extends G{name="EngineVersionNotSupportedError";code="P5012";constructor(t){super("Engine version is not supported",U(t,!1))}};N(Qt,"EngineVersionNotSupportedError");f();u();c();p();m();var Wn="Request timed out",Kt=class extends G{name="GatewayTimeoutError";code="P5009";constructor(t,r=Wn){super(r,U(t,!1))}};N(Kt,"GatewayTimeoutError");f();u();c();p();m();var tp="Interactive transaction error",Wt=class extends G{name="InteractiveTransactionError";code="P5015";constructor(t,r=tp){super(r,U(t,!1))}};N(Wt,"InteractiveTransactionError");f();u();c();p();m();var rp="Request parameters are invalid",Ht=class extends G{name="InvalidRequestError";code="P5011";constructor(t,r=rp){super(r,U(t,!1))}};N(Ht,"InvalidRequestError");f();u();c();p();m();var Hn="Requested resource does not exist",zt=class extends G{name="NotFoundError";code="P5003";constructor(t,r=Hn){super(r,U(t,!1))}};N(zt,"NotFoundError");f();u();c();p();m();var zn="Unknown server error",gt=class extends G{name="ServerError";code="P5006";logs;constructor(t,r,n){super(r||zn,U(t,!0)),this.logs=n}};N(gt,"ServerError");f();u();c();p();m();var Yn="Unauthorized, check your connection string",Yt=class extends G{name="UnauthorizedError";code="P5007";constructor(t,r=Yn){super(r,U(t,!1))}};N(Yt,"UnauthorizedError");f();u();c();p();m();var Zn="Usage exceeded, retry again later",Zt=class extends G{name="UsageExceededError";code="P5008";constructor(t,r=Zn){super(r,U(t,!0))}};N(Zt,"UsageExceededError");async function np(e){let t;try{t=await e.text()}catch{return{type:"EmptyError"}}try{let r=JSON.parse(t);if(typeof r=="string")switch(r){case"InternalDataProxyError":return{type:"DataProxyError",body:r};default:return{type:"UnknownTextError",body:r}}if(typeof r=="object"&&r!==null){if("is_panic"in r&&"message"in r&&"error_code"in r)return{type:"QueryEngineError",body:r};if("EngineNotStarted"in r||"InteractiveTransactionMisrouted"in r||"InvalidRequestError"in r){let n=Object.values(r)[0].reason;return typeof n=="string"&&!["SchemaMissing","EngineVersionNotSupported"].includes(n)?{type:"UnknownJsonError",body:r}:{type:"DataProxyError",body:r}}}return{type:"UnknownJsonError",body:r}}catch{return t===""?{type:"EmptyError"}:{type:"UnknownTextError",body:t}}}async function Xt(e,t){if(e.ok)return;let r={clientVersion:t,response:e},n=await np(e);if(n.type==="QueryEngineError")throw new se(n.body.message,{code:n.body.error_code,clientVersion:t});if(n.type==="DataProxyError"){if(n.body==="InternalDataProxyError")throw new gt(r,"Internal Data Proxy error");if("EngineNotStarted"in n.body){if(n.body.EngineNotStarted.reason==="SchemaMissing")return new $e(r);if(n.body.EngineNotStarted.reason==="EngineVersionNotSupported")throw new Qt(r);if("EngineStartupError"in n.body.EngineNotStarted.reason){let{msg:i,logs:o}=n.body.EngineNotStarted.reason.EngineStartupError;throw new Jt(r,i,o)}if("KnownEngineStartupError"in n.body.EngineNotStarted.reason){let{msg:i,error_code:o}=n.body.EngineNotStarted.reason.KnownEngineStartupError;throw new Q(i,t,o)}if("HealthcheckTimeout"in n.body.EngineNotStarted.reason){let{logs:i}=n.body.EngineNotStarted.reason.HealthcheckTimeout;throw new Gt(r,i)}}if("InteractiveTransactionMisrouted"in n.body){let i={IDParseError:"Could not parse interactive transaction ID",NoQueryEngineFoundError:"Could not find Query Engine for the specified host and transaction ID",TransactionStartError:"Could not start interactive transaction"};throw new Wt(r,i[n.body.InteractiveTransactionMisrouted.reason])}if("InvalidRequestError"in n.body)throw new Ht(r,n.body.InvalidRequestError.reason)}if(e.status===401||e.status===403)throw new Yt(r,ht(Yn,n));if(e.status===404)return new zt(r,ht(Hn,n));if(e.status===429)throw new Zt(r,ht(Zn,n));if(e.status===504)throw new Kt(r,ht(Wn,n));if(e.status>=500)throw new gt(r,ht(zn,n));if(e.status>=400)throw new jt(r,ht(Kn,n))}function ht(e,t){return t.type==="EmptyError"?e:`${e}: ${JSON.stringify(t)}`}f();u();c();p();m();function Ss(e){let t=Math.pow(2,e)*50,r=Math.ceil(Math.random()*t)-Math.ceil(t/2),n=t+r;return new Promise(i=>setTimeout(()=>i(n),n))}f();u();c();p();m();var Ae="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";function Is(e){let t=new TextEncoder().encode(e),r="",n=t.byteLength,i=n%3,o=n-i,s,a,l,d,g;for(let h=0;h>18,a=(g&258048)>>12,l=(g&4032)>>6,d=g&63,r+=Ae[s]+Ae[a]+Ae[l]+Ae[d];return i==1?(g=t[o],s=(g&252)>>2,a=(g&3)<<4,r+=Ae[s]+Ae[a]+"=="):i==2&&(g=t[o]<<8|t[o+1],s=(g&64512)>>10,a=(g&1008)>>4,l=(g&15)<<2,r+=Ae[s]+Ae[a]+Ae[l]+"="),r}f();u();c();p();m();function Os(e){if(!!e.generator?.previewFeatures.some(r=>r.toLowerCase().includes("metrics")))throw new Q("The `metrics` preview feature is not yet available with Accelerate.\nPlease remove `metrics` from the `previewFeatures` in your schema.\n\nMore information about Accelerate: https://pris.ly/d/accelerate",e.clientVersion)}f();u();c();p();m();var ks={"@prisma/debug":"workspace:*","@prisma/engines-version":"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7","@prisma/fetch-engine":"workspace:*","@prisma/get-platform":"workspace:*"};f();u();c();p();m();f();u();c();p();m();var er=class extends ie{name="RequestError";code="P5010";constructor(t,r){super(`Cannot fetch data from service: -${t}`,U(r,!0))}};N(er,"RequestError");async function je(e,t,r=n=>n){let{clientVersion:n,...i}=t,o=r(fetch);try{return await o(e,i)}catch(s){let a=s.message??"Unknown error";throw new er(a,{clientVersion:n,cause:s})}}var op=/^[1-9][0-9]*\.[0-9]+\.[0-9]+$/,Ds=Z("prisma:client:dataproxyEngine");async function sp(e,t){let r=ks["@prisma/engines-version"],n=t.clientVersion??"unknown";if(y.env.PRISMA_CLIENT_DATA_PROXY_CLIENT_VERSION||globalThis.PRISMA_CLIENT_DATA_PROXY_CLIENT_VERSION)return y.env.PRISMA_CLIENT_DATA_PROXY_CLIENT_VERSION||globalThis.PRISMA_CLIENT_DATA_PROXY_CLIENT_VERSION;if(e.includes("accelerate")&&n!=="0.0.0"&&n!=="in-memory")return n;let[i,o]=n?.split("-")??[];if(o===void 0&&op.test(i))return i;if(o!==void 0||n==="0.0.0"||n==="in-memory"){let[s]=r.split("-")??[],[a,l,d]=s.split("."),g=ap(`<=${a}.${l}.${d}`),h=await je(g,{clientVersion:n});if(!h.ok)throw new Error(`Failed to fetch stable Prisma version, unpkg.com status ${h.status} ${h.statusText}, response body: ${await h.text()||""}`);let T=await h.text();Ds("length of body fetched from unpkg.com",T.length);let I;try{I=JSON.parse(T)}catch(S){throw console.error("JSON.parse error: body fetched from unpkg.com: ",T),S}return I.version}throw new Ve("Only `major.minor.patch` versions are supported by Accelerate.",{clientVersion:n})}async function Ms(e,t){let r=await sp(e,t);return Ds("version",r),r}function ap(e){return encodeURI(`https://unpkg.com/prisma@${e}/package.json`)}var _s=3,tr=Z("prisma:client:dataproxyEngine"),yt=class{name="DataProxyEngine";inlineSchema;inlineSchemaHash;inlineDatasources;config;logEmitter;env;clientVersion;engineHash;tracingHelper;remoteClientVersion;host;headerBuilder;startPromise;protocol;constructor(t){Os(t),this.config=t,this.env=t.env,this.inlineSchema=Is(t.inlineSchema),this.inlineDatasources=t.inlineDatasources,this.inlineSchemaHash=t.inlineSchemaHash,this.clientVersion=t.clientVersion,this.engineHash=t.engineVersion,this.logEmitter=t.logEmitter,this.tracingHelper=t.tracingHelper}apiKey(){return this.headerBuilder.apiKey}version(){return this.engineHash}async start(){this.startPromise!==void 0&&await this.startPromise,this.startPromise=(async()=>{let{apiKey:t,url:r}=this.getURLAndAPIKey();this.host=r.host,this.protocol=r.protocol,this.headerBuilder=new Hr({apiKey:t,tracingHelper:this.tracingHelper,logLevel:this.config.logLevel??"error",logQueries:this.config.logQueries,engineHash:this.engineHash}),this.remoteClientVersion=await Ms(this.host,this.config),tr("host",this.host),tr("protocol",this.protocol)})(),await this.startPromise}async stop(){}propagateResponseExtensions(t){t?.logs?.length&&t.logs.forEach(r=>{switch(r.level){case"debug":case"trace":tr(r);break;case"error":case"warn":case"info":{this.logEmitter.emit(r.level,{timestamp:Qn(r.timestamp),message:r.attributes.message??"",target:r.target??"BinaryEngine"});break}case"query":{this.logEmitter.emit("query",{query:r.attributes.query??"",timestamp:Qn(r.timestamp),duration:r.attributes.duration_ms??0,params:r.attributes.params??"",target:r.target??"BinaryEngine"});break}default:r.level}}),t?.traces?.length&&this.tracingHelper.dispatchEngineSpans(t.traces)}onBeforeExit(){throw new Error('"beforeExit" hook is not applicable to the remote query engine')}async url(t){return await this.start(),`${this.protocol}//${this.host}/${this.remoteClientVersion}/${this.inlineSchemaHash}/${t}`}async uploadSchema(){let t={name:"schemaUpload",internal:!0};return this.tracingHelper.runInChildSpan(t,async()=>{let r=await je(await this.url("schema"),{method:"PUT",headers:this.headerBuilder.build(),body:this.inlineSchema,clientVersion:this.clientVersion});r.ok||tr("schema response status",r.status);let n=await Xt(r,this.clientVersion);if(n)throw this.logEmitter.emit("warn",{message:`Error while uploading schema: ${n.message}`,timestamp:new Date,target:""}),n;this.logEmitter.emit("info",{message:`Schema (re)uploaded (hash: ${this.inlineSchemaHash})`,timestamp:new Date,target:""})})}request(t,{traceparent:r,interactiveTransaction:n,customDataProxyFetch:i}){return this.requestInternal({body:t,traceparent:r,interactiveTransaction:n,customDataProxyFetch:i})}async requestBatch(t,{traceparent:r,transaction:n,customDataProxyFetch:i}){let o=n?.kind==="itx"?n.options:void 0,s=Gr(t,n);return(await this.requestInternal({body:s,customDataProxyFetch:i,interactiveTransaction:o,traceparent:r})).map(l=>(l.extensions&&this.propagateResponseExtensions(l.extensions),"errors"in l?this.convertProtocolErrorsToClientError(l.errors):l))}requestInternal({body:t,traceparent:r,customDataProxyFetch:n,interactiveTransaction:i}){return this.withRetry({actionGerund:"querying",callback:async({logHttpCall:o})=>{let s=i?`${i.payload.endpoint}/graphql`:await this.url("graphql");o(s);let a=await je(s,{method:"POST",headers:this.headerBuilder.build({traceparent:r,transactionId:i?.id}),body:JSON.stringify(t),clientVersion:this.clientVersion},n);a.ok||tr("graphql response status",a.status),await this.handleError(await Xt(a,this.clientVersion));let l=await a.json();if(l.extensions&&this.propagateResponseExtensions(l.extensions),"errors"in l)throw this.convertProtocolErrorsToClientError(l.errors);return"batchResult"in l?l.batchResult:l}})}async transaction(t,r,n){let i={start:"starting",commit:"committing",rollback:"rolling back"};return this.withRetry({actionGerund:`${i[t]} transaction`,callback:async({logHttpCall:o})=>{if(t==="start"){let s=JSON.stringify({max_wait:n.maxWait,timeout:n.timeout,isolation_level:n.isolationLevel}),a=await this.url("transaction/start");o(a);let l=await je(a,{method:"POST",headers:this.headerBuilder.build({traceparent:r.traceparent}),body:s,clientVersion:this.clientVersion});await this.handleError(await Xt(l,this.clientVersion));let d=await l.json(),{extensions:g}=d;g&&this.propagateResponseExtensions(g);let h=d.id,T=d["data-proxy"].endpoint;return{id:h,payload:{endpoint:T}}}else{let s=`${n.payload.endpoint}/${t}`;o(s);let a=await je(s,{method:"POST",headers:this.headerBuilder.build({traceparent:r.traceparent}),clientVersion:this.clientVersion});await this.handleError(await Xt(a,this.clientVersion));let l=await a.json(),{extensions:d}=l;d&&this.propagateResponseExtensions(d);return}}})}getURLAndAPIKey(){return Rs({clientVersion:this.clientVersion,env:this.env,inlineDatasources:this.inlineDatasources,overrideDatasources:this.config.overrideDatasources})}metrics(){throw new Ve("Metrics are not yet supported for Accelerate",{clientVersion:this.clientVersion})}async withRetry(t){for(let r=0;;r++){let n=i=>{this.logEmitter.emit("info",{message:`Calling ${i} (n=${r})`,timestamp:new Date,target:""})};try{return await t.callback({logHttpCall:n})}catch(i){if(!(i instanceof ie)||!i.isRetryable)throw i;if(r>=_s)throw i instanceof dt?i.cause:i;this.logEmitter.emit("warn",{message:`Attempt ${r+1}/${_s} failed for ${t.actionGerund}: ${i.message??"(unknown)"}`,timestamp:new Date,target:""});let o=await Ss(r);this.logEmitter.emit("warn",{message:`Retrying after ${o}ms`,timestamp:new Date,target:""})}}}async handleError(t){if(t instanceof $e)throw await this.uploadSchema(),new dt({clientVersion:this.clientVersion,cause:t});if(t)throw t}convertProtocolErrorsToClientError(t){return t.length===1?Jr(t[0],this.config.clientVersion,this.config.activeProvider):new ae(JSON.stringify(t),{clientVersion:this.config.clientVersion})}applyPendingMigrations(){throw new Error("Method not implemented.")}};f();u();c();p();m();function Ns({url:e,adapter:t,copyEngine:r,targetBuildType:n}){let i=[],o=[],s=C=>{i.push({_tag:"warning",value:C})},a=C=>{let M=C.join(` -`);o.push({_tag:"error",value:M})},l=!!e?.startsWith("prisma://"),d=dr(e),g=!!t,h=l||d;!g&&r&&h&&n!=="client"&&n!=="wasm-compiler-edge"&&s(["recommend--no-engine","In production, we recommend using `prisma generate --no-engine` (See: `prisma generate --help`)"]);let T=h||!r;g&&(T||n==="edge")&&(n==="edge"?a(["Prisma Client was configured to use the `adapter` option but it was imported via its `/edge` endpoint.","Please either remove the `/edge` endpoint or remove the `adapter` from the Prisma Client constructor."]):h?a(["You've provided both a driver adapter and an Accelerate database URL. Driver adapters currently cannot connect to Accelerate.","Please provide either a driver adapter with a direct database URL or an Accelerate URL and no driver adapter."]):r||a(["Prisma Client was configured to use the `adapter` option but `prisma generate` was run with `--no-engine`.","Please run `prisma generate` without `--no-engine` to be able to use Prisma Client with the adapter."]));let I={accelerate:T,ppg:d,driverAdapters:g};function S(C){return C.length>0}return S(o)?{ok:!1,diagnostics:{warnings:i,errors:o},isUsing:I}:{ok:!0,diagnostics:{warnings:i},isUsing:I}}function Fs({copyEngine:e=!0},t){let r;try{r=ft({inlineDatasources:t.inlineDatasources,overrideDatasources:t.overrideDatasources,env:{...t.env,...y.env},clientVersion:t.clientVersion})}catch{}let{ok:n,isUsing:i,diagnostics:o}=Ns({url:r,adapter:t.adapter,copyEngine:e,targetBuildType:"edge"});for(let h of o.warnings)hr(...h.value);if(!n){let h=o.errors[0];throw new ee(h.value,{clientVersion:t.clientVersion})}let s=Ze(t.generator),a=s==="library",l=s==="binary",d=s==="client",g=(i.accelerate||i.ppg)&&!i.driverAdapters;return i.accelerate?new yt(t):(i.driverAdapters,i.accelerate,new yt(t))}f();u();c();p();m();function Ls({generator:e}){return e?.previewFeatures??[]}f();u();c();p();m();var Us=e=>({command:e});f();u();c();p();m();f();u();c();p();m();var Bs=e=>e.strings.reduce((t,r,n)=>`${t}@P${n}${r}`);f();u();c();p();m();function wt(e){try{return qs(e,"fast")}catch{return qs(e,"slow")}}function qs(e,t){return JSON.stringify(e.map(r=>$s(r,t)))}function $s(e,t){if(Array.isArray(e))return e.map(r=>$s(r,t));if(typeof e=="bigint")return{prisma__type:"bigint",prisma__value:e.toString()};if(Xe(e))return{prisma__type:"date",prisma__value:e.toJSON()};if(Me.isDecimal(e))return{prisma__type:"decimal",prisma__value:e.toJSON()};if(w.Buffer.isBuffer(e))return{prisma__type:"bytes",prisma__value:e.toString("base64")};if(lp(e))return{prisma__type:"bytes",prisma__value:w.Buffer.from(e).toString("base64")};if(ArrayBuffer.isView(e)){let{buffer:r,byteOffset:n,byteLength:i}=e;return{prisma__type:"bytes",prisma__value:w.Buffer.from(r,n,i).toString("base64")}}return typeof e=="object"&&t==="slow"?js(e):e}function lp(e){return e instanceof ArrayBuffer||e instanceof SharedArrayBuffer?!0:typeof e=="object"&&e!==null?e[Symbol.toStringTag]==="ArrayBuffer"||e[Symbol.toStringTag]==="SharedArrayBuffer":!1}function js(e){if(typeof e!="object"||e===null)return e;if(typeof e.toJSON=="function")return e.toJSON();if(Array.isArray(e))return e.map(Vs);let t={};for(let r of Object.keys(e))t[r]=Vs(e[r]);return t}function Vs(e){return typeof e=="bigint"?e.toString():js(e)}var up=/^(\s*alter\s)/i,Gs=Z("prisma:client");function Xn(e,t,r,n){if(!(e!=="postgresql"&&e!=="cockroachdb")&&r.length>0&&up.exec(t))throw new Error(`Running ALTER using ${n} is not supported -Using the example below you can still execute your query with Prisma, but please note that it is vulnerable to SQL injection attacks and requires you to take care of input sanitization. - -Example: - await prisma.$executeRawUnsafe(\`ALTER USER prisma WITH PASSWORD '\${password}'\`) - -More Information: https://pris.ly/d/execute-raw -`)}var ei=({clientMethod:e,activeProvider:t})=>r=>{let n="",i;if(qr(r))n=r.sql,i={values:wt(r.values),__prismaRawParameters__:!0};else if(Array.isArray(r)){let[o,...s]=r;n=o,i={values:wt(s||[]),__prismaRawParameters__:!0}}else switch(t){case"sqlite":case"mysql":{n=r.sql,i={values:wt(r.values),__prismaRawParameters__:!0};break}case"cockroachdb":case"postgresql":case"postgres":{n=r.text,i={values:wt(r.values),__prismaRawParameters__:!0};break}case"sqlserver":{n=Bs(r),i={values:wt(r.values),__prismaRawParameters__:!0};break}default:throw new Error(`The ${t} provider does not support ${e}`)}return i?.values?Gs(`prisma.${e}(${n}, ${i.values})`):Gs(`prisma.${e}(${n})`),{query:n,parameters:i}},Js={requestArgsToMiddlewareArgs(e){return[e.strings,...e.values]},middlewareArgsToRequestArgs(e){let[t,...r]=e;return new ue(t,r)}},Qs={requestArgsToMiddlewareArgs(e){return[e]},middlewareArgsToRequestArgs(e){return e[0]}};f();u();c();p();m();function ti(e){return function(r,n){let i,o=(s=e)=>{try{return s===void 0||s?.kind==="itx"?i??=Ks(r(s)):Ks(r(s))}catch(a){return Promise.reject(a)}};return{get spec(){return n},then(s,a){return o().then(s,a)},catch(s){return o().catch(s)},finally(s){return o().finally(s)},requestTransaction(s){let a=o(s);return a.requestTransaction?a.requestTransaction(s):a},[Symbol.toStringTag]:"PrismaPromise"}}}function Ks(e){return typeof e.then=="function"?e:Promise.resolve(e)}f();u();c();p();m();var cp=dn.split(".")[0],pp={isEnabled(){return!1},getTraceParent(){return"00-10-10-00"},dispatchEngineSpans(){},getActiveContext(){},runInChildSpan(e,t){return t()}},ri=class{isEnabled(){return this.getGlobalTracingHelper().isEnabled()}getTraceParent(t){return this.getGlobalTracingHelper().getTraceParent(t)}dispatchEngineSpans(t){return this.getGlobalTracingHelper().dispatchEngineSpans(t)}getActiveContext(){return this.getGlobalTracingHelper().getActiveContext()}runInChildSpan(t,r){return this.getGlobalTracingHelper().runInChildSpan(t,r)}getGlobalTracingHelper(){let t=globalThis[`V${cp}_PRISMA_INSTRUMENTATION`],r=globalThis.PRISMA_INSTRUMENTATION;return t?.helper??r?.helper??pp}};function Ws(){return new ri}f();u();c();p();m();function Hs(e,t=()=>{}){let r,n=new Promise(i=>r=i);return{then(i){return--e===0&&r(t()),i?.(n)}}}f();u();c();p();m();function zs(e){return typeof e=="string"?e:e.reduce((t,r)=>{let n=typeof r=="string"?r:r.level;return n==="query"?t:t&&(r==="info"||t==="info")?"info":n},void 0)}f();u();c();p();m();f();u();c();p();m();function zr(e){return typeof e.batchRequestIdx=="number"}f();u();c();p();m();function Ys(e){if(e.action!=="findUnique"&&e.action!=="findUniqueOrThrow")return;let t=[];return e.modelName&&t.push(e.modelName),e.query.arguments&&t.push(ni(e.query.arguments)),t.push(ni(e.query.selection)),t.join("")}function ni(e){return`(${Object.keys(e).sort().map(r=>{let n=e[r];return typeof n=="object"&&n!==null?`(${r} ${ni(n)})`:r}).join(" ")})`}f();u();c();p();m();var mp={aggregate:!1,aggregateRaw:!1,createMany:!0,createManyAndReturn:!0,createOne:!0,deleteMany:!0,deleteOne:!0,executeRaw:!0,findFirst:!1,findFirstOrThrow:!1,findMany:!1,findRaw:!1,findUnique:!1,findUniqueOrThrow:!1,groupBy:!1,queryRaw:!1,runCommandRaw:!0,updateMany:!0,updateManyAndReturn:!0,updateOne:!0,upsertOne:!0};function ii(e){return mp[e]}f();u();c();p();m();var Yr=class{constructor(t){this.options=t;this.batches={}}batches;tickActive=!1;request(t){let r=this.options.batchBy(t);return r?(this.batches[r]||(this.batches[r]=[],this.tickActive||(this.tickActive=!0,y.nextTick(()=>{this.dispatchBatches(),this.tickActive=!1}))),new Promise((n,i)=>{this.batches[r].push({request:t,resolve:n,reject:i})})):this.options.singleLoader(t)}dispatchBatches(){for(let t in this.batches){let r=this.batches[t];delete this.batches[t],r.length===1?this.options.singleLoader(r[0].request).then(n=>{n instanceof Error?r[0].reject(n):r[0].resolve(n)}).catch(n=>{r[0].reject(n)}):(r.sort((n,i)=>this.options.batchOrder(n.request,i.request)),this.options.batchLoader(r.map(n=>n.request)).then(n=>{if(n instanceof Error)for(let i=0;i{for(let i=0;iGe("bigint",r));case"bytes-array":return t.map(r=>Ge("bytes",r));case"decimal-array":return t.map(r=>Ge("decimal",r));case"datetime-array":return t.map(r=>Ge("datetime",r));case"date-array":return t.map(r=>Ge("date",r));case"time-array":return t.map(r=>Ge("time",r));default:return t}}function oi(e){let t=[],r=fp(e);for(let n=0;n{let{transaction:o,otelParentCtx:s}=n[0],a=n.map(h=>h.protocolQuery),l=this.client._tracingHelper.getTraceParent(s),d=n.some(h=>ii(h.protocolQuery.action));return(await this.client._engine.requestBatch(a,{traceparent:l,transaction:gp(o),containsWrite:d,customDataProxyFetch:i})).map((h,T)=>{if(h instanceof Error)return h;try{return this.mapQueryEngineResult(n[T],h)}catch(I){return I}})}),singleLoader:async n=>{let i=n.transaction?.kind==="itx"?Zs(n.transaction):void 0,o=await this.client._engine.request(n.protocolQuery,{traceparent:this.client._tracingHelper.getTraceParent(),interactiveTransaction:i,isWrite:ii(n.protocolQuery.action),customDataProxyFetch:n.customDataProxyFetch});return this.mapQueryEngineResult(n,o)},batchBy:n=>n.transaction?.id?`transaction-${n.transaction.id}`:Ys(n.protocolQuery),batchOrder(n,i){return n.transaction?.kind==="batch"&&i.transaction?.kind==="batch"?n.transaction.index-i.transaction.index:0}})}async request(t){try{return await this.dataloader.request(t)}catch(r){let{clientMethod:n,callsite:i,transaction:o,args:s,modelName:a}=t;this.handleAndLogRequestError({error:r,clientMethod:n,callsite:i,transaction:o,args:s,modelName:a,globalOmit:t.globalOmit})}}mapQueryEngineResult({dataPath:t,unpacker:r},n){let i=n?.data,o=this.unpack(i,t,r);return y.env.PRISMA_CLIENT_GET_TIME?{data:o}:o}handleAndLogRequestError(t){try{this.handleRequestError(t)}catch(r){throw this.logEmitter&&this.logEmitter.emit("error",{message:r.message,target:t.clientMethod,timestamp:new Date}),r}}handleRequestError({error:t,clientMethod:r,callsite:n,transaction:i,args:o,modelName:s,globalOmit:a}){if(dp(t),hp(t,i))throw t;if(t instanceof se&&yp(t)){let d=Xs(t.meta);Fr({args:o,errors:[d],callsite:n,errorFormat:this.client._errorFormat,originalMethod:r,clientVersion:this.client._clientVersion,globalOmit:a})}let l=t.message;if(n&&(l=Cr({callsite:n,originalMethod:r,isPanic:t.isPanic,showColors:this.client._errorFormat==="pretty",message:l})),l=this.sanitizeMessage(l),t.code){let d=s?{modelName:s,...t.meta}:t.meta;throw new se(l,{code:t.code,clientVersion:this.client._clientVersion,meta:d,batchRequestIdx:t.batchRequestIdx})}else{if(t.isPanic)throw new Ce(l,this.client._clientVersion);if(t instanceof ae)throw new ae(l,{clientVersion:this.client._clientVersion,batchRequestIdx:t.batchRequestIdx});if(t instanceof Q)throw new Q(l,this.client._clientVersion);if(t instanceof Ce)throw new Ce(l,this.client._clientVersion)}throw t.clientVersion=this.client._clientVersion,t}sanitizeMessage(t){return this.client._errorFormat&&this.client._errorFormat!=="pretty"?En(t):t}unpack(t,r,n){if(!t||(t.data&&(t=t.data),!t))return t;let i=Object.keys(t)[0],o=Object.values(t)[0],s=r.filter(d=>d!=="select"&&d!=="include"),a=Vn(o,s),l=i==="queryRaw"?oi(a):$t(a);return n?n(l):l}get[Symbol.toStringTag](){return"RequestHandler"}};function gp(e){if(e){if(e.kind==="batch")return{kind:"batch",options:{isolationLevel:e.isolationLevel}};if(e.kind==="itx")return{kind:"itx",options:Zs(e)};Ue(e,"Unknown transaction kind")}}function Zs(e){return{id:e.id,payload:e.payload}}function hp(e,t){return zr(e)&&t?.kind==="batch"&&e.batchRequestIdx!==t.index}function yp(e){return e.code==="P2009"||e.code==="P2012"}function Xs(e){if(e.kind==="Union")return{kind:"Union",errors:e.errors.map(Xs)};if(Array.isArray(e.selectionPath)){let[,...t]=e.selectionPath;return{...e,selectionPath:t}}return e}f();u();c();p();m();var ea=As;f();u();c();p();m();var oa=Qe(Sn());f();u();c();p();m();var q=class extends Error{constructor(t){super(t+` -Read more at https://pris.ly/d/client-constructor`),this.name="PrismaClientConstructorValidationError"}get[Symbol.toStringTag](){return"PrismaClientConstructorValidationError"}};N(q,"PrismaClientConstructorValidationError");var ta=["datasources","datasourceUrl","errorFormat","adapter","log","transactionOptions","omit","__internal"],ra=["pretty","colorless","minimal"],na=["info","query","warn","error"],wp={datasources:(e,{datasourceNames:t})=>{if(e){if(typeof e!="object"||Array.isArray(e))throw new q(`Invalid value ${JSON.stringify(e)} for "datasources" provided to PrismaClient constructor`);for(let[r,n]of Object.entries(e)){if(!t.includes(r)){let i=Et(r,t)||` Available datasources: ${t.join(", ")}`;throw new q(`Unknown datasource ${r} provided to PrismaClient constructor.${i}`)}if(typeof n!="object"||Array.isArray(n))throw new q(`Invalid value ${JSON.stringify(e)} for datasource "${r}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`);if(n&&typeof n=="object")for(let[i,o]of Object.entries(n)){if(i!=="url")throw new q(`Invalid value ${JSON.stringify(e)} for datasource "${r}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`);if(typeof o!="string")throw new q(`Invalid value ${JSON.stringify(o)} for datasource "${r}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`)}}}},adapter:(e,t)=>{if(!e&&Ze(t.generator)==="client")throw new q('Using engine type "client" requires a driver adapter to be provided to PrismaClient constructor.');if(e!==null){if(e===void 0)throw new q('"adapter" property must not be undefined, use null to conditionally disable driver adapters.');if(Ze(t.generator)==="binary")throw new q('Cannot use a driver adapter with the "binary" Query Engine. Please use the "library" Query Engine.')}},datasourceUrl:e=>{if(typeof e<"u"&&typeof e!="string")throw new q(`Invalid value ${JSON.stringify(e)} for "datasourceUrl" provided to PrismaClient constructor. -Expected string or undefined.`)},errorFormat:e=>{if(e){if(typeof e!="string")throw new q(`Invalid value ${JSON.stringify(e)} for "errorFormat" provided to PrismaClient constructor.`);if(!ra.includes(e)){let t=Et(e,ra);throw new q(`Invalid errorFormat ${e} provided to PrismaClient constructor.${t}`)}}},log:e=>{if(!e)return;if(!Array.isArray(e))throw new q(`Invalid value ${JSON.stringify(e)} for "log" provided to PrismaClient constructor.`);function t(r){if(typeof r=="string"&&!na.includes(r)){let n=Et(r,na);throw new q(`Invalid log level "${r}" provided to PrismaClient constructor.${n}`)}}for(let r of e){t(r);let n={level:t,emit:i=>{let o=["stdout","event"];if(!o.includes(i)){let s=Et(i,o);throw new q(`Invalid value ${JSON.stringify(i)} for "emit" in logLevel provided to PrismaClient constructor.${s}`)}}};if(r&&typeof r=="object")for(let[i,o]of Object.entries(r))if(n[i])n[i](o);else throw new q(`Invalid property ${i} for "log" provided to PrismaClient constructor`)}},transactionOptions:e=>{if(!e)return;let t=e.maxWait;if(t!=null&&t<=0)throw new q(`Invalid value ${t} for maxWait in "transactionOptions" provided to PrismaClient constructor. maxWait needs to be greater than 0`);let r=e.timeout;if(r!=null&&r<=0)throw new q(`Invalid value ${r} for timeout in "transactionOptions" provided to PrismaClient constructor. timeout needs to be greater than 0`)},omit:(e,t)=>{if(typeof e!="object")throw new q('"omit" option is expected to be an object.');if(e===null)throw new q('"omit" option can not be `null`');let r=[];for(let[n,i]of Object.entries(e)){let o=bp(n,t.runtimeDataModel);if(!o){r.push({kind:"UnknownModel",modelKey:n});continue}for(let[s,a]of Object.entries(i)){let l=o.fields.find(d=>d.name===s);if(!l){r.push({kind:"UnknownField",modelKey:n,fieldName:s});continue}if(l.relationName){r.push({kind:"RelationInOmit",modelKey:n,fieldName:s});continue}typeof a!="boolean"&&r.push({kind:"InvalidFieldValue",modelKey:n,fieldName:s})}}if(r.length>0)throw new q(xp(e,r))},__internal:e=>{if(!e)return;let t=["debug","engine","configOverride"];if(typeof e!="object")throw new q(`Invalid value ${JSON.stringify(e)} for "__internal" to PrismaClient constructor`);for(let[r]of Object.entries(e))if(!t.includes(r)){let n=Et(r,t);throw new q(`Invalid property ${JSON.stringify(r)} for "__internal" provided to PrismaClient constructor.${n}`)}}};function sa(e,t){for(let[r,n]of Object.entries(e)){if(!ta.includes(r)){let i=Et(r,ta);throw new q(`Unknown property ${r} provided to PrismaClient constructor.${i}`)}wp[r](n,t)}if(e.datasourceUrl&&e.datasources)throw new q('Can not use "datasourceUrl" and "datasources" options at the same time. Pick one of them')}function Et(e,t){if(t.length===0||typeof e!="string")return"";let r=Ep(e,t);return r?` Did you mean "${r}"?`:""}function Ep(e,t){if(t.length===0)return null;let r=t.map(i=>({value:i,distance:(0,oa.default)(e,i)}));r.sort((i,o)=>i.distanceSe(n)===t);if(r)return e[r]}function xp(e,t){let r=ut(e);for(let o of t)switch(o.kind){case"UnknownModel":r.arguments.getField(o.modelKey)?.markAsError(),r.addErrorMessage(()=>`Unknown model name: ${o.modelKey}.`);break;case"UnknownField":r.arguments.getDeepField([o.modelKey,o.fieldName])?.markAsError(),r.addErrorMessage(()=>`Model "${o.modelKey}" does not have a field named "${o.fieldName}".`);break;case"RelationInOmit":r.arguments.getDeepField([o.modelKey,o.fieldName])?.markAsError(),r.addErrorMessage(()=>'Relations are already excluded by default and can not be specified in "omit".');break;case"InvalidFieldValue":r.arguments.getDeepFieldValue([o.modelKey,o.fieldName])?.markAsError(),r.addErrorMessage(()=>"Omit field option value must be a boolean.");break}let{message:n,args:i}=Nr(r,"colorless");return`Error validating "omit" option: - -${i} - -${n}`}f();u();c();p();m();function aa(e){return e.length===0?Promise.resolve([]):new Promise((t,r)=>{let n=new Array(e.length),i=null,o=!1,s=0,a=()=>{o||(s++,s===e.length&&(o=!0,i?r(i):t(n)))},l=d=>{o||(o=!0,r(d))};for(let d=0;d{n[d]=g,a()},g=>{if(!zr(g)){l(g);return}g.batchRequestIdx===d?l(g):(i||(i=g),a())})})}var Fe=Z("prisma:client");typeof globalThis=="object"&&(globalThis.NODE_CLIENT=!0);var Pp={requestArgsToMiddlewareArgs:e=>e,middlewareArgsToRequestArgs:e=>e},vp=Symbol.for("prisma.client.transaction.id"),Tp={id:0,nextId(){return++this.id}};function Ap(e){class t{_originalClient=this;_runtimeDataModel;_requestHandler;_connectionPromise;_disconnectionPromise;_engineConfig;_accelerateEngineConfig;_clientVersion;_errorFormat;_tracingHelper;_previewFeatures;_activeProvider;_globalOmit;_extensions;_engine;_appliedParent;_createPrismaPromise=ti();constructor(n){e=n?.__internal?.configOverride?.(e)??e,Ps(e),n&&sa(n,e);let i=new Vr().on("error",()=>{});this._extensions=ct.empty(),this._previewFeatures=Ls(e),this._clientVersion=e.clientVersion??ea,this._activeProvider=e.activeProvider,this._globalOmit=n?.omit,this._tracingHelper=Ws();let o=e.relativeEnvPaths&&{rootEnvPath:e.relativeEnvPaths.rootEnvPath&&pr.resolve(e.dirname,e.relativeEnvPaths.rootEnvPath),schemaEnvPath:e.relativeEnvPaths.schemaEnvPath&&pr.resolve(e.dirname,e.relativeEnvPaths.schemaEnvPath)},s;if(n?.adapter){s=n.adapter;let l=e.activeProvider==="postgresql"||e.activeProvider==="cockroachdb"?"postgres":e.activeProvider;if(s.provider!==l)throw new Q(`The Driver Adapter \`${s.adapterName}\`, based on \`${s.provider}\`, is not compatible with the provider \`${l}\` specified in the Prisma schema.`,this._clientVersion);if(n.datasources||n.datasourceUrl!==void 0)throw new Q("Custom datasource configuration is not compatible with Prisma Driver Adapters. Please define the database connection string directly in the Driver Adapter configuration.",this._clientVersion)}let a=e.injectableEdgeEnv?.();try{let l=n??{},d=l.__internal??{},g=d.debug===!0;g&&Z.enable("prisma:client");let h=pr.resolve(e.dirname,e.relativePath);ji.existsSync(h)||(h=e.dirname),Fe("dirname",e.dirname),Fe("relativePath",e.relativePath),Fe("cwd",h);let T=d.engine||{};if(l.errorFormat?this._errorFormat=l.errorFormat:y.env.NODE_ENV==="production"?this._errorFormat="minimal":y.env.NO_COLOR?this._errorFormat="colorless":this._errorFormat="colorless",this._runtimeDataModel=e.runtimeDataModel,this._engineConfig={cwd:h,dirname:e.dirname,enableDebugLogs:g,allowTriggerPanic:T.allowTriggerPanic,prismaPath:T.binaryPath??void 0,engineEndpoint:T.endpoint,generator:e.generator,showColors:this._errorFormat==="pretty",logLevel:l.log&&zs(l.log),logQueries:l.log&&!!(typeof l.log=="string"?l.log==="query":l.log.find(I=>typeof I=="string"?I==="query":I.level==="query")),env:a?.parsed??{},flags:[],engineWasm:e.engineWasm,compilerWasm:e.compilerWasm,clientVersion:e.clientVersion,engineVersion:e.engineVersion,previewFeatures:this._previewFeatures,activeProvider:e.activeProvider,inlineSchema:e.inlineSchema,overrideDatasources:vs(l,e.datasourceNames),inlineDatasources:e.inlineDatasources,inlineSchemaHash:e.inlineSchemaHash,tracingHelper:this._tracingHelper,transactionOptions:{maxWait:l.transactionOptions?.maxWait??2e3,timeout:l.transactionOptions?.timeout??5e3,isolationLevel:l.transactionOptions?.isolationLevel},logEmitter:i,isBundled:e.isBundled,adapter:s},this._accelerateEngineConfig={...this._engineConfig,accelerateUtils:{resolveDatasourceUrl:ft,getBatchRequestPayload:Gr,prismaGraphQLToJSError:Jr,PrismaClientUnknownRequestError:ae,PrismaClientInitializationError:Q,PrismaClientKnownRequestError:se,debug:Z("prisma:client:accelerateEngine"),engineVersion:ua.version,clientVersion:e.clientVersion}},Fe("clientVersion",e.clientVersion),this._engine=Fs(e,this._engineConfig),this._requestHandler=new Zr(this,i),l.log)for(let I of l.log){let S=typeof I=="string"?I:I.emit==="stdout"?I.level:null;S&&this.$on(S,C=>{Tt.log(`${Tt.tags[S]??""}`,C.message||C.query)})}}catch(l){throw l.clientVersion=this._clientVersion,l}return this._appliedParent=qt(this)}get[Symbol.toStringTag](){return"PrismaClient"}$on(n,i){return n==="beforeExit"?this._engine.onBeforeExit(i):n&&this._engineConfig.logEmitter.on(n,i),this}$connect(){try{return this._engine.start()}catch(n){throw n.clientVersion=this._clientVersion,n}}async $disconnect(){try{await this._engine.stop()}catch(n){throw n.clientVersion=this._clientVersion,n}finally{$i()}}$executeRawInternal(n,i,o,s){let a=this._activeProvider;return this._request({action:"executeRaw",args:o,transaction:n,clientMethod:i,argsMapper:ei({clientMethod:i,activeProvider:a}),callsite:Ne(this._errorFormat),dataPath:[],middlewareArgsMapper:s})}$executeRaw(n,...i){return this._createPrismaPromise(o=>{if(n.raw!==void 0||n.sql!==void 0){let[s,a]=la(n,i);return Xn(this._activeProvider,s.text,s.values,Array.isArray(n)?"prisma.$executeRaw``":"prisma.$executeRaw(sql``)"),this.$executeRawInternal(o,"$executeRaw",s,a)}throw new ee("`$executeRaw` is a tag function, please use it like the following:\n```\nconst result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`\n```\n\nOr read our docs at https://www.prisma.io/docs/concepts/components/prisma-client/raw-database-access#executeraw\n",{clientVersion:this._clientVersion})})}$executeRawUnsafe(n,...i){return this._createPrismaPromise(o=>(Xn(this._activeProvider,n,i,"prisma.$executeRawUnsafe(, [...values])"),this.$executeRawInternal(o,"$executeRawUnsafe",[n,...i])))}$runCommandRaw(n){if(e.activeProvider!=="mongodb")throw new ee(`The ${e.activeProvider} provider does not support $runCommandRaw. Use the mongodb provider.`,{clientVersion:this._clientVersion});return this._createPrismaPromise(i=>this._request({args:n,clientMethod:"$runCommandRaw",dataPath:[],action:"runCommandRaw",argsMapper:Us,callsite:Ne(this._errorFormat),transaction:i}))}async $queryRawInternal(n,i,o,s){let a=this._activeProvider;return this._request({action:"queryRaw",args:o,transaction:n,clientMethod:i,argsMapper:ei({clientMethod:i,activeProvider:a}),callsite:Ne(this._errorFormat),dataPath:[],middlewareArgsMapper:s})}$queryRaw(n,...i){return this._createPrismaPromise(o=>{if(n.raw!==void 0||n.sql!==void 0)return this.$queryRawInternal(o,"$queryRaw",...la(n,i));throw new ee("`$queryRaw` is a tag function, please use it like the following:\n```\nconst result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`\n```\n\nOr read our docs at https://www.prisma.io/docs/concepts/components/prisma-client/raw-database-access#queryraw\n",{clientVersion:this._clientVersion})})}$queryRawTyped(n){return this._createPrismaPromise(i=>{if(!this._hasPreviewFlag("typedSql"))throw new ee("`typedSql` preview feature must be enabled in order to access $queryRawTyped API",{clientVersion:this._clientVersion});return this.$queryRawInternal(i,"$queryRawTyped",n)})}$queryRawUnsafe(n,...i){return this._createPrismaPromise(o=>this.$queryRawInternal(o,"$queryRawUnsafe",[n,...i]))}_transactionWithArray({promises:n,options:i}){let o=Tp.nextId(),s=Hs(n.length),a=n.map((l,d)=>{if(l?.[Symbol.toStringTag]!=="PrismaPromise")throw new Error("All elements of the array need to be Prisma Client promises. Hint: Please make sure you are not awaiting the Prisma client calls you intended to pass in the $transaction function.");let g=i?.isolationLevel??this._engineConfig.transactionOptions.isolationLevel,h={kind:"batch",id:o,index:d,isolationLevel:g,lock:s};return l.requestTransaction?.(h)??l});return aa(a)}async _transactionWithCallback({callback:n,options:i}){let o={traceparent:this._tracingHelper.getTraceParent()},s={maxWait:i?.maxWait??this._engineConfig.transactionOptions.maxWait,timeout:i?.timeout??this._engineConfig.transactionOptions.timeout,isolationLevel:i?.isolationLevel??this._engineConfig.transactionOptions.isolationLevel},a=await this._engine.transaction("start",o,s),l;try{let d={kind:"itx",...a};l=await n(this._createItxClient(d)),await this._engine.transaction("commit",o,a)}catch(d){throw await this._engine.transaction("rollback",o,a).catch(()=>{}),d}return l}_createItxClient(n){return me(qt(me(as(this),[te("_appliedParent",()=>this._appliedParent._createItxClient(n)),te("_createPrismaPromise",()=>ti(n)),te(vp,()=>n.id)])),[pt(ms)])}$transaction(n,i){let o;typeof n=="function"?this._engineConfig.adapter?.adapterName==="@prisma/adapter-d1"?o=()=>{throw new Error("Cloudflare D1 does not support interactive transactions. We recommend you to refactor your queries with that limitation in mind, and use batch transactions with `prisma.$transactions([])` where applicable.")}:o=()=>this._transactionWithCallback({callback:n,options:i}):o=()=>this._transactionWithArray({promises:n,options:i});let s={name:"transaction",attributes:{method:"$transaction"}};return this._tracingHelper.runInChildSpan(s,o)}_request(n){n.otelParentCtx=this._tracingHelper.getActiveContext();let i=n.middlewareArgsMapper??Pp,o={args:i.requestArgsToMiddlewareArgs(n.args),dataPath:n.dataPath,runInTransaction:!!n.transaction,action:n.action,model:n.model},s={operation:{name:"operation",attributes:{method:o.action,model:o.model,name:o.model?`${o.model}.${o.action}`:o.action}}},a=async l=>{let{runInTransaction:d,args:g,...h}=l,T={...n,...h};g&&(T.args=i.middlewareArgsToRequestArgs(g)),n.transaction!==void 0&&d===!1&&delete T.transaction;let I=await hs(this,T);return T.model?ps({result:I,modelName:T.model,args:T.args,extensions:this._extensions,runtimeDataModel:this._runtimeDataModel,globalOmit:this._globalOmit}):I};return this._tracingHelper.runInChildSpan(s.operation,()=>a(o))}async _executeRequest({args:n,clientMethod:i,dataPath:o,callsite:s,action:a,model:l,argsMapper:d,transaction:g,unpacker:h,otelParentCtx:T,customDataProxyFetch:I}){try{n=d?d(n):n;let S={name:"serialize"},C=this._tracingHelper.runInChildSpan(S,()=>Fn({modelName:l,runtimeDataModel:this._runtimeDataModel,action:a,args:n,clientMethod:i,callsite:s,extensions:this._extensions,errorFormat:this._errorFormat,clientVersion:this._clientVersion,previewFeatures:this._previewFeatures,globalOmit:this._globalOmit}));return Z.enabled("prisma:client")&&(Fe("Prisma Client call:"),Fe(`prisma.${i}(${Yo(n)})`),Fe("Generated request:"),Fe(JSON.stringify(C,null,2)+` -`)),g?.kind==="batch"&&await g.lock,this._requestHandler.request({protocolQuery:C,modelName:l,action:a,clientMethod:i,dataPath:o,callsite:s,args:n,extensions:this._extensions,transaction:g,unpacker:h,otelParentCtx:T,otelChildCtx:this._tracingHelper.getActiveContext(),globalOmit:this._globalOmit,customDataProxyFetch:I})}catch(S){throw S.clientVersion=this._clientVersion,S}}$metrics=new Lt(this);_hasPreviewFlag(n){return!!this._engineConfig.previewFeatures?.includes(n)}$applyPendingMigrations(){return this._engine.applyPendingMigrations()}$extends=ls}return t}function la(e,t){return Rp(e)?[new ue(e,t),Js]:[e,Qs]}function Rp(e){return Array.isArray(e)&&Array.isArray(e.raw)}f();u();c();p();m();var Cp=new Set(["toJSON","$$typeof","asymmetricMatch",Symbol.iterator,Symbol.toStringTag,Symbol.isConcatSpreadable,Symbol.toPrimitive]);function Sp(e){return new Proxy(e,{get(t,r){if(r in t)return t[r];if(!Cp.has(r))throw new TypeError(`Invalid enum value: ${String(r)}`)}})}f();u();c();p();m();var export_warnEnvConflicts=void 0;export{Rr as DMMF,Z as Debug,Me as Decimal,Ci as Extensions,Lt as MetricsClient,Q as PrismaClientInitializationError,se as PrismaClientKnownRequestError,Ce as PrismaClientRustPanicError,ae as PrismaClientUnknownRequestError,ee as PrismaClientValidationError,Ii as Public,ue as Sql,nc as createParam,fc as defineDmmfProperty,$t as deserializeJsonResponse,oi as deserializeRawResult,Il as dmmfToRuntimeDataModel,yc as empty,Ap as getPrismaClient,Jn as getRuntime,hc as join,Sp as makeStrictEnum,gc as makeTypedQueryFactory,kn as objectEnumValues,Ko as raw,Fn as serializeJsonQuery,_n as skip,Wo as sqltag,export_warnEnvConflicts as warnEnvConflicts,hr as warnOnce}; -//# sourceMappingURL=edge-esm.js.map diff --git a/frontend/generated/prisma/runtime/edge.js b/frontend/generated/prisma/runtime/edge.js deleted file mode 100644 index 16f980c..0000000 --- a/frontend/generated/prisma/runtime/edge.js +++ /dev/null @@ -1,35 +0,0 @@ - -/* !!! This is code generated by Prisma. Do not edit directly. !!! -/* eslint-disable */ -// biome-ignore-all lint: generated file -"use strict";var ba=Object.create;var lr=Object.defineProperty;var xa=Object.getOwnPropertyDescriptor;var Pa=Object.getOwnPropertyNames;var va=Object.getPrototypeOf,Ta=Object.prototype.hasOwnProperty;var fe=(e,t)=>()=>(e&&(t=e(e=0)),t);var Je=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),vt=(e,t)=>{for(var r in t)lr(e,r,{get:t[r],enumerable:!0})},ci=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of Pa(t))!Ta.call(e,i)&&i!==r&&lr(e,i,{get:()=>t[i],enumerable:!(n=xa(t,i))||n.enumerable});return e};var Qe=(e,t,r)=>(r=e!=null?ba(va(e)):{},ci(t||!e||!e.__esModule?lr(r,"default",{value:e,enumerable:!0}):r,e)),Aa=e=>ci(lr({},"__esModule",{value:!0}),e);var y,b,u=fe(()=>{"use strict";y={nextTick:(e,...t)=>{setTimeout(()=>{e(...t)},0)},env:{},version:"",cwd:()=>"/",stderr:{},argv:["/bin/node"],pid:1e4},{cwd:b}=y});var x,c=fe(()=>{"use strict";x=globalThis.performance??(()=>{let e=Date.now();return{now:()=>Date.now()-e}})()});var E,p=fe(()=>{"use strict";E=()=>{};E.prototype=E});var m=fe(()=>{"use strict"});var Ii=Je(ze=>{"use strict";f();u();c();p();m();var gi=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),Ra=gi(e=>{"use strict";e.byteLength=l,e.toByteArray=g,e.fromByteArray=I;var t=[],r=[],n=typeof Uint8Array<"u"?Uint8Array:Array,i="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";for(o=0,s=i.length;o0)throw new Error("Invalid string. Length must be a multiple of 4");var M=S.indexOf("=");M===-1&&(M=C);var F=M===C?0:4-M%4;return[M,F]}function l(S){var C=a(S),M=C[0],F=C[1];return(M+F)*3/4-F}function d(S,C,M){return(C+M)*3/4-M}function g(S){var C,M=a(S),F=M[0],B=M[1],O=new n(d(S,F,B)),L=0,le=B>0?F-4:F,J;for(J=0;J>16&255,O[L++]=C>>8&255,O[L++]=C&255;return B===2&&(C=r[S.charCodeAt(J)]<<2|r[S.charCodeAt(J+1)]>>4,O[L++]=C&255),B===1&&(C=r[S.charCodeAt(J)]<<10|r[S.charCodeAt(J+1)]<<4|r[S.charCodeAt(J+2)]>>2,O[L++]=C>>8&255,O[L++]=C&255),O}function h(S){return t[S>>18&63]+t[S>>12&63]+t[S>>6&63]+t[S&63]}function T(S,C,M){for(var F,B=[],O=C;Ole?le:L+O));return F===1?(C=S[M-1],B.push(t[C>>2]+t[C<<4&63]+"==")):F===2&&(C=(S[M-2]<<8)+S[M-1],B.push(t[C>>10]+t[C>>4&63]+t[C<<2&63]+"=")),B.join("")}}),Ca=gi(e=>{e.read=function(t,r,n,i,o){var s,a,l=o*8-i-1,d=(1<>1,h=-7,T=n?o-1:0,I=n?-1:1,S=t[r+T];for(T+=I,s=S&(1<<-h)-1,S>>=-h,h+=l;h>0;s=s*256+t[r+T],T+=I,h-=8);for(a=s&(1<<-h)-1,s>>=-h,h+=i;h>0;a=a*256+t[r+T],T+=I,h-=8);if(s===0)s=1-g;else{if(s===d)return a?NaN:(S?-1:1)*(1/0);a=a+Math.pow(2,i),s=s-g}return(S?-1:1)*a*Math.pow(2,s-i)},e.write=function(t,r,n,i,o,s){var a,l,d,g=s*8-o-1,h=(1<>1,I=o===23?Math.pow(2,-24)-Math.pow(2,-77):0,S=i?0:s-1,C=i?1:-1,M=r<0||r===0&&1/r<0?1:0;for(r=Math.abs(r),isNaN(r)||r===1/0?(l=isNaN(r)?1:0,a=h):(a=Math.floor(Math.log(r)/Math.LN2),r*(d=Math.pow(2,-a))<1&&(a--,d*=2),a+T>=1?r+=I/d:r+=I*Math.pow(2,1-T),r*d>=2&&(a++,d/=2),a+T>=h?(l=0,a=h):a+T>=1?(l=(r*d-1)*Math.pow(2,o),a=a+T):(l=r*Math.pow(2,T-1)*Math.pow(2,o),a=0));o>=8;t[n+S]=l&255,S+=C,l/=256,o-=8);for(a=a<0;t[n+S]=a&255,S+=C,a/=256,g-=8);t[n+S-C]|=M*128}}),un=Ra(),We=Ca(),pi=typeof Symbol=="function"&&typeof Symbol.for=="function"?Symbol.for("nodejs.util.inspect.custom"):null;ze.Buffer=A;ze.SlowBuffer=Ma;ze.INSPECT_MAX_BYTES=50;var ur=2147483647;ze.kMaxLength=ur;A.TYPED_ARRAY_SUPPORT=Sa();!A.TYPED_ARRAY_SUPPORT&&typeof console<"u"&&typeof console.error=="function"&&console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");function Sa(){try{let e=new Uint8Array(1),t={foo:function(){return 42}};return Object.setPrototypeOf(t,Uint8Array.prototype),Object.setPrototypeOf(e,t),e.foo()===42}catch{return!1}}Object.defineProperty(A.prototype,"parent",{enumerable:!0,get:function(){if(A.isBuffer(this))return this.buffer}});Object.defineProperty(A.prototype,"offset",{enumerable:!0,get:function(){if(A.isBuffer(this))return this.byteOffset}});function xe(e){if(e>ur)throw new RangeError('The value "'+e+'" is invalid for option "size"');let t=new Uint8Array(e);return Object.setPrototypeOf(t,A.prototype),t}function A(e,t,r){if(typeof e=="number"){if(typeof t=="string")throw new TypeError('The "string" argument must be of type string. Received type number');return mn(e)}return hi(e,t,r)}A.poolSize=8192;function hi(e,t,r){if(typeof e=="string")return Oa(e,t);if(ArrayBuffer.isView(e))return ka(e);if(e==null)throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type "+typeof e);if(de(e,ArrayBuffer)||e&&de(e.buffer,ArrayBuffer)||typeof SharedArrayBuffer<"u"&&(de(e,SharedArrayBuffer)||e&&de(e.buffer,SharedArrayBuffer)))return wi(e,t,r);if(typeof e=="number")throw new TypeError('The "value" argument must not be of type number. Received type number');let n=e.valueOf&&e.valueOf();if(n!=null&&n!==e)return A.from(n,t,r);let i=Da(e);if(i)return i;if(typeof Symbol<"u"&&Symbol.toPrimitive!=null&&typeof e[Symbol.toPrimitive]=="function")return A.from(e[Symbol.toPrimitive]("string"),t,r);throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type "+typeof e)}A.from=function(e,t,r){return hi(e,t,r)};Object.setPrototypeOf(A.prototype,Uint8Array.prototype);Object.setPrototypeOf(A,Uint8Array);function yi(e){if(typeof e!="number")throw new TypeError('"size" argument must be of type number');if(e<0)throw new RangeError('The value "'+e+'" is invalid for option "size"')}function Ia(e,t,r){return yi(e),e<=0?xe(e):t!==void 0?typeof r=="string"?xe(e).fill(t,r):xe(e).fill(t):xe(e)}A.alloc=function(e,t,r){return Ia(e,t,r)};function mn(e){return yi(e),xe(e<0?0:fn(e)|0)}A.allocUnsafe=function(e){return mn(e)};A.allocUnsafeSlow=function(e){return mn(e)};function Oa(e,t){if((typeof t!="string"||t==="")&&(t="utf8"),!A.isEncoding(t))throw new TypeError("Unknown encoding: "+t);let r=Ei(e,t)|0,n=xe(r),i=n.write(e,t);return i!==r&&(n=n.slice(0,i)),n}function cn(e){let t=e.length<0?0:fn(e.length)|0,r=xe(t);for(let n=0;n=ur)throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+ur.toString(16)+" bytes");return e|0}function Ma(e){return+e!=e&&(e=0),A.alloc(+e)}A.isBuffer=function(e){return e!=null&&e._isBuffer===!0&&e!==A.prototype};A.compare=function(e,t){if(de(e,Uint8Array)&&(e=A.from(e,e.offset,e.byteLength)),de(t,Uint8Array)&&(t=A.from(t,t.offset,t.byteLength)),!A.isBuffer(e)||!A.isBuffer(t))throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');if(e===t)return 0;let r=e.length,n=t.length;for(let i=0,o=Math.min(r,n);in.length?(A.isBuffer(o)||(o=A.from(o)),o.copy(n,i)):Uint8Array.prototype.set.call(n,o,i);else if(A.isBuffer(o))o.copy(n,i);else throw new TypeError('"list" argument must be an Array of Buffers');i+=o.length}return n};function Ei(e,t){if(A.isBuffer(e))return e.length;if(ArrayBuffer.isView(e)||de(e,ArrayBuffer))return e.byteLength;if(typeof e!="string")throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type '+typeof e);let r=e.length,n=arguments.length>2&&arguments[2]===!0;if(!n&&r===0)return 0;let i=!1;for(;;)switch(t){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":return pn(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return r*2;case"hex":return r>>>1;case"base64":return Si(e).length;default:if(i)return n?-1:pn(e).length;t=(""+t).toLowerCase(),i=!0}}A.byteLength=Ei;function _a(e,t,r){let n=!1;if((t===void 0||t<0)&&(t=0),t>this.length||((r===void 0||r>this.length)&&(r=this.length),r<=0)||(r>>>=0,t>>>=0,r<=t))return"";for(e||(e="utf8");;)switch(e){case"hex":return Ga(this,t,r);case"utf8":case"utf-8":return xi(this,t,r);case"ascii":return $a(this,t,r);case"latin1":case"binary":return ja(this,t,r);case"base64":return qa(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return Ja(this,t,r);default:if(n)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),n=!0}}A.prototype._isBuffer=!0;function Le(e,t,r){let n=e[t];e[t]=e[r],e[r]=n}A.prototype.swap16=function(){let e=this.length;if(e%2!==0)throw new RangeError("Buffer size must be a multiple of 16-bits");for(let t=0;tt&&(e+=" ... "),""};pi&&(A.prototype[pi]=A.prototype.inspect);A.prototype.compare=function(e,t,r,n,i){if(de(e,Uint8Array)&&(e=A.from(e,e.offset,e.byteLength)),!A.isBuffer(e))throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type '+typeof e);if(t===void 0&&(t=0),r===void 0&&(r=e?e.length:0),n===void 0&&(n=0),i===void 0&&(i=this.length),t<0||r>e.length||n<0||i>this.length)throw new RangeError("out of range index");if(n>=i&&t>=r)return 0;if(n>=i)return-1;if(t>=r)return 1;if(t>>>=0,r>>>=0,n>>>=0,i>>>=0,this===e)return 0;let o=i-n,s=r-t,a=Math.min(o,s),l=this.slice(n,i),d=e.slice(t,r);for(let g=0;g2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),r=+r,gn(r)&&(r=i?0:e.length-1),r<0&&(r=e.length+r),r>=e.length){if(i)return-1;r=e.length-1}else if(r<0)if(i)r=0;else return-1;if(typeof t=="string"&&(t=A.from(t,n)),A.isBuffer(t))return t.length===0?-1:mi(e,t,r,n,i);if(typeof t=="number")return t=t&255,typeof Uint8Array.prototype.indexOf=="function"?i?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):mi(e,[t],r,n,i);throw new TypeError("val must be string, number or Buffer")}function mi(e,t,r,n,i){let o=1,s=e.length,a=t.length;if(n!==void 0&&(n=String(n).toLowerCase(),n==="ucs2"||n==="ucs-2"||n==="utf16le"||n==="utf-16le")){if(e.length<2||t.length<2)return-1;o=2,s/=2,a/=2,r/=2}function l(g,h){return o===1?g[h]:g.readUInt16BE(h*o)}let d;if(i){let g=-1;for(d=r;ds&&(r=s-a),d=r;d>=0;d--){let g=!0;for(let h=0;hi&&(n=i)):n=i;let o=t.length;n>o/2&&(n=o/2);let s;for(s=0;s>>0,isFinite(r)?(r=r>>>0,n===void 0&&(n="utf8")):(n=r,r=void 0);else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");let i=this.length-t;if((r===void 0||r>i)&&(r=i),e.length>0&&(r<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");let o=!1;for(;;)switch(n){case"hex":return Na(this,e,t,r);case"utf8":case"utf-8":return Fa(this,e,t,r);case"ascii":case"latin1":case"binary":return La(this,e,t,r);case"base64":return Ua(this,e,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return Ba(this,e,t,r);default:if(o)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),o=!0}};A.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};function qa(e,t,r){return t===0&&r===e.length?un.fromByteArray(e):un.fromByteArray(e.slice(t,r))}function xi(e,t,r){r=Math.min(e.length,r);let n=[],i=t;for(;i239?4:o>223?3:o>191?2:1;if(i+a<=r){let l,d,g,h;switch(a){case 1:o<128&&(s=o);break;case 2:l=e[i+1],(l&192)===128&&(h=(o&31)<<6|l&63,h>127&&(s=h));break;case 3:l=e[i+1],d=e[i+2],(l&192)===128&&(d&192)===128&&(h=(o&15)<<12|(l&63)<<6|d&63,h>2047&&(h<55296||h>57343)&&(s=h));break;case 4:l=e[i+1],d=e[i+2],g=e[i+3],(l&192)===128&&(d&192)===128&&(g&192)===128&&(h=(o&15)<<18|(l&63)<<12|(d&63)<<6|g&63,h>65535&&h<1114112&&(s=h))}}s===null?(s=65533,a=1):s>65535&&(s-=65536,n.push(s>>>10&1023|55296),s=56320|s&1023),n.push(s),i+=a}return Va(n)}var fi=4096;function Va(e){let t=e.length;if(t<=fi)return String.fromCharCode.apply(String,e);let r="",n=0;for(;nn)&&(r=n);let i="";for(let o=t;or&&(e=r),t<0?(t+=r,t<0&&(t=0)):t>r&&(t=r),tr)throw new RangeError("Trying to access beyond buffer length")}A.prototype.readUintLE=A.prototype.readUIntLE=function(e,t,r){e=e>>>0,t=t>>>0,r||W(e,t,this.length);let n=this[e],i=1,o=0;for(;++o>>0,t=t>>>0,r||W(e,t,this.length);let n=this[e+--t],i=1;for(;t>0&&(i*=256);)n+=this[e+--t]*i;return n};A.prototype.readUint8=A.prototype.readUInt8=function(e,t){return e=e>>>0,t||W(e,1,this.length),this[e]};A.prototype.readUint16LE=A.prototype.readUInt16LE=function(e,t){return e=e>>>0,t||W(e,2,this.length),this[e]|this[e+1]<<8};A.prototype.readUint16BE=A.prototype.readUInt16BE=function(e,t){return e=e>>>0,t||W(e,2,this.length),this[e]<<8|this[e+1]};A.prototype.readUint32LE=A.prototype.readUInt32LE=function(e,t){return e=e>>>0,t||W(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+this[e+3]*16777216};A.prototype.readUint32BE=A.prototype.readUInt32BE=function(e,t){return e=e>>>0,t||W(e,4,this.length),this[e]*16777216+(this[e+1]<<16|this[e+2]<<8|this[e+3])};A.prototype.readBigUInt64LE=Se(function(e){e=e>>>0,He(e,"offset");let t=this[e],r=this[e+7];(t===void 0||r===void 0)&&Tt(e,this.length-8);let n=t+this[++e]*2**8+this[++e]*2**16+this[++e]*2**24,i=this[++e]+this[++e]*2**8+this[++e]*2**16+r*2**24;return BigInt(n)+(BigInt(i)<>>0,He(e,"offset");let t=this[e],r=this[e+7];(t===void 0||r===void 0)&&Tt(e,this.length-8);let n=t*2**24+this[++e]*2**16+this[++e]*2**8+this[++e],i=this[++e]*2**24+this[++e]*2**16+this[++e]*2**8+r;return(BigInt(n)<>>0,t=t>>>0,r||W(e,t,this.length);let n=this[e],i=1,o=0;for(;++o=i&&(n-=Math.pow(2,8*t)),n};A.prototype.readIntBE=function(e,t,r){e=e>>>0,t=t>>>0,r||W(e,t,this.length);let n=t,i=1,o=this[e+--n];for(;n>0&&(i*=256);)o+=this[e+--n]*i;return i*=128,o>=i&&(o-=Math.pow(2,8*t)),o};A.prototype.readInt8=function(e,t){return e=e>>>0,t||W(e,1,this.length),this[e]&128?(255-this[e]+1)*-1:this[e]};A.prototype.readInt16LE=function(e,t){e=e>>>0,t||W(e,2,this.length);let r=this[e]|this[e+1]<<8;return r&32768?r|4294901760:r};A.prototype.readInt16BE=function(e,t){e=e>>>0,t||W(e,2,this.length);let r=this[e+1]|this[e]<<8;return r&32768?r|4294901760:r};A.prototype.readInt32LE=function(e,t){return e=e>>>0,t||W(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24};A.prototype.readInt32BE=function(e,t){return e=e>>>0,t||W(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]};A.prototype.readBigInt64LE=Se(function(e){e=e>>>0,He(e,"offset");let t=this[e],r=this[e+7];(t===void 0||r===void 0)&&Tt(e,this.length-8);let n=this[e+4]+this[e+5]*2**8+this[e+6]*2**16+(r<<24);return(BigInt(n)<>>0,He(e,"offset");let t=this[e],r=this[e+7];(t===void 0||r===void 0)&&Tt(e,this.length-8);let n=(t<<24)+this[++e]*2**16+this[++e]*2**8+this[++e];return(BigInt(n)<>>0,t||W(e,4,this.length),We.read(this,e,!0,23,4)};A.prototype.readFloatBE=function(e,t){return e=e>>>0,t||W(e,4,this.length),We.read(this,e,!1,23,4)};A.prototype.readDoubleLE=function(e,t){return e=e>>>0,t||W(e,8,this.length),We.read(this,e,!0,52,8)};A.prototype.readDoubleBE=function(e,t){return e=e>>>0,t||W(e,8,this.length),We.read(this,e,!1,52,8)};function re(e,t,r,n,i,o){if(!A.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>i||te.length)throw new RangeError("Index out of range")}A.prototype.writeUintLE=A.prototype.writeUIntLE=function(e,t,r,n){if(e=+e,t=t>>>0,r=r>>>0,!n){let s=Math.pow(2,8*r)-1;re(this,e,t,r,s,0)}let i=1,o=0;for(this[t]=e&255;++o>>0,r=r>>>0,!n){let s=Math.pow(2,8*r)-1;re(this,e,t,r,s,0)}let i=r-1,o=1;for(this[t+i]=e&255;--i>=0&&(o*=256);)this[t+i]=e/o&255;return t+r};A.prototype.writeUint8=A.prototype.writeUInt8=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,1,255,0),this[t]=e&255,t+1};A.prototype.writeUint16LE=A.prototype.writeUInt16LE=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,2,65535,0),this[t]=e&255,this[t+1]=e>>>8,t+2};A.prototype.writeUint16BE=A.prototype.writeUInt16BE=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,2,65535,0),this[t]=e>>>8,this[t+1]=e&255,t+2};A.prototype.writeUint32LE=A.prototype.writeUInt32LE=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,4,4294967295,0),this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=e&255,t+4};A.prototype.writeUint32BE=A.prototype.writeUInt32BE=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,4,4294967295,0),this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=e&255,t+4};function Pi(e,t,r,n,i){Ci(t,n,i,e,r,7);let o=Number(t&BigInt(4294967295));e[r++]=o,o=o>>8,e[r++]=o,o=o>>8,e[r++]=o,o=o>>8,e[r++]=o;let s=Number(t>>BigInt(32)&BigInt(4294967295));return e[r++]=s,s=s>>8,e[r++]=s,s=s>>8,e[r++]=s,s=s>>8,e[r++]=s,r}function vi(e,t,r,n,i){Ci(t,n,i,e,r,7);let o=Number(t&BigInt(4294967295));e[r+7]=o,o=o>>8,e[r+6]=o,o=o>>8,e[r+5]=o,o=o>>8,e[r+4]=o;let s=Number(t>>BigInt(32)&BigInt(4294967295));return e[r+3]=s,s=s>>8,e[r+2]=s,s=s>>8,e[r+1]=s,s=s>>8,e[r]=s,r+8}A.prototype.writeBigUInt64LE=Se(function(e,t=0){return Pi(this,e,t,BigInt(0),BigInt("0xffffffffffffffff"))});A.prototype.writeBigUInt64BE=Se(function(e,t=0){return vi(this,e,t,BigInt(0),BigInt("0xffffffffffffffff"))});A.prototype.writeIntLE=function(e,t,r,n){if(e=+e,t=t>>>0,!n){let a=Math.pow(2,8*r-1);re(this,e,t,r,a-1,-a)}let i=0,o=1,s=0;for(this[t]=e&255;++i>0)-s&255;return t+r};A.prototype.writeIntBE=function(e,t,r,n){if(e=+e,t=t>>>0,!n){let a=Math.pow(2,8*r-1);re(this,e,t,r,a-1,-a)}let i=r-1,o=1,s=0;for(this[t+i]=e&255;--i>=0&&(o*=256);)e<0&&s===0&&this[t+i+1]!==0&&(s=1),this[t+i]=(e/o>>0)-s&255;return t+r};A.prototype.writeInt8=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,1,127,-128),e<0&&(e=255+e+1),this[t]=e&255,t+1};A.prototype.writeInt16LE=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,2,32767,-32768),this[t]=e&255,this[t+1]=e>>>8,t+2};A.prototype.writeInt16BE=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,2,32767,-32768),this[t]=e>>>8,this[t+1]=e&255,t+2};A.prototype.writeInt32LE=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,4,2147483647,-2147483648),this[t]=e&255,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24,t+4};A.prototype.writeInt32BE=function(e,t,r){return e=+e,t=t>>>0,r||re(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=e&255,t+4};A.prototype.writeBigInt64LE=Se(function(e,t=0){return Pi(this,e,t,-BigInt("0x8000000000000000"),BigInt("0x7fffffffffffffff"))});A.prototype.writeBigInt64BE=Se(function(e,t=0){return vi(this,e,t,-BigInt("0x8000000000000000"),BigInt("0x7fffffffffffffff"))});function Ti(e,t,r,n,i,o){if(r+n>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function Ai(e,t,r,n,i){return t=+t,r=r>>>0,i||Ti(e,t,r,4,34028234663852886e22,-34028234663852886e22),We.write(e,t,r,n,23,4),r+4}A.prototype.writeFloatLE=function(e,t,r){return Ai(this,e,t,!0,r)};A.prototype.writeFloatBE=function(e,t,r){return Ai(this,e,t,!1,r)};function Ri(e,t,r,n,i){return t=+t,r=r>>>0,i||Ti(e,t,r,8,17976931348623157e292,-17976931348623157e292),We.write(e,t,r,n,52,8),r+8}A.prototype.writeDoubleLE=function(e,t,r){return Ri(this,e,t,!0,r)};A.prototype.writeDoubleBE=function(e,t,r){return Ri(this,e,t,!1,r)};A.prototype.copy=function(e,t,r,n){if(!A.isBuffer(e))throw new TypeError("argument should be a Buffer");if(r||(r=0),!n&&n!==0&&(n=this.length),t>=e.length&&(t=e.length),t||(t=0),n>0&&n=this.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),e.length-t>>0,r=r===void 0?this.length:r>>>0,e||(e=0);let i;if(typeof e=="number")for(i=t;i2**32?i=di(String(r)):typeof r=="bigint"&&(i=String(r),(r>BigInt(2)**BigInt(32)||r<-(BigInt(2)**BigInt(32)))&&(i=di(i)),i+="n"),n+=` It must be ${t}. Received ${i}`,n},RangeError);function di(e){let t="",r=e.length,n=e[0]==="-"?1:0;for(;r>=n+4;r-=3)t=`_${e.slice(r-3,r)}${t}`;return`${e.slice(0,r)}${t}`}function Qa(e,t,r){He(t,"offset"),(e[t]===void 0||e[t+r]===void 0)&&Tt(t,e.length-(r+1))}function Ci(e,t,r,n,i,o){if(e>r||e3?t===0||t===BigInt(0)?a=`>= 0${s} and < 2${s} ** ${(o+1)*8}${s}`:a=`>= -(2${s} ** ${(o+1)*8-1}${s}) and < 2 ** ${(o+1)*8-1}${s}`:a=`>= ${t}${s} and <= ${r}${s}`,new Ke.ERR_OUT_OF_RANGE("value",a,e)}Qa(n,i,o)}function He(e,t){if(typeof e!="number")throw new Ke.ERR_INVALID_ARG_TYPE(t,"number",e)}function Tt(e,t,r){throw Math.floor(e)!==e?(He(e,r),new Ke.ERR_OUT_OF_RANGE(r||"offset","an integer",e)):t<0?new Ke.ERR_BUFFER_OUT_OF_BOUNDS:new Ke.ERR_OUT_OF_RANGE(r||"offset",`>= ${r?1:0} and <= ${t}`,e)}var Ka=/[^+/0-9A-Za-z-_]/g;function Wa(e){if(e=e.split("=")[0],e=e.trim().replace(Ka,""),e.length<2)return"";for(;e.length%4!==0;)e=e+"=";return e}function pn(e,t){t=t||1/0;let r,n=e.length,i=null,o=[];for(let s=0;s55295&&r<57344){if(!i){if(r>56319){(t-=3)>-1&&o.push(239,191,189);continue}else if(s+1===n){(t-=3)>-1&&o.push(239,191,189);continue}i=r;continue}if(r<56320){(t-=3)>-1&&o.push(239,191,189),i=r;continue}r=(i-55296<<10|r-56320)+65536}else i&&(t-=3)>-1&&o.push(239,191,189);if(i=null,r<128){if((t-=1)<0)break;o.push(r)}else if(r<2048){if((t-=2)<0)break;o.push(r>>6|192,r&63|128)}else if(r<65536){if((t-=3)<0)break;o.push(r>>12|224,r>>6&63|128,r&63|128)}else if(r<1114112){if((t-=4)<0)break;o.push(r>>18|240,r>>12&63|128,r>>6&63|128,r&63|128)}else throw new Error("Invalid code point")}return o}function Ha(e){let t=[];for(let r=0;r>8,i=r%256,o.push(i),o.push(n);return o}function Si(e){return un.toByteArray(Wa(e))}function cr(e,t,r,n){let i;for(i=0;i=t.length||i>=e.length);++i)t[i+r]=e[i];return i}function de(e,t){return e instanceof t||e!=null&&e.constructor!=null&&e.constructor.name!=null&&e.constructor.name===t.name}function gn(e){return e!==e}var Ya=function(){let e="0123456789abcdef",t=new Array(256);for(let r=0;r<16;++r){let n=r*16;for(let i=0;i<16;++i)t[n+i]=e[r]+e[i]}return t}();function Se(e){return typeof BigInt>"u"?Za:e}function Za(){throw new Error("BigInt not supported")}});var w,f=fe(()=>{"use strict";w=Qe(Ii())});function il(){return!1}function bn(){return{dev:0,ino:0,mode:0,nlink:0,uid:0,gid:0,rdev:0,size:0,blksize:0,blocks:0,atimeMs:0,mtimeMs:0,ctimeMs:0,birthtimeMs:0,atime:new Date,mtime:new Date,ctime:new Date,birthtime:new Date}}function ol(){return bn()}function sl(){return[]}function al(e){e(null,[])}function ll(){return""}function ul(){return""}function cl(){}function pl(){}function ml(){}function fl(){}function dl(){}function gl(){}function hl(){}function yl(){}function wl(){return{close:()=>{},on:()=>{},removeAllListeners:()=>{}}}function El(e,t){t(null,bn())}var bl,xl,Qi,Ki=fe(()=>{"use strict";f();u();c();p();m();bl={},xl={existsSync:il,lstatSync:bn,stat:El,statSync:ol,readdirSync:sl,readdir:al,readlinkSync:ll,realpathSync:ul,chmodSync:cl,renameSync:pl,mkdirSync:ml,rmdirSync:fl,rmSync:dl,unlinkSync:gl,watchFile:hl,unwatchFile:yl,watch:wl,promises:bl},Qi=xl});var Wi=Je((df,Pl)=>{Pl.exports={name:"@prisma/internals",version:"6.19.1",description:"This package is intended for Prisma's internal use",main:"dist/index.js",types:"dist/index.d.ts",repository:{type:"git",url:"https://github.com/prisma/prisma.git",directory:"packages/internals"},homepage:"https://www.prisma.io",author:"Tim Suchanek ",bugs:"https://github.com/prisma/prisma/issues",license:"Apache-2.0",scripts:{dev:"DEV=true tsx helpers/build.ts",build:"tsx helpers/build.ts",test:"dotenv -e ../../.db.env -- jest --silent",prepublishOnly:"pnpm run build"},files:["README.md","dist","!**/libquery_engine*","!dist/get-generators/engines/*","scripts"],devDependencies:{"@babel/helper-validator-identifier":"7.25.9","@opentelemetry/api":"1.9.0","@swc/core":"1.11.5","@swc/jest":"0.2.37","@types/babel__helper-validator-identifier":"7.15.2","@types/jest":"29.5.14","@types/node":"18.19.76","@types/resolve":"1.20.6",archiver:"6.0.2","checkpoint-client":"1.1.33","cli-truncate":"4.0.0",dotenv:"16.5.0",empathic:"2.0.0","escape-string-regexp":"5.0.0",execa:"8.0.1","fast-glob":"3.3.3","find-up":"7.0.0","fp-ts":"2.16.9","fs-extra":"11.3.0","global-directory":"4.0.0",globby:"11.1.0","identifier-regex":"1.0.0","indent-string":"4.0.0","is-windows":"1.0.2","is-wsl":"3.1.0",jest:"29.7.0","jest-junit":"16.0.0",kleur:"4.1.5","mock-stdin":"1.0.0","new-github-issue-url":"0.2.1","node-fetch":"3.3.2","npm-packlist":"5.1.3",open:"7.4.2","p-map":"4.0.0",resolve:"1.22.10","string-width":"7.2.0","strip-indent":"4.0.0","temp-dir":"2.0.0",tempy:"1.0.1","terminal-link":"4.0.0",tmp:"0.2.3","ts-pattern":"5.6.2","ts-toolbelt":"9.6.0",typescript:"5.4.5",yarn:"1.22.22"},dependencies:{"@prisma/config":"workspace:*","@prisma/debug":"workspace:*","@prisma/dmmf":"workspace:*","@prisma/driver-adapter-utils":"workspace:*","@prisma/engines":"workspace:*","@prisma/fetch-engine":"workspace:*","@prisma/generator":"workspace:*","@prisma/generator-helper":"workspace:*","@prisma/get-platform":"workspace:*","@prisma/prisma-schema-wasm":"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7","@prisma/schema-engine-wasm":"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7","@prisma/schema-files-loader":"workspace:*",arg:"5.0.2",prompts:"2.4.2"},peerDependencies:{typescript:">=5.1.0"},peerDependenciesMeta:{typescript:{optional:!0}},sideEffects:!1}});function Tl(...e){return e.join("/")}function Al(...e){return e.join("/")}function Rl(e){let t=Hi(e),r=zi(e),[n,i]=t.split(".");return{root:"/",dir:r,base:t,ext:i,name:n}}function Hi(e){let t=e.split("/");return t[t.length-1]}function zi(e){return e.split("/").slice(0,-1).join("/")}function Sl(e){let t=e.split("/").filter(i=>i!==""&&i!=="."),r=[];for(let i of t)i===".."?r.pop():r.push(i);let n=r.join("/");return e.startsWith("/")?"/"+n:n}var Yi,Cl,Il,Ol,dr,Zi=fe(()=>{"use strict";f();u();c();p();m();Yi="/",Cl=":";Il={sep:Yi},Ol={basename:Hi,delimiter:Cl,dirname:zi,join:Al,normalize:Sl,parse:Rl,posix:Il,resolve:Tl,sep:Yi},dr=Ol});var Pn=Je((Mf,Ml)=>{Ml.exports={name:"@prisma/engines-version",version:"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7",main:"index.js",types:"index.d.ts",license:"Apache-2.0",author:"Tim Suchanek ",prisma:{enginesVersion:"c2990dca591cba766e3b7ef5d9e8a84796e47ab7"},repository:{type:"git",url:"https://github.com/prisma/engines-wrapper.git",directory:"packages/engines-version"},devDependencies:{"@types/node":"18.19.76",typescript:"4.9.5"},files:["index.js","index.d.ts"],scripts:{build:"tsc -d"}}});var Xi=Je(gr=>{"use strict";f();u();c();p();m();Object.defineProperty(gr,"__esModule",{value:!0});gr.enginesVersion=void 0;gr.enginesVersion=Pn().prisma.enginesVersion});var ro=Je((Qf,to)=>{"use strict";f();u();c();p();m();to.exports=(e,t=1,r)=>{if(r={indent:" ",includeEmptyLines:!1,...r},typeof e!="string")throw new TypeError(`Expected \`input\` to be a \`string\`, got \`${typeof e}\``);if(typeof t!="number")throw new TypeError(`Expected \`count\` to be a \`number\`, got \`${typeof t}\``);if(typeof r.indent!="string")throw new TypeError(`Expected \`options.indent\` to be a \`string\`, got \`${typeof r.indent}\``);if(t===0)return e;let n=r.includeEmptyLines?/^/gm:/^(?!\s*$)/gm;return e.replace(n,r.indent.repeat(t))}});var Nn=Je((Jy,vo)=>{"use strict";f();u();c();p();m();vo.exports=function(){function e(t,r,n,i,o){return tn?n+1:t+1:i===o?r:r+1}return function(t,r){if(t===r)return 0;if(t.length>r.length){var n=t;t=r,r=n}for(var i=t.length,o=r.length;i>0&&t.charCodeAt(i-1)===r.charCodeAt(o-1);)i--,o--;for(var s=0;s{"use strict";f();u();c();p();m()});var Io=fe(()=>{"use strict";f();u();c();p();m()});var Jr,Xo=fe(()=>{"use strict";f();u();c();p();m();Jr=class{events={};on(t,r){return this.events[t]||(this.events[t]=[]),this.events[t].push(r),this}emit(t,...r){return this.events[t]?(this.events[t].forEach(n=>{n(...r)}),!0):!1}}});var kp={};vt(kp,{DMMF:()=>Dt,Debug:()=>z,Decimal:()=>Ae,Extensions:()=>hn,MetricsClient:()=>pt,PrismaClientInitializationError:()=>Q,PrismaClientKnownRequestError:()=>ne,PrismaClientRustPanicError:()=>Pe,PrismaClientUnknownRequestError:()=>ie,PrismaClientValidationError:()=>X,Public:()=>yn,Sql:()=>se,createParam:()=>Jo,defineDmmfProperty:()=>Yo,deserializeJsonResponse:()=>dt,deserializeRawResult:()=>nn,dmmfToRuntimeDataModel:()=>ao,empty:()=>ts,getPrismaClient:()=>ya,getRuntime:()=>Zr,join:()=>es,makeStrictEnum:()=>wa,makeTypedQueryFactory:()=>Zo,objectEnumValues:()=>Nr,raw:()=>Gn,serializeJsonQuery:()=>$r,skip:()=>Vr,sqltag:()=>Jn,warnEnvConflicts:()=>void 0,warnOnce:()=>St});module.exports=Aa(kp);f();u();c();p();m();var hn={};vt(hn,{defineExtension:()=>Oi,getExtensionContext:()=>ki});f();u();c();p();m();f();u();c();p();m();function Oi(e){return typeof e=="function"?e:t=>t.$extends(e)}f();u();c();p();m();function ki(e){return e}var yn={};vt(yn,{validator:()=>Di});f();u();c();p();m();f();u();c();p();m();function Di(...e){return t=>t}f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();var wn,Mi,_i,Ni,Fi=!0;typeof y<"u"&&({FORCE_COLOR:wn,NODE_DISABLE_COLORS:Mi,NO_COLOR:_i,TERM:Ni}=y.env||{},Fi=y.stdout&&y.stdout.isTTY);var Xa={enabled:!Mi&&_i==null&&Ni!=="dumb"&&(wn!=null&&wn!=="0"||Fi)};function j(e,t){let r=new RegExp(`\\x1b\\[${t}m`,"g"),n=`\x1B[${e}m`,i=`\x1B[${t}m`;return function(o){return!Xa.enabled||o==null?o:n+(~(""+o).indexOf(i)?o.replace(r,i+n):o)+i}}var Pm=j(0,0),pr=j(1,22),mr=j(2,22),vm=j(3,23),Li=j(4,24),Tm=j(7,27),Am=j(8,28),Rm=j(9,29),Cm=j(30,39),Ye=j(31,39),Ui=j(32,39),Bi=j(33,39),qi=j(34,39),Sm=j(35,39),Vi=j(36,39),Im=j(37,39),$i=j(90,39),Om=j(90,39),km=j(40,49),Dm=j(41,49),Mm=j(42,49),_m=j(43,49),Nm=j(44,49),Fm=j(45,49),Lm=j(46,49),Um=j(47,49);f();u();c();p();m();var el=100,ji=["green","yellow","blue","magenta","cyan","red"],fr=[],Gi=Date.now(),tl=0,En=typeof y<"u"?y.env:{};globalThis.DEBUG??=En.DEBUG??"";globalThis.DEBUG_COLORS??=En.DEBUG_COLORS?En.DEBUG_COLORS==="true":!0;var At={enable(e){typeof e=="string"&&(globalThis.DEBUG=e)},disable(){let e=globalThis.DEBUG;return globalThis.DEBUG="",e},enabled(e){let t=globalThis.DEBUG.split(",").map(i=>i.replace(/[.+?^${}()|[\]\\]/g,"\\$&")),r=t.some(i=>i===""||i[0]==="-"?!1:e.match(RegExp(i.split("*").join(".*")+"$"))),n=t.some(i=>i===""||i[0]!=="-"?!1:e.match(RegExp(i.slice(1).split("*").join(".*")+"$")));return r&&!n},log:(...e)=>{let[t,r,...n]=e;(console.warn??console.log)(`${t} ${r}`,...n)},formatters:{}};function rl(e){let t={color:ji[tl++%ji.length],enabled:At.enabled(e),namespace:e,log:At.log,extend:()=>{}},r=(...n)=>{let{enabled:i,namespace:o,color:s,log:a}=t;if(n.length!==0&&fr.push([o,...n]),fr.length>el&&fr.shift(),At.enabled(o)||i){let l=n.map(g=>typeof g=="string"?g:nl(g)),d=`+${Date.now()-Gi}ms`;Gi=Date.now(),a(o,...l,d)}};return new Proxy(r,{get:(n,i)=>t[i],set:(n,i,o)=>t[i]=o})}var z=new Proxy(rl,{get:(e,t)=>At[t],set:(e,t,r)=>At[t]=r});function nl(e,t=2){let r=new Set;return JSON.stringify(e,(n,i)=>{if(typeof i=="object"&&i!==null){if(r.has(i))return"[Circular *]";r.add(i)}else if(typeof i=="bigint")return i.toString();return i},t)}function Ji(){fr.length=0}f();u();c();p();m();f();u();c();p();m();var vl=Wi(),xn=vl.version;f();u();c();p();m();function Ze(e){let t=kl();return t||(e?.config.engineType==="library"?"library":e?.config.engineType==="binary"?"binary":e?.config.engineType==="client"?"client":Dl())}function kl(){let e=y.env.PRISMA_CLIENT_ENGINE_TYPE;return e==="library"?"library":e==="binary"?"binary":e==="client"?"client":void 0}function Dl(){return"library"}f();u();c();p();m();var eo="prisma+postgres",hr=`${eo}:`;function yr(e){return e?.toString().startsWith(`${hr}//`)??!1}function vn(e){if(!yr(e))return!1;let{host:t}=new URL(e);return t.includes("localhost")||t.includes("127.0.0.1")||t.includes("[::1]")}var Ct={};vt(Ct,{error:()=>Fl,info:()=>Nl,log:()=>_l,query:()=>Ll,should:()=>no,tags:()=>Rt,warn:()=>Tn});f();u();c();p();m();var Rt={error:Ye("prisma:error"),warn:Bi("prisma:warn"),info:Vi("prisma:info"),query:qi("prisma:query")},no={warn:()=>!y.env.PRISMA_DISABLE_WARNINGS};function _l(...e){console.log(...e)}function Tn(e,...t){no.warn()&&console.warn(`${Rt.warn} ${e}`,...t)}function Nl(e,...t){console.info(`${Rt.info} ${e}`,...t)}function Fl(e,...t){console.error(`${Rt.error} ${e}`,...t)}function Ll(e,...t){console.log(`${Rt.query} ${e}`,...t)}f();u();c();p();m();function Ue(e,t){throw new Error(t)}f();u();c();p();m();f();u();c();p();m();function An({onlyFirst:e=!1}={}){let r=["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?(?:\\u0007|\\u001B\\u005C|\\u009C))","(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"].join("|");return new RegExp(r,e?void 0:"g")}var Ul=An();function Rn(e){if(typeof e!="string")throw new TypeError(`Expected a \`string\`, got \`${typeof e}\``);return e.replace(Ul,"")}f();u();c();p();m();function Cn(e,t){return Object.prototype.hasOwnProperty.call(e,t)}f();u();c();p();m();function wr(e,t){let r={};for(let n of Object.keys(e))r[n]=t(e[n],n);return r}f();u();c();p();m();function Sn(e,t){if(e.length===0)return;let r=e[0];for(let n=1;n{io.has(e)||(io.add(e),Tn(t,...r))};var Q=class e extends Error{clientVersion;errorCode;retryable;constructor(t,r,n){super(t),this.name="PrismaClientInitializationError",this.clientVersion=r,this.errorCode=n,Error.captureStackTrace(e)}get[Symbol.toStringTag](){return"PrismaClientInitializationError"}};N(Q,"PrismaClientInitializationError");f();u();c();p();m();var ne=class extends Error{code;meta;clientVersion;batchRequestIdx;constructor(t,{code:r,clientVersion:n,meta:i,batchRequestIdx:o}){super(t),this.name="PrismaClientKnownRequestError",this.code=r,this.clientVersion=n,this.meta=i,Object.defineProperty(this,"batchRequestIdx",{value:o,enumerable:!1,writable:!0})}get[Symbol.toStringTag](){return"PrismaClientKnownRequestError"}};N(ne,"PrismaClientKnownRequestError");f();u();c();p();m();var Pe=class extends Error{clientVersion;constructor(t,r){super(t),this.name="PrismaClientRustPanicError",this.clientVersion=r}get[Symbol.toStringTag](){return"PrismaClientRustPanicError"}};N(Pe,"PrismaClientRustPanicError");f();u();c();p();m();var ie=class extends Error{clientVersion;batchRequestIdx;constructor(t,{clientVersion:r,batchRequestIdx:n}){super(t),this.name="PrismaClientUnknownRequestError",this.clientVersion=r,Object.defineProperty(this,"batchRequestIdx",{value:n,writable:!0,enumerable:!1})}get[Symbol.toStringTag](){return"PrismaClientUnknownRequestError"}};N(ie,"PrismaClientUnknownRequestError");f();u();c();p();m();var X=class extends Error{name="PrismaClientValidationError";clientVersion;constructor(t,{clientVersion:r}){super(t),this.clientVersion=r}get[Symbol.toStringTag](){return"PrismaClientValidationError"}};N(X,"PrismaClientValidationError");f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();var ge=class{_map=new Map;get(t){return this._map.get(t)?.value}set(t,r){this._map.set(t,{value:r})}getOrCreate(t,r){let n=this._map.get(t);if(n)return n.value;let i=r();return this.set(t,i),i}};f();u();c();p();m();function Ie(e){return e.substring(0,1).toLowerCase()+e.substring(1)}f();u();c();p();m();function so(e,t){let r={};for(let n of e){let i=n[t];r[i]=n}return r}f();u();c();p();m();function It(e){let t;return{get(){return t||(t={value:e()}),t.value}}}f();u();c();p();m();function ao(e){return{models:In(e.models),enums:In(e.enums),types:In(e.types)}}function In(e){let t={};for(let{name:r,...n}of e)t[r]=n;return t}f();u();c();p();m();function Xe(e){return e instanceof Date||Object.prototype.toString.call(e)==="[object Date]"}function Er(e){return e.toString()!=="Invalid Date"}f();u();c();p();m();f();u();c();p();m();var et=9e15,Me=1e9,On="0123456789abcdef",Pr="2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058",vr="3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789",kn={precision:20,rounding:4,modulo:1,toExpNeg:-7,toExpPos:21,minE:-et,maxE:et,crypto:!1},po,ve,_=!0,Ar="[DecimalError] ",De=Ar+"Invalid argument: ",mo=Ar+"Precision limit exceeded",fo=Ar+"crypto unavailable",go="[object Decimal]",ee=Math.floor,K=Math.pow,Bl=/^0b([01]+(\.[01]*)?|\.[01]+)(p[+-]?\d+)?$/i,ql=/^0x([0-9a-f]+(\.[0-9a-f]*)?|\.[0-9a-f]+)(p[+-]?\d+)?$/i,Vl=/^0o([0-7]+(\.[0-7]*)?|\.[0-7]+)(p[+-]?\d+)?$/i,ho=/^(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i,pe=1e7,D=7,$l=9007199254740991,jl=Pr.length-1,Dn=vr.length-1,R={toStringTag:go};R.absoluteValue=R.abs=function(){var e=new this.constructor(this);return e.s<0&&(e.s=1),k(e)};R.ceil=function(){return k(new this.constructor(this),this.e+1,2)};R.clampedTo=R.clamp=function(e,t){var r,n=this,i=n.constructor;if(e=new i(e),t=new i(t),!e.s||!t.s)return new i(NaN);if(e.gt(t))throw Error(De+t);return r=n.cmp(e),r<0?e:n.cmp(t)>0?t:new i(n)};R.comparedTo=R.cmp=function(e){var t,r,n,i,o=this,s=o.d,a=(e=new o.constructor(e)).d,l=o.s,d=e.s;if(!s||!a)return!l||!d?NaN:l!==d?l:s===a?0:!s^l<0?1:-1;if(!s[0]||!a[0])return s[0]?l:a[0]?-d:0;if(l!==d)return l;if(o.e!==e.e)return o.e>e.e^l<0?1:-1;for(n=s.length,i=a.length,t=0,r=na[t]^l<0?1:-1;return n===i?0:n>i^l<0?1:-1};R.cosine=R.cos=function(){var e,t,r=this,n=r.constructor;return r.d?r.d[0]?(e=n.precision,t=n.rounding,n.precision=e+Math.max(r.e,r.sd())+D,n.rounding=1,r=Gl(n,xo(n,r)),n.precision=e,n.rounding=t,k(ve==2||ve==3?r.neg():r,e,t,!0)):new n(1):new n(NaN)};R.cubeRoot=R.cbrt=function(){var e,t,r,n,i,o,s,a,l,d,g=this,h=g.constructor;if(!g.isFinite()||g.isZero())return new h(g);for(_=!1,o=g.s*K(g.s*g,1/3),!o||Math.abs(o)==1/0?(r=Y(g.d),e=g.e,(o=(e-r.length+1)%3)&&(r+=o==1||o==-2?"0":"00"),o=K(r,1/3),e=ee((e+1)/3)-(e%3==(e<0?-1:2)),o==1/0?r="5e"+e:(r=o.toExponential(),r=r.slice(0,r.indexOf("e")+1)+e),n=new h(r),n.s=g.s):n=new h(o.toString()),s=(e=h.precision)+3;;)if(a=n,l=a.times(a).times(a),d=l.plus(g),n=V(d.plus(g).times(a),d.plus(l),s+2,1),Y(a.d).slice(0,s)===(r=Y(n.d)).slice(0,s))if(r=r.slice(s-3,s+1),r=="9999"||!i&&r=="4999"){if(!i&&(k(a,e+1,0),a.times(a).times(a).eq(g))){n=a;break}s+=4,i=1}else{(!+r||!+r.slice(1)&&r.charAt(0)=="5")&&(k(n,e+1,1),t=!n.times(n).times(n).eq(g));break}return _=!0,k(n,e,h.rounding,t)};R.decimalPlaces=R.dp=function(){var e,t=this.d,r=NaN;if(t){if(e=t.length-1,r=(e-ee(this.e/D))*D,e=t[e],e)for(;e%10==0;e/=10)r--;r<0&&(r=0)}return r};R.dividedBy=R.div=function(e){return V(this,new this.constructor(e))};R.dividedToIntegerBy=R.divToInt=function(e){var t=this,r=t.constructor;return k(V(t,new r(e),0,1,1),r.precision,r.rounding)};R.equals=R.eq=function(e){return this.cmp(e)===0};R.floor=function(){return k(new this.constructor(this),this.e+1,3)};R.greaterThan=R.gt=function(e){return this.cmp(e)>0};R.greaterThanOrEqualTo=R.gte=function(e){var t=this.cmp(e);return t==1||t===0};R.hyperbolicCosine=R.cosh=function(){var e,t,r,n,i,o=this,s=o.constructor,a=new s(1);if(!o.isFinite())return new s(o.s?1/0:NaN);if(o.isZero())return a;r=s.precision,n=s.rounding,s.precision=r+Math.max(o.e,o.sd())+4,s.rounding=1,i=o.d.length,i<32?(e=Math.ceil(i/3),t=(1/Cr(4,e)).toString()):(e=16,t="2.3283064365386962890625e-10"),o=tt(s,1,o.times(t),new s(1),!0);for(var l,d=e,g=new s(8);d--;)l=o.times(o),o=a.minus(l.times(g.minus(l.times(g))));return k(o,s.precision=r,s.rounding=n,!0)};R.hyperbolicSine=R.sinh=function(){var e,t,r,n,i=this,o=i.constructor;if(!i.isFinite()||i.isZero())return new o(i);if(t=o.precision,r=o.rounding,o.precision=t+Math.max(i.e,i.sd())+4,o.rounding=1,n=i.d.length,n<3)i=tt(o,2,i,i,!0);else{e=1.4*Math.sqrt(n),e=e>16?16:e|0,i=i.times(1/Cr(5,e)),i=tt(o,2,i,i,!0);for(var s,a=new o(5),l=new o(16),d=new o(20);e--;)s=i.times(i),i=i.times(a.plus(s.times(l.times(s).plus(d))))}return o.precision=t,o.rounding=r,k(i,t,r,!0)};R.hyperbolicTangent=R.tanh=function(){var e,t,r=this,n=r.constructor;return r.isFinite()?r.isZero()?new n(r):(e=n.precision,t=n.rounding,n.precision=e+7,n.rounding=1,V(r.sinh(),r.cosh(),n.precision=e,n.rounding=t)):new n(r.s)};R.inverseCosine=R.acos=function(){var e=this,t=e.constructor,r=e.abs().cmp(1),n=t.precision,i=t.rounding;return r!==-1?r===0?e.isNeg()?he(t,n,i):new t(0):new t(NaN):e.isZero()?he(t,n+4,i).times(.5):(t.precision=n+6,t.rounding=1,e=new t(1).minus(e).div(e.plus(1)).sqrt().atan(),t.precision=n,t.rounding=i,e.times(2))};R.inverseHyperbolicCosine=R.acosh=function(){var e,t,r=this,n=r.constructor;return r.lte(1)?new n(r.eq(1)?0:NaN):r.isFinite()?(e=n.precision,t=n.rounding,n.precision=e+Math.max(Math.abs(r.e),r.sd())+4,n.rounding=1,_=!1,r=r.times(r).minus(1).sqrt().plus(r),_=!0,n.precision=e,n.rounding=t,r.ln()):new n(r)};R.inverseHyperbolicSine=R.asinh=function(){var e,t,r=this,n=r.constructor;return!r.isFinite()||r.isZero()?new n(r):(e=n.precision,t=n.rounding,n.precision=e+2*Math.max(Math.abs(r.e),r.sd())+6,n.rounding=1,_=!1,r=r.times(r).plus(1).sqrt().plus(r),_=!0,n.precision=e,n.rounding=t,r.ln())};R.inverseHyperbolicTangent=R.atanh=function(){var e,t,r,n,i=this,o=i.constructor;return i.isFinite()?i.e>=0?new o(i.abs().eq(1)?i.s/0:i.isZero()?i:NaN):(e=o.precision,t=o.rounding,n=i.sd(),Math.max(n,e)<2*-i.e-1?k(new o(i),e,t,!0):(o.precision=r=n-i.e,i=V(i.plus(1),new o(1).minus(i),r+e,1),o.precision=e+4,o.rounding=1,i=i.ln(),o.precision=e,o.rounding=t,i.times(.5))):new o(NaN)};R.inverseSine=R.asin=function(){var e,t,r,n,i=this,o=i.constructor;return i.isZero()?new o(i):(t=i.abs().cmp(1),r=o.precision,n=o.rounding,t!==-1?t===0?(e=he(o,r+4,n).times(.5),e.s=i.s,e):new o(NaN):(o.precision=r+6,o.rounding=1,i=i.div(new o(1).minus(i.times(i)).sqrt().plus(1)).atan(),o.precision=r,o.rounding=n,i.times(2)))};R.inverseTangent=R.atan=function(){var e,t,r,n,i,o,s,a,l,d=this,g=d.constructor,h=g.precision,T=g.rounding;if(d.isFinite()){if(d.isZero())return new g(d);if(d.abs().eq(1)&&h+4<=Dn)return s=he(g,h+4,T).times(.25),s.s=d.s,s}else{if(!d.s)return new g(NaN);if(h+4<=Dn)return s=he(g,h+4,T).times(.5),s.s=d.s,s}for(g.precision=a=h+10,g.rounding=1,r=Math.min(28,a/D+2|0),e=r;e;--e)d=d.div(d.times(d).plus(1).sqrt().plus(1));for(_=!1,t=Math.ceil(a/D),n=1,l=d.times(d),s=new g(d),i=d;e!==-1;)if(i=i.times(l),o=s.minus(i.div(n+=2)),i=i.times(l),s=o.plus(i.div(n+=2)),s.d[t]!==void 0)for(e=t;s.d[e]===o.d[e]&&e--;);return r&&(s=s.times(2<this.d.length-2};R.isNaN=function(){return!this.s};R.isNegative=R.isNeg=function(){return this.s<0};R.isPositive=R.isPos=function(){return this.s>0};R.isZero=function(){return!!this.d&&this.d[0]===0};R.lessThan=R.lt=function(e){return this.cmp(e)<0};R.lessThanOrEqualTo=R.lte=function(e){return this.cmp(e)<1};R.logarithm=R.log=function(e){var t,r,n,i,o,s,a,l,d=this,g=d.constructor,h=g.precision,T=g.rounding,I=5;if(e==null)e=new g(10),t=!0;else{if(e=new g(e),r=e.d,e.s<0||!r||!r[0]||e.eq(1))return new g(NaN);t=e.eq(10)}if(r=d.d,d.s<0||!r||!r[0]||d.eq(1))return new g(r&&!r[0]?-1/0:d.s!=1?NaN:r?0:1/0);if(t)if(r.length>1)o=!0;else{for(i=r[0];i%10===0;)i/=10;o=i!==1}if(_=!1,a=h+I,s=ke(d,a),n=t?Tr(g,a+10):ke(e,a),l=V(s,n,a,1),Ot(l.d,i=h,T))do if(a+=10,s=ke(d,a),n=t?Tr(g,a+10):ke(e,a),l=V(s,n,a,1),!o){+Y(l.d).slice(i+1,i+15)+1==1e14&&(l=k(l,h+1,0));break}while(Ot(l.d,i+=10,T));return _=!0,k(l,h,T)};R.minus=R.sub=function(e){var t,r,n,i,o,s,a,l,d,g,h,T,I=this,S=I.constructor;if(e=new S(e),!I.d||!e.d)return!I.s||!e.s?e=new S(NaN):I.d?e.s=-e.s:e=new S(e.d||I.s!==e.s?I:NaN),e;if(I.s!=e.s)return e.s=-e.s,I.plus(e);if(d=I.d,T=e.d,a=S.precision,l=S.rounding,!d[0]||!T[0]){if(T[0])e.s=-e.s;else if(d[0])e=new S(I);else return new S(l===3?-0:0);return _?k(e,a,l):e}if(r=ee(e.e/D),g=ee(I.e/D),d=d.slice(),o=g-r,o){for(h=o<0,h?(t=d,o=-o,s=T.length):(t=T,r=g,s=d.length),n=Math.max(Math.ceil(a/D),s)+2,o>n&&(o=n,t.length=1),t.reverse(),n=o;n--;)t.push(0);t.reverse()}else{for(n=d.length,s=T.length,h=n0;--n)d[s++]=0;for(n=T.length;n>o;){if(d[--n]s?o+1:s+1,i>s&&(i=s,r.length=1),r.reverse();i--;)r.push(0);r.reverse()}for(s=d.length,i=g.length,s-i<0&&(i=s,r=g,g=d,d=r),t=0;i;)t=(d[--i]=d[i]+g[i]+t)/pe|0,d[i]%=pe;for(t&&(d.unshift(t),++n),s=d.length;d[--s]==0;)d.pop();return e.d=d,e.e=Rr(d,n),_?k(e,a,l):e};R.precision=R.sd=function(e){var t,r=this;if(e!==void 0&&e!==!!e&&e!==1&&e!==0)throw Error(De+e);return r.d?(t=yo(r.d),e&&r.e+1>t&&(t=r.e+1)):t=NaN,t};R.round=function(){var e=this,t=e.constructor;return k(new t(e),e.e+1,t.rounding)};R.sine=R.sin=function(){var e,t,r=this,n=r.constructor;return r.isFinite()?r.isZero()?new n(r):(e=n.precision,t=n.rounding,n.precision=e+Math.max(r.e,r.sd())+D,n.rounding=1,r=Ql(n,xo(n,r)),n.precision=e,n.rounding=t,k(ve>2?r.neg():r,e,t,!0)):new n(NaN)};R.squareRoot=R.sqrt=function(){var e,t,r,n,i,o,s=this,a=s.d,l=s.e,d=s.s,g=s.constructor;if(d!==1||!a||!a[0])return new g(!d||d<0&&(!a||a[0])?NaN:a?s:1/0);for(_=!1,d=Math.sqrt(+s),d==0||d==1/0?(t=Y(a),(t.length+l)%2==0&&(t+="0"),d=Math.sqrt(t),l=ee((l+1)/2)-(l<0||l%2),d==1/0?t="5e"+l:(t=d.toExponential(),t=t.slice(0,t.indexOf("e")+1)+l),n=new g(t)):n=new g(d.toString()),r=(l=g.precision)+3;;)if(o=n,n=o.plus(V(s,o,r+2,1)).times(.5),Y(o.d).slice(0,r)===(t=Y(n.d)).slice(0,r))if(t=t.slice(r-3,r+1),t=="9999"||!i&&t=="4999"){if(!i&&(k(o,l+1,0),o.times(o).eq(s))){n=o;break}r+=4,i=1}else{(!+t||!+t.slice(1)&&t.charAt(0)=="5")&&(k(n,l+1,1),e=!n.times(n).eq(s));break}return _=!0,k(n,l,g.rounding,e)};R.tangent=R.tan=function(){var e,t,r=this,n=r.constructor;return r.isFinite()?r.isZero()?new n(r):(e=n.precision,t=n.rounding,n.precision=e+10,n.rounding=1,r=r.sin(),r.s=1,r=V(r,new n(1).minus(r.times(r)).sqrt(),e+10,0),n.precision=e,n.rounding=t,k(ve==2||ve==4?r.neg():r,e,t,!0)):new n(NaN)};R.times=R.mul=function(e){var t,r,n,i,o,s,a,l,d,g=this,h=g.constructor,T=g.d,I=(e=new h(e)).d;if(e.s*=g.s,!T||!T[0]||!I||!I[0])return new h(!e.s||T&&!T[0]&&!I||I&&!I[0]&&!T?NaN:!T||!I?e.s/0:e.s*0);for(r=ee(g.e/D)+ee(e.e/D),l=T.length,d=I.length,l=0;){for(t=0,i=l+n;i>n;)a=o[i]+I[n]*T[i-n-1]+t,o[i--]=a%pe|0,t=a/pe|0;o[i]=(o[i]+t)%pe|0}for(;!o[--s];)o.pop();return t?++r:o.shift(),e.d=o,e.e=Rr(o,r),_?k(e,h.precision,h.rounding):e};R.toBinary=function(e,t){return _n(this,2,e,t)};R.toDecimalPlaces=R.toDP=function(e,t){var r=this,n=r.constructor;return r=new n(r),e===void 0?r:(oe(e,0,Me),t===void 0?t=n.rounding:oe(t,0,8),k(r,e+r.e+1,t))};R.toExponential=function(e,t){var r,n=this,i=n.constructor;return e===void 0?r=ye(n,!0):(oe(e,0,Me),t===void 0?t=i.rounding:oe(t,0,8),n=k(new i(n),e+1,t),r=ye(n,!0,e+1)),n.isNeg()&&!n.isZero()?"-"+r:r};R.toFixed=function(e,t){var r,n,i=this,o=i.constructor;return e===void 0?r=ye(i):(oe(e,0,Me),t===void 0?t=o.rounding:oe(t,0,8),n=k(new o(i),e+i.e+1,t),r=ye(n,!1,e+n.e+1)),i.isNeg()&&!i.isZero()?"-"+r:r};R.toFraction=function(e){var t,r,n,i,o,s,a,l,d,g,h,T,I=this,S=I.d,C=I.constructor;if(!S)return new C(I);if(d=r=new C(1),n=l=new C(0),t=new C(n),o=t.e=yo(S)-I.e-1,s=o%D,t.d[0]=K(10,s<0?D+s:s),e==null)e=o>0?t:d;else{if(a=new C(e),!a.isInt()||a.lt(d))throw Error(De+a);e=a.gt(t)?o>0?t:d:a}for(_=!1,a=new C(Y(S)),g=C.precision,C.precision=o=S.length*D*2;h=V(a,t,0,1,1),i=r.plus(h.times(n)),i.cmp(e)!=1;)r=n,n=i,i=d,d=l.plus(h.times(i)),l=i,i=t,t=a.minus(h.times(i)),a=i;return i=V(e.minus(r),n,0,1,1),l=l.plus(i.times(d)),r=r.plus(i.times(n)),l.s=d.s=I.s,T=V(d,n,o,1).minus(I).abs().cmp(V(l,r,o,1).minus(I).abs())<1?[d,n]:[l,r],C.precision=g,_=!0,T};R.toHexadecimal=R.toHex=function(e,t){return _n(this,16,e,t)};R.toNearest=function(e,t){var r=this,n=r.constructor;if(r=new n(r),e==null){if(!r.d)return r;e=new n(1),t=n.rounding}else{if(e=new n(e),t===void 0?t=n.rounding:oe(t,0,8),!r.d)return e.s?r:e;if(!e.d)return e.s&&(e.s=r.s),e}return e.d[0]?(_=!1,r=V(r,e,0,t,1).times(e),_=!0,k(r)):(e.s=r.s,r=e),r};R.toNumber=function(){return+this};R.toOctal=function(e,t){return _n(this,8,e,t)};R.toPower=R.pow=function(e){var t,r,n,i,o,s,a=this,l=a.constructor,d=+(e=new l(e));if(!a.d||!e.d||!a.d[0]||!e.d[0])return new l(K(+a,d));if(a=new l(a),a.eq(1))return a;if(n=l.precision,o=l.rounding,e.eq(1))return k(a,n,o);if(t=ee(e.e/D),t>=e.d.length-1&&(r=d<0?-d:d)<=$l)return i=wo(l,a,r,n),e.s<0?new l(1).div(i):k(i,n,o);if(s=a.s,s<0){if(tl.maxE+1||t0?s/0:0):(_=!1,l.rounding=a.s=1,r=Math.min(12,(t+"").length),i=Mn(e.times(ke(a,n+r)),n),i.d&&(i=k(i,n+5,1),Ot(i.d,n,o)&&(t=n+10,i=k(Mn(e.times(ke(a,t+r)),t),t+5,1),+Y(i.d).slice(n+1,n+15)+1==1e14&&(i=k(i,n+1,0)))),i.s=s,_=!0,l.rounding=o,k(i,n,o))};R.toPrecision=function(e,t){var r,n=this,i=n.constructor;return e===void 0?r=ye(n,n.e<=i.toExpNeg||n.e>=i.toExpPos):(oe(e,1,Me),t===void 0?t=i.rounding:oe(t,0,8),n=k(new i(n),e,t),r=ye(n,e<=n.e||n.e<=i.toExpNeg,e)),n.isNeg()&&!n.isZero()?"-"+r:r};R.toSignificantDigits=R.toSD=function(e,t){var r=this,n=r.constructor;return e===void 0?(e=n.precision,t=n.rounding):(oe(e,1,Me),t===void 0?t=n.rounding:oe(t,0,8)),k(new n(r),e,t)};R.toString=function(){var e=this,t=e.constructor,r=ye(e,e.e<=t.toExpNeg||e.e>=t.toExpPos);return e.isNeg()&&!e.isZero()?"-"+r:r};R.truncated=R.trunc=function(){return k(new this.constructor(this),this.e+1,1)};R.valueOf=R.toJSON=function(){var e=this,t=e.constructor,r=ye(e,e.e<=t.toExpNeg||e.e>=t.toExpPos);return e.isNeg()?"-"+r:r};function Y(e){var t,r,n,i=e.length-1,o="",s=e[0];if(i>0){for(o+=s,t=1;tr)throw Error(De+e)}function Ot(e,t,r,n){var i,o,s,a;for(o=e[0];o>=10;o/=10)--t;return--t<0?(t+=D,i=0):(i=Math.ceil((t+1)/D),t%=D),o=K(10,D-t),a=e[i]%o|0,n==null?t<3?(t==0?a=a/100|0:t==1&&(a=a/10|0),s=r<4&&a==99999||r>3&&a==49999||a==5e4||a==0):s=(r<4&&a+1==o||r>3&&a+1==o/2)&&(e[i+1]/o/100|0)==K(10,t-2)-1||(a==o/2||a==0)&&(e[i+1]/o/100|0)==0:t<4?(t==0?a=a/1e3|0:t==1?a=a/100|0:t==2&&(a=a/10|0),s=(n||r<4)&&a==9999||!n&&r>3&&a==4999):s=((n||r<4)&&a+1==o||!n&&r>3&&a+1==o/2)&&(e[i+1]/o/1e3|0)==K(10,t-3)-1,s}function br(e,t,r){for(var n,i=[0],o,s=0,a=e.length;sr-1&&(i[n+1]===void 0&&(i[n+1]=0),i[n+1]+=i[n]/r|0,i[n]%=r)}return i.reverse()}function Gl(e,t){var r,n,i;if(t.isZero())return t;n=t.d.length,n<32?(r=Math.ceil(n/3),i=(1/Cr(4,r)).toString()):(r=16,i="2.3283064365386962890625e-10"),e.precision+=r,t=tt(e,1,t.times(i),new e(1));for(var o=r;o--;){var s=t.times(t);t=s.times(s).minus(s).times(8).plus(1)}return e.precision-=r,t}var V=function(){function e(n,i,o){var s,a=0,l=n.length;for(n=n.slice();l--;)s=n[l]*i+a,n[l]=s%o|0,a=s/o|0;return a&&n.unshift(a),n}function t(n,i,o,s){var a,l;if(o!=s)l=o>s?1:-1;else for(a=l=0;ai[a]?1:-1;break}return l}function r(n,i,o,s){for(var a=0;o--;)n[o]-=a,a=n[o]1;)n.shift()}return function(n,i,o,s,a,l){var d,g,h,T,I,S,C,M,F,B,O,L,le,J,sn,or,Pt,an,ce,sr,ar=n.constructor,ln=n.s==i.s?1:-1,Z=n.d,$=i.d;if(!Z||!Z[0]||!$||!$[0])return new ar(!n.s||!i.s||(Z?$&&Z[0]==$[0]:!$)?NaN:Z&&Z[0]==0||!$?ln*0:ln/0);for(l?(I=1,g=n.e-i.e):(l=pe,I=D,g=ee(n.e/I)-ee(i.e/I)),ce=$.length,Pt=Z.length,F=new ar(ln),B=F.d=[],h=0;$[h]==(Z[h]||0);h++);if($[h]>(Z[h]||0)&&g--,o==null?(J=o=ar.precision,s=ar.rounding):a?J=o+(n.e-i.e)+1:J=o,J<0)B.push(1),S=!0;else{if(J=J/I+2|0,h=0,ce==1){for(T=0,$=$[0],J++;(h1&&($=e($,T,l),Z=e(Z,T,l),ce=$.length,Pt=Z.length),or=ce,O=Z.slice(0,ce),L=O.length;L=l/2&&++an;do T=0,d=t($,O,ce,L),d<0?(le=O[0],ce!=L&&(le=le*l+(O[1]||0)),T=le/an|0,T>1?(T>=l&&(T=l-1),C=e($,T,l),M=C.length,L=O.length,d=t(C,O,M,L),d==1&&(T--,r(C,ce=10;T/=10)h++;F.e=h+g*I-1,k(F,a?o+F.e+1:o,s,S)}return F}}();function k(e,t,r,n){var i,o,s,a,l,d,g,h,T,I=e.constructor;e:if(t!=null){if(h=e.d,!h)return e;for(i=1,a=h[0];a>=10;a/=10)i++;if(o=t-i,o<0)o+=D,s=t,g=h[T=0],l=g/K(10,i-s-1)%10|0;else if(T=Math.ceil((o+1)/D),a=h.length,T>=a)if(n){for(;a++<=T;)h.push(0);g=l=0,i=1,o%=D,s=o-D+1}else break e;else{for(g=a=h[T],i=1;a>=10;a/=10)i++;o%=D,s=o-D+i,l=s<0?0:g/K(10,i-s-1)%10|0}if(n=n||t<0||h[T+1]!==void 0||(s<0?g:g%K(10,i-s-1)),d=r<4?(l||n)&&(r==0||r==(e.s<0?3:2)):l>5||l==5&&(r==4||n||r==6&&(o>0?s>0?g/K(10,i-s):0:h[T-1])%10&1||r==(e.s<0?8:7)),t<1||!h[0])return h.length=0,d?(t-=e.e+1,h[0]=K(10,(D-t%D)%D),e.e=-t||0):h[0]=e.e=0,e;if(o==0?(h.length=T,a=1,T--):(h.length=T+1,a=K(10,D-o),h[T]=s>0?(g/K(10,i-s)%K(10,s)|0)*a:0),d)for(;;)if(T==0){for(o=1,s=h[0];s>=10;s/=10)o++;for(s=h[0]+=a,a=1;s>=10;s/=10)a++;o!=a&&(e.e++,h[0]==pe&&(h[0]=1));break}else{if(h[T]+=a,h[T]!=pe)break;h[T--]=0,a=1}for(o=h.length;h[--o]===0;)h.pop()}return _&&(e.e>I.maxE?(e.d=null,e.e=NaN):e.e0?o=o.charAt(0)+"."+o.slice(1)+Oe(n):s>1&&(o=o.charAt(0)+"."+o.slice(1)),o=o+(e.e<0?"e":"e+")+e.e):i<0?(o="0."+Oe(-i-1)+o,r&&(n=r-s)>0&&(o+=Oe(n))):i>=s?(o+=Oe(i+1-s),r&&(n=r-i-1)>0&&(o=o+"."+Oe(n))):((n=i+1)0&&(i+1===s&&(o+="."),o+=Oe(n))),o}function Rr(e,t){var r=e[0];for(t*=D;r>=10;r/=10)t++;return t}function Tr(e,t,r){if(t>jl)throw _=!0,r&&(e.precision=r),Error(mo);return k(new e(Pr),t,1,!0)}function he(e,t,r){if(t>Dn)throw Error(mo);return k(new e(vr),t,r,!0)}function yo(e){var t=e.length-1,r=t*D+1;if(t=e[t],t){for(;t%10==0;t/=10)r--;for(t=e[0];t>=10;t/=10)r++}return r}function Oe(e){for(var t="";e--;)t+="0";return t}function wo(e,t,r,n){var i,o=new e(1),s=Math.ceil(n/D+4);for(_=!1;;){if(r%2&&(o=o.times(t),uo(o.d,s)&&(i=!0)),r=ee(r/2),r===0){r=o.d.length-1,i&&o.d[r]===0&&++o.d[r];break}t=t.times(t),uo(t.d,s)}return _=!0,o}function lo(e){return e.d[e.d.length-1]&1}function Eo(e,t,r){for(var n,i,o=new e(t[0]),s=0;++s17)return new T(e.d?e.d[0]?e.s<0?0:1/0:1:e.s?e.s<0?0:e:NaN);for(t==null?(_=!1,l=S):l=t,a=new T(.03125);e.e>-2;)e=e.times(a),h+=5;for(n=Math.log(K(2,h))/Math.LN10*2+5|0,l+=n,r=o=s=new T(1),T.precision=l;;){if(o=k(o.times(e),l,1),r=r.times(++g),a=s.plus(V(o,r,l,1)),Y(a.d).slice(0,l)===Y(s.d).slice(0,l)){for(i=h;i--;)s=k(s.times(s),l,1);if(t==null)if(d<3&&Ot(s.d,l-n,I,d))T.precision=l+=10,r=o=a=new T(1),g=0,d++;else return k(s,T.precision=S,I,_=!0);else return T.precision=S,s}s=a}}function ke(e,t){var r,n,i,o,s,a,l,d,g,h,T,I=1,S=10,C=e,M=C.d,F=C.constructor,B=F.rounding,O=F.precision;if(C.s<0||!M||!M[0]||!C.e&&M[0]==1&&M.length==1)return new F(M&&!M[0]?-1/0:C.s!=1?NaN:M?0:C);if(t==null?(_=!1,g=O):g=t,F.precision=g+=S,r=Y(M),n=r.charAt(0),Math.abs(o=C.e)<15e14){for(;n<7&&n!=1||n==1&&r.charAt(1)>3;)C=C.times(e),r=Y(C.d),n=r.charAt(0),I++;o=C.e,n>1?(C=new F("0."+r),o++):C=new F(n+"."+r.slice(1))}else return d=Tr(F,g+2,O).times(o+""),C=ke(new F(n+"."+r.slice(1)),g-S).plus(d),F.precision=O,t==null?k(C,O,B,_=!0):C;for(h=C,l=s=C=V(C.minus(1),C.plus(1),g,1),T=k(C.times(C),g,1),i=3;;){if(s=k(s.times(T),g,1),d=l.plus(V(s,new F(i),g,1)),Y(d.d).slice(0,g)===Y(l.d).slice(0,g))if(l=l.times(2),o!==0&&(l=l.plus(Tr(F,g+2,O).times(o+""))),l=V(l,new F(I),g,1),t==null)if(Ot(l.d,g-S,B,a))F.precision=g+=S,d=s=C=V(h.minus(1),h.plus(1),g,1),T=k(C.times(C),g,1),i=a=1;else return k(l,F.precision=O,B,_=!0);else return F.precision=O,l;l=d,i+=2}}function bo(e){return String(e.s*e.s/0)}function xr(e,t){var r,n,i;for((r=t.indexOf("."))>-1&&(t=t.replace(".","")),(n=t.search(/e/i))>0?(r<0&&(r=n),r+=+t.slice(n+1),t=t.substring(0,n)):r<0&&(r=t.length),n=0;t.charCodeAt(n)===48;n++);for(i=t.length;t.charCodeAt(i-1)===48;--i);if(t=t.slice(n,i),t){if(i-=n,e.e=r=r-n-1,e.d=[],n=(r+1)%D,r<0&&(n+=D),ne.constructor.maxE?(e.d=null,e.e=NaN):e.e-1){if(t=t.replace(/(\d)_(?=\d)/g,"$1"),ho.test(t))return xr(e,t)}else if(t==="Infinity"||t==="NaN")return+t||(e.s=NaN),e.e=NaN,e.d=null,e;if(ql.test(t))r=16,t=t.toLowerCase();else if(Bl.test(t))r=2;else if(Vl.test(t))r=8;else throw Error(De+t);for(o=t.search(/p/i),o>0?(l=+t.slice(o+1),t=t.substring(2,o)):t=t.slice(2),o=t.indexOf("."),s=o>=0,n=e.constructor,s&&(t=t.replace(".",""),a=t.length,o=a-o,i=wo(n,new n(r),o,o*2)),d=br(t,r,pe),g=d.length-1,o=g;d[o]===0;--o)d.pop();return o<0?new n(e.s*0):(e.e=Rr(d,g),e.d=d,_=!1,s&&(e=V(e,i,a*4)),l&&(e=e.times(Math.abs(l)<54?K(2,l):Te.pow(2,l))),_=!0,e)}function Ql(e,t){var r,n=t.d.length;if(n<3)return t.isZero()?t:tt(e,2,t,t);r=1.4*Math.sqrt(n),r=r>16?16:r|0,t=t.times(1/Cr(5,r)),t=tt(e,2,t,t);for(var i,o=new e(5),s=new e(16),a=new e(20);r--;)i=t.times(t),t=t.times(o.plus(i.times(s.times(i).minus(a))));return t}function tt(e,t,r,n,i){var o,s,a,l,d=1,g=e.precision,h=Math.ceil(g/D);for(_=!1,l=r.times(r),a=new e(n);;){if(s=V(a.times(l),new e(t++*t++),g,1),a=i?n.plus(s):n.minus(s),n=V(s.times(l),new e(t++*t++),g,1),s=a.plus(n),s.d[h]!==void 0){for(o=h;s.d[o]===a.d[o]&&o--;);if(o==-1)break}o=a,a=n,n=s,s=o,d++}return _=!0,s.d.length=h+1,s}function Cr(e,t){for(var r=e;--t;)r*=e;return r}function xo(e,t){var r,n=t.s<0,i=he(e,e.precision,1),o=i.times(.5);if(t=t.abs(),t.lte(o))return ve=n?4:1,t;if(r=t.divToInt(i),r.isZero())ve=n?3:2;else{if(t=t.minus(r.times(i)),t.lte(o))return ve=lo(r)?n?2:3:n?4:1,t;ve=lo(r)?n?1:4:n?3:2}return t.minus(i).abs()}function _n(e,t,r,n){var i,o,s,a,l,d,g,h,T,I=e.constructor,S=r!==void 0;if(S?(oe(r,1,Me),n===void 0?n=I.rounding:oe(n,0,8)):(r=I.precision,n=I.rounding),!e.isFinite())g=bo(e);else{for(g=ye(e),s=g.indexOf("."),S?(i=2,t==16?r=r*4-3:t==8&&(r=r*3-2)):i=t,s>=0&&(g=g.replace(".",""),T=new I(1),T.e=g.length-s,T.d=br(ye(T),10,i),T.e=T.d.length),h=br(g,10,i),o=l=h.length;h[--l]==0;)h.pop();if(!h[0])g=S?"0p+0":"0";else{if(s<0?o--:(e=new I(e),e.d=h,e.e=o,e=V(e,T,r,n,0,i),h=e.d,o=e.e,d=po),s=h[r],a=i/2,d=d||h[r+1]!==void 0,d=n<4?(s!==void 0||d)&&(n===0||n===(e.s<0?3:2)):s>a||s===a&&(n===4||d||n===6&&h[r-1]&1||n===(e.s<0?8:7)),h.length=r,d)for(;++h[--r]>i-1;)h[r]=0,r||(++o,h.unshift(1));for(l=h.length;!h[l-1];--l);for(s=0,g="";s1)if(t==16||t==8){for(s=t==16?4:3,--l;l%s;l++)g+="0";for(h=br(g,i,t),l=h.length;!h[l-1];--l);for(s=1,g="1.";sl)for(o-=l;o--;)g+="0";else ot)return e.length=t,!0}function Kl(e){return new this(e).abs()}function Wl(e){return new this(e).acos()}function Hl(e){return new this(e).acosh()}function zl(e,t){return new this(e).plus(t)}function Yl(e){return new this(e).asin()}function Zl(e){return new this(e).asinh()}function Xl(e){return new this(e).atan()}function eu(e){return new this(e).atanh()}function tu(e,t){e=new this(e),t=new this(t);var r,n=this.precision,i=this.rounding,o=n+4;return!e.s||!t.s?r=new this(NaN):!e.d&&!t.d?(r=he(this,o,1).times(t.s>0?.25:.75),r.s=e.s):!t.d||e.isZero()?(r=t.s<0?he(this,n,i):new this(0),r.s=e.s):!e.d||t.isZero()?(r=he(this,o,1).times(.5),r.s=e.s):t.s<0?(this.precision=o,this.rounding=1,r=this.atan(V(e,t,o,1)),t=he(this,o,1),this.precision=n,this.rounding=i,r=e.s<0?r.minus(t):r.plus(t)):r=this.atan(V(e,t,o,1)),r}function ru(e){return new this(e).cbrt()}function nu(e){return k(e=new this(e),e.e+1,2)}function iu(e,t,r){return new this(e).clamp(t,r)}function ou(e){if(!e||typeof e!="object")throw Error(Ar+"Object expected");var t,r,n,i=e.defaults===!0,o=["precision",1,Me,"rounding",0,8,"toExpNeg",-et,0,"toExpPos",0,et,"maxE",0,et,"minE",-et,0,"modulo",0,9];for(t=0;t=o[t+1]&&n<=o[t+2])this[r]=n;else throw Error(De+r+": "+n);if(r="crypto",i&&(this[r]=kn[r]),(n=e[r])!==void 0)if(n===!0||n===!1||n===0||n===1)if(n)if(typeof crypto<"u"&&crypto&&(crypto.getRandomValues||crypto.randomBytes))this[r]=!0;else throw Error(fo);else this[r]=!1;else throw Error(De+r+": "+n);return this}function su(e){return new this(e).cos()}function au(e){return new this(e).cosh()}function Po(e){var t,r,n;function i(o){var s,a,l,d=this;if(!(d instanceof i))return new i(o);if(d.constructor=i,co(o)){d.s=o.s,_?!o.d||o.e>i.maxE?(d.e=NaN,d.d=null):o.e=10;a/=10)s++;_?s>i.maxE?(d.e=NaN,d.d=null):s=429e7?t[o]=crypto.getRandomValues(new Uint32Array(1))[0]:a[o++]=i%1e7;else if(crypto.randomBytes){for(t=crypto.randomBytes(n*=4);o=214e7?crypto.randomBytes(4).copy(t,o):(a.push(i%1e7),o+=4);o=n/4}else throw Error(fo);else for(;o=10;i/=10)n++;nkt,datamodelEnumToSchemaEnum:()=>Du});f();u();c();p();m();f();u();c();p();m();function Du(e){return{name:e.name,values:e.values.map(t=>t.name)}}f();u();c();p();m();var kt=(O=>(O.findUnique="findUnique",O.findUniqueOrThrow="findUniqueOrThrow",O.findFirst="findFirst",O.findFirstOrThrow="findFirstOrThrow",O.findMany="findMany",O.create="create",O.createMany="createMany",O.createManyAndReturn="createManyAndReturn",O.update="update",O.updateMany="updateMany",O.updateManyAndReturn="updateManyAndReturn",O.upsert="upsert",O.delete="delete",O.deleteMany="deleteMany",O.groupBy="groupBy",O.count="count",O.aggregate="aggregate",O.findRaw="findRaw",O.aggregateRaw="aggregateRaw",O))(kt||{});var Mu=Qe(ro());var _u={red:Ye,gray:$i,dim:mr,bold:pr,underline:Li,highlightSource:e=>e.highlight()},Nu={red:e=>e,gray:e=>e,dim:e=>e,bold:e=>e,underline:e=>e,highlightSource:e=>e};function Fu({message:e,originalMethod:t,isPanic:r,callArguments:n}){return{functionName:`prisma.${t}()`,message:e,isPanic:r??!1,callArguments:n}}function Lu({functionName:e,location:t,message:r,isPanic:n,contextLines:i,callArguments:o},s){let a=[""],l=t?" in":":";if(n?(a.push(s.red(`Oops, an unknown error occurred! This is ${s.bold("on us")}, you did nothing wrong.`)),a.push(s.red(`It occurred in the ${s.bold(`\`${e}\``)} invocation${l}`))):a.push(s.red(`Invalid ${s.bold(`\`${e}\``)} invocation${l}`)),t&&a.push(s.underline(Uu(t))),i){a.push("");let d=[i.toString()];o&&(d.push(o),d.push(s.dim(")"))),a.push(d.join("")),o&&a.push("")}else a.push(""),o&&a.push(o),a.push("");return a.push(r),a.join(` -`)}function Uu(e){let t=[e.fileName];return e.lineNumber&&t.push(String(e.lineNumber)),e.columnNumber&&t.push(String(e.columnNumber)),t.join(":")}function Sr(e){let t=e.showColors?_u:Nu,r;return typeof $getTemplateParameters<"u"?r=$getTemplateParameters(e,t):r=Fu(e),Lu(r,t)}f();u();c();p();m();var ko=Qe(Nn());f();u();c();p();m();function Ro(e,t,r){let n=Co(e),i=Bu(n),o=Vu(i);o?Ir(o,t,r):t.addErrorMessage(()=>"Unknown error")}function Co(e){return e.errors.flatMap(t=>t.kind==="Union"?Co(t):[t])}function Bu(e){let t=new Map,r=[];for(let n of e){if(n.kind!=="InvalidArgumentType"){r.push(n);continue}let i=`${n.selectionPath.join(".")}:${n.argumentPath.join(".")}`,o=t.get(i);o?t.set(i,{...n,argument:{...n.argument,typeNames:qu(o.argument.typeNames,n.argument.typeNames)}}):t.set(i,n)}return r.push(...t.values()),r}function qu(e,t){return[...new Set(e.concat(t))]}function Vu(e){return Sn(e,(t,r)=>{let n=To(t),i=To(r);return n!==i?n-i:Ao(t)-Ao(r)})}function To(e){let t=0;return Array.isArray(e.selectionPath)&&(t+=e.selectionPath.length),Array.isArray(e.argumentPath)&&(t+=e.argumentPath.length),t}function Ao(e){switch(e.kind){case"InvalidArgumentValue":case"ValueTooLarge":return 20;case"InvalidArgumentType":return 10;case"RequiredArgumentMissing":return-10;default:return 0}}f();u();c();p();m();var ue=class{constructor(t,r){this.name=t;this.value=r}isRequired=!1;makeRequired(){return this.isRequired=!0,this}write(t){let{colors:{green:r}}=t.context;t.addMarginSymbol(r(this.isRequired?"+":"?")),t.write(r(this.name)),this.isRequired||t.write(r("?")),t.write(r(": ")),typeof this.value=="string"?t.write(r(this.value)):t.write(this.value)}};f();u();c();p();m();f();u();c();p();m();Io();f();u();c();p();m();var nt=class{constructor(t=0,r){this.context=r;this.currentIndent=t}lines=[];currentLine="";currentIndent=0;marginSymbol;afterNextNewLineCallback;write(t){return typeof t=="string"?this.currentLine+=t:t.write(this),this}writeJoined(t,r,n=(i,o)=>o.write(i)){let i=r.length-1;for(let o=0;o0&&this.currentIndent--,this}addMarginSymbol(t){return this.marginSymbol=t,this}toString(){return this.lines.concat(this.indentedCurrentLine()).join(` -`)}getCurrentLineLength(){return this.currentLine.length}indentedCurrentLine(){let t=this.currentLine.padStart(this.currentLine.length+2*this.currentIndent);return this.marginSymbol?this.marginSymbol+t.slice(1):t}};So();f();u();c();p();m();f();u();c();p();m();var Or=class{constructor(t){this.value=t}write(t){t.write(this.value)}markAsError(){this.value.markAsError()}};f();u();c();p();m();var kr=e=>e,Dr={bold:kr,red:kr,green:kr,dim:kr,enabled:!1},Oo={bold:pr,red:Ye,green:Ui,dim:mr,enabled:!0},it={write(e){e.writeLine(",")}};f();u();c();p();m();var we=class{constructor(t){this.contents=t}isUnderlined=!1;color=t=>t;underline(){return this.isUnderlined=!0,this}setColor(t){return this.color=t,this}write(t){let r=t.getCurrentLineLength();t.write(this.color(this.contents)),this.isUnderlined&&t.afterNextNewline(()=>{t.write(" ".repeat(r)).writeLine(this.color("~".repeat(this.contents.length)))})}};f();u();c();p();m();var _e=class{hasError=!1;markAsError(){return this.hasError=!0,this}};var ot=class extends _e{items=[];addItem(t){return this.items.push(new Or(t)),this}getField(t){return this.items[t]}getPrintWidth(){return this.items.length===0?2:Math.max(...this.items.map(r=>r.value.getPrintWidth()))+2}write(t){if(this.items.length===0){this.writeEmpty(t);return}this.writeWithItems(t)}writeEmpty(t){let r=new we("[]");this.hasError&&r.setColor(t.context.colors.red).underline(),t.write(r)}writeWithItems(t){let{colors:r}=t.context;t.writeLine("[").withIndent(()=>t.writeJoined(it,this.items).newLine()).write("]"),this.hasError&&t.afterNextNewline(()=>{t.writeLine(r.red("~".repeat(this.getPrintWidth())))})}asObject(){}};var st=class e extends _e{fields={};suggestions=[];addField(t){this.fields[t.name]=t}addSuggestion(t){this.suggestions.push(t)}getField(t){return this.fields[t]}getDeepField(t){let[r,...n]=t,i=this.getField(r);if(!i)return;let o=i;for(let s of n){let a;if(o.value instanceof e?a=o.value.getField(s):o.value instanceof ot&&(a=o.value.getField(Number(s))),!a)return;o=a}return o}getDeepFieldValue(t){return t.length===0?this:this.getDeepField(t)?.value}hasField(t){return!!this.getField(t)}removeAllFields(){this.fields={}}removeField(t){delete this.fields[t]}getFields(){return this.fields}isEmpty(){return Object.keys(this.fields).length===0}getFieldValue(t){return this.getField(t)?.value}getDeepSubSelectionValue(t){let r=this;for(let n of t){if(!(r instanceof e))return;let i=r.getSubSelectionValue(n);if(!i)return;r=i}return r}getDeepSelectionParent(t){let r=this.getSelectionParent();if(!r)return;let n=r;for(let i of t){let o=n.value.getFieldValue(i);if(!o||!(o instanceof e))return;let s=o.getSelectionParent();if(!s)return;n=s}return n}getSelectionParent(){let t=this.getField("select")?.value.asObject();if(t)return{kind:"select",value:t};let r=this.getField("include")?.value.asObject();if(r)return{kind:"include",value:r}}getSubSelectionValue(t){return this.getSelectionParent()?.value.fields[t].value}getPrintWidth(){let t=Object.values(this.fields);return t.length==0?2:Math.max(...t.map(n=>n.getPrintWidth()))+2}write(t){let r=Object.values(this.fields);if(r.length===0&&this.suggestions.length===0){this.writeEmpty(t);return}this.writeWithContents(t,r)}asObject(){return this}writeEmpty(t){let r=new we("{}");this.hasError&&r.setColor(t.context.colors.red).underline(),t.write(r)}writeWithContents(t,r){t.writeLine("{").withIndent(()=>{t.writeJoined(it,[...r,...this.suggestions]).newLine()}),t.write("}"),this.hasError&&t.afterNextNewline(()=>{t.writeLine(t.context.colors.red("~".repeat(this.getPrintWidth())))})}};f();u();c();p();m();var H=class extends _e{constructor(r){super();this.text=r}getPrintWidth(){return this.text.length}write(r){let n=new we(this.text);this.hasError&&n.underline().setColor(r.context.colors.red),r.write(n)}asObject(){}};f();u();c();p();m();var Mt=class{fields=[];addField(t,r){return this.fields.push({write(n){let{green:i,dim:o}=n.context.colors;n.write(i(o(`${t}: ${r}`))).addMarginSymbol(i(o("+")))}}),this}write(t){let{colors:{green:r}}=t.context;t.writeLine(r("{")).withIndent(()=>{t.writeJoined(it,this.fields).newLine()}).write(r("}")).addMarginSymbol(r("+"))}};function Ir(e,t,r){switch(e.kind){case"MutuallyExclusiveFields":$u(e,t);break;case"IncludeOnScalar":ju(e,t);break;case"EmptySelection":Gu(e,t,r);break;case"UnknownSelectionField":Wu(e,t);break;case"InvalidSelectionValue":Hu(e,t);break;case"UnknownArgument":zu(e,t);break;case"UnknownInputField":Yu(e,t);break;case"RequiredArgumentMissing":Zu(e,t);break;case"InvalidArgumentType":Xu(e,t);break;case"InvalidArgumentValue":ec(e,t);break;case"ValueTooLarge":tc(e,t);break;case"SomeFieldsMissing":rc(e,t);break;case"TooManyFieldsGiven":nc(e,t);break;case"Union":Ro(e,t,r);break;default:throw new Error("not implemented: "+e.kind)}}function $u(e,t){let r=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();r&&(r.getField(e.firstField)?.markAsError(),r.getField(e.secondField)?.markAsError()),t.addErrorMessage(n=>`Please ${n.bold("either")} use ${n.green(`\`${e.firstField}\``)} or ${n.green(`\`${e.secondField}\``)}, but ${n.red("not both")} at the same time.`)}function ju(e,t){let[r,n]=at(e.selectionPath),i=e.outputType,o=t.arguments.getDeepSelectionParent(r)?.value;if(o&&(o.getField(n)?.markAsError(),i))for(let s of i.fields)s.isRelation&&o.addSuggestion(new ue(s.name,"true"));t.addErrorMessage(s=>{let a=`Invalid scalar field ${s.red(`\`${n}\``)} for ${s.bold("include")} statement`;return i?a+=` on model ${s.bold(i.name)}. ${_t(s)}`:a+=".",a+=` -Note that ${s.bold("include")} statements only accept relation fields.`,a})}function Gu(e,t,r){let n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(n){let i=n.getField("omit")?.value.asObject();if(i){Ju(e,t,i);return}if(n.hasField("select")){Qu(e,t);return}}if(r?.[Ie(e.outputType.name)]){Ku(e,t);return}t.addErrorMessage(()=>`Unknown field at "${e.selectionPath.join(".")} selection"`)}function Ju(e,t,r){r.removeAllFields();for(let n of e.outputType.fields)r.addSuggestion(new ue(n.name,"false"));t.addErrorMessage(n=>`The ${n.red("omit")} statement includes every field of the model ${n.bold(e.outputType.name)}. At least one field must be included in the result`)}function Qu(e,t){let r=e.outputType,n=t.arguments.getDeepSelectionParent(e.selectionPath)?.value,i=n?.isEmpty()??!1;n&&(n.removeAllFields(),_o(n,r)),t.addErrorMessage(o=>i?`The ${o.red("`select`")} statement for type ${o.bold(r.name)} must not be empty. ${_t(o)}`:`The ${o.red("`select`")} statement for type ${o.bold(r.name)} needs ${o.bold("at least one truthy value")}.`)}function Ku(e,t){let r=new Mt;for(let i of e.outputType.fields)i.isRelation||r.addField(i.name,"false");let n=new ue("omit",r).makeRequired();if(e.selectionPath.length===0)t.arguments.addSuggestion(n);else{let[i,o]=at(e.selectionPath),a=t.arguments.getDeepSelectionParent(i)?.value.asObject()?.getField(o);if(a){let l=a?.value.asObject()??new st;l.addSuggestion(n),a.value=l}}t.addErrorMessage(i=>`The global ${i.red("omit")} configuration excludes every field of the model ${i.bold(e.outputType.name)}. At least one field must be included in the result`)}function Wu(e,t){let r=No(e.selectionPath,t);if(r.parentKind!=="unknown"){r.field.markAsError();let n=r.parent;switch(r.parentKind){case"select":_o(n,e.outputType);break;case"include":ic(n,e.outputType);break;case"omit":oc(n,e.outputType);break}}t.addErrorMessage(n=>{let i=[`Unknown field ${n.red(`\`${r.fieldName}\``)}`];return r.parentKind!=="unknown"&&i.push(`for ${n.bold(r.parentKind)} statement`),i.push(`on model ${n.bold(`\`${e.outputType.name}\``)}.`),i.push(_t(n)),i.join(" ")})}function Hu(e,t){let r=No(e.selectionPath,t);r.parentKind!=="unknown"&&r.field.value.markAsError(),t.addErrorMessage(n=>`Invalid value for selection field \`${n.red(r.fieldName)}\`: ${e.underlyingError}`)}function zu(e,t){let r=e.argumentPath[0],n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();n&&(n.getField(r)?.markAsError(),sc(n,e.arguments)),t.addErrorMessage(i=>Do(i,r,e.arguments.map(o=>o.name)))}function Yu(e,t){let[r,n]=at(e.argumentPath),i=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(i){i.getDeepField(e.argumentPath)?.markAsError();let o=i.getDeepFieldValue(r)?.asObject();o&&Fo(o,e.inputType)}t.addErrorMessage(o=>Do(o,n,e.inputType.fields.map(s=>s.name)))}function Do(e,t,r){let n=[`Unknown argument \`${e.red(t)}\`.`],i=lc(t,r);return i&&n.push(`Did you mean \`${e.green(i)}\`?`),r.length>0&&n.push(_t(e)),n.join(" ")}function Zu(e,t){let r;t.addErrorMessage(l=>r?.value instanceof H&&r.value.text==="null"?`Argument \`${l.green(o)}\` must not be ${l.red("null")}.`:`Argument \`${l.green(o)}\` is missing.`);let n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(!n)return;let[i,o]=at(e.argumentPath),s=new Mt,a=n.getDeepFieldValue(i)?.asObject();if(a){if(r=a.getField(o),r&&a.removeField(o),e.inputTypes.length===1&&e.inputTypes[0].kind==="object"){for(let l of e.inputTypes[0].fields)s.addField(l.name,l.typeNames.join(" | "));a.addSuggestion(new ue(o,s).makeRequired())}else{let l=e.inputTypes.map(Mo).join(" | ");a.addSuggestion(new ue(o,l).makeRequired())}if(e.dependentArgumentPath){n.getDeepField(e.dependentArgumentPath)?.markAsError();let[,l]=at(e.dependentArgumentPath);t.addErrorMessage(d=>`Argument \`${d.green(o)}\` is required because argument \`${d.green(l)}\` was provided.`)}}}function Mo(e){return e.kind==="list"?`${Mo(e.elementType)}[]`:e.name}function Xu(e,t){let r=e.argument.name,n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();n&&n.getDeepFieldValue(e.argumentPath)?.markAsError(),t.addErrorMessage(i=>{let o=Mr("or",e.argument.typeNames.map(s=>i.green(s)));return`Argument \`${i.bold(r)}\`: Invalid value provided. Expected ${o}, provided ${i.red(e.inferredType)}.`})}function ec(e,t){let r=e.argument.name,n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();n&&n.getDeepFieldValue(e.argumentPath)?.markAsError(),t.addErrorMessage(i=>{let o=[`Invalid value for argument \`${i.bold(r)}\``];if(e.underlyingError&&o.push(`: ${e.underlyingError}`),o.push("."),e.argument.typeNames.length>0){let s=Mr("or",e.argument.typeNames.map(a=>i.green(a)));o.push(` Expected ${s}.`)}return o.join("")})}function tc(e,t){let r=e.argument.name,n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject(),i;if(n){let s=n.getDeepField(e.argumentPath)?.value;s?.markAsError(),s instanceof H&&(i=s.text)}t.addErrorMessage(o=>{let s=["Unable to fit value"];return i&&s.push(o.red(i)),s.push(`into a 64-bit signed integer for field \`${o.bold(r)}\``),s.join(" ")})}function rc(e,t){let r=e.argumentPath[e.argumentPath.length-1],n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(n){let i=n.getDeepFieldValue(e.argumentPath)?.asObject();i&&Fo(i,e.inputType)}t.addErrorMessage(i=>{let o=[`Argument \`${i.bold(r)}\` of type ${i.bold(e.inputType.name)} needs`];return e.constraints.minFieldCount===1?e.constraints.requiredFields?o.push(`${i.green("at least one of")} ${Mr("or",e.constraints.requiredFields.map(s=>`\`${i.bold(s)}\``))} arguments.`):o.push(`${i.green("at least one")} argument.`):o.push(`${i.green(`at least ${e.constraints.minFieldCount}`)} arguments.`),o.push(_t(i)),o.join(" ")})}function nc(e,t){let r=e.argumentPath[e.argumentPath.length-1],n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject(),i=[];if(n){let o=n.getDeepFieldValue(e.argumentPath)?.asObject();o&&(o.markAsError(),i=Object.keys(o.getFields()))}t.addErrorMessage(o=>{let s=[`Argument \`${o.bold(r)}\` of type ${o.bold(e.inputType.name)} needs`];return e.constraints.minFieldCount===1&&e.constraints.maxFieldCount==1?s.push(`${o.green("exactly one")} argument,`):e.constraints.maxFieldCount==1?s.push(`${o.green("at most one")} argument,`):s.push(`${o.green(`at most ${e.constraints.maxFieldCount}`)} arguments,`),s.push(`but you provided ${Mr("and",i.map(a=>o.red(a)))}. Please choose`),e.constraints.maxFieldCount===1?s.push("one."):s.push(`${e.constraints.maxFieldCount}.`),s.join(" ")})}function _o(e,t){for(let r of t.fields)e.hasField(r.name)||e.addSuggestion(new ue(r.name,"true"))}function ic(e,t){for(let r of t.fields)r.isRelation&&!e.hasField(r.name)&&e.addSuggestion(new ue(r.name,"true"))}function oc(e,t){for(let r of t.fields)!e.hasField(r.name)&&!r.isRelation&&e.addSuggestion(new ue(r.name,"true"))}function sc(e,t){for(let r of t)e.hasField(r.name)||e.addSuggestion(new ue(r.name,r.typeNames.join(" | ")))}function No(e,t){let[r,n]=at(e),i=t.arguments.getDeepSubSelectionValue(r)?.asObject();if(!i)return{parentKind:"unknown",fieldName:n};let o=i.getFieldValue("select")?.asObject(),s=i.getFieldValue("include")?.asObject(),a=i.getFieldValue("omit")?.asObject(),l=o?.getField(n);return o&&l?{parentKind:"select",parent:o,field:l,fieldName:n}:(l=s?.getField(n),s&&l?{parentKind:"include",field:l,parent:s,fieldName:n}:(l=a?.getField(n),a&&l?{parentKind:"omit",field:l,parent:a,fieldName:n}:{parentKind:"unknown",fieldName:n}))}function Fo(e,t){if(t.kind==="object")for(let r of t.fields)e.hasField(r.name)||e.addSuggestion(new ue(r.name,r.typeNames.join(" | ")))}function at(e){let t=[...e],r=t.pop();if(!r)throw new Error("unexpected empty path");return[t,r]}function _t({green:e,enabled:t}){return"Available options are "+(t?`listed in ${e("green")}`:"marked with ?")+"."}function Mr(e,t){if(t.length===1)return t[0];let r=[...t],n=r.pop();return`${r.join(", ")} ${e} ${n}`}var ac=3;function lc(e,t){let r=1/0,n;for(let i of t){let o=(0,ko.default)(e,i);o>ac||o`}};function lt(e){return e instanceof Nt}f();u();c();p();m();var _r=Symbol(),Ln=new WeakMap,Re=class{constructor(t){t===_r?Ln.set(this,`Prisma.${this._getName()}`):Ln.set(this,`new Prisma.${this._getNamespace()}.${this._getName()}()`)}_getName(){return this.constructor.name}toString(){return Ln.get(this)}},Ft=class extends Re{_getNamespace(){return"NullTypes"}},Lt=class extends Ft{#e};Un(Lt,"DbNull");var Ut=class extends Ft{#e};Un(Ut,"JsonNull");var Bt=class extends Ft{#e};Un(Bt,"AnyNull");var Nr={classes:{DbNull:Lt,JsonNull:Ut,AnyNull:Bt},instances:{DbNull:new Lt(_r),JsonNull:new Ut(_r),AnyNull:new Bt(_r)}};function Un(e,t){Object.defineProperty(e,"name",{value:t,configurable:!0})}f();u();c();p();m();var Lo=": ",Fr=class{constructor(t,r){this.name=t;this.value=r}hasError=!1;markAsError(){this.hasError=!0}getPrintWidth(){return this.name.length+this.value.getPrintWidth()+Lo.length}write(t){let r=new we(this.name);this.hasError&&r.underline().setColor(t.context.colors.red),t.write(r).write(Lo).write(this.value)}};var Bn=class{arguments;errorMessages=[];constructor(t){this.arguments=t}write(t){t.write(this.arguments)}addErrorMessage(t){this.errorMessages.push(t)}renderAllMessages(t){return this.errorMessages.map(r=>r(t)).join(` -`)}};function ut(e){return new Bn(Uo(e))}function Uo(e){let t=new st;for(let[r,n]of Object.entries(e)){let i=new Fr(r,Bo(n));t.addField(i)}return t}function Bo(e){if(typeof e=="string")return new H(JSON.stringify(e));if(typeof e=="number"||typeof e=="boolean")return new H(String(e));if(typeof e=="bigint")return new H(`${e}n`);if(e===null)return new H("null");if(e===void 0)return new H("undefined");if(rt(e))return new H(`new Prisma.Decimal("${e.toFixed()}")`);if(e instanceof Uint8Array)return w.Buffer.isBuffer(e)?new H(`Buffer.alloc(${e.byteLength})`):new H(`new Uint8Array(${e.byteLength})`);if(e instanceof Date){let t=Er(e)?e.toISOString():"Invalid Date";return new H(`new Date("${t}")`)}return e instanceof Re?new H(`Prisma.${e._getName()}`):lt(e)?new H(`prisma.${Ie(e.modelName)}.$fields.${e.name}`):Array.isArray(e)?uc(e):typeof e=="object"?Uo(e):new H(Object.prototype.toString.call(e))}function uc(e){let t=new ot;for(let r of e)t.addItem(Bo(r));return t}function Lr(e,t){let r=t==="pretty"?Oo:Dr,n=e.renderAllMessages(r),i=new nt(0,{colors:r}).write(e).toString();return{message:n,args:i}}function Ur({args:e,errors:t,errorFormat:r,callsite:n,originalMethod:i,clientVersion:o,globalOmit:s}){let a=ut(e);for(let h of t)Ir(h,a,s);let{message:l,args:d}=Lr(a,r),g=Sr({message:l,callsite:n,originalMethod:i,showColors:r==="pretty",callArguments:d});throw new X(g,{clientVersion:o})}f();u();c();p();m();f();u();c();p();m();function Ee(e){return e.replace(/^./,t=>t.toLowerCase())}f();u();c();p();m();function Vo(e,t,r){let n=Ee(r);return!t.result||!(t.result.$allModels||t.result[n])?e:cc({...e,...qo(t.name,e,t.result.$allModels),...qo(t.name,e,t.result[n])})}function cc(e){let t=new ge,r=(n,i)=>t.getOrCreate(n,()=>i.has(n)?[n]:(i.add(n),e[n]?e[n].needs.flatMap(o=>r(o,i)):[n]));return wr(e,n=>({...n,needs:r(n.name,new Set)}))}function qo(e,t,r){return r?wr(r,({needs:n,compute:i},o)=>({name:o,needs:n?Object.keys(n).filter(s=>n[s]):[],compute:pc(t,o,i)})):{}}function pc(e,t,r){let n=e?.[t]?.compute;return n?i=>r({...i,[t]:n(i)}):r}function $o(e,t){if(!t)return e;let r={...e};for(let n of Object.values(t))if(e[n.name])for(let i of n.needs)r[i]=!0;return r}function jo(e,t){if(!t)return e;let r={...e};for(let n of Object.values(t))if(!e[n.name])for(let i of n.needs)delete r[i];return r}var Br=class{constructor(t,r){this.extension=t;this.previous=r}computedFieldsCache=new ge;modelExtensionsCache=new ge;queryCallbacksCache=new ge;clientExtensions=It(()=>this.extension.client?{...this.previous?.getAllClientExtensions(),...this.extension.client}:this.previous?.getAllClientExtensions());batchCallbacks=It(()=>{let t=this.previous?.getAllBatchQueryCallbacks()??[],r=this.extension.query?.$__internalBatch;return r?t.concat(r):t});getAllComputedFields(t){return this.computedFieldsCache.getOrCreate(t,()=>Vo(this.previous?.getAllComputedFields(t),this.extension,t))}getAllClientExtensions(){return this.clientExtensions.get()}getAllModelExtensions(t){return this.modelExtensionsCache.getOrCreate(t,()=>{let r=Ee(t);return!this.extension.model||!(this.extension.model[r]||this.extension.model.$allModels)?this.previous?.getAllModelExtensions(t):{...this.previous?.getAllModelExtensions(t),...this.extension.model.$allModels,...this.extension.model[r]}})}getAllQueryCallbacks(t,r){return this.queryCallbacksCache.getOrCreate(`${t}:${r}`,()=>{let n=this.previous?.getAllQueryCallbacks(t,r)??[],i=[],o=this.extension.query;return!o||!(o[t]||o.$allModels||o[r]||o.$allOperations)?n:(o[t]!==void 0&&(o[t][r]!==void 0&&i.push(o[t][r]),o[t].$allOperations!==void 0&&i.push(o[t].$allOperations)),t!=="$none"&&o.$allModels!==void 0&&(o.$allModels[r]!==void 0&&i.push(o.$allModels[r]),o.$allModels.$allOperations!==void 0&&i.push(o.$allModels.$allOperations)),o[r]!==void 0&&i.push(o[r]),o.$allOperations!==void 0&&i.push(o.$allOperations),n.concat(i))})}getAllBatchQueryCallbacks(){return this.batchCallbacks.get()}},ct=class e{constructor(t){this.head=t}static empty(){return new e}static single(t){return new e(new Br(t))}isEmpty(){return this.head===void 0}append(t){return new e(new Br(t,this.head))}getAllComputedFields(t){return this.head?.getAllComputedFields(t)}getAllClientExtensions(){return this.head?.getAllClientExtensions()}getAllModelExtensions(t){return this.head?.getAllModelExtensions(t)}getAllQueryCallbacks(t,r){return this.head?.getAllQueryCallbacks(t,r)??[]}getAllBatchQueryCallbacks(){return this.head?.getAllBatchQueryCallbacks()??[]}};f();u();c();p();m();var qr=class{constructor(t){this.name=t}};function Go(e){return e instanceof qr}function Jo(e){return new qr(e)}f();u();c();p();m();f();u();c();p();m();var Qo=Symbol(),qt=class{constructor(t){if(t!==Qo)throw new Error("Skip instance can not be constructed directly")}ifUndefined(t){return t===void 0?Vr:t}},Vr=new qt(Qo);function be(e){return e instanceof qt}var mc={findUnique:"findUnique",findUniqueOrThrow:"findUniqueOrThrow",findFirst:"findFirst",findFirstOrThrow:"findFirstOrThrow",findMany:"findMany",count:"aggregate",create:"createOne",createMany:"createMany",createManyAndReturn:"createManyAndReturn",update:"updateOne",updateMany:"updateMany",updateManyAndReturn:"updateManyAndReturn",upsert:"upsertOne",delete:"deleteOne",deleteMany:"deleteMany",executeRaw:"executeRaw",queryRaw:"queryRaw",aggregate:"aggregate",groupBy:"groupBy",runCommandRaw:"runCommandRaw",findRaw:"findRaw",aggregateRaw:"aggregateRaw"},Ko="explicitly `undefined` values are not allowed";function $r({modelName:e,action:t,args:r,runtimeDataModel:n,extensions:i=ct.empty(),callsite:o,clientMethod:s,errorFormat:a,clientVersion:l,previewFeatures:d,globalOmit:g}){let h=new qn({runtimeDataModel:n,modelName:e,action:t,rootArgs:r,callsite:o,extensions:i,selectionPath:[],argumentPath:[],originalMethod:s,errorFormat:a,clientVersion:l,previewFeatures:d,globalOmit:g});return{modelName:e,action:mc[t],query:Vt(r,h)}}function Vt({select:e,include:t,...r}={},n){let i=r.omit;return delete r.omit,{arguments:Ho(r,n),selection:fc(e,t,i,n)}}function fc(e,t,r,n){return e?(t?n.throwValidationError({kind:"MutuallyExclusiveFields",firstField:"include",secondField:"select",selectionPath:n.getSelectionPath()}):r&&n.throwValidationError({kind:"MutuallyExclusiveFields",firstField:"omit",secondField:"select",selectionPath:n.getSelectionPath()}),yc(e,n)):dc(n,t,r)}function dc(e,t,r){let n={};return e.modelOrType&&!e.isRawAction()&&(n.$composites=!0,n.$scalars=!0),t&&gc(n,t,e),hc(n,r,e),n}function gc(e,t,r){for(let[n,i]of Object.entries(t)){if(be(i))continue;let o=r.nestSelection(n);if(Vn(i,o),i===!1||i===void 0){e[n]=!1;continue}let s=r.findField(n);if(s&&s.kind!=="object"&&r.throwValidationError({kind:"IncludeOnScalar",selectionPath:r.getSelectionPath().concat(n),outputType:r.getOutputTypeDescription()}),s){e[n]=Vt(i===!0?{}:i,o);continue}if(i===!0){e[n]=!0;continue}e[n]=Vt(i,o)}}function hc(e,t,r){let n=r.getComputedFields(),i={...r.getGlobalOmit(),...t},o=jo(i,n);for(let[s,a]of Object.entries(o)){if(be(a))continue;Vn(a,r.nestSelection(s));let l=r.findField(s);n?.[s]&&!l||(e[s]=!a)}}function yc(e,t){let r={},n=t.getComputedFields(),i=$o(e,n);for(let[o,s]of Object.entries(i)){if(be(s))continue;let a=t.nestSelection(o);Vn(s,a);let l=t.findField(o);if(!(n?.[o]&&!l)){if(s===!1||s===void 0||be(s)){r[o]=!1;continue}if(s===!0){l?.kind==="object"?r[o]=Vt({},a):r[o]=!0;continue}r[o]=Vt(s,a)}}return r}function Wo(e,t){if(e===null)return null;if(typeof e=="string"||typeof e=="number"||typeof e=="boolean")return e;if(typeof e=="bigint")return{$type:"BigInt",value:String(e)};if(Xe(e)){if(Er(e))return{$type:"DateTime",value:e.toISOString()};t.throwValidationError({kind:"InvalidArgumentValue",selectionPath:t.getSelectionPath(),argumentPath:t.getArgumentPath(),argument:{name:t.getArgumentName(),typeNames:["Date"]},underlyingError:"Provided Date object is invalid"})}if(Go(e))return{$type:"Param",value:e.name};if(lt(e))return{$type:"FieldRef",value:{_ref:e.name,_container:e.modelName}};if(Array.isArray(e))return wc(e,t);if(ArrayBuffer.isView(e)){let{buffer:r,byteOffset:n,byteLength:i}=e;return{$type:"Bytes",value:w.Buffer.from(r,n,i).toString("base64")}}if(Ec(e))return e.values;if(rt(e))return{$type:"Decimal",value:e.toFixed()};if(e instanceof Re){if(e!==Nr.instances[e._getName()])throw new Error("Invalid ObjectEnumValue");return{$type:"Enum",value:e._getName()}}if(bc(e))return e.toJSON();if(typeof e=="object")return Ho(e,t);t.throwValidationError({kind:"InvalidArgumentValue",selectionPath:t.getSelectionPath(),argumentPath:t.getArgumentPath(),argument:{name:t.getArgumentName(),typeNames:[]},underlyingError:`We could not serialize ${Object.prototype.toString.call(e)} value. Serialize the object to JSON or implement a ".toJSON()" method on it`})}function Ho(e,t){if(e.$type)return{$type:"Raw",value:e};let r={};for(let n in e){let i=e[n],o=t.nestArgument(n);be(i)||(i!==void 0?r[n]=Wo(i,o):t.isPreviewFeatureOn("strictUndefinedChecks")&&t.throwValidationError({kind:"InvalidArgumentValue",argumentPath:o.getArgumentPath(),selectionPath:t.getSelectionPath(),argument:{name:t.getArgumentName(),typeNames:[]},underlyingError:Ko}))}return r}function wc(e,t){let r=[];for(let n=0;n({name:t.name,typeName:"boolean",isRelation:t.kind==="object"}))}}isRawAction(){return["executeRaw","queryRaw","runCommandRaw","findRaw","aggregateRaw"].includes(this.params.action)}isPreviewFeatureOn(t){return this.params.previewFeatures.includes(t)}getComputedFields(){if(this.params.modelName)return this.params.extensions.getAllComputedFields(this.params.modelName)}findField(t){return this.modelOrType?.fields.find(r=>r.name===t)}nestSelection(t){let r=this.findField(t),n=r?.kind==="object"?r.type:void 0;return new e({...this.params,modelName:n,selectionPath:this.params.selectionPath.concat(t)})}getGlobalOmit(){return this.params.modelName&&this.shouldApplyGlobalOmit()?this.params.globalOmit?.[Ie(this.params.modelName)]??{}:{}}shouldApplyGlobalOmit(){switch(this.params.action){case"findFirst":case"findFirstOrThrow":case"findUniqueOrThrow":case"findMany":case"upsert":case"findUnique":case"createManyAndReturn":case"create":case"update":case"updateManyAndReturn":case"delete":return!0;case"executeRaw":case"aggregateRaw":case"runCommandRaw":case"findRaw":case"createMany":case"deleteMany":case"groupBy":case"updateMany":case"count":case"aggregate":case"queryRaw":return!1;default:Ue(this.params.action,"Unknown action")}}nestArgument(t){return new e({...this.params,argumentPath:this.params.argumentPath.concat(t)})}};f();u();c();p();m();function zo(e){if(!e._hasPreviewFlag("metrics"))throw new X("`metrics` preview feature must be enabled in order to access metrics API",{clientVersion:e._clientVersion})}var pt=class{_client;constructor(t){this._client=t}prometheus(t){return zo(this._client),this._client._engine.metrics({format:"prometheus",...t})}json(t){return zo(this._client),this._client._engine.metrics({format:"json",...t})}};f();u();c();p();m();function Yo(e,t){let r=It(()=>xc(t));Object.defineProperty(e,"dmmf",{get:()=>r.get()})}function xc(e){return{datamodel:{models:$n(e.models),enums:$n(e.enums),types:$n(e.types)}}}function $n(e){return Object.entries(e).map(([t,r])=>({name:t,...r}))}f();u();c();p();m();var jn=new WeakMap,jr="$$PrismaTypedSql",$t=class{constructor(t,r){jn.set(this,{sql:t,values:r}),Object.defineProperty(this,jr,{value:jr})}get sql(){return jn.get(this).sql}get values(){return jn.get(this).values}};function Zo(e){return(...t)=>new $t(e,t)}function Gr(e){return e!=null&&e[jr]===jr}f();u();c();p();m();var ha=Qe(Pn());f();u();c();p();m();Xo();Ki();Zi();f();u();c();p();m();var se=class e{constructor(t,r){if(t.length-1!==r.length)throw t.length===0?new TypeError("Expected at least 1 string"):new TypeError(`Expected ${t.length} strings to have ${t.length-1} values`);let n=r.reduce((s,a)=>s+(a instanceof e?a.values.length:1),0);this.values=new Array(n),this.strings=new Array(n+1),this.strings[0]=t[0];let i=0,o=0;for(;ie.getPropertyValue(r))},getPropertyDescriptor(r){return e.getPropertyDescriptor?.(r)}}}f();u();c();p();m();f();u();c();p();m();var Qr={enumerable:!0,configurable:!0,writable:!0};function Kr(e){let t=new Set(e);return{getPrototypeOf:()=>Object.prototype,getOwnPropertyDescriptor:()=>Qr,has:(r,n)=>t.has(n),set:(r,n,i)=>t.add(n)&&Reflect.set(r,n,i),ownKeys:()=>[...t]}}var rs=Symbol.for("nodejs.util.inspect.custom");function me(e,t){let r=Pc(t),n=new Set,i=new Proxy(e,{get(o,s){if(n.has(s))return o[s];let a=r.get(s);return a?a.getPropertyValue(s):o[s]},has(o,s){if(n.has(s))return!0;let a=r.get(s);return a?a.has?.(s)??!0:Reflect.has(o,s)},ownKeys(o){let s=ns(Reflect.ownKeys(o),r),a=ns(Array.from(r.keys()),r);return[...new Set([...s,...a,...n])]},set(o,s,a){return r.get(s)?.getPropertyDescriptor?.(s)?.writable===!1?!1:(n.add(s),Reflect.set(o,s,a))},getOwnPropertyDescriptor(o,s){let a=Reflect.getOwnPropertyDescriptor(o,s);if(a&&!a.configurable)return a;let l=r.get(s);return l?l.getPropertyDescriptor?{...Qr,...l?.getPropertyDescriptor(s)}:Qr:a},defineProperty(o,s,a){return n.add(s),Reflect.defineProperty(o,s,a)},getPrototypeOf:()=>Object.prototype});return i[rs]=function(){let o={...this};return delete o[rs],o},i}function Pc(e){let t=new Map;for(let r of e){let n=r.getKeys();for(let i of n)t.set(i,r)}return t}function ns(e,t){return e.filter(r=>t.get(r)?.has?.(r)??!0)}f();u();c();p();m();function mt(e){return{getKeys(){return e},has(){return!1},getPropertyValue(){}}}f();u();c();p();m();function Wr(e,t){return{batch:e,transaction:t?.kind==="batch"?{isolationLevel:t.options.isolationLevel}:void 0}}f();u();c();p();m();function is(e){if(e===void 0)return"";let t=ut(e);return new nt(0,{colors:Dr}).write(t).toString()}f();u();c();p();m();var vc="P2037";function Hr({error:e,user_facing_error:t},r,n){return t.error_code?new ne(Tc(t,n),{code:t.error_code,clientVersion:r,meta:t.meta,batchRequestIdx:t.batch_request_idx}):new ie(e,{clientVersion:r,batchRequestIdx:t.batch_request_idx})}function Tc(e,t){let r=e.message;return(t==="postgresql"||t==="postgres"||t==="mysql")&&e.error_code===vc&&(r+=` -Prisma Accelerate has built-in connection pooling to prevent such errors: https://pris.ly/client/error-accelerate`),r}f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();var Qn=class{getLocation(){return null}};function Ne(e){return typeof $EnabledCallSite=="function"&&e!=="minimal"?new $EnabledCallSite:new Qn}f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();var os={_avg:!0,_count:!0,_sum:!0,_min:!0,_max:!0};function ft(e={}){let t=Rc(e);return Object.entries(t).reduce((n,[i,o])=>(os[i]!==void 0?n.select[i]={select:o}:n[i]=o,n),{select:{}})}function Rc(e={}){return typeof e._count=="boolean"?{...e,_count:{_all:e._count}}:e}function zr(e={}){return t=>(typeof e._count=="boolean"&&(t._count=t._count._all),t)}function ss(e,t){let r=zr(e);return t({action:"aggregate",unpacker:r,argsMapper:ft})(e)}f();u();c();p();m();function Cc(e={}){let{select:t,...r}=e;return typeof t=="object"?ft({...r,_count:t}):ft({...r,_count:{_all:!0}})}function Sc(e={}){return typeof e.select=="object"?t=>zr(e)(t)._count:t=>zr(e)(t)._count._all}function as(e,t){return t({action:"count",unpacker:Sc(e),argsMapper:Cc})(e)}f();u();c();p();m();function Ic(e={}){let t=ft(e);if(Array.isArray(t.by))for(let r of t.by)typeof r=="string"&&(t.select[r]=!0);else typeof t.by=="string"&&(t.select[t.by]=!0);return t}function Oc(e={}){return t=>(typeof e?._count=="boolean"&&t.forEach(r=>{r._count=r._count._all}),t)}function ls(e,t){return t({action:"groupBy",unpacker:Oc(e),argsMapper:Ic})(e)}function us(e,t,r){if(t==="aggregate")return n=>ss(n,r);if(t==="count")return n=>as(n,r);if(t==="groupBy")return n=>ls(n,r)}f();u();c();p();m();function cs(e,t){let r=t.fields.filter(i=>!i.relationName),n=so(r,"name");return new Proxy({},{get(i,o){if(o in i||typeof o=="symbol")return i[o];let s=n[o];if(s)return new Nt(e,o,s.type,s.isList,s.kind==="enum")},...Kr(Object.keys(n))})}f();u();c();p();m();f();u();c();p();m();var ps=e=>Array.isArray(e)?e:e.split("."),Kn=(e,t)=>ps(t).reduce((r,n)=>r&&r[n],e),ms=(e,t,r)=>ps(t).reduceRight((n,i,o,s)=>Object.assign({},Kn(e,s.slice(0,o)),{[i]:n}),r);function kc(e,t){return e===void 0||t===void 0?[]:[...t,"select",e]}function Dc(e,t,r){return t===void 0?e??{}:ms(t,r,e||!0)}function Wn(e,t,r,n,i,o){let a=e._runtimeDataModel.models[t].fields.reduce((l,d)=>({...l,[d.name]:d}),{});return l=>{let d=Ne(e._errorFormat),g=kc(n,i),h=Dc(l,o,g),T=r({dataPath:g,callsite:d})(h),I=Mc(e,t);return new Proxy(T,{get(S,C){if(!I.includes(C))return S[C];let F=[a[C].type,r,C],B=[g,h];return Wn(e,...F,...B)},...Kr([...I,...Object.getOwnPropertyNames(T)])})}}function Mc(e,t){return e._runtimeDataModel.models[t].fields.filter(r=>r.kind==="object").map(r=>r.name)}var _c=["findUnique","findUniqueOrThrow","findFirst","findFirstOrThrow","create","update","upsert","delete"],Nc=["aggregate","count","groupBy"];function Hn(e,t){let r=e._extensions.getAllModelExtensions(t)??{},n=[Fc(e,t),Uc(e,t),jt(r),te("name",()=>t),te("$name",()=>t),te("$parent",()=>e._appliedParent)];return me({},n)}function Fc(e,t){let r=Ee(t),n=Object.keys(kt).concat("count");return{getKeys(){return n},getPropertyValue(i){let o=i,s=a=>l=>{let d=Ne(e._errorFormat);return e._createPrismaPromise(g=>{let h={args:l,dataPath:[],action:o,model:t,clientMethod:`${r}.${i}`,jsModelName:r,transaction:g,callsite:d};return e._request({...h,...a})},{action:o,args:l,model:t})};return _c.includes(o)?Wn(e,t,s):Lc(i)?us(e,i,s):s({})}}}function Lc(e){return Nc.includes(e)}function Uc(e,t){return Be(te("fields",()=>{let r=e._runtimeDataModel.models[t];return cs(t,r)}))}f();u();c();p();m();function fs(e){return e.replace(/^./,t=>t.toUpperCase())}var zn=Symbol();function Gt(e){let t=[Bc(e),qc(e),te(zn,()=>e),te("$parent",()=>e._appliedParent)],r=e._extensions.getAllClientExtensions();return r&&t.push(jt(r)),me(e,t)}function Bc(e){let t=Object.getPrototypeOf(e._originalClient),r=[...new Set(Object.getOwnPropertyNames(t))];return{getKeys(){return r},getPropertyValue(n){return e[n]}}}function qc(e){let t=Object.keys(e._runtimeDataModel.models),r=t.map(Ee),n=[...new Set(t.concat(r))];return Be({getKeys(){return n},getPropertyValue(i){let o=fs(i);if(e._runtimeDataModel.models[o]!==void 0)return Hn(e,o);if(e._runtimeDataModel.models[i]!==void 0)return Hn(e,i)},getPropertyDescriptor(i){if(!r.includes(i))return{enumerable:!1}}})}function ds(e){return e[zn]?e[zn]:e}function gs(e){if(typeof e=="function")return e(this);if(e.client?.__AccelerateEngine){let r=e.client.__AccelerateEngine;this._originalClient._engine=new r(this._originalClient._accelerateEngineConfig)}let t=Object.create(this._originalClient,{_extensions:{value:this._extensions.append(e)},_appliedParent:{value:this,configurable:!0},$on:{value:void 0}});return Gt(t)}f();u();c();p();m();f();u();c();p();m();function hs({result:e,modelName:t,select:r,omit:n,extensions:i}){let o=i.getAllComputedFields(t);if(!o)return e;let s=[],a=[];for(let l of Object.values(o)){if(n){if(n[l.name])continue;let d=l.needs.filter(g=>n[g]);d.length>0&&a.push(mt(d))}else if(r){if(!r[l.name])continue;let d=l.needs.filter(g=>!r[g]);d.length>0&&a.push(mt(d))}Vc(e,l.needs)&&s.push($c(l,me(e,s)))}return s.length>0||a.length>0?me(e,[...s,...a]):e}function Vc(e,t){return t.every(r=>Cn(e,r))}function $c(e,t){return Be(te(e.name,()=>e.compute(t)))}f();u();c();p();m();function Yr({visitor:e,result:t,args:r,runtimeDataModel:n,modelName:i}){if(Array.isArray(t)){for(let s=0;sg.name===o);if(!l||l.kind!=="object"||!l.relationName)continue;let d=typeof s=="object"?s:{};t[o]=Yr({visitor:i,result:t[o],args:d,modelName:l.type,runtimeDataModel:n})}}function ws({result:e,modelName:t,args:r,extensions:n,runtimeDataModel:i,globalOmit:o}){return n.isEmpty()||e==null||typeof e!="object"||!i.models[t]?e:Yr({result:e,args:r??{},modelName:t,runtimeDataModel:i,visitor:(a,l,d)=>{let g=Ee(l);return hs({result:a,modelName:g,select:d.select,omit:d.select?void 0:{...o?.[g],...d.omit},extensions:n})}})}f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();var jc=["$connect","$disconnect","$on","$transaction","$extends"],Es=jc;function bs(e){if(e instanceof se)return Gc(e);if(Gr(e))return Jc(e);if(Array.isArray(e)){let r=[e[0]];for(let n=1;n{let o=t.customDataProxyFetch;return"transaction"in t&&i!==void 0&&(t.transaction?.kind==="batch"&&t.transaction.lock.then(),t.transaction=i),n===r.length?e._executeRequest(t):r[n]({model:t.model,operation:t.model?t.action:t.clientMethod,args:bs(t.args??{}),__internalParams:t,query:(s,a=t)=>{let l=a.customDataProxyFetch;return a.customDataProxyFetch=Rs(o,l),a.args=s,Ps(e,a,r,n+1)}})})}function vs(e,t){let{jsModelName:r,action:n,clientMethod:i}=t,o=r?n:i;if(e._extensions.isEmpty())return e._executeRequest(t);let s=e._extensions.getAllQueryCallbacks(r??"$none",o);return Ps(e,t,s)}function Ts(e){return t=>{let r={requests:t},n=t[0].extensions.getAllBatchQueryCallbacks();return n.length?As(r,n,0,e):e(r)}}function As(e,t,r,n){if(r===t.length)return n(e);let i=e.customDataProxyFetch,o=e.requests[0].transaction;return t[r]({args:{queries:e.requests.map(s=>({model:s.modelName,operation:s.action,args:s.args})),transaction:o?{isolationLevel:o.kind==="batch"?o.isolationLevel:void 0}:void 0},__internalParams:e,query(s,a=e){let l=a.customDataProxyFetch;return a.customDataProxyFetch=Rs(i,l),As(a,t,r+1,n)}})}var xs=e=>e;function Rs(e=xs,t=xs){return r=>e(t(r))}f();u();c();p();m();var Cs=z("prisma:client"),Ss={Vercel:"vercel","Netlify CI":"netlify"};function Is({postinstall:e,ciName:t,clientVersion:r,generator:n}){if(Cs("checkPlatformCaching:postinstall",e),Cs("checkPlatformCaching:ciName",t),e===!0&&!(n?.output&&typeof(n.output.fromEnvVar??n.output.value)=="string")&&t&&t in Ss){let i=`Prisma has detected that this project was built on ${t}, which caches dependencies. This leads to an outdated Prisma Client because Prisma's auto-generation isn't triggered. To fix this, make sure to run the \`prisma generate\` command during the build process. - -Learn how: https://pris.ly/d/${Ss[t]}-build`;throw console.error(i),new Q(i,r)}}f();u();c();p();m();function Os(e,t){return e?e.datasources?e.datasources:e.datasourceUrl?{[t[0]]:{url:e.datasourceUrl}}:{}:{}}f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();function ks(e,t){throw new Error(t)}function Qc(e){return e!==null&&typeof e=="object"&&typeof e.$type=="string"}function Kc(e,t){let r={};for(let n of Object.keys(e))r[n]=t(e[n],n);return r}function dt(e){return e===null?e:Array.isArray(e)?e.map(dt):typeof e=="object"?Qc(e)?Wc(e):e.constructor!==null&&e.constructor.name!=="Object"?e:Kc(e,dt):e}function Wc({$type:e,value:t}){switch(e){case"BigInt":return BigInt(t);case"Bytes":{let{buffer:r,byteOffset:n,byteLength:i}=w.Buffer.from(t,"base64");return new Uint8Array(r,n,i)}case"DateTime":return new Date(t);case"Decimal":return new Te(t);case"Json":return JSON.parse(t);default:ks(t,"Unknown tagged value")}}var Ds="6.19.1";f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();var zc=()=>globalThis.process?.release?.name==="node",Yc=()=>!!globalThis.Bun||!!globalThis.process?.versions?.bun,Zc=()=>!!globalThis.Deno,Xc=()=>typeof globalThis.Netlify=="object",ep=()=>typeof globalThis.EdgeRuntime=="object",tp=()=>globalThis.navigator?.userAgent==="Cloudflare-Workers";function rp(){return[[Xc,"netlify"],[ep,"edge-light"],[tp,"workerd"],[Zc,"deno"],[Yc,"bun"],[zc,"node"]].flatMap(r=>r[0]()?[r[1]]:[]).at(0)??""}var np={node:"Node.js",workerd:"Cloudflare Workers",deno:"Deno and Deno Deploy",netlify:"Netlify Edge Functions","edge-light":"Edge Runtime (Vercel Edge Functions, Vercel Edge Middleware, Next.js (Pages Router) Edge API Routes, Next.js (App Router) Edge Route Handlers or Next.js Middleware)"};function Zr(){let e=rp();return{id:e,prettyName:np[e]||e,isEdge:["workerd","deno","netlify","edge-light"].includes(e)}}function gt({inlineDatasources:e,overrideDatasources:t,env:r,clientVersion:n}){let i,o=Object.keys(e)[0],s=e[o]?.url,a=t[o]?.url;if(o===void 0?i=void 0:a?i=a:s?.value?i=s.value:s?.fromEnvVar&&(i=r[s.fromEnvVar]),s?.fromEnvVar!==void 0&&i===void 0)throw Zr().id==="workerd"?new Q(`error: Environment variable not found: ${s.fromEnvVar}. - -In Cloudflare module Workers, environment variables are available only in the Worker's \`env\` parameter of \`fetch\`. -To solve this, provide the connection string directly: https://pris.ly/d/cloudflare-datasource-url`,n):new Q(`error: Environment variable not found: ${s.fromEnvVar}.`,n);if(i===void 0)throw new Q("error: Missing URL environment variable, value, or override.",n);return i}f();u();c();p();m();f();u();c();p();m();f();u();c();p();m();var Xr=class extends Error{clientVersion;cause;constructor(t,r){super(t),this.clientVersion=r.clientVersion,this.cause=r.cause}get[Symbol.toStringTag](){return this.name}};var ae=class extends Xr{isRetryable;constructor(t,r){super(t,r),this.isRetryable=r.isRetryable??!0}};f();u();c();p();m();function U(e,t){return{...e,isRetryable:t}}var qe=class extends ae{name="InvalidDatasourceError";code="P6001";constructor(t,r){super(t,U(r,!1))}};N(qe,"InvalidDatasourceError");function Ms(e){let t={clientVersion:e.clientVersion},r=Object.keys(e.inlineDatasources)[0],n=gt({inlineDatasources:e.inlineDatasources,overrideDatasources:e.overrideDatasources,clientVersion:e.clientVersion,env:{...e.env,...typeof y<"u"?y.env:{}}}),i;try{i=new URL(n)}catch{throw new qe(`Error validating datasource \`${r}\`: the URL must start with the protocol \`prisma://\``,t)}let{protocol:o,searchParams:s}=i;if(o!=="prisma:"&&o!==hr)throw new qe(`Error validating datasource \`${r}\`: the URL must start with the protocol \`prisma://\` or \`prisma+postgres://\``,t);let a=s.get("api_key");if(a===null||a.length<1)throw new qe(`Error validating datasource \`${r}\`: the URL must contain a valid API key`,t);let l=vn(i)?"http:":"https:";y.env.TEST_CLIENT_ENGINE_REMOTE_EXECUTOR&&i.searchParams.has("use_http")&&(l="http:");let d=new URL(i.href.replace(o,l));return{apiKey:a,url:d}}f();u();c();p();m();var _s=Qe(Xi()),en=class{apiKey;tracingHelper;logLevel;logQueries;engineHash;constructor({apiKey:t,tracingHelper:r,logLevel:n,logQueries:i,engineHash:o}){this.apiKey=t,this.tracingHelper=r,this.logLevel=n,this.logQueries=i,this.engineHash=o}build({traceparent:t,transactionId:r}={}){let n={Accept:"application/json",Authorization:`Bearer ${this.apiKey}`,"Content-Type":"application/json","Prisma-Engine-Hash":this.engineHash,"Prisma-Engine-Version":_s.enginesVersion};this.tracingHelper.isEnabled()&&(n.traceparent=t??this.tracingHelper.getTraceParent()),r&&(n["X-Transaction-Id"]=r);let i=this.#e();return i.length>0&&(n["X-Capture-Telemetry"]=i.join(", ")),n}#e(){let t=[];return this.tracingHelper.isEnabled()&&t.push("tracing"),this.logLevel&&t.push(this.logLevel),this.logQueries&&t.push("query"),t}};f();u();c();p();m();function ip(e){return e[0]*1e3+e[1]/1e6}function Yn(e){return new Date(ip(e))}f();u();c();p();m();f();u();c();p();m();var ht=class extends ae{name="ForcedRetryError";code="P5001";constructor(t){super("This request must be retried",U(t,!0))}};N(ht,"ForcedRetryError");f();u();c();p();m();var Ve=class extends ae{name="NotImplementedYetError";code="P5004";constructor(t,r){super(t,U(r,!1))}};N(Ve,"NotImplementedYetError");f();u();c();p();m();f();u();c();p();m();var G=class extends ae{response;constructor(t,r){super(t,r),this.response=r.response;let n=this.response.headers.get("prisma-request-id");if(n){let i=`(The request id was: ${n})`;this.message=this.message+" "+i}}};var $e=class extends G{name="SchemaMissingError";code="P5005";constructor(t){super("Schema needs to be uploaded",U(t,!0))}};N($e,"SchemaMissingError");f();u();c();p();m();f();u();c();p();m();var Zn="This request could not be understood by the server",Qt=class extends G{name="BadRequestError";code="P5000";constructor(t,r,n){super(r||Zn,U(t,!1)),n&&(this.code=n)}};N(Qt,"BadRequestError");f();u();c();p();m();var Kt=class extends G{name="HealthcheckTimeoutError";code="P5013";logs;constructor(t,r){super("Engine not started: healthcheck timeout",U(t,!0)),this.logs=r}};N(Kt,"HealthcheckTimeoutError");f();u();c();p();m();var Wt=class extends G{name="EngineStartupError";code="P5014";logs;constructor(t,r,n){super(r,U(t,!0)),this.logs=n}};N(Wt,"EngineStartupError");f();u();c();p();m();var Ht=class extends G{name="EngineVersionNotSupportedError";code="P5012";constructor(t){super("Engine version is not supported",U(t,!1))}};N(Ht,"EngineVersionNotSupportedError");f();u();c();p();m();var Xn="Request timed out",zt=class extends G{name="GatewayTimeoutError";code="P5009";constructor(t,r=Xn){super(r,U(t,!1))}};N(zt,"GatewayTimeoutError");f();u();c();p();m();var op="Interactive transaction error",Yt=class extends G{name="InteractiveTransactionError";code="P5015";constructor(t,r=op){super(r,U(t,!1))}};N(Yt,"InteractiveTransactionError");f();u();c();p();m();var sp="Request parameters are invalid",Zt=class extends G{name="InvalidRequestError";code="P5011";constructor(t,r=sp){super(r,U(t,!1))}};N(Zt,"InvalidRequestError");f();u();c();p();m();var ei="Requested resource does not exist",Xt=class extends G{name="NotFoundError";code="P5003";constructor(t,r=ei){super(r,U(t,!1))}};N(Xt,"NotFoundError");f();u();c();p();m();var ti="Unknown server error",yt=class extends G{name="ServerError";code="P5006";logs;constructor(t,r,n){super(r||ti,U(t,!0)),this.logs=n}};N(yt,"ServerError");f();u();c();p();m();var ri="Unauthorized, check your connection string",er=class extends G{name="UnauthorizedError";code="P5007";constructor(t,r=ri){super(r,U(t,!1))}};N(er,"UnauthorizedError");f();u();c();p();m();var ni="Usage exceeded, retry again later",tr=class extends G{name="UsageExceededError";code="P5008";constructor(t,r=ni){super(r,U(t,!0))}};N(tr,"UsageExceededError");async function ap(e){let t;try{t=await e.text()}catch{return{type:"EmptyError"}}try{let r=JSON.parse(t);if(typeof r=="string")switch(r){case"InternalDataProxyError":return{type:"DataProxyError",body:r};default:return{type:"UnknownTextError",body:r}}if(typeof r=="object"&&r!==null){if("is_panic"in r&&"message"in r&&"error_code"in r)return{type:"QueryEngineError",body:r};if("EngineNotStarted"in r||"InteractiveTransactionMisrouted"in r||"InvalidRequestError"in r){let n=Object.values(r)[0].reason;return typeof n=="string"&&!["SchemaMissing","EngineVersionNotSupported"].includes(n)?{type:"UnknownJsonError",body:r}:{type:"DataProxyError",body:r}}}return{type:"UnknownJsonError",body:r}}catch{return t===""?{type:"EmptyError"}:{type:"UnknownTextError",body:t}}}async function rr(e,t){if(e.ok)return;let r={clientVersion:t,response:e},n=await ap(e);if(n.type==="QueryEngineError")throw new ne(n.body.message,{code:n.body.error_code,clientVersion:t});if(n.type==="DataProxyError"){if(n.body==="InternalDataProxyError")throw new yt(r,"Internal Data Proxy error");if("EngineNotStarted"in n.body){if(n.body.EngineNotStarted.reason==="SchemaMissing")return new $e(r);if(n.body.EngineNotStarted.reason==="EngineVersionNotSupported")throw new Ht(r);if("EngineStartupError"in n.body.EngineNotStarted.reason){let{msg:i,logs:o}=n.body.EngineNotStarted.reason.EngineStartupError;throw new Wt(r,i,o)}if("KnownEngineStartupError"in n.body.EngineNotStarted.reason){let{msg:i,error_code:o}=n.body.EngineNotStarted.reason.KnownEngineStartupError;throw new Q(i,t,o)}if("HealthcheckTimeout"in n.body.EngineNotStarted.reason){let{logs:i}=n.body.EngineNotStarted.reason.HealthcheckTimeout;throw new Kt(r,i)}}if("InteractiveTransactionMisrouted"in n.body){let i={IDParseError:"Could not parse interactive transaction ID",NoQueryEngineFoundError:"Could not find Query Engine for the specified host and transaction ID",TransactionStartError:"Could not start interactive transaction"};throw new Yt(r,i[n.body.InteractiveTransactionMisrouted.reason])}if("InvalidRequestError"in n.body)throw new Zt(r,n.body.InvalidRequestError.reason)}if(e.status===401||e.status===403)throw new er(r,wt(ri,n));if(e.status===404)return new Xt(r,wt(ei,n));if(e.status===429)throw new tr(r,wt(ni,n));if(e.status===504)throw new zt(r,wt(Xn,n));if(e.status>=500)throw new yt(r,wt(ti,n));if(e.status>=400)throw new Qt(r,wt(Zn,n))}function wt(e,t){return t.type==="EmptyError"?e:`${e}: ${JSON.stringify(t)}`}f();u();c();p();m();function Ns(e){let t=Math.pow(2,e)*50,r=Math.ceil(Math.random()*t)-Math.ceil(t/2),n=t+r;return new Promise(i=>setTimeout(()=>i(n),n))}f();u();c();p();m();var Ce="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";function Fs(e){let t=new TextEncoder().encode(e),r="",n=t.byteLength,i=n%3,o=n-i,s,a,l,d,g;for(let h=0;h>18,a=(g&258048)>>12,l=(g&4032)>>6,d=g&63,r+=Ce[s]+Ce[a]+Ce[l]+Ce[d];return i==1?(g=t[o],s=(g&252)>>2,a=(g&3)<<4,r+=Ce[s]+Ce[a]+"=="):i==2&&(g=t[o]<<8|t[o+1],s=(g&64512)>>10,a=(g&1008)>>4,l=(g&15)<<2,r+=Ce[s]+Ce[a]+Ce[l]+"="),r}f();u();c();p();m();function Ls(e){if(!!e.generator?.previewFeatures.some(r=>r.toLowerCase().includes("metrics")))throw new Q("The `metrics` preview feature is not yet available with Accelerate.\nPlease remove `metrics` from the `previewFeatures` in your schema.\n\nMore information about Accelerate: https://pris.ly/d/accelerate",e.clientVersion)}f();u();c();p();m();var Us={"@prisma/debug":"workspace:*","@prisma/engines-version":"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7","@prisma/fetch-engine":"workspace:*","@prisma/get-platform":"workspace:*"};f();u();c();p();m();f();u();c();p();m();var nr=class extends ae{name="RequestError";code="P5010";constructor(t,r){super(`Cannot fetch data from service: -${t}`,U(r,!0))}};N(nr,"RequestError");async function je(e,t,r=n=>n){let{clientVersion:n,...i}=t,o=r(fetch);try{return await o(e,i)}catch(s){let a=s.message??"Unknown error";throw new nr(a,{clientVersion:n,cause:s})}}var up=/^[1-9][0-9]*\.[0-9]+\.[0-9]+$/,Bs=z("prisma:client:dataproxyEngine");async function cp(e,t){let r=Us["@prisma/engines-version"],n=t.clientVersion??"unknown";if(y.env.PRISMA_CLIENT_DATA_PROXY_CLIENT_VERSION||globalThis.PRISMA_CLIENT_DATA_PROXY_CLIENT_VERSION)return y.env.PRISMA_CLIENT_DATA_PROXY_CLIENT_VERSION||globalThis.PRISMA_CLIENT_DATA_PROXY_CLIENT_VERSION;if(e.includes("accelerate")&&n!=="0.0.0"&&n!=="in-memory")return n;let[i,o]=n?.split("-")??[];if(o===void 0&&up.test(i))return i;if(o!==void 0||n==="0.0.0"||n==="in-memory"){let[s]=r.split("-")??[],[a,l,d]=s.split("."),g=pp(`<=${a}.${l}.${d}`),h=await je(g,{clientVersion:n});if(!h.ok)throw new Error(`Failed to fetch stable Prisma version, unpkg.com status ${h.status} ${h.statusText}, response body: ${await h.text()||""}`);let T=await h.text();Bs("length of body fetched from unpkg.com",T.length);let I;try{I=JSON.parse(T)}catch(S){throw console.error("JSON.parse error: body fetched from unpkg.com: ",T),S}return I.version}throw new Ve("Only `major.minor.patch` versions are supported by Accelerate.",{clientVersion:n})}async function qs(e,t){let r=await cp(e,t);return Bs("version",r),r}function pp(e){return encodeURI(`https://unpkg.com/prisma@${e}/package.json`)}var Vs=3,ir=z("prisma:client:dataproxyEngine"),Et=class{name="DataProxyEngine";inlineSchema;inlineSchemaHash;inlineDatasources;config;logEmitter;env;clientVersion;engineHash;tracingHelper;remoteClientVersion;host;headerBuilder;startPromise;protocol;constructor(t){Ls(t),this.config=t,this.env=t.env,this.inlineSchema=Fs(t.inlineSchema),this.inlineDatasources=t.inlineDatasources,this.inlineSchemaHash=t.inlineSchemaHash,this.clientVersion=t.clientVersion,this.engineHash=t.engineVersion,this.logEmitter=t.logEmitter,this.tracingHelper=t.tracingHelper}apiKey(){return this.headerBuilder.apiKey}version(){return this.engineHash}async start(){this.startPromise!==void 0&&await this.startPromise,this.startPromise=(async()=>{let{apiKey:t,url:r}=this.getURLAndAPIKey();this.host=r.host,this.protocol=r.protocol,this.headerBuilder=new en({apiKey:t,tracingHelper:this.tracingHelper,logLevel:this.config.logLevel??"error",logQueries:this.config.logQueries,engineHash:this.engineHash}),this.remoteClientVersion=await qs(this.host,this.config),ir("host",this.host),ir("protocol",this.protocol)})(),await this.startPromise}async stop(){}propagateResponseExtensions(t){t?.logs?.length&&t.logs.forEach(r=>{switch(r.level){case"debug":case"trace":ir(r);break;case"error":case"warn":case"info":{this.logEmitter.emit(r.level,{timestamp:Yn(r.timestamp),message:r.attributes.message??"",target:r.target??"BinaryEngine"});break}case"query":{this.logEmitter.emit("query",{query:r.attributes.query??"",timestamp:Yn(r.timestamp),duration:r.attributes.duration_ms??0,params:r.attributes.params??"",target:r.target??"BinaryEngine"});break}default:r.level}}),t?.traces?.length&&this.tracingHelper.dispatchEngineSpans(t.traces)}onBeforeExit(){throw new Error('"beforeExit" hook is not applicable to the remote query engine')}async url(t){return await this.start(),`${this.protocol}//${this.host}/${this.remoteClientVersion}/${this.inlineSchemaHash}/${t}`}async uploadSchema(){let t={name:"schemaUpload",internal:!0};return this.tracingHelper.runInChildSpan(t,async()=>{let r=await je(await this.url("schema"),{method:"PUT",headers:this.headerBuilder.build(),body:this.inlineSchema,clientVersion:this.clientVersion});r.ok||ir("schema response status",r.status);let n=await rr(r,this.clientVersion);if(n)throw this.logEmitter.emit("warn",{message:`Error while uploading schema: ${n.message}`,timestamp:new Date,target:""}),n;this.logEmitter.emit("info",{message:`Schema (re)uploaded (hash: ${this.inlineSchemaHash})`,timestamp:new Date,target:""})})}request(t,{traceparent:r,interactiveTransaction:n,customDataProxyFetch:i}){return this.requestInternal({body:t,traceparent:r,interactiveTransaction:n,customDataProxyFetch:i})}async requestBatch(t,{traceparent:r,transaction:n,customDataProxyFetch:i}){let o=n?.kind==="itx"?n.options:void 0,s=Wr(t,n);return(await this.requestInternal({body:s,customDataProxyFetch:i,interactiveTransaction:o,traceparent:r})).map(l=>(l.extensions&&this.propagateResponseExtensions(l.extensions),"errors"in l?this.convertProtocolErrorsToClientError(l.errors):l))}requestInternal({body:t,traceparent:r,customDataProxyFetch:n,interactiveTransaction:i}){return this.withRetry({actionGerund:"querying",callback:async({logHttpCall:o})=>{let s=i?`${i.payload.endpoint}/graphql`:await this.url("graphql");o(s);let a=await je(s,{method:"POST",headers:this.headerBuilder.build({traceparent:r,transactionId:i?.id}),body:JSON.stringify(t),clientVersion:this.clientVersion},n);a.ok||ir("graphql response status",a.status),await this.handleError(await rr(a,this.clientVersion));let l=await a.json();if(l.extensions&&this.propagateResponseExtensions(l.extensions),"errors"in l)throw this.convertProtocolErrorsToClientError(l.errors);return"batchResult"in l?l.batchResult:l}})}async transaction(t,r,n){let i={start:"starting",commit:"committing",rollback:"rolling back"};return this.withRetry({actionGerund:`${i[t]} transaction`,callback:async({logHttpCall:o})=>{if(t==="start"){let s=JSON.stringify({max_wait:n.maxWait,timeout:n.timeout,isolation_level:n.isolationLevel}),a=await this.url("transaction/start");o(a);let l=await je(a,{method:"POST",headers:this.headerBuilder.build({traceparent:r.traceparent}),body:s,clientVersion:this.clientVersion});await this.handleError(await rr(l,this.clientVersion));let d=await l.json(),{extensions:g}=d;g&&this.propagateResponseExtensions(g);let h=d.id,T=d["data-proxy"].endpoint;return{id:h,payload:{endpoint:T}}}else{let s=`${n.payload.endpoint}/${t}`;o(s);let a=await je(s,{method:"POST",headers:this.headerBuilder.build({traceparent:r.traceparent}),clientVersion:this.clientVersion});await this.handleError(await rr(a,this.clientVersion));let l=await a.json(),{extensions:d}=l;d&&this.propagateResponseExtensions(d);return}}})}getURLAndAPIKey(){return Ms({clientVersion:this.clientVersion,env:this.env,inlineDatasources:this.inlineDatasources,overrideDatasources:this.config.overrideDatasources})}metrics(){throw new Ve("Metrics are not yet supported for Accelerate",{clientVersion:this.clientVersion})}async withRetry(t){for(let r=0;;r++){let n=i=>{this.logEmitter.emit("info",{message:`Calling ${i} (n=${r})`,timestamp:new Date,target:""})};try{return await t.callback({logHttpCall:n})}catch(i){if(!(i instanceof ae)||!i.isRetryable)throw i;if(r>=Vs)throw i instanceof ht?i.cause:i;this.logEmitter.emit("warn",{message:`Attempt ${r+1}/${Vs} failed for ${t.actionGerund}: ${i.message??"(unknown)"}`,timestamp:new Date,target:""});let o=await Ns(r);this.logEmitter.emit("warn",{message:`Retrying after ${o}ms`,timestamp:new Date,target:""})}}}async handleError(t){if(t instanceof $e)throw await this.uploadSchema(),new ht({clientVersion:this.clientVersion,cause:t});if(t)throw t}convertProtocolErrorsToClientError(t){return t.length===1?Hr(t[0],this.config.clientVersion,this.config.activeProvider):new ie(JSON.stringify(t),{clientVersion:this.config.clientVersion})}applyPendingMigrations(){throw new Error("Method not implemented.")}};f();u();c();p();m();function $s({url:e,adapter:t,copyEngine:r,targetBuildType:n}){let i=[],o=[],s=C=>{i.push({_tag:"warning",value:C})},a=C=>{let M=C.join(` -`);o.push({_tag:"error",value:M})},l=!!e?.startsWith("prisma://"),d=yr(e),g=!!t,h=l||d;!g&&r&&h&&n!=="client"&&n!=="wasm-compiler-edge"&&s(["recommend--no-engine","In production, we recommend using `prisma generate --no-engine` (See: `prisma generate --help`)"]);let T=h||!r;g&&(T||n==="edge")&&(n==="edge"?a(["Prisma Client was configured to use the `adapter` option but it was imported via its `/edge` endpoint.","Please either remove the `/edge` endpoint or remove the `adapter` from the Prisma Client constructor."]):h?a(["You've provided both a driver adapter and an Accelerate database URL. Driver adapters currently cannot connect to Accelerate.","Please provide either a driver adapter with a direct database URL or an Accelerate URL and no driver adapter."]):r||a(["Prisma Client was configured to use the `adapter` option but `prisma generate` was run with `--no-engine`.","Please run `prisma generate` without `--no-engine` to be able to use Prisma Client with the adapter."]));let I={accelerate:T,ppg:d,driverAdapters:g};function S(C){return C.length>0}return S(o)?{ok:!1,diagnostics:{warnings:i,errors:o},isUsing:I}:{ok:!0,diagnostics:{warnings:i},isUsing:I}}function js({copyEngine:e=!0},t){let r;try{r=gt({inlineDatasources:t.inlineDatasources,overrideDatasources:t.overrideDatasources,env:{...t.env,...y.env},clientVersion:t.clientVersion})}catch{}let{ok:n,isUsing:i,diagnostics:o}=$s({url:r,adapter:t.adapter,copyEngine:e,targetBuildType:"edge"});for(let h of o.warnings)St(...h.value);if(!n){let h=o.errors[0];throw new X(h.value,{clientVersion:t.clientVersion})}let s=Ze(t.generator),a=s==="library",l=s==="binary",d=s==="client",g=(i.accelerate||i.ppg)&&!i.driverAdapters;return i.accelerate?new Et(t):(i.driverAdapters,i.accelerate,new Et(t))}f();u();c();p();m();function Gs({generator:e}){return e?.previewFeatures??[]}f();u();c();p();m();var Js=e=>({command:e});f();u();c();p();m();f();u();c();p();m();var Qs=e=>e.strings.reduce((t,r,n)=>`${t}@P${n}${r}`);f();u();c();p();m();function bt(e){try{return Ks(e,"fast")}catch{return Ks(e,"slow")}}function Ks(e,t){return JSON.stringify(e.map(r=>Hs(r,t)))}function Hs(e,t){if(Array.isArray(e))return e.map(r=>Hs(r,t));if(typeof e=="bigint")return{prisma__type:"bigint",prisma__value:e.toString()};if(Xe(e))return{prisma__type:"date",prisma__value:e.toJSON()};if(Ae.isDecimal(e))return{prisma__type:"decimal",prisma__value:e.toJSON()};if(w.Buffer.isBuffer(e))return{prisma__type:"bytes",prisma__value:e.toString("base64")};if(mp(e))return{prisma__type:"bytes",prisma__value:w.Buffer.from(e).toString("base64")};if(ArrayBuffer.isView(e)){let{buffer:r,byteOffset:n,byteLength:i}=e;return{prisma__type:"bytes",prisma__value:w.Buffer.from(r,n,i).toString("base64")}}return typeof e=="object"&&t==="slow"?zs(e):e}function mp(e){return e instanceof ArrayBuffer||e instanceof SharedArrayBuffer?!0:typeof e=="object"&&e!==null?e[Symbol.toStringTag]==="ArrayBuffer"||e[Symbol.toStringTag]==="SharedArrayBuffer":!1}function zs(e){if(typeof e!="object"||e===null)return e;if(typeof e.toJSON=="function")return e.toJSON();if(Array.isArray(e))return e.map(Ws);let t={};for(let r of Object.keys(e))t[r]=Ws(e[r]);return t}function Ws(e){return typeof e=="bigint"?e.toString():zs(e)}var fp=/^(\s*alter\s)/i,Ys=z("prisma:client");function ii(e,t,r,n){if(!(e!=="postgresql"&&e!=="cockroachdb")&&r.length>0&&fp.exec(t))throw new Error(`Running ALTER using ${n} is not supported -Using the example below you can still execute your query with Prisma, but please note that it is vulnerable to SQL injection attacks and requires you to take care of input sanitization. - -Example: - await prisma.$executeRawUnsafe(\`ALTER USER prisma WITH PASSWORD '\${password}'\`) - -More Information: https://pris.ly/d/execute-raw -`)}var oi=({clientMethod:e,activeProvider:t})=>r=>{let n="",i;if(Gr(r))n=r.sql,i={values:bt(r.values),__prismaRawParameters__:!0};else if(Array.isArray(r)){let[o,...s]=r;n=o,i={values:bt(s||[]),__prismaRawParameters__:!0}}else switch(t){case"sqlite":case"mysql":{n=r.sql,i={values:bt(r.values),__prismaRawParameters__:!0};break}case"cockroachdb":case"postgresql":case"postgres":{n=r.text,i={values:bt(r.values),__prismaRawParameters__:!0};break}case"sqlserver":{n=Qs(r),i={values:bt(r.values),__prismaRawParameters__:!0};break}default:throw new Error(`The ${t} provider does not support ${e}`)}return i?.values?Ys(`prisma.${e}(${n}, ${i.values})`):Ys(`prisma.${e}(${n})`),{query:n,parameters:i}},Zs={requestArgsToMiddlewareArgs(e){return[e.strings,...e.values]},middlewareArgsToRequestArgs(e){let[t,...r]=e;return new se(t,r)}},Xs={requestArgsToMiddlewareArgs(e){return[e]},middlewareArgsToRequestArgs(e){return e[0]}};f();u();c();p();m();function si(e){return function(r,n){let i,o=(s=e)=>{try{return s===void 0||s?.kind==="itx"?i??=ea(r(s)):ea(r(s))}catch(a){return Promise.reject(a)}};return{get spec(){return n},then(s,a){return o().then(s,a)},catch(s){return o().catch(s)},finally(s){return o().finally(s)},requestTransaction(s){let a=o(s);return a.requestTransaction?a.requestTransaction(s):a},[Symbol.toStringTag]:"PrismaPromise"}}}function ea(e){return typeof e.then=="function"?e:Promise.resolve(e)}f();u();c();p();m();var dp=xn.split(".")[0],gp={isEnabled(){return!1},getTraceParent(){return"00-10-10-00"},dispatchEngineSpans(){},getActiveContext(){},runInChildSpan(e,t){return t()}},ai=class{isEnabled(){return this.getGlobalTracingHelper().isEnabled()}getTraceParent(t){return this.getGlobalTracingHelper().getTraceParent(t)}dispatchEngineSpans(t){return this.getGlobalTracingHelper().dispatchEngineSpans(t)}getActiveContext(){return this.getGlobalTracingHelper().getActiveContext()}runInChildSpan(t,r){return this.getGlobalTracingHelper().runInChildSpan(t,r)}getGlobalTracingHelper(){let t=globalThis[`V${dp}_PRISMA_INSTRUMENTATION`],r=globalThis.PRISMA_INSTRUMENTATION;return t?.helper??r?.helper??gp}};function ta(){return new ai}f();u();c();p();m();function ra(e,t=()=>{}){let r,n=new Promise(i=>r=i);return{then(i){return--e===0&&r(t()),i?.(n)}}}f();u();c();p();m();function na(e){return typeof e=="string"?e:e.reduce((t,r)=>{let n=typeof r=="string"?r:r.level;return n==="query"?t:t&&(r==="info"||t==="info")?"info":n},void 0)}f();u();c();p();m();f();u();c();p();m();function tn(e){return typeof e.batchRequestIdx=="number"}f();u();c();p();m();function ia(e){if(e.action!=="findUnique"&&e.action!=="findUniqueOrThrow")return;let t=[];return e.modelName&&t.push(e.modelName),e.query.arguments&&t.push(li(e.query.arguments)),t.push(li(e.query.selection)),t.join("")}function li(e){return`(${Object.keys(e).sort().map(r=>{let n=e[r];return typeof n=="object"&&n!==null?`(${r} ${li(n)})`:r}).join(" ")})`}f();u();c();p();m();var hp={aggregate:!1,aggregateRaw:!1,createMany:!0,createManyAndReturn:!0,createOne:!0,deleteMany:!0,deleteOne:!0,executeRaw:!0,findFirst:!1,findFirstOrThrow:!1,findMany:!1,findRaw:!1,findUnique:!1,findUniqueOrThrow:!1,groupBy:!1,queryRaw:!1,runCommandRaw:!0,updateMany:!0,updateManyAndReturn:!0,updateOne:!0,upsertOne:!0};function ui(e){return hp[e]}f();u();c();p();m();var rn=class{constructor(t){this.options=t;this.batches={}}batches;tickActive=!1;request(t){let r=this.options.batchBy(t);return r?(this.batches[r]||(this.batches[r]=[],this.tickActive||(this.tickActive=!0,y.nextTick(()=>{this.dispatchBatches(),this.tickActive=!1}))),new Promise((n,i)=>{this.batches[r].push({request:t,resolve:n,reject:i})})):this.options.singleLoader(t)}dispatchBatches(){for(let t in this.batches){let r=this.batches[t];delete this.batches[t],r.length===1?this.options.singleLoader(r[0].request).then(n=>{n instanceof Error?r[0].reject(n):r[0].resolve(n)}).catch(n=>{r[0].reject(n)}):(r.sort((n,i)=>this.options.batchOrder(n.request,i.request)),this.options.batchLoader(r.map(n=>n.request)).then(n=>{if(n instanceof Error)for(let i=0;i{for(let i=0;iGe("bigint",r));case"bytes-array":return t.map(r=>Ge("bytes",r));case"decimal-array":return t.map(r=>Ge("decimal",r));case"datetime-array":return t.map(r=>Ge("datetime",r));case"date-array":return t.map(r=>Ge("date",r));case"time-array":return t.map(r=>Ge("time",r));default:return t}}function nn(e){let t=[],r=yp(e);for(let n=0;n{let{transaction:o,otelParentCtx:s}=n[0],a=n.map(h=>h.protocolQuery),l=this.client._tracingHelper.getTraceParent(s),d=n.some(h=>ui(h.protocolQuery.action));return(await this.client._engine.requestBatch(a,{traceparent:l,transaction:Ep(o),containsWrite:d,customDataProxyFetch:i})).map((h,T)=>{if(h instanceof Error)return h;try{return this.mapQueryEngineResult(n[T],h)}catch(I){return I}})}),singleLoader:async n=>{let i=n.transaction?.kind==="itx"?oa(n.transaction):void 0,o=await this.client._engine.request(n.protocolQuery,{traceparent:this.client._tracingHelper.getTraceParent(),interactiveTransaction:i,isWrite:ui(n.protocolQuery.action),customDataProxyFetch:n.customDataProxyFetch});return this.mapQueryEngineResult(n,o)},batchBy:n=>n.transaction?.id?`transaction-${n.transaction.id}`:ia(n.protocolQuery),batchOrder(n,i){return n.transaction?.kind==="batch"&&i.transaction?.kind==="batch"?n.transaction.index-i.transaction.index:0}})}async request(t){try{return await this.dataloader.request(t)}catch(r){let{clientMethod:n,callsite:i,transaction:o,args:s,modelName:a}=t;this.handleAndLogRequestError({error:r,clientMethod:n,callsite:i,transaction:o,args:s,modelName:a,globalOmit:t.globalOmit})}}mapQueryEngineResult({dataPath:t,unpacker:r},n){let i=n?.data,o=this.unpack(i,t,r);return y.env.PRISMA_CLIENT_GET_TIME?{data:o}:o}handleAndLogRequestError(t){try{this.handleRequestError(t)}catch(r){throw this.logEmitter&&this.logEmitter.emit("error",{message:r.message,target:t.clientMethod,timestamp:new Date}),r}}handleRequestError({error:t,clientMethod:r,callsite:n,transaction:i,args:o,modelName:s,globalOmit:a}){if(wp(t),bp(t,i))throw t;if(t instanceof ne&&xp(t)){let d=sa(t.meta);Ur({args:o,errors:[d],callsite:n,errorFormat:this.client._errorFormat,originalMethod:r,clientVersion:this.client._clientVersion,globalOmit:a})}let l=t.message;if(n&&(l=Sr({callsite:n,originalMethod:r,isPanic:t.isPanic,showColors:this.client._errorFormat==="pretty",message:l})),l=this.sanitizeMessage(l),t.code){let d=s?{modelName:s,...t.meta}:t.meta;throw new ne(l,{code:t.code,clientVersion:this.client._clientVersion,meta:d,batchRequestIdx:t.batchRequestIdx})}else{if(t.isPanic)throw new Pe(l,this.client._clientVersion);if(t instanceof ie)throw new ie(l,{clientVersion:this.client._clientVersion,batchRequestIdx:t.batchRequestIdx});if(t instanceof Q)throw new Q(l,this.client._clientVersion);if(t instanceof Pe)throw new Pe(l,this.client._clientVersion)}throw t.clientVersion=this.client._clientVersion,t}sanitizeMessage(t){return this.client._errorFormat&&this.client._errorFormat!=="pretty"?Rn(t):t}unpack(t,r,n){if(!t||(t.data&&(t=t.data),!t))return t;let i=Object.keys(t)[0],o=Object.values(t)[0],s=r.filter(d=>d!=="select"&&d!=="include"),a=Kn(o,s),l=i==="queryRaw"?nn(a):dt(a);return n?n(l):l}get[Symbol.toStringTag](){return"RequestHandler"}};function Ep(e){if(e){if(e.kind==="batch")return{kind:"batch",options:{isolationLevel:e.isolationLevel}};if(e.kind==="itx")return{kind:"itx",options:oa(e)};Ue(e,"Unknown transaction kind")}}function oa(e){return{id:e.id,payload:e.payload}}function bp(e,t){return tn(e)&&t?.kind==="batch"&&e.batchRequestIdx!==t.index}function xp(e){return e.code==="P2009"||e.code==="P2012"}function sa(e){if(e.kind==="Union")return{kind:"Union",errors:e.errors.map(sa)};if(Array.isArray(e.selectionPath)){let[,...t]=e.selectionPath;return{...e,selectionPath:t}}return e}f();u();c();p();m();var aa=Ds;f();u();c();p();m();var ma=Qe(Nn());f();u();c();p();m();var q=class extends Error{constructor(t){super(t+` -Read more at https://pris.ly/d/client-constructor`),this.name="PrismaClientConstructorValidationError"}get[Symbol.toStringTag](){return"PrismaClientConstructorValidationError"}};N(q,"PrismaClientConstructorValidationError");var la=["datasources","datasourceUrl","errorFormat","adapter","log","transactionOptions","omit","__internal"],ua=["pretty","colorless","minimal"],ca=["info","query","warn","error"],Pp={datasources:(e,{datasourceNames:t})=>{if(e){if(typeof e!="object"||Array.isArray(e))throw new q(`Invalid value ${JSON.stringify(e)} for "datasources" provided to PrismaClient constructor`);for(let[r,n]of Object.entries(e)){if(!t.includes(r)){let i=xt(r,t)||` Available datasources: ${t.join(", ")}`;throw new q(`Unknown datasource ${r} provided to PrismaClient constructor.${i}`)}if(typeof n!="object"||Array.isArray(n))throw new q(`Invalid value ${JSON.stringify(e)} for datasource "${r}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`);if(n&&typeof n=="object")for(let[i,o]of Object.entries(n)){if(i!=="url")throw new q(`Invalid value ${JSON.stringify(e)} for datasource "${r}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`);if(typeof o!="string")throw new q(`Invalid value ${JSON.stringify(o)} for datasource "${r}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`)}}}},adapter:(e,t)=>{if(!e&&Ze(t.generator)==="client")throw new q('Using engine type "client" requires a driver adapter to be provided to PrismaClient constructor.');if(e!==null){if(e===void 0)throw new q('"adapter" property must not be undefined, use null to conditionally disable driver adapters.');if(Ze(t.generator)==="binary")throw new q('Cannot use a driver adapter with the "binary" Query Engine. Please use the "library" Query Engine.')}},datasourceUrl:e=>{if(typeof e<"u"&&typeof e!="string")throw new q(`Invalid value ${JSON.stringify(e)} for "datasourceUrl" provided to PrismaClient constructor. -Expected string or undefined.`)},errorFormat:e=>{if(e){if(typeof e!="string")throw new q(`Invalid value ${JSON.stringify(e)} for "errorFormat" provided to PrismaClient constructor.`);if(!ua.includes(e)){let t=xt(e,ua);throw new q(`Invalid errorFormat ${e} provided to PrismaClient constructor.${t}`)}}},log:e=>{if(!e)return;if(!Array.isArray(e))throw new q(`Invalid value ${JSON.stringify(e)} for "log" provided to PrismaClient constructor.`);function t(r){if(typeof r=="string"&&!ca.includes(r)){let n=xt(r,ca);throw new q(`Invalid log level "${r}" provided to PrismaClient constructor.${n}`)}}for(let r of e){t(r);let n={level:t,emit:i=>{let o=["stdout","event"];if(!o.includes(i)){let s=xt(i,o);throw new q(`Invalid value ${JSON.stringify(i)} for "emit" in logLevel provided to PrismaClient constructor.${s}`)}}};if(r&&typeof r=="object")for(let[i,o]of Object.entries(r))if(n[i])n[i](o);else throw new q(`Invalid property ${i} for "log" provided to PrismaClient constructor`)}},transactionOptions:e=>{if(!e)return;let t=e.maxWait;if(t!=null&&t<=0)throw new q(`Invalid value ${t} for maxWait in "transactionOptions" provided to PrismaClient constructor. maxWait needs to be greater than 0`);let r=e.timeout;if(r!=null&&r<=0)throw new q(`Invalid value ${r} for timeout in "transactionOptions" provided to PrismaClient constructor. timeout needs to be greater than 0`)},omit:(e,t)=>{if(typeof e!="object")throw new q('"omit" option is expected to be an object.');if(e===null)throw new q('"omit" option can not be `null`');let r=[];for(let[n,i]of Object.entries(e)){let o=Tp(n,t.runtimeDataModel);if(!o){r.push({kind:"UnknownModel",modelKey:n});continue}for(let[s,a]of Object.entries(i)){let l=o.fields.find(d=>d.name===s);if(!l){r.push({kind:"UnknownField",modelKey:n,fieldName:s});continue}if(l.relationName){r.push({kind:"RelationInOmit",modelKey:n,fieldName:s});continue}typeof a!="boolean"&&r.push({kind:"InvalidFieldValue",modelKey:n,fieldName:s})}}if(r.length>0)throw new q(Ap(e,r))},__internal:e=>{if(!e)return;let t=["debug","engine","configOverride"];if(typeof e!="object")throw new q(`Invalid value ${JSON.stringify(e)} for "__internal" to PrismaClient constructor`);for(let[r]of Object.entries(e))if(!t.includes(r)){let n=xt(r,t);throw new q(`Invalid property ${JSON.stringify(r)} for "__internal" provided to PrismaClient constructor.${n}`)}}};function fa(e,t){for(let[r,n]of Object.entries(e)){if(!la.includes(r)){let i=xt(r,la);throw new q(`Unknown property ${r} provided to PrismaClient constructor.${i}`)}Pp[r](n,t)}if(e.datasourceUrl&&e.datasources)throw new q('Can not use "datasourceUrl" and "datasources" options at the same time. Pick one of them')}function xt(e,t){if(t.length===0||typeof e!="string")return"";let r=vp(e,t);return r?` Did you mean "${r}"?`:""}function vp(e,t){if(t.length===0)return null;let r=t.map(i=>({value:i,distance:(0,ma.default)(e,i)}));r.sort((i,o)=>i.distanceIe(n)===t);if(r)return e[r]}function Ap(e,t){let r=ut(e);for(let o of t)switch(o.kind){case"UnknownModel":r.arguments.getField(o.modelKey)?.markAsError(),r.addErrorMessage(()=>`Unknown model name: ${o.modelKey}.`);break;case"UnknownField":r.arguments.getDeepField([o.modelKey,o.fieldName])?.markAsError(),r.addErrorMessage(()=>`Model "${o.modelKey}" does not have a field named "${o.fieldName}".`);break;case"RelationInOmit":r.arguments.getDeepField([o.modelKey,o.fieldName])?.markAsError(),r.addErrorMessage(()=>'Relations are already excluded by default and can not be specified in "omit".');break;case"InvalidFieldValue":r.arguments.getDeepFieldValue([o.modelKey,o.fieldName])?.markAsError(),r.addErrorMessage(()=>"Omit field option value must be a boolean.");break}let{message:n,args:i}=Lr(r,"colorless");return`Error validating "omit" option: - -${i} - -${n}`}f();u();c();p();m();function da(e){return e.length===0?Promise.resolve([]):new Promise((t,r)=>{let n=new Array(e.length),i=null,o=!1,s=0,a=()=>{o||(s++,s===e.length&&(o=!0,i?r(i):t(n)))},l=d=>{o||(o=!0,r(d))};for(let d=0;d{n[d]=g,a()},g=>{if(!tn(g)){l(g);return}g.batchRequestIdx===d?l(g):(i||(i=g),a())})})}var Fe=z("prisma:client");typeof globalThis=="object"&&(globalThis.NODE_CLIENT=!0);var Rp={requestArgsToMiddlewareArgs:e=>e,middlewareArgsToRequestArgs:e=>e},Cp=Symbol.for("prisma.client.transaction.id"),Sp={id:0,nextId(){return++this.id}};function ya(e){class t{_originalClient=this;_runtimeDataModel;_requestHandler;_connectionPromise;_disconnectionPromise;_engineConfig;_accelerateEngineConfig;_clientVersion;_errorFormat;_tracingHelper;_previewFeatures;_activeProvider;_globalOmit;_extensions;_engine;_appliedParent;_createPrismaPromise=si();constructor(n){e=n?.__internal?.configOverride?.(e)??e,Is(e),n&&fa(n,e);let i=new Jr().on("error",()=>{});this._extensions=ct.empty(),this._previewFeatures=Gs(e),this._clientVersion=e.clientVersion??aa,this._activeProvider=e.activeProvider,this._globalOmit=n?.omit,this._tracingHelper=ta();let o=e.relativeEnvPaths&&{rootEnvPath:e.relativeEnvPaths.rootEnvPath&&dr.resolve(e.dirname,e.relativeEnvPaths.rootEnvPath),schemaEnvPath:e.relativeEnvPaths.schemaEnvPath&&dr.resolve(e.dirname,e.relativeEnvPaths.schemaEnvPath)},s;if(n?.adapter){s=n.adapter;let l=e.activeProvider==="postgresql"||e.activeProvider==="cockroachdb"?"postgres":e.activeProvider;if(s.provider!==l)throw new Q(`The Driver Adapter \`${s.adapterName}\`, based on \`${s.provider}\`, is not compatible with the provider \`${l}\` specified in the Prisma schema.`,this._clientVersion);if(n.datasources||n.datasourceUrl!==void 0)throw new Q("Custom datasource configuration is not compatible with Prisma Driver Adapters. Please define the database connection string directly in the Driver Adapter configuration.",this._clientVersion)}let a=e.injectableEdgeEnv?.();try{let l=n??{},d=l.__internal??{},g=d.debug===!0;g&&z.enable("prisma:client");let h=dr.resolve(e.dirname,e.relativePath);Qi.existsSync(h)||(h=e.dirname),Fe("dirname",e.dirname),Fe("relativePath",e.relativePath),Fe("cwd",h);let T=d.engine||{};if(l.errorFormat?this._errorFormat=l.errorFormat:y.env.NODE_ENV==="production"?this._errorFormat="minimal":y.env.NO_COLOR?this._errorFormat="colorless":this._errorFormat="colorless",this._runtimeDataModel=e.runtimeDataModel,this._engineConfig={cwd:h,dirname:e.dirname,enableDebugLogs:g,allowTriggerPanic:T.allowTriggerPanic,prismaPath:T.binaryPath??void 0,engineEndpoint:T.endpoint,generator:e.generator,showColors:this._errorFormat==="pretty",logLevel:l.log&&na(l.log),logQueries:l.log&&!!(typeof l.log=="string"?l.log==="query":l.log.find(I=>typeof I=="string"?I==="query":I.level==="query")),env:a?.parsed??{},flags:[],engineWasm:e.engineWasm,compilerWasm:e.compilerWasm,clientVersion:e.clientVersion,engineVersion:e.engineVersion,previewFeatures:this._previewFeatures,activeProvider:e.activeProvider,inlineSchema:e.inlineSchema,overrideDatasources:Os(l,e.datasourceNames),inlineDatasources:e.inlineDatasources,inlineSchemaHash:e.inlineSchemaHash,tracingHelper:this._tracingHelper,transactionOptions:{maxWait:l.transactionOptions?.maxWait??2e3,timeout:l.transactionOptions?.timeout??5e3,isolationLevel:l.transactionOptions?.isolationLevel},logEmitter:i,isBundled:e.isBundled,adapter:s},this._accelerateEngineConfig={...this._engineConfig,accelerateUtils:{resolveDatasourceUrl:gt,getBatchRequestPayload:Wr,prismaGraphQLToJSError:Hr,PrismaClientUnknownRequestError:ie,PrismaClientInitializationError:Q,PrismaClientKnownRequestError:ne,debug:z("prisma:client:accelerateEngine"),engineVersion:ha.version,clientVersion:e.clientVersion}},Fe("clientVersion",e.clientVersion),this._engine=js(e,this._engineConfig),this._requestHandler=new on(this,i),l.log)for(let I of l.log){let S=typeof I=="string"?I:I.emit==="stdout"?I.level:null;S&&this.$on(S,C=>{Ct.log(`${Ct.tags[S]??""}`,C.message||C.query)})}}catch(l){throw l.clientVersion=this._clientVersion,l}return this._appliedParent=Gt(this)}get[Symbol.toStringTag](){return"PrismaClient"}$on(n,i){return n==="beforeExit"?this._engine.onBeforeExit(i):n&&this._engineConfig.logEmitter.on(n,i),this}$connect(){try{return this._engine.start()}catch(n){throw n.clientVersion=this._clientVersion,n}}async $disconnect(){try{await this._engine.stop()}catch(n){throw n.clientVersion=this._clientVersion,n}finally{Ji()}}$executeRawInternal(n,i,o,s){let a=this._activeProvider;return this._request({action:"executeRaw",args:o,transaction:n,clientMethod:i,argsMapper:oi({clientMethod:i,activeProvider:a}),callsite:Ne(this._errorFormat),dataPath:[],middlewareArgsMapper:s})}$executeRaw(n,...i){return this._createPrismaPromise(o=>{if(n.raw!==void 0||n.sql!==void 0){let[s,a]=ga(n,i);return ii(this._activeProvider,s.text,s.values,Array.isArray(n)?"prisma.$executeRaw``":"prisma.$executeRaw(sql``)"),this.$executeRawInternal(o,"$executeRaw",s,a)}throw new X("`$executeRaw` is a tag function, please use it like the following:\n```\nconst result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`\n```\n\nOr read our docs at https://www.prisma.io/docs/concepts/components/prisma-client/raw-database-access#executeraw\n",{clientVersion:this._clientVersion})})}$executeRawUnsafe(n,...i){return this._createPrismaPromise(o=>(ii(this._activeProvider,n,i,"prisma.$executeRawUnsafe(, [...values])"),this.$executeRawInternal(o,"$executeRawUnsafe",[n,...i])))}$runCommandRaw(n){if(e.activeProvider!=="mongodb")throw new X(`The ${e.activeProvider} provider does not support $runCommandRaw. Use the mongodb provider.`,{clientVersion:this._clientVersion});return this._createPrismaPromise(i=>this._request({args:n,clientMethod:"$runCommandRaw",dataPath:[],action:"runCommandRaw",argsMapper:Js,callsite:Ne(this._errorFormat),transaction:i}))}async $queryRawInternal(n,i,o,s){let a=this._activeProvider;return this._request({action:"queryRaw",args:o,transaction:n,clientMethod:i,argsMapper:oi({clientMethod:i,activeProvider:a}),callsite:Ne(this._errorFormat),dataPath:[],middlewareArgsMapper:s})}$queryRaw(n,...i){return this._createPrismaPromise(o=>{if(n.raw!==void 0||n.sql!==void 0)return this.$queryRawInternal(o,"$queryRaw",...ga(n,i));throw new X("`$queryRaw` is a tag function, please use it like the following:\n```\nconst result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`\n```\n\nOr read our docs at https://www.prisma.io/docs/concepts/components/prisma-client/raw-database-access#queryraw\n",{clientVersion:this._clientVersion})})}$queryRawTyped(n){return this._createPrismaPromise(i=>{if(!this._hasPreviewFlag("typedSql"))throw new X("`typedSql` preview feature must be enabled in order to access $queryRawTyped API",{clientVersion:this._clientVersion});return this.$queryRawInternal(i,"$queryRawTyped",n)})}$queryRawUnsafe(n,...i){return this._createPrismaPromise(o=>this.$queryRawInternal(o,"$queryRawUnsafe",[n,...i]))}_transactionWithArray({promises:n,options:i}){let o=Sp.nextId(),s=ra(n.length),a=n.map((l,d)=>{if(l?.[Symbol.toStringTag]!=="PrismaPromise")throw new Error("All elements of the array need to be Prisma Client promises. Hint: Please make sure you are not awaiting the Prisma client calls you intended to pass in the $transaction function.");let g=i?.isolationLevel??this._engineConfig.transactionOptions.isolationLevel,h={kind:"batch",id:o,index:d,isolationLevel:g,lock:s};return l.requestTransaction?.(h)??l});return da(a)}async _transactionWithCallback({callback:n,options:i}){let o={traceparent:this._tracingHelper.getTraceParent()},s={maxWait:i?.maxWait??this._engineConfig.transactionOptions.maxWait,timeout:i?.timeout??this._engineConfig.transactionOptions.timeout,isolationLevel:i?.isolationLevel??this._engineConfig.transactionOptions.isolationLevel},a=await this._engine.transaction("start",o,s),l;try{let d={kind:"itx",...a};l=await n(this._createItxClient(d)),await this._engine.transaction("commit",o,a)}catch(d){throw await this._engine.transaction("rollback",o,a).catch(()=>{}),d}return l}_createItxClient(n){return me(Gt(me(ds(this),[te("_appliedParent",()=>this._appliedParent._createItxClient(n)),te("_createPrismaPromise",()=>si(n)),te(Cp,()=>n.id)])),[mt(Es)])}$transaction(n,i){let o;typeof n=="function"?this._engineConfig.adapter?.adapterName==="@prisma/adapter-d1"?o=()=>{throw new Error("Cloudflare D1 does not support interactive transactions. We recommend you to refactor your queries with that limitation in mind, and use batch transactions with `prisma.$transactions([])` where applicable.")}:o=()=>this._transactionWithCallback({callback:n,options:i}):o=()=>this._transactionWithArray({promises:n,options:i});let s={name:"transaction",attributes:{method:"$transaction"}};return this._tracingHelper.runInChildSpan(s,o)}_request(n){n.otelParentCtx=this._tracingHelper.getActiveContext();let i=n.middlewareArgsMapper??Rp,o={args:i.requestArgsToMiddlewareArgs(n.args),dataPath:n.dataPath,runInTransaction:!!n.transaction,action:n.action,model:n.model},s={operation:{name:"operation",attributes:{method:o.action,model:o.model,name:o.model?`${o.model}.${o.action}`:o.action}}},a=async l=>{let{runInTransaction:d,args:g,...h}=l,T={...n,...h};g&&(T.args=i.middlewareArgsToRequestArgs(g)),n.transaction!==void 0&&d===!1&&delete T.transaction;let I=await vs(this,T);return T.model?ws({result:I,modelName:T.model,args:T.args,extensions:this._extensions,runtimeDataModel:this._runtimeDataModel,globalOmit:this._globalOmit}):I};return this._tracingHelper.runInChildSpan(s.operation,()=>a(o))}async _executeRequest({args:n,clientMethod:i,dataPath:o,callsite:s,action:a,model:l,argsMapper:d,transaction:g,unpacker:h,otelParentCtx:T,customDataProxyFetch:I}){try{n=d?d(n):n;let S={name:"serialize"},C=this._tracingHelper.runInChildSpan(S,()=>$r({modelName:l,runtimeDataModel:this._runtimeDataModel,action:a,args:n,clientMethod:i,callsite:s,extensions:this._extensions,errorFormat:this._errorFormat,clientVersion:this._clientVersion,previewFeatures:this._previewFeatures,globalOmit:this._globalOmit}));return z.enabled("prisma:client")&&(Fe("Prisma Client call:"),Fe(`prisma.${i}(${is(n)})`),Fe("Generated request:"),Fe(JSON.stringify(C,null,2)+` -`)),g?.kind==="batch"&&await g.lock,this._requestHandler.request({protocolQuery:C,modelName:l,action:a,clientMethod:i,dataPath:o,callsite:s,args:n,extensions:this._extensions,transaction:g,unpacker:h,otelParentCtx:T,otelChildCtx:this._tracingHelper.getActiveContext(),globalOmit:this._globalOmit,customDataProxyFetch:I})}catch(S){throw S.clientVersion=this._clientVersion,S}}$metrics=new pt(this);_hasPreviewFlag(n){return!!this._engineConfig.previewFeatures?.includes(n)}$applyPendingMigrations(){return this._engine.applyPendingMigrations()}$extends=gs}return t}function ga(e,t){return Ip(e)?[new se(e,t),Zs]:[e,Xs]}function Ip(e){return Array.isArray(e)&&Array.isArray(e.raw)}f();u();c();p();m();var Op=new Set(["toJSON","$$typeof","asymmetricMatch",Symbol.iterator,Symbol.toStringTag,Symbol.isConcatSpreadable,Symbol.toPrimitive]);function wa(e){return new Proxy(e,{get(t,r){if(r in t)return t[r];if(!Op.has(r))throw new TypeError(`Invalid enum value: ${String(r)}`)}})}f();u();c();p();m();0&&(module.exports={DMMF,Debug,Decimal,Extensions,MetricsClient,PrismaClientInitializationError,PrismaClientKnownRequestError,PrismaClientRustPanicError,PrismaClientUnknownRequestError,PrismaClientValidationError,Public,Sql,createParam,defineDmmfProperty,deserializeJsonResponse,deserializeRawResult,dmmfToRuntimeDataModel,empty,getPrismaClient,getRuntime,join,makeStrictEnum,makeTypedQueryFactory,objectEnumValues,raw,serializeJsonQuery,skip,sqltag,warnEnvConflicts,warnOnce}); -//# sourceMappingURL=edge.js.map diff --git a/frontend/generated/prisma/runtime/index-browser.d.ts b/frontend/generated/prisma/runtime/index-browser.d.ts deleted file mode 100644 index 0e96e4b..0000000 --- a/frontend/generated/prisma/runtime/index-browser.d.ts +++ /dev/null @@ -1,370 +0,0 @@ -declare class AnyNull extends NullTypesEnumValue { - #private; -} - -declare type Args = T extends { - [K: symbol]: { - types: { - operations: { - [K in F]: { - args: any; - }; - }; - }; - }; -} ? T[symbol]['types']['operations'][F]['args'] : any; - -declare class DbNull extends NullTypesEnumValue { - #private; -} - -export declare function Decimal(n: Decimal.Value): Decimal; - -export declare namespace Decimal { - export type Constructor = typeof Decimal; - export type Instance = Decimal; - export type Rounding = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8; - export type Modulo = Rounding | 9; - export type Value = string | number | Decimal; - - // http://mikemcl.github.io/decimal.js/#constructor-properties - export interface Config { - precision?: number; - rounding?: Rounding; - toExpNeg?: number; - toExpPos?: number; - minE?: number; - maxE?: number; - crypto?: boolean; - modulo?: Modulo; - defaults?: boolean; - } -} - -export declare class Decimal { - readonly d: number[]; - readonly e: number; - readonly s: number; - - constructor(n: Decimal.Value); - - absoluteValue(): Decimal; - abs(): Decimal; - - ceil(): Decimal; - - clampedTo(min: Decimal.Value, max: Decimal.Value): Decimal; - clamp(min: Decimal.Value, max: Decimal.Value): Decimal; - - comparedTo(n: Decimal.Value): number; - cmp(n: Decimal.Value): number; - - cosine(): Decimal; - cos(): Decimal; - - cubeRoot(): Decimal; - cbrt(): Decimal; - - decimalPlaces(): number; - dp(): number; - - dividedBy(n: Decimal.Value): Decimal; - div(n: Decimal.Value): Decimal; - - dividedToIntegerBy(n: Decimal.Value): Decimal; - divToInt(n: Decimal.Value): Decimal; - - equals(n: Decimal.Value): boolean; - eq(n: Decimal.Value): boolean; - - floor(): Decimal; - - greaterThan(n: Decimal.Value): boolean; - gt(n: Decimal.Value): boolean; - - greaterThanOrEqualTo(n: Decimal.Value): boolean; - gte(n: Decimal.Value): boolean; - - hyperbolicCosine(): Decimal; - cosh(): Decimal; - - hyperbolicSine(): Decimal; - sinh(): Decimal; - - hyperbolicTangent(): Decimal; - tanh(): Decimal; - - inverseCosine(): Decimal; - acos(): Decimal; - - inverseHyperbolicCosine(): Decimal; - acosh(): Decimal; - - inverseHyperbolicSine(): Decimal; - asinh(): Decimal; - - inverseHyperbolicTangent(): Decimal; - atanh(): Decimal; - - inverseSine(): Decimal; - asin(): Decimal; - - inverseTangent(): Decimal; - atan(): Decimal; - - isFinite(): boolean; - - isInteger(): boolean; - isInt(): boolean; - - isNaN(): boolean; - - isNegative(): boolean; - isNeg(): boolean; - - isPositive(): boolean; - isPos(): boolean; - - isZero(): boolean; - - lessThan(n: Decimal.Value): boolean; - lt(n: Decimal.Value): boolean; - - lessThanOrEqualTo(n: Decimal.Value): boolean; - lte(n: Decimal.Value): boolean; - - logarithm(n?: Decimal.Value): Decimal; - log(n?: Decimal.Value): Decimal; - - minus(n: Decimal.Value): Decimal; - sub(n: Decimal.Value): Decimal; - - modulo(n: Decimal.Value): Decimal; - mod(n: Decimal.Value): Decimal; - - naturalExponential(): Decimal; - exp(): Decimal; - - naturalLogarithm(): Decimal; - ln(): Decimal; - - negated(): Decimal; - neg(): Decimal; - - plus(n: Decimal.Value): Decimal; - add(n: Decimal.Value): Decimal; - - precision(includeZeros?: boolean): number; - sd(includeZeros?: boolean): number; - - round(): Decimal; - - sine() : Decimal; - sin() : Decimal; - - squareRoot(): Decimal; - sqrt(): Decimal; - - tangent() : Decimal; - tan() : Decimal; - - times(n: Decimal.Value): Decimal; - mul(n: Decimal.Value) : Decimal; - - toBinary(significantDigits?: number): string; - toBinary(significantDigits: number, rounding: Decimal.Rounding): string; - - toDecimalPlaces(decimalPlaces?: number): Decimal; - toDecimalPlaces(decimalPlaces: number, rounding: Decimal.Rounding): Decimal; - toDP(decimalPlaces?: number): Decimal; - toDP(decimalPlaces: number, rounding: Decimal.Rounding): Decimal; - - toExponential(decimalPlaces?: number): string; - toExponential(decimalPlaces: number, rounding: Decimal.Rounding): string; - - toFixed(decimalPlaces?: number): string; - toFixed(decimalPlaces: number, rounding: Decimal.Rounding): string; - - toFraction(max_denominator?: Decimal.Value): Decimal[]; - - toHexadecimal(significantDigits?: number): string; - toHexadecimal(significantDigits: number, rounding: Decimal.Rounding): string; - toHex(significantDigits?: number): string; - toHex(significantDigits: number, rounding?: Decimal.Rounding): string; - - toJSON(): string; - - toNearest(n: Decimal.Value, rounding?: Decimal.Rounding): Decimal; - - toNumber(): number; - - toOctal(significantDigits?: number): string; - toOctal(significantDigits: number, rounding: Decimal.Rounding): string; - - toPower(n: Decimal.Value): Decimal; - pow(n: Decimal.Value): Decimal; - - toPrecision(significantDigits?: number): string; - toPrecision(significantDigits: number, rounding: Decimal.Rounding): string; - - toSignificantDigits(significantDigits?: number): Decimal; - toSignificantDigits(significantDigits: number, rounding: Decimal.Rounding): Decimal; - toSD(significantDigits?: number): Decimal; - toSD(significantDigits: number, rounding: Decimal.Rounding): Decimal; - - toString(): string; - - truncated(): Decimal; - trunc(): Decimal; - - valueOf(): string; - - static abs(n: Decimal.Value): Decimal; - static acos(n: Decimal.Value): Decimal; - static acosh(n: Decimal.Value): Decimal; - static add(x: Decimal.Value, y: Decimal.Value): Decimal; - static asin(n: Decimal.Value): Decimal; - static asinh(n: Decimal.Value): Decimal; - static atan(n: Decimal.Value): Decimal; - static atanh(n: Decimal.Value): Decimal; - static atan2(y: Decimal.Value, x: Decimal.Value): Decimal; - static cbrt(n: Decimal.Value): Decimal; - static ceil(n: Decimal.Value): Decimal; - static clamp(n: Decimal.Value, min: Decimal.Value, max: Decimal.Value): Decimal; - static clone(object?: Decimal.Config): Decimal.Constructor; - static config(object: Decimal.Config): Decimal.Constructor; - static cos(n: Decimal.Value): Decimal; - static cosh(n: Decimal.Value): Decimal; - static div(x: Decimal.Value, y: Decimal.Value): Decimal; - static exp(n: Decimal.Value): Decimal; - static floor(n: Decimal.Value): Decimal; - static hypot(...n: Decimal.Value[]): Decimal; - static isDecimal(object: any): object is Decimal; - static ln(n: Decimal.Value): Decimal; - static log(n: Decimal.Value, base?: Decimal.Value): Decimal; - static log2(n: Decimal.Value): Decimal; - static log10(n: Decimal.Value): Decimal; - static max(...n: Decimal.Value[]): Decimal; - static min(...n: Decimal.Value[]): Decimal; - static mod(x: Decimal.Value, y: Decimal.Value): Decimal; - static mul(x: Decimal.Value, y: Decimal.Value): Decimal; - static noConflict(): Decimal.Constructor; // Browser only - static pow(base: Decimal.Value, exponent: Decimal.Value): Decimal; - static random(significantDigits?: number): Decimal; - static round(n: Decimal.Value): Decimal; - static set(object: Decimal.Config): Decimal.Constructor; - static sign(n: Decimal.Value): number; - static sin(n: Decimal.Value): Decimal; - static sinh(n: Decimal.Value): Decimal; - static sqrt(n: Decimal.Value): Decimal; - static sub(x: Decimal.Value, y: Decimal.Value): Decimal; - static sum(...n: Decimal.Value[]): Decimal; - static tan(n: Decimal.Value): Decimal; - static tanh(n: Decimal.Value): Decimal; - static trunc(n: Decimal.Value): Decimal; - - static readonly default?: Decimal.Constructor; - static readonly Decimal?: Decimal.Constructor; - - static readonly precision: number; - static readonly rounding: Decimal.Rounding; - static readonly toExpNeg: number; - static readonly toExpPos: number; - static readonly minE: number; - static readonly maxE: number; - static readonly crypto: boolean; - static readonly modulo: Decimal.Modulo; - - static readonly ROUND_UP: 0; - static readonly ROUND_DOWN: 1; - static readonly ROUND_CEIL: 2; - static readonly ROUND_FLOOR: 3; - static readonly ROUND_HALF_UP: 4; - static readonly ROUND_HALF_DOWN: 5; - static readonly ROUND_HALF_EVEN: 6; - static readonly ROUND_HALF_CEIL: 7; - static readonly ROUND_HALF_FLOOR: 8; - static readonly EUCLID: 9; -} - -declare type Exact = (A extends unknown ? (W extends A ? { - [K in keyof A]: Exact; -} : W) : never) | (A extends Narrowable ? A : never); - -export declare function getRuntime(): GetRuntimeOutput; - -declare type GetRuntimeOutput = { - id: RuntimeName; - prettyName: string; - isEdge: boolean; -}; - -declare class JsonNull extends NullTypesEnumValue { - #private; -} - -/** - * Generates more strict variant of an enum which, unlike regular enum, - * throws on non-existing property access. This can be useful in following situations: - * - we have an API, that accepts both `undefined` and `SomeEnumType` as an input - * - enum values are generated dynamically from DMMF. - * - * In that case, if using normal enums and no compile-time typechecking, using non-existing property - * will result in `undefined` value being used, which will be accepted. Using strict enum - * in this case will help to have a runtime exception, telling you that you are probably doing something wrong. - * - * Note: if you need to check for existence of a value in the enum you can still use either - * `in` operator or `hasOwnProperty` function. - * - * @param definition - * @returns - */ -export declare function makeStrictEnum>(definition: T): T; - -declare type Narrowable = string | number | bigint | boolean | []; - -declare class NullTypesEnumValue extends ObjectEnumValue { - _getNamespace(): string; -} - -/** - * Base class for unique values of object-valued enums. - */ -declare abstract class ObjectEnumValue { - constructor(arg?: symbol); - abstract _getNamespace(): string; - _getName(): string; - toString(): string; -} - -export declare const objectEnumValues: { - classes: { - DbNull: typeof DbNull; - JsonNull: typeof JsonNull; - AnyNull: typeof AnyNull; - }; - instances: { - DbNull: DbNull; - JsonNull: JsonNull; - AnyNull: AnyNull; - }; -}; - -declare type Operation = 'findFirst' | 'findFirstOrThrow' | 'findUnique' | 'findUniqueOrThrow' | 'findMany' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'aggregate' | 'count' | 'groupBy' | '$queryRaw' | '$executeRaw' | '$queryRawUnsafe' | '$executeRawUnsafe' | 'findRaw' | 'aggregateRaw' | '$runCommandRaw'; - -declare namespace Public { - export { - validator - } -} -export { Public } - -declare type RuntimeName = 'workerd' | 'deno' | 'netlify' | 'node' | 'bun' | 'edge-light' | ''; - -declare function validator(): (select: Exact) => S; - -declare function validator, O extends keyof C[M] & Operation>(client: C, model: M, operation: O): (select: Exact>) => S; - -declare function validator, O extends keyof C[M] & Operation, P extends keyof Args>(client: C, model: M, operation: O, prop: P): (select: Exact[P]>) => S; - -export { } diff --git a/frontend/generated/prisma/runtime/index-browser.js b/frontend/generated/prisma/runtime/index-browser.js deleted file mode 100644 index 086502f..0000000 --- a/frontend/generated/prisma/runtime/index-browser.js +++ /dev/null @@ -1,17 +0,0 @@ - -/* !!! This is code generated by Prisma. Do not edit directly. !!! -/* eslint-disable */ -// biome-ignore-all lint: generated file -"use strict";var pe=Object.defineProperty;var Xe=Object.getOwnPropertyDescriptor;var Ke=Object.getOwnPropertyNames;var Qe=Object.prototype.hasOwnProperty;var Ye=e=>{throw TypeError(e)};var Oe=(e,n)=>{for(var i in n)pe(e,i,{get:n[i],enumerable:!0})},xe=(e,n,i,t)=>{if(n&&typeof n=="object"||typeof n=="function")for(let r of Ke(n))!Qe.call(e,r)&&r!==i&&pe(e,r,{get:()=>n[r],enumerable:!(t=Xe(n,r))||t.enumerable});return e};var ze=e=>xe(pe({},"__esModule",{value:!0}),e);var ne=(e,n,i)=>n.has(e)?Ye("Cannot add the same private member more than once"):n instanceof WeakSet?n.add(e):n.set(e,i);var ii={};Oe(ii,{Decimal:()=>Je,Public:()=>ge,getRuntime:()=>_e,makeStrictEnum:()=>qe,objectEnumValues:()=>Ae});module.exports=ze(ii);var ge={};Oe(ge,{validator:()=>Re});function Re(...e){return n=>n}var ie=Symbol(),me=new WeakMap,we=class{constructor(n){n===ie?me.set(this,"Prisma.".concat(this._getName())):me.set(this,"new Prisma.".concat(this._getNamespace(),".").concat(this._getName(),"()"))}_getName(){return this.constructor.name}toString(){return me.get(this)}},G=class extends we{_getNamespace(){return"NullTypes"}},Ne,J=class extends G{constructor(){super(...arguments);ne(this,Ne)}};Ne=new WeakMap;ke(J,"DbNull");var ve,X=class extends G{constructor(){super(...arguments);ne(this,ve)}};ve=new WeakMap;ke(X,"JsonNull");var Ee,K=class extends G{constructor(){super(...arguments);ne(this,Ee)}};Ee=new WeakMap;ke(K,"AnyNull");var Ae={classes:{DbNull:J,JsonNull:X,AnyNull:K},instances:{DbNull:new J(ie),JsonNull:new X(ie),AnyNull:new K(ie)}};function ke(e,n){Object.defineProperty(e,"name",{value:n,configurable:!0})}var ye=new Set(["toJSON","$$typeof","asymmetricMatch",Symbol.iterator,Symbol.toStringTag,Symbol.isConcatSpreadable,Symbol.toPrimitive]);function qe(e){return new Proxy(e,{get(n,i){if(i in n)return n[i];if(!ye.has(i))throw new TypeError("Invalid enum value: ".concat(String(i)))}})}var en=()=>{var e,n;return((n=(e=globalThis.process)==null?void 0:e.release)==null?void 0:n.name)==="node"},nn=()=>{var e,n;return!!globalThis.Bun||!!((n=(e=globalThis.process)==null?void 0:e.versions)!=null&&n.bun)},tn=()=>!!globalThis.Deno,rn=()=>typeof globalThis.Netlify=="object",sn=()=>typeof globalThis.EdgeRuntime=="object",on=()=>{var e;return((e=globalThis.navigator)==null?void 0:e.userAgent)==="Cloudflare-Workers"};function un(){var i;return(i=[[rn,"netlify"],[sn,"edge-light"],[on,"workerd"],[tn,"deno"],[nn,"bun"],[en,"node"]].flatMap(t=>t[0]()?[t[1]]:[]).at(0))!=null?i:""}var fn={node:"Node.js",workerd:"Cloudflare Workers",deno:"Deno and Deno Deploy",netlify:"Netlify Edge Functions","edge-light":"Edge Runtime (Vercel Edge Functions, Vercel Edge Middleware, Next.js (Pages Router) Edge API Routes, Next.js (App Router) Edge Route Handlers or Next.js Middleware)"};function _e(){let e=un();return{id:e,prettyName:fn[e]||e,isEdge:["workerd","deno","netlify","edge-light"].includes(e)}}var V=9e15,H=1e9,Se="0123456789abcdef",se="2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058",oe="3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789",Me={precision:20,rounding:4,modulo:1,toExpNeg:-7,toExpPos:21,minE:-V,maxE:V,crypto:!1},Le,Z,w=!0,fe="[DecimalError] ",$=fe+"Invalid argument: ",Ie=fe+"Precision limit exceeded",Ze=fe+"crypto unavailable",Ue="[object Decimal]",R=Math.floor,C=Math.pow,cn=/^0b([01]+(\.[01]*)?|\.[01]+)(p[+-]?\d+)?$/i,ln=/^0x([0-9a-f]+(\.[0-9a-f]*)?|\.[0-9a-f]+)(p[+-]?\d+)?$/i,an=/^0o([0-7]+(\.[0-7]*)?|\.[0-7]+)(p[+-]?\d+)?$/i,Be=/^(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i,D=1e7,m=7,dn=9007199254740991,hn=se.length-1,Ce=oe.length-1,h={toStringTag:Ue};h.absoluteValue=h.abs=function(){var e=new this.constructor(this);return e.s<0&&(e.s=1),p(e)};h.ceil=function(){return p(new this.constructor(this),this.e+1,2)};h.clampedTo=h.clamp=function(e,n){var i,t=this,r=t.constructor;if(e=new r(e),n=new r(n),!e.s||!n.s)return new r(NaN);if(e.gt(n))throw Error($+n);return i=t.cmp(e),i<0?e:t.cmp(n)>0?n:new r(t)};h.comparedTo=h.cmp=function(e){var n,i,t,r,s=this,o=s.d,u=(e=new s.constructor(e)).d,c=s.s,f=e.s;if(!o||!u)return!c||!f?NaN:c!==f?c:o===u?0:!o^c<0?1:-1;if(!o[0]||!u[0])return o[0]?c:u[0]?-f:0;if(c!==f)return c;if(s.e!==e.e)return s.e>e.e^c<0?1:-1;for(t=o.length,r=u.length,n=0,i=tu[n]^c<0?1:-1;return t===r?0:t>r^c<0?1:-1};h.cosine=h.cos=function(){var e,n,i=this,t=i.constructor;return i.d?i.d[0]?(e=t.precision,n=t.rounding,t.precision=e+Math.max(i.e,i.sd())+m,t.rounding=1,i=pn(t,We(t,i)),t.precision=e,t.rounding=n,p(Z==2||Z==3?i.neg():i,e,n,!0)):new t(1):new t(NaN)};h.cubeRoot=h.cbrt=function(){var e,n,i,t,r,s,o,u,c,f,l=this,a=l.constructor;if(!l.isFinite()||l.isZero())return new a(l);for(w=!1,s=l.s*C(l.s*l,1/3),!s||Math.abs(s)==1/0?(i=b(l.d),e=l.e,(s=(e-i.length+1)%3)&&(i+=s==1||s==-2?"0":"00"),s=C(i,1/3),e=R((e+1)/3)-(e%3==(e<0?-1:2)),s==1/0?i="5e"+e:(i=s.toExponential(),i=i.slice(0,i.indexOf("e")+1)+e),t=new a(i),t.s=l.s):t=new a(s.toString()),o=(e=a.precision)+3;;)if(u=t,c=u.times(u).times(u),f=c.plus(l),t=k(f.plus(l).times(u),f.plus(c),o+2,1),b(u.d).slice(0,o)===(i=b(t.d)).slice(0,o))if(i=i.slice(o-3,o+1),i=="9999"||!r&&i=="4999"){if(!r&&(p(u,e+1,0),u.times(u).times(u).eq(l))){t=u;break}o+=4,r=1}else{(!+i||!+i.slice(1)&&i.charAt(0)=="5")&&(p(t,e+1,1),n=!t.times(t).times(t).eq(l));break}return w=!0,p(t,e,a.rounding,n)};h.decimalPlaces=h.dp=function(){var e,n=this.d,i=NaN;if(n){if(e=n.length-1,i=(e-R(this.e/m))*m,e=n[e],e)for(;e%10==0;e/=10)i--;i<0&&(i=0)}return i};h.dividedBy=h.div=function(e){return k(this,new this.constructor(e))};h.dividedToIntegerBy=h.divToInt=function(e){var n=this,i=n.constructor;return p(k(n,new i(e),0,1,1),i.precision,i.rounding)};h.equals=h.eq=function(e){return this.cmp(e)===0};h.floor=function(){return p(new this.constructor(this),this.e+1,3)};h.greaterThan=h.gt=function(e){return this.cmp(e)>0};h.greaterThanOrEqualTo=h.gte=function(e){var n=this.cmp(e);return n==1||n===0};h.hyperbolicCosine=h.cosh=function(){var e,n,i,t,r,s=this,o=s.constructor,u=new o(1);if(!s.isFinite())return new o(s.s?1/0:NaN);if(s.isZero())return u;i=o.precision,t=o.rounding,o.precision=i+Math.max(s.e,s.sd())+4,o.rounding=1,r=s.d.length,r<32?(e=Math.ceil(r/3),n=(1/le(4,e)).toString()):(e=16,n="2.3283064365386962890625e-10"),s=j(o,1,s.times(n),new o(1),!0);for(var c,f=e,l=new o(8);f--;)c=s.times(s),s=u.minus(c.times(l.minus(c.times(l))));return p(s,o.precision=i,o.rounding=t,!0)};h.hyperbolicSine=h.sinh=function(){var e,n,i,t,r=this,s=r.constructor;if(!r.isFinite()||r.isZero())return new s(r);if(n=s.precision,i=s.rounding,s.precision=n+Math.max(r.e,r.sd())+4,s.rounding=1,t=r.d.length,t<3)r=j(s,2,r,r,!0);else{e=1.4*Math.sqrt(t),e=e>16?16:e|0,r=r.times(1/le(5,e)),r=j(s,2,r,r,!0);for(var o,u=new s(5),c=new s(16),f=new s(20);e--;)o=r.times(r),r=r.times(u.plus(o.times(c.times(o).plus(f))))}return s.precision=n,s.rounding=i,p(r,n,i,!0)};h.hyperbolicTangent=h.tanh=function(){var e,n,i=this,t=i.constructor;return i.isFinite()?i.isZero()?new t(i):(e=t.precision,n=t.rounding,t.precision=e+7,t.rounding=1,k(i.sinh(),i.cosh(),t.precision=e,t.rounding=n)):new t(i.s)};h.inverseCosine=h.acos=function(){var e=this,n=e.constructor,i=e.abs().cmp(1),t=n.precision,r=n.rounding;return i!==-1?i===0?e.isNeg()?F(n,t,r):new n(0):new n(NaN):e.isZero()?F(n,t+4,r).times(.5):(n.precision=t+6,n.rounding=1,e=new n(1).minus(e).div(e.plus(1)).sqrt().atan(),n.precision=t,n.rounding=r,e.times(2))};h.inverseHyperbolicCosine=h.acosh=function(){var e,n,i=this,t=i.constructor;return i.lte(1)?new t(i.eq(1)?0:NaN):i.isFinite()?(e=t.precision,n=t.rounding,t.precision=e+Math.max(Math.abs(i.e),i.sd())+4,t.rounding=1,w=!1,i=i.times(i).minus(1).sqrt().plus(i),w=!0,t.precision=e,t.rounding=n,i.ln()):new t(i)};h.inverseHyperbolicSine=h.asinh=function(){var e,n,i=this,t=i.constructor;return!i.isFinite()||i.isZero()?new t(i):(e=t.precision,n=t.rounding,t.precision=e+2*Math.max(Math.abs(i.e),i.sd())+6,t.rounding=1,w=!1,i=i.times(i).plus(1).sqrt().plus(i),w=!0,t.precision=e,t.rounding=n,i.ln())};h.inverseHyperbolicTangent=h.atanh=function(){var e,n,i,t,r=this,s=r.constructor;return r.isFinite()?r.e>=0?new s(r.abs().eq(1)?r.s/0:r.isZero()?r:NaN):(e=s.precision,n=s.rounding,t=r.sd(),Math.max(t,e)<2*-r.e-1?p(new s(r),e,n,!0):(s.precision=i=t-r.e,r=k(r.plus(1),new s(1).minus(r),i+e,1),s.precision=e+4,s.rounding=1,r=r.ln(),s.precision=e,s.rounding=n,r.times(.5))):new s(NaN)};h.inverseSine=h.asin=function(){var e,n,i,t,r=this,s=r.constructor;return r.isZero()?new s(r):(n=r.abs().cmp(1),i=s.precision,t=s.rounding,n!==-1?n===0?(e=F(s,i+4,t).times(.5),e.s=r.s,e):new s(NaN):(s.precision=i+6,s.rounding=1,r=r.div(new s(1).minus(r.times(r)).sqrt().plus(1)).atan(),s.precision=i,s.rounding=t,r.times(2)))};h.inverseTangent=h.atan=function(){var e,n,i,t,r,s,o,u,c,f=this,l=f.constructor,a=l.precision,d=l.rounding;if(f.isFinite()){if(f.isZero())return new l(f);if(f.abs().eq(1)&&a+4<=Ce)return o=F(l,a+4,d).times(.25),o.s=f.s,o}else{if(!f.s)return new l(NaN);if(a+4<=Ce)return o=F(l,a+4,d).times(.5),o.s=f.s,o}for(l.precision=u=a+10,l.rounding=1,i=Math.min(28,u/m+2|0),e=i;e;--e)f=f.div(f.times(f).plus(1).sqrt().plus(1));for(w=!1,n=Math.ceil(u/m),t=1,c=f.times(f),o=new l(f),r=f;e!==-1;)if(r=r.times(c),s=o.minus(r.div(t+=2)),r=r.times(c),o=s.plus(r.div(t+=2)),o.d[n]!==void 0)for(e=n;o.d[e]===s.d[e]&&e--;);return i&&(o=o.times(2<this.d.length-2};h.isNaN=function(){return!this.s};h.isNegative=h.isNeg=function(){return this.s<0};h.isPositive=h.isPos=function(){return this.s>0};h.isZero=function(){return!!this.d&&this.d[0]===0};h.lessThan=h.lt=function(e){return this.cmp(e)<0};h.lessThanOrEqualTo=h.lte=function(e){return this.cmp(e)<1};h.logarithm=h.log=function(e){var n,i,t,r,s,o,u,c,f=this,l=f.constructor,a=l.precision,d=l.rounding,g=5;if(e==null)e=new l(10),n=!0;else{if(e=new l(e),i=e.d,e.s<0||!i||!i[0]||e.eq(1))return new l(NaN);n=e.eq(10)}if(i=f.d,f.s<0||!i||!i[0]||f.eq(1))return new l(i&&!i[0]?-1/0:f.s!=1?NaN:i?0:1/0);if(n)if(i.length>1)s=!0;else{for(r=i[0];r%10===0;)r/=10;s=r!==1}if(w=!1,u=a+g,o=B(f,u),t=n?ue(l,u+10):B(e,u),c=k(o,t,u,1),Q(c.d,r=a,d))do if(u+=10,o=B(f,u),t=n?ue(l,u+10):B(e,u),c=k(o,t,u,1),!s){+b(c.d).slice(r+1,r+15)+1==1e14&&(c=p(c,a+1,0));break}while(Q(c.d,r+=10,d));return w=!0,p(c,a,d)};h.minus=h.sub=function(e){var n,i,t,r,s,o,u,c,f,l,a,d,g=this,v=g.constructor;if(e=new v(e),!g.d||!e.d)return!g.s||!e.s?e=new v(NaN):g.d?e.s=-e.s:e=new v(e.d||g.s!==e.s?g:NaN),e;if(g.s!=e.s)return e.s=-e.s,g.plus(e);if(f=g.d,d=e.d,u=v.precision,c=v.rounding,!f[0]||!d[0]){if(d[0])e.s=-e.s;else if(f[0])e=new v(g);else return new v(c===3?-0:0);return w?p(e,u,c):e}if(i=R(e.e/m),l=R(g.e/m),f=f.slice(),s=l-i,s){for(a=s<0,a?(n=f,s=-s,o=d.length):(n=d,i=l,o=f.length),t=Math.max(Math.ceil(u/m),o)+2,s>t&&(s=t,n.length=1),n.reverse(),t=s;t--;)n.push(0);n.reverse()}else{for(t=f.length,o=d.length,a=t0;--t)f[o++]=0;for(t=d.length;t>s;){if(f[--t]o?s+1:o+1,r>o&&(r=o,i.length=1),i.reverse();r--;)i.push(0);i.reverse()}for(o=f.length,r=l.length,o-r<0&&(r=o,i=l,l=f,f=i),n=0;r;)n=(f[--r]=f[r]+l[r]+n)/D|0,f[r]%=D;for(n&&(f.unshift(n),++t),o=f.length;f[--o]==0;)f.pop();return e.d=f,e.e=ce(f,t),w?p(e,u,c):e};h.precision=h.sd=function(e){var n,i=this;if(e!==void 0&&e!==!!e&&e!==1&&e!==0)throw Error($+e);return i.d?(n=$e(i.d),e&&i.e+1>n&&(n=i.e+1)):n=NaN,n};h.round=function(){var e=this,n=e.constructor;return p(new n(e),e.e+1,n.rounding)};h.sine=h.sin=function(){var e,n,i=this,t=i.constructor;return i.isFinite()?i.isZero()?new t(i):(e=t.precision,n=t.rounding,t.precision=e+Math.max(i.e,i.sd())+m,t.rounding=1,i=mn(t,We(t,i)),t.precision=e,t.rounding=n,p(Z>2?i.neg():i,e,n,!0)):new t(NaN)};h.squareRoot=h.sqrt=function(){var e,n,i,t,r,s,o=this,u=o.d,c=o.e,f=o.s,l=o.constructor;if(f!==1||!u||!u[0])return new l(!f||f<0&&(!u||u[0])?NaN:u?o:1/0);for(w=!1,f=Math.sqrt(+o),f==0||f==1/0?(n=b(u),(n.length+c)%2==0&&(n+="0"),f=Math.sqrt(n),c=R((c+1)/2)-(c<0||c%2),f==1/0?n="5e"+c:(n=f.toExponential(),n=n.slice(0,n.indexOf("e")+1)+c),t=new l(n)):t=new l(f.toString()),i=(c=l.precision)+3;;)if(s=t,t=s.plus(k(o,s,i+2,1)).times(.5),b(s.d).slice(0,i)===(n=b(t.d)).slice(0,i))if(n=n.slice(i-3,i+1),n=="9999"||!r&&n=="4999"){if(!r&&(p(s,c+1,0),s.times(s).eq(o))){t=s;break}i+=4,r=1}else{(!+n||!+n.slice(1)&&n.charAt(0)=="5")&&(p(t,c+1,1),e=!t.times(t).eq(o));break}return w=!0,p(t,c,l.rounding,e)};h.tangent=h.tan=function(){var e,n,i=this,t=i.constructor;return i.isFinite()?i.isZero()?new t(i):(e=t.precision,n=t.rounding,t.precision=e+10,t.rounding=1,i=i.sin(),i.s=1,i=k(i,new t(1).minus(i.times(i)).sqrt(),e+10,0),t.precision=e,t.rounding=n,p(Z==2||Z==4?i.neg():i,e,n,!0)):new t(NaN)};h.times=h.mul=function(e){var n,i,t,r,s,o,u,c,f,l=this,a=l.constructor,d=l.d,g=(e=new a(e)).d;if(e.s*=l.s,!d||!d[0]||!g||!g[0])return new a(!e.s||d&&!d[0]&&!g||g&&!g[0]&&!d?NaN:!d||!g?e.s/0:e.s*0);for(i=R(l.e/m)+R(e.e/m),c=d.length,f=g.length,c=0;){for(n=0,r=c+t;r>t;)u=s[r]+g[t]*d[r-t-1]+n,s[r--]=u%D|0,n=u/D|0;s[r]=(s[r]+n)%D|0}for(;!s[--o];)s.pop();return n?++i:s.shift(),e.d=s,e.e=ce(s,i),w?p(e,a.precision,a.rounding):e};h.toBinary=function(e,n){return Pe(this,2,e,n)};h.toDecimalPlaces=h.toDP=function(e,n){var i=this,t=i.constructor;return i=new t(i),e===void 0?i:(q(e,0,H),n===void 0?n=t.rounding:q(n,0,8),p(i,e+i.e+1,n))};h.toExponential=function(e,n){var i,t=this,r=t.constructor;return e===void 0?i=L(t,!0):(q(e,0,H),n===void 0?n=r.rounding:q(n,0,8),t=p(new r(t),e+1,n),i=L(t,!0,e+1)),t.isNeg()&&!t.isZero()?"-"+i:i};h.toFixed=function(e,n){var i,t,r=this,s=r.constructor;return e===void 0?i=L(r):(q(e,0,H),n===void 0?n=s.rounding:q(n,0,8),t=p(new s(r),e+r.e+1,n),i=L(t,!1,e+t.e+1)),r.isNeg()&&!r.isZero()?"-"+i:i};h.toFraction=function(e){var n,i,t,r,s,o,u,c,f,l,a,d,g=this,v=g.d,N=g.constructor;if(!v)return new N(g);if(f=i=new N(1),t=c=new N(0),n=new N(t),s=n.e=$e(v)-g.e-1,o=s%m,n.d[0]=C(10,o<0?m+o:o),e==null)e=s>0?n:f;else{if(u=new N(e),!u.isInt()||u.lt(f))throw Error($+u);e=u.gt(n)?s>0?n:f:u}for(w=!1,u=new N(b(v)),l=N.precision,N.precision=s=v.length*m*2;a=k(u,n,0,1,1),r=i.plus(a.times(t)),r.cmp(e)!=1;)i=t,t=r,r=f,f=c.plus(a.times(r)),c=r,r=n,n=u.minus(a.times(r)),u=r;return r=k(e.minus(i),t,0,1,1),c=c.plus(r.times(f)),i=i.plus(r.times(t)),c.s=f.s=g.s,d=k(f,t,s,1).minus(g).abs().cmp(k(c,i,s,1).minus(g).abs())<1?[f,t]:[c,i],N.precision=l,w=!0,d};h.toHexadecimal=h.toHex=function(e,n){return Pe(this,16,e,n)};h.toNearest=function(e,n){var i=this,t=i.constructor;if(i=new t(i),e==null){if(!i.d)return i;e=new t(1),n=t.rounding}else{if(e=new t(e),n===void 0?n=t.rounding:q(n,0,8),!i.d)return e.s?i:e;if(!e.d)return e.s&&(e.s=i.s),e}return e.d[0]?(w=!1,i=k(i,e,0,n,1).times(e),w=!0,p(i)):(e.s=i.s,i=e),i};h.toNumber=function(){return+this};h.toOctal=function(e,n){return Pe(this,8,e,n)};h.toPower=h.pow=function(e){var n,i,t,r,s,o,u=this,c=u.constructor,f=+(e=new c(e));if(!u.d||!e.d||!u.d[0]||!e.d[0])return new c(C(+u,f));if(u=new c(u),u.eq(1))return u;if(t=c.precision,s=c.rounding,e.eq(1))return p(u,t,s);if(n=R(e.e/m),n>=e.d.length-1&&(i=f<0?-f:f)<=dn)return r=He(c,u,i,t),e.s<0?new c(1).div(r):p(r,t,s);if(o=u.s,o<0){if(nc.maxE+1||n0?o/0:0):(w=!1,c.rounding=u.s=1,i=Math.min(12,(n+"").length),r=be(e.times(B(u,t+i)),t),r.d&&(r=p(r,t+5,1),Q(r.d,t,s)&&(n=t+10,r=p(be(e.times(B(u,n+i)),n),n+5,1),+b(r.d).slice(t+1,t+15)+1==1e14&&(r=p(r,t+1,0)))),r.s=o,w=!0,c.rounding=s,p(r,t,s))};h.toPrecision=function(e,n){var i,t=this,r=t.constructor;return e===void 0?i=L(t,t.e<=r.toExpNeg||t.e>=r.toExpPos):(q(e,1,H),n===void 0?n=r.rounding:q(n,0,8),t=p(new r(t),e,n),i=L(t,e<=t.e||t.e<=r.toExpNeg,e)),t.isNeg()&&!t.isZero()?"-"+i:i};h.toSignificantDigits=h.toSD=function(e,n){var i=this,t=i.constructor;return e===void 0?(e=t.precision,n=t.rounding):(q(e,1,H),n===void 0?n=t.rounding:q(n,0,8)),p(new t(i),e,n)};h.toString=function(){var e=this,n=e.constructor,i=L(e,e.e<=n.toExpNeg||e.e>=n.toExpPos);return e.isNeg()&&!e.isZero()?"-"+i:i};h.truncated=h.trunc=function(){return p(new this.constructor(this),this.e+1,1)};h.valueOf=h.toJSON=function(){var e=this,n=e.constructor,i=L(e,e.e<=n.toExpNeg||e.e>=n.toExpPos);return e.isNeg()?"-"+i:i};function b(e){var n,i,t,r=e.length-1,s="",o=e[0];if(r>0){for(s+=o,n=1;ni)throw Error($+e)}function Q(e,n,i,t){var r,s,o,u;for(s=e[0];s>=10;s/=10)--n;return--n<0?(n+=m,r=0):(r=Math.ceil((n+1)/m),n%=m),s=C(10,m-n),u=e[r]%s|0,t==null?n<3?(n==0?u=u/100|0:n==1&&(u=u/10|0),o=i<4&&u==99999||i>3&&u==49999||u==5e4||u==0):o=(i<4&&u+1==s||i>3&&u+1==s/2)&&(e[r+1]/s/100|0)==C(10,n-2)-1||(u==s/2||u==0)&&(e[r+1]/s/100|0)==0:n<4?(n==0?u=u/1e3|0:n==1?u=u/100|0:n==2&&(u=u/10|0),o=(t||i<4)&&u==9999||!t&&i>3&&u==4999):o=((t||i<4)&&u+1==s||!t&&i>3&&u+1==s/2)&&(e[r+1]/s/1e3|0)==C(10,n-3)-1,o}function te(e,n,i){for(var t,r=[0],s,o=0,u=e.length;oi-1&&(r[t+1]===void 0&&(r[t+1]=0),r[t+1]+=r[t]/i|0,r[t]%=i)}return r.reverse()}function pn(e,n){var i,t,r;if(n.isZero())return n;t=n.d.length,t<32?(i=Math.ceil(t/3),r=(1/le(4,i)).toString()):(i=16,r="2.3283064365386962890625e-10"),e.precision+=i,n=j(e,1,n.times(r),new e(1));for(var s=i;s--;){var o=n.times(n);n=o.times(o).minus(o).times(8).plus(1)}return e.precision-=i,n}var k=function(){function e(t,r,s){var o,u=0,c=t.length;for(t=t.slice();c--;)o=t[c]*r+u,t[c]=o%s|0,u=o/s|0;return u&&t.unshift(u),t}function n(t,r,s,o){var u,c;if(s!=o)c=s>o?1:-1;else for(u=c=0;ur[u]?1:-1;break}return c}function i(t,r,s,o){for(var u=0;s--;)t[s]-=u,u=t[s]1;)t.shift()}return function(t,r,s,o,u,c){var f,l,a,d,g,v,N,A,M,_,E,P,x,I,ae,z,W,de,T,y,ee=t.constructor,he=t.s==r.s?1:-1,O=t.d,S=r.d;if(!O||!O[0]||!S||!S[0])return new ee(!t.s||!r.s||(O?S&&O[0]==S[0]:!S)?NaN:O&&O[0]==0||!S?he*0:he/0);for(c?(g=1,l=t.e-r.e):(c=D,g=m,l=R(t.e/g)-R(r.e/g)),T=S.length,W=O.length,M=new ee(he),_=M.d=[],a=0;S[a]==(O[a]||0);a++);if(S[a]>(O[a]||0)&&l--,s==null?(I=s=ee.precision,o=ee.rounding):u?I=s+(t.e-r.e)+1:I=s,I<0)_.push(1),v=!0;else{if(I=I/g+2|0,a=0,T==1){for(d=0,S=S[0],I++;(a1&&(S=e(S,d,c),O=e(O,d,c),T=S.length,W=O.length),z=T,E=O.slice(0,T),P=E.length;P=c/2&&++de;do d=0,f=n(S,E,T,P),f<0?(x=E[0],T!=P&&(x=x*c+(E[1]||0)),d=x/de|0,d>1?(d>=c&&(d=c-1),N=e(S,d,c),A=N.length,P=E.length,f=n(N,E,A,P),f==1&&(d--,i(N,T=10;d/=10)a++;M.e=a+l*g-1,p(M,u?s+M.e+1:s,o,v)}return M}}();function p(e,n,i,t){var r,s,o,u,c,f,l,a,d,g=e.constructor;e:if(n!=null){if(a=e.d,!a)return e;for(r=1,u=a[0];u>=10;u/=10)r++;if(s=n-r,s<0)s+=m,o=n,l=a[d=0],c=l/C(10,r-o-1)%10|0;else if(d=Math.ceil((s+1)/m),u=a.length,d>=u)if(t){for(;u++<=d;)a.push(0);l=c=0,r=1,s%=m,o=s-m+1}else break e;else{for(l=u=a[d],r=1;u>=10;u/=10)r++;s%=m,o=s-m+r,c=o<0?0:l/C(10,r-o-1)%10|0}if(t=t||n<0||a[d+1]!==void 0||(o<0?l:l%C(10,r-o-1)),f=i<4?(c||t)&&(i==0||i==(e.s<0?3:2)):c>5||c==5&&(i==4||t||i==6&&(s>0?o>0?l/C(10,r-o):0:a[d-1])%10&1||i==(e.s<0?8:7)),n<1||!a[0])return a.length=0,f?(n-=e.e+1,a[0]=C(10,(m-n%m)%m),e.e=-n||0):a[0]=e.e=0,e;if(s==0?(a.length=d,u=1,d--):(a.length=d+1,u=C(10,m-s),a[d]=o>0?(l/C(10,r-o)%C(10,o)|0)*u:0),f)for(;;)if(d==0){for(s=1,o=a[0];o>=10;o/=10)s++;for(o=a[0]+=u,u=1;o>=10;o/=10)u++;s!=u&&(e.e++,a[0]==D&&(a[0]=1));break}else{if(a[d]+=u,a[d]!=D)break;a[d--]=0,u=1}for(s=a.length;a[--s]===0;)a.pop()}return w&&(e.e>g.maxE?(e.d=null,e.e=NaN):e.e0?s=s.charAt(0)+"."+s.slice(1)+U(t):o>1&&(s=s.charAt(0)+"."+s.slice(1)),s=s+(e.e<0?"e":"e+")+e.e):r<0?(s="0."+U(-r-1)+s,i&&(t=i-o)>0&&(s+=U(t))):r>=o?(s+=U(r+1-o),i&&(t=i-r-1)>0&&(s=s+"."+U(t))):((t=r+1)0&&(r+1===o&&(s+="."),s+=U(t))),s}function ce(e,n){var i=e[0];for(n*=m;i>=10;i/=10)n++;return n}function ue(e,n,i){if(n>hn)throw w=!0,i&&(e.precision=i),Error(Ie);return p(new e(se),n,1,!0)}function F(e,n,i){if(n>Ce)throw Error(Ie);return p(new e(oe),n,i,!0)}function $e(e){var n=e.length-1,i=n*m+1;if(n=e[n],n){for(;n%10==0;n/=10)i--;for(n=e[0];n>=10;n/=10)i++}return i}function U(e){for(var n="";e--;)n+="0";return n}function He(e,n,i,t){var r,s=new e(1),o=Math.ceil(t/m+4);for(w=!1;;){if(i%2&&(s=s.times(n),De(s.d,o)&&(r=!0)),i=R(i/2),i===0){i=s.d.length-1,r&&s.d[i]===0&&++s.d[i];break}n=n.times(n),De(n.d,o)}return w=!0,s}function Te(e){return e.d[e.d.length-1]&1}function Ve(e,n,i){for(var t,r,s=new e(n[0]),o=0;++o17)return new d(e.d?e.d[0]?e.s<0?0:1/0:1:e.s?e.s<0?0:e:NaN);for(n==null?(w=!1,c=v):c=n,u=new d(.03125);e.e>-2;)e=e.times(u),a+=5;for(t=Math.log(C(2,a))/Math.LN10*2+5|0,c+=t,i=s=o=new d(1),d.precision=c;;){if(s=p(s.times(e),c,1),i=i.times(++l),u=o.plus(k(s,i,c,1)),b(u.d).slice(0,c)===b(o.d).slice(0,c)){for(r=a;r--;)o=p(o.times(o),c,1);if(n==null)if(f<3&&Q(o.d,c-t,g,f))d.precision=c+=10,i=s=u=new d(1),l=0,f++;else return p(o,d.precision=v,g,w=!0);else return d.precision=v,o}o=u}}function B(e,n){var i,t,r,s,o,u,c,f,l,a,d,g=1,v=10,N=e,A=N.d,M=N.constructor,_=M.rounding,E=M.precision;if(N.s<0||!A||!A[0]||!N.e&&A[0]==1&&A.length==1)return new M(A&&!A[0]?-1/0:N.s!=1?NaN:A?0:N);if(n==null?(w=!1,l=E):l=n,M.precision=l+=v,i=b(A),t=i.charAt(0),Math.abs(s=N.e)<15e14){for(;t<7&&t!=1||t==1&&i.charAt(1)>3;)N=N.times(e),i=b(N.d),t=i.charAt(0),g++;s=N.e,t>1?(N=new M("0."+i),s++):N=new M(t+"."+i.slice(1))}else return f=ue(M,l+2,E).times(s+""),N=B(new M(t+"."+i.slice(1)),l-v).plus(f),M.precision=E,n==null?p(N,E,_,w=!0):N;for(a=N,c=o=N=k(N.minus(1),N.plus(1),l,1),d=p(N.times(N),l,1),r=3;;){if(o=p(o.times(d),l,1),f=c.plus(k(o,new M(r),l,1)),b(f.d).slice(0,l)===b(c.d).slice(0,l))if(c=c.times(2),s!==0&&(c=c.plus(ue(M,l+2,E).times(s+""))),c=k(c,new M(g),l,1),n==null)if(Q(c.d,l-v,_,u))M.precision=l+=v,f=o=N=k(a.minus(1),a.plus(1),l,1),d=p(N.times(N),l,1),r=u=1;else return p(c,M.precision=E,_,w=!0);else return M.precision=E,c;c=f,r+=2}}function je(e){return String(e.s*e.s/0)}function re(e,n){var i,t,r;for((i=n.indexOf("."))>-1&&(n=n.replace(".","")),(t=n.search(/e/i))>0?(i<0&&(i=t),i+=+n.slice(t+1),n=n.substring(0,t)):i<0&&(i=n.length),t=0;n.charCodeAt(t)===48;t++);for(r=n.length;n.charCodeAt(r-1)===48;--r);if(n=n.slice(t,r),n){if(r-=t,e.e=i=i-t-1,e.d=[],t=(i+1)%m,i<0&&(t+=m),te.constructor.maxE?(e.d=null,e.e=NaN):e.e-1){if(n=n.replace(/(\d)_(?=\d)/g,"$1"),Be.test(n))return re(e,n)}else if(n==="Infinity"||n==="NaN")return+n||(e.s=NaN),e.e=NaN,e.d=null,e;if(ln.test(n))i=16,n=n.toLowerCase();else if(cn.test(n))i=2;else if(an.test(n))i=8;else throw Error($+n);for(s=n.search(/p/i),s>0?(c=+n.slice(s+1),n=n.substring(2,s)):n=n.slice(2),s=n.indexOf("."),o=s>=0,t=e.constructor,o&&(n=n.replace(".",""),u=n.length,s=u-s,r=He(t,new t(i),s,s*2)),f=te(n,i,D),l=f.length-1,s=l;f[s]===0;--s)f.pop();return s<0?new t(e.s*0):(e.e=ce(f,l),e.d=f,w=!1,o&&(e=k(e,r,u*4)),c&&(e=e.times(Math.abs(c)<54?C(2,c):Y.pow(2,c))),w=!0,e)}function mn(e,n){var i,t=n.d.length;if(t<3)return n.isZero()?n:j(e,2,n,n);i=1.4*Math.sqrt(t),i=i>16?16:i|0,n=n.times(1/le(5,i)),n=j(e,2,n,n);for(var r,s=new e(5),o=new e(16),u=new e(20);i--;)r=n.times(n),n=n.times(s.plus(r.times(o.times(r).minus(u))));return n}function j(e,n,i,t,r){var s,o,u,c,f=1,l=e.precision,a=Math.ceil(l/m);for(w=!1,c=i.times(i),u=new e(t);;){if(o=k(u.times(c),new e(n++*n++),l,1),u=r?t.plus(o):t.minus(o),t=k(o.times(c),new e(n++*n++),l,1),o=u.plus(t),o.d[a]!==void 0){for(s=a;o.d[s]===u.d[s]&&s--;);if(s==-1)break}s=u,u=t,t=o,o=s,f++}return w=!0,o.d.length=a+1,o}function le(e,n){for(var i=e;--n;)i*=e;return i}function We(e,n){var i,t=n.s<0,r=F(e,e.precision,1),s=r.times(.5);if(n=n.abs(),n.lte(s))return Z=t?4:1,n;if(i=n.divToInt(r),i.isZero())Z=t?3:2;else{if(n=n.minus(i.times(r)),n.lte(s))return Z=Te(i)?t?2:3:t?4:1,n;Z=Te(i)?t?1:4:t?3:2}return n.minus(r).abs()}function Pe(e,n,i,t){var r,s,o,u,c,f,l,a,d,g=e.constructor,v=i!==void 0;if(v?(q(i,1,H),t===void 0?t=g.rounding:q(t,0,8)):(i=g.precision,t=g.rounding),!e.isFinite())l=je(e);else{for(l=L(e),o=l.indexOf("."),v?(r=2,n==16?i=i*4-3:n==8&&(i=i*3-2)):r=n,o>=0&&(l=l.replace(".",""),d=new g(1),d.e=l.length-o,d.d=te(L(d),10,r),d.e=d.d.length),a=te(l,10,r),s=c=a.length;a[--c]==0;)a.pop();if(!a[0])l=v?"0p+0":"0";else{if(o<0?s--:(e=new g(e),e.d=a,e.e=s,e=k(e,d,i,t,0,r),a=e.d,s=e.e,f=Le),o=a[i],u=r/2,f=f||a[i+1]!==void 0,f=t<4?(o!==void 0||f)&&(t===0||t===(e.s<0?3:2)):o>u||o===u&&(t===4||f||t===6&&a[i-1]&1||t===(e.s<0?8:7)),a.length=i,f)for(;++a[--i]>r-1;)a[i]=0,i||(++s,a.unshift(1));for(c=a.length;!a[c-1];--c);for(o=0,l="";o1)if(n==16||n==8){for(o=n==16?4:3,--c;c%o;c++)l+="0";for(a=te(l,r,n),c=a.length;!a[c-1];--c);for(o=1,l="1.";oc)for(s-=c;s--;)l+="0";else sn)return e.length=n,!0}function wn(e){return new this(e).abs()}function Nn(e){return new this(e).acos()}function vn(e){return new this(e).acosh()}function En(e,n){return new this(e).plus(n)}function kn(e){return new this(e).asin()}function Sn(e){return new this(e).asinh()}function Mn(e){return new this(e).atan()}function Cn(e){return new this(e).atanh()}function bn(e,n){e=new this(e),n=new this(n);var i,t=this.precision,r=this.rounding,s=t+4;return!e.s||!n.s?i=new this(NaN):!e.d&&!n.d?(i=F(this,s,1).times(n.s>0?.25:.75),i.s=e.s):!n.d||e.isZero()?(i=n.s<0?F(this,t,r):new this(0),i.s=e.s):!e.d||n.isZero()?(i=F(this,s,1).times(.5),i.s=e.s):n.s<0?(this.precision=s,this.rounding=1,i=this.atan(k(e,n,s,1)),n=F(this,s,1),this.precision=t,this.rounding=r,i=e.s<0?i.minus(n):i.plus(n)):i=this.atan(k(e,n,s,1)),i}function Pn(e){return new this(e).cbrt()}function On(e){return p(e=new this(e),e.e+1,2)}function Rn(e,n,i){return new this(e).clamp(n,i)}function An(e){if(!e||typeof e!="object")throw Error(fe+"Object expected");var n,i,t,r=e.defaults===!0,s=["precision",1,H,"rounding",0,8,"toExpNeg",-V,0,"toExpPos",0,V,"maxE",0,V,"minE",-V,0,"modulo",0,9];for(n=0;n=s[n+1]&&t<=s[n+2])this[i]=t;else throw Error($+i+": "+t);if(i="crypto",r&&(this[i]=Me[i]),(t=e[i])!==void 0)if(t===!0||t===!1||t===0||t===1)if(t)if(typeof crypto<"u"&&crypto&&(crypto.getRandomValues||crypto.randomBytes))this[i]=!0;else throw Error(Ze);else this[i]=!1;else throw Error($+i+": "+t);return this}function qn(e){return new this(e).cos()}function _n(e){return new this(e).cosh()}function Ge(e){var n,i,t;function r(s){var o,u,c,f=this;if(!(f instanceof r))return new r(s);if(f.constructor=r,Fe(s)){f.s=s.s,w?!s.d||s.e>r.maxE?(f.e=NaN,f.d=null):s.e=10;u/=10)o++;w?o>r.maxE?(f.e=NaN,f.d=null):o=429e7?n[s]=crypto.getRandomValues(new Uint32Array(1))[0]:u[s++]=r%1e7;else if(crypto.randomBytes){for(n=crypto.randomBytes(t*=4);s=214e7?crypto.randomBytes(4).copy(n,s):(u.push(r%1e7),s+=4);s=t/4}else throw Error(Ze);else for(;s=10;r/=10)t++;t - * MIT Licence - *) -*/ -//# sourceMappingURL=index-browser.js.map diff --git a/frontend/generated/prisma/runtime/library.d.ts b/frontend/generated/prisma/runtime/library.d.ts deleted file mode 100644 index ffaec81..0000000 --- a/frontend/generated/prisma/runtime/library.d.ts +++ /dev/null @@ -1,3982 +0,0 @@ -/** - * @param this - */ -declare function $extends(this: Client, extension: ExtensionArgs | ((client: Client) => Client)): Client; - -declare type AccelerateEngineConfig = { - inlineSchema: EngineConfig['inlineSchema']; - inlineSchemaHash: EngineConfig['inlineSchemaHash']; - env: EngineConfig['env']; - generator?: { - previewFeatures: string[]; - }; - inlineDatasources: EngineConfig['inlineDatasources']; - overrideDatasources: EngineConfig['overrideDatasources']; - clientVersion: EngineConfig['clientVersion']; - engineVersion: EngineConfig['engineVersion']; - logEmitter: EngineConfig['logEmitter']; - logQueries?: EngineConfig['logQueries']; - logLevel?: EngineConfig['logLevel']; - tracingHelper: EngineConfig['tracingHelper']; - accelerateUtils?: AccelerateUtils; -}; - -/** - * A stripped down interface of `fetch` that `@prisma/extension-accelerate` - * relies on. It must be in sync with the corresponding definition in the - * Accelerate extension. - * - * This is the actual interface exposed by the extension. We can't use the - * custom fetch function provided by it as normal fetch because the API is - * different. Notably, `headers` must be an object and not a `Headers` - * instance, and `url` must be a `string` and not a `URL`. - * - * The return type is `Response` but we can't specify this in an exported type - * because it would end up referencing external types from `@types/node` or DOM - * which can fail typechecking depending on TypeScript configuration in a user's - * project. - */ -declare type AccelerateExtensionFetch = (url: string, options: { - body?: string; - method?: string; - headers: Record; -}) => Promise; - -declare type AccelerateExtensionFetchDecorator = (fetch: AccelerateExtensionFetch) => AccelerateExtensionFetch; - -declare type AccelerateUtils = EngineConfig['accelerateUtils']; - -export declare type Action = keyof typeof DMMF_2.ModelAction | 'executeRaw' | 'queryRaw' | 'runCommandRaw'; - -declare type ActiveConnectorType = Exclude; - -/** - * An interface that exposes some basic information about the - * adapter like its name and provider type. - */ -declare interface AdapterInfo { - readonly provider: Provider; - readonly adapterName: (typeof officialPrismaAdapters)[number] | (string & {}); -} - -export declare type Aggregate = '_count' | '_max' | '_min' | '_avg' | '_sum'; - -export declare type AllModelsToStringIndex, K extends PropertyKey> = Args extends { - [P in K]: { - $allModels: infer AllModels; - }; -} ? { - [P in K]: Record; -} : {}; - -declare class AnyNull extends NullTypesEnumValue { - #private; -} - -export declare type ApplyOmit = Compute<{ - [K in keyof T as OmitValue extends true ? never : K]: T[K]; -}>; - -export declare type Args = T extends { - [K: symbol]: { - types: { - operations: { - [K in F]: { - args: any; - }; - }; - }; - }; -} ? T[symbol]['types']['operations'][F]['args'] : any; - -export declare type Args_3 = Args; - -declare type ArgScalarType = 'string' | 'int' | 'bigint' | 'float' | 'decimal' | 'boolean' | 'enum' | 'uuid' | 'json' | 'datetime' | 'bytes' | 'unknown'; - -declare type ArgType = { - scalarType: ArgScalarType; - dbType?: string; - arity: Arity; -}; - -declare type Arity = 'scalar' | 'list'; - -/** - * Attributes is a map from string to attribute values. - * - * Note: only the own enumerable keys are counted as valid attribute keys. - */ -declare interface Attributes { - [attributeKey: string]: AttributeValue | undefined; -} - -/** - * Attribute values may be any non-nullish primitive value except an object. - * - * null or undefined attribute values are invalid and will result in undefined behavior. - */ -declare type AttributeValue = string | number | boolean | Array | Array | Array; - -export declare type BaseDMMF = { - readonly datamodel: Omit; -}; - -declare type BatchArgs = { - queries: BatchQuery[]; - transaction?: { - isolationLevel?: IsolationLevel_2; - }; -}; - -declare type BatchInternalParams = { - requests: RequestParams[]; - customDataProxyFetch?: AccelerateExtensionFetchDecorator; -}; - -declare type BatchQuery = { - model: string | undefined; - operation: string; - args: JsArgs | RawQueryArgs; -}; - -declare type BatchQueryEngineResult = QueryEngineResultData | Error; - -declare type BatchQueryOptionsCb = (args: BatchQueryOptionsCbArgs) => Promise; - -declare type BatchQueryOptionsCbArgs = { - args: BatchArgs; - query: (args: BatchArgs, __internalParams?: BatchInternalParams) => Promise; - __internalParams: BatchInternalParams; -}; - -declare type BatchResponse = MultiBatchResponse | CompactedBatchResponse; - -declare type BatchTransactionOptions = { - isolationLevel?: Transaction_2.IsolationLevel; -}; - -declare interface BinaryTargetsEnvValue { - fromEnvVar: string | null; - value: string; - native?: boolean; -} - -/** - * Equivalent to `Uint8Array` before TypeScript 5.7, and `Uint8Array` in TypeScript 5.7 and beyond. - */ -export declare type Bytes = ReturnType; - -export declare type Call = (F & { - params: P; -})['returns']; - -declare interface CallSite { - getLocation(): LocationInFile | null; -} - -export declare type Cast = A extends W ? A : W; - -declare type Client = ReturnType extends new () => infer T ? T : never; - -export declare type ClientArg = { - [MethodName in string]: unknown; -}; - -export declare type ClientArgs = { - client: ClientArg; -}; - -export declare type ClientBuiltInProp = keyof DynamicClientExtensionThisBuiltin; - -export declare type ClientOptionDef = undefined | { - [K in string]: any; -}; - -export declare type ClientOtherOps = { - $queryRaw(query: TemplateStringsArray | Sql, ...values: any[]): PrismaPromise; - $queryRawTyped(query: TypedSql): PrismaPromise; - $queryRawUnsafe(query: string, ...values: any[]): PrismaPromise; - $executeRaw(query: TemplateStringsArray | Sql, ...values: any[]): PrismaPromise; - $executeRawUnsafe(query: string, ...values: any[]): PrismaPromise; - $runCommandRaw(command: InputJsonObject): PrismaPromise; -}; - -declare type ColumnType = (typeof ColumnTypeEnum)[keyof typeof ColumnTypeEnum]; - -declare const ColumnTypeEnum: { - readonly Int32: 0; - readonly Int64: 1; - readonly Float: 2; - readonly Double: 3; - readonly Numeric: 4; - readonly Boolean: 5; - readonly Character: 6; - readonly Text: 7; - readonly Date: 8; - readonly Time: 9; - readonly DateTime: 10; - readonly Json: 11; - readonly Enum: 12; - readonly Bytes: 13; - readonly Set: 14; - readonly Uuid: 15; - readonly Int32Array: 64; - readonly Int64Array: 65; - readonly FloatArray: 66; - readonly DoubleArray: 67; - readonly NumericArray: 68; - readonly BooleanArray: 69; - readonly CharacterArray: 70; - readonly TextArray: 71; - readonly DateArray: 72; - readonly TimeArray: 73; - readonly DateTimeArray: 74; - readonly JsonArray: 75; - readonly EnumArray: 76; - readonly BytesArray: 77; - readonly UuidArray: 78; - readonly UnknownNumber: 128; -}; - -declare type CompactedBatchResponse = { - type: 'compacted'; - plan: QueryPlanNode; - arguments: Record[]; - nestedSelection: string[]; - keys: string[]; - expectNonEmpty: boolean; -}; - -declare type CompilerWasmLoadingConfig = { - /** - * WASM-bindgen runtime for corresponding module - */ - getRuntime: () => Promise<{ - __wbg_set_wasm(exports: unknown): void; - QueryCompiler: QueryCompilerConstructor; - }>; - /** - * Loads the raw wasm module for the wasm compiler engine. This configuration is - * generated specifically for each type of client, eg. Node.js client and Edge - * clients will have different implementations. - * @remarks this is a callback on purpose, we only load the wasm if needed. - * @remarks only used by ClientEngine - */ - getQueryCompilerWasmModule: () => Promise; -}; - -export declare type Compute = T extends Function ? T : { - [K in keyof T]: T[K]; -} & unknown; - -export declare type ComputeDeep = T extends Function ? T : { - [K in keyof T]: ComputeDeep; -} & unknown; - -declare type ComputedField = { - name: string; - needs: string[]; - compute: ResultArgsFieldCompute; -}; - -declare type ComputedFieldsMap = { - [fieldName: string]: ComputedField; -}; - -declare type ConnectionInfo = { - schemaName?: string; - maxBindValues?: number; - supportsRelationJoins: boolean; -}; - -declare type ConnectorType = 'mysql' | 'mongodb' | 'sqlite' | 'postgresql' | 'postgres' | 'prisma+postgres' | 'sqlserver' | 'cockroachdb'; - -declare interface Context { - /** - * Get a value from the context. - * - * @param key key which identifies a context value - */ - getValue(key: symbol): unknown; - /** - * Create a new context which inherits from this context and has - * the given key set to the given value. - * - * @param key context key for which to set the value - * @param value value to set for the given key - */ - setValue(key: symbol, value: unknown): Context; - /** - * Return a new context which inherits from this context but does - * not contain a value for the given key. - * - * @param key context key for which to clear a value - */ - deleteValue(key: symbol): Context; -} - -declare type Context_2 = T extends { - [K: symbol]: { - ctx: infer C; - }; -} ? C & T & { - /** - * @deprecated Use `$name` instead. - */ - name?: string; - $name?: string; - $parent?: unknown; -} : T & { - /** - * @deprecated Use `$name` instead. - */ - name?: string; - $name?: string; - $parent?: unknown; -}; - -export declare type Count = { - [K in keyof O]: Count; -} & {}; - -export declare function createParam(name: string): Param; - -declare class DataLoader { - private options; - batches: { - [key: string]: Job[]; - }; - private tickActive; - constructor(options: DataLoaderOptions); - request(request: T): Promise; - private dispatchBatches; - get [Symbol.toStringTag](): string; -} - -declare type DataLoaderOptions = { - singleLoader: (request: T) => Promise; - batchLoader: (request: T[]) => Promise; - batchBy: (request: T) => string | undefined; - batchOrder: (requestA: T, requestB: T) => number; -}; - -declare type Datamodel = ReadonlyDeep_2<{ - models: Model[]; - enums: DatamodelEnum[]; - types: Model[]; - indexes: Index[]; -}>; - -declare type DatamodelEnum = ReadonlyDeep_2<{ - name: string; - values: EnumValue[]; - dbName?: string | null; - documentation?: string; -}>; - -declare function datamodelEnumToSchemaEnum(datamodelEnum: DatamodelEnum): SchemaEnum; - -declare type DataRule = { - type: 'rowCountEq'; - args: number; -} | { - type: 'rowCountNeq'; - args: number; -} | { - type: 'affectedRowCountEq'; - args: number; -} | { - type: 'never'; -}; - -declare type Datasource = { - url?: string; -}; - -declare type Datasources = { - [name in string]: Datasource; -}; - -declare class DbNull extends NullTypesEnumValue { - #private; -} - -export declare const Debug: typeof debugCreate & { - enable(namespace: any): void; - disable(): any; - enabled(namespace: string): boolean; - log: (...args: string[]) => void; - formatters: {}; -}; - -/** - * Create a new debug instance with the given namespace. - * - * @example - * ```ts - * import Debug from '@prisma/debug' - * const debug = Debug('prisma:client') - * debug('Hello World') - * ``` - */ -declare function debugCreate(namespace: string): ((...args: any[]) => void) & { - color: string; - enabled: boolean; - namespace: string; - log: (...args: string[]) => void; - extend: () => void; -}; - -export declare function Decimal(n: Decimal.Value): Decimal; - -export declare namespace Decimal { - export type Constructor = typeof Decimal; - export type Instance = Decimal; - export type Rounding = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8; - export type Modulo = Rounding | 9; - export type Value = string | number | Decimal; - - // http://mikemcl.github.io/decimal.js/#constructor-properties - export interface Config { - precision?: number; - rounding?: Rounding; - toExpNeg?: number; - toExpPos?: number; - minE?: number; - maxE?: number; - crypto?: boolean; - modulo?: Modulo; - defaults?: boolean; - } -} - -export declare class Decimal { - readonly d: number[]; - readonly e: number; - readonly s: number; - - constructor(n: Decimal.Value); - - absoluteValue(): Decimal; - abs(): Decimal; - - ceil(): Decimal; - - clampedTo(min: Decimal.Value, max: Decimal.Value): Decimal; - clamp(min: Decimal.Value, max: Decimal.Value): Decimal; - - comparedTo(n: Decimal.Value): number; - cmp(n: Decimal.Value): number; - - cosine(): Decimal; - cos(): Decimal; - - cubeRoot(): Decimal; - cbrt(): Decimal; - - decimalPlaces(): number; - dp(): number; - - dividedBy(n: Decimal.Value): Decimal; - div(n: Decimal.Value): Decimal; - - dividedToIntegerBy(n: Decimal.Value): Decimal; - divToInt(n: Decimal.Value): Decimal; - - equals(n: Decimal.Value): boolean; - eq(n: Decimal.Value): boolean; - - floor(): Decimal; - - greaterThan(n: Decimal.Value): boolean; - gt(n: Decimal.Value): boolean; - - greaterThanOrEqualTo(n: Decimal.Value): boolean; - gte(n: Decimal.Value): boolean; - - hyperbolicCosine(): Decimal; - cosh(): Decimal; - - hyperbolicSine(): Decimal; - sinh(): Decimal; - - hyperbolicTangent(): Decimal; - tanh(): Decimal; - - inverseCosine(): Decimal; - acos(): Decimal; - - inverseHyperbolicCosine(): Decimal; - acosh(): Decimal; - - inverseHyperbolicSine(): Decimal; - asinh(): Decimal; - - inverseHyperbolicTangent(): Decimal; - atanh(): Decimal; - - inverseSine(): Decimal; - asin(): Decimal; - - inverseTangent(): Decimal; - atan(): Decimal; - - isFinite(): boolean; - - isInteger(): boolean; - isInt(): boolean; - - isNaN(): boolean; - - isNegative(): boolean; - isNeg(): boolean; - - isPositive(): boolean; - isPos(): boolean; - - isZero(): boolean; - - lessThan(n: Decimal.Value): boolean; - lt(n: Decimal.Value): boolean; - - lessThanOrEqualTo(n: Decimal.Value): boolean; - lte(n: Decimal.Value): boolean; - - logarithm(n?: Decimal.Value): Decimal; - log(n?: Decimal.Value): Decimal; - - minus(n: Decimal.Value): Decimal; - sub(n: Decimal.Value): Decimal; - - modulo(n: Decimal.Value): Decimal; - mod(n: Decimal.Value): Decimal; - - naturalExponential(): Decimal; - exp(): Decimal; - - naturalLogarithm(): Decimal; - ln(): Decimal; - - negated(): Decimal; - neg(): Decimal; - - plus(n: Decimal.Value): Decimal; - add(n: Decimal.Value): Decimal; - - precision(includeZeros?: boolean): number; - sd(includeZeros?: boolean): number; - - round(): Decimal; - - sine() : Decimal; - sin() : Decimal; - - squareRoot(): Decimal; - sqrt(): Decimal; - - tangent() : Decimal; - tan() : Decimal; - - times(n: Decimal.Value): Decimal; - mul(n: Decimal.Value) : Decimal; - - toBinary(significantDigits?: number): string; - toBinary(significantDigits: number, rounding: Decimal.Rounding): string; - - toDecimalPlaces(decimalPlaces?: number): Decimal; - toDecimalPlaces(decimalPlaces: number, rounding: Decimal.Rounding): Decimal; - toDP(decimalPlaces?: number): Decimal; - toDP(decimalPlaces: number, rounding: Decimal.Rounding): Decimal; - - toExponential(decimalPlaces?: number): string; - toExponential(decimalPlaces: number, rounding: Decimal.Rounding): string; - - toFixed(decimalPlaces?: number): string; - toFixed(decimalPlaces: number, rounding: Decimal.Rounding): string; - - toFraction(max_denominator?: Decimal.Value): Decimal[]; - - toHexadecimal(significantDigits?: number): string; - toHexadecimal(significantDigits: number, rounding: Decimal.Rounding): string; - toHex(significantDigits?: number): string; - toHex(significantDigits: number, rounding?: Decimal.Rounding): string; - - toJSON(): string; - - toNearest(n: Decimal.Value, rounding?: Decimal.Rounding): Decimal; - - toNumber(): number; - - toOctal(significantDigits?: number): string; - toOctal(significantDigits: number, rounding: Decimal.Rounding): string; - - toPower(n: Decimal.Value): Decimal; - pow(n: Decimal.Value): Decimal; - - toPrecision(significantDigits?: number): string; - toPrecision(significantDigits: number, rounding: Decimal.Rounding): string; - - toSignificantDigits(significantDigits?: number): Decimal; - toSignificantDigits(significantDigits: number, rounding: Decimal.Rounding): Decimal; - toSD(significantDigits?: number): Decimal; - toSD(significantDigits: number, rounding: Decimal.Rounding): Decimal; - - toString(): string; - - truncated(): Decimal; - trunc(): Decimal; - - valueOf(): string; - - static abs(n: Decimal.Value): Decimal; - static acos(n: Decimal.Value): Decimal; - static acosh(n: Decimal.Value): Decimal; - static add(x: Decimal.Value, y: Decimal.Value): Decimal; - static asin(n: Decimal.Value): Decimal; - static asinh(n: Decimal.Value): Decimal; - static atan(n: Decimal.Value): Decimal; - static atanh(n: Decimal.Value): Decimal; - static atan2(y: Decimal.Value, x: Decimal.Value): Decimal; - static cbrt(n: Decimal.Value): Decimal; - static ceil(n: Decimal.Value): Decimal; - static clamp(n: Decimal.Value, min: Decimal.Value, max: Decimal.Value): Decimal; - static clone(object?: Decimal.Config): Decimal.Constructor; - static config(object: Decimal.Config): Decimal.Constructor; - static cos(n: Decimal.Value): Decimal; - static cosh(n: Decimal.Value): Decimal; - static div(x: Decimal.Value, y: Decimal.Value): Decimal; - static exp(n: Decimal.Value): Decimal; - static floor(n: Decimal.Value): Decimal; - static hypot(...n: Decimal.Value[]): Decimal; - static isDecimal(object: any): object is Decimal; - static ln(n: Decimal.Value): Decimal; - static log(n: Decimal.Value, base?: Decimal.Value): Decimal; - static log2(n: Decimal.Value): Decimal; - static log10(n: Decimal.Value): Decimal; - static max(...n: Decimal.Value[]): Decimal; - static min(...n: Decimal.Value[]): Decimal; - static mod(x: Decimal.Value, y: Decimal.Value): Decimal; - static mul(x: Decimal.Value, y: Decimal.Value): Decimal; - static noConflict(): Decimal.Constructor; // Browser only - static pow(base: Decimal.Value, exponent: Decimal.Value): Decimal; - static random(significantDigits?: number): Decimal; - static round(n: Decimal.Value): Decimal; - static set(object: Decimal.Config): Decimal.Constructor; - static sign(n: Decimal.Value): number; - static sin(n: Decimal.Value): Decimal; - static sinh(n: Decimal.Value): Decimal; - static sqrt(n: Decimal.Value): Decimal; - static sub(x: Decimal.Value, y: Decimal.Value): Decimal; - static sum(...n: Decimal.Value[]): Decimal; - static tan(n: Decimal.Value): Decimal; - static tanh(n: Decimal.Value): Decimal; - static trunc(n: Decimal.Value): Decimal; - - static readonly default?: Decimal.Constructor; - static readonly Decimal?: Decimal.Constructor; - - static readonly precision: number; - static readonly rounding: Decimal.Rounding; - static readonly toExpNeg: number; - static readonly toExpPos: number; - static readonly minE: number; - static readonly maxE: number; - static readonly crypto: boolean; - static readonly modulo: Decimal.Modulo; - - static readonly ROUND_UP: 0; - static readonly ROUND_DOWN: 1; - static readonly ROUND_CEIL: 2; - static readonly ROUND_FLOOR: 3; - static readonly ROUND_HALF_UP: 4; - static readonly ROUND_HALF_DOWN: 5; - static readonly ROUND_HALF_EVEN: 6; - static readonly ROUND_HALF_CEIL: 7; - static readonly ROUND_HALF_FLOOR: 8; - static readonly EUCLID: 9; -} - -/** - * Interface for any Decimal.js-like library - * Allows us to accept Decimal.js from different - * versions and some compatible alternatives - */ -export declare interface DecimalJsLike { - d: number[]; - e: number; - s: number; - toFixed(): string; -} - -export declare type DefaultArgs = InternalArgs<{}, {}, {}, {}>; - -export declare type DefaultSelection = Args extends { - omit: infer LocalOmit; -} ? ApplyOmit['default'], PatchFlat>>> : ApplyOmit['default'], ExtractGlobalOmit>>; - -export declare function defineDmmfProperty(target: object, runtimeDataModel: RuntimeDataModel): void; - -declare function defineExtension(ext: ExtensionArgs | ((client: Client) => Client)): (client: Client) => Client; - -declare const denylist: readonly ["$connect", "$disconnect", "$on", "$transaction", "$extends"]; - -declare type Deprecation = ReadonlyDeep_2<{ - sinceVersion: string; - reason: string; - plannedRemovalVersion?: string; -}>; - -declare type DeserializedResponse = Array>; - -export declare function deserializeJsonResponse(result: unknown): unknown; - -export declare function deserializeRawResult(response: RawResponse): DeserializedResponse; - -export declare type DevTypeMapDef = { - meta: { - modelProps: string; - }; - model: { - [Model in PropertyKey]: { - [Operation in PropertyKey]: DevTypeMapFnDef; - }; - }; - other: { - [Operation in PropertyKey]: DevTypeMapFnDef; - }; -}; - -export declare type DevTypeMapFnDef = { - args: any; - result: any; - payload: OperationPayload; -}; - -export declare namespace DMMF { - export { - datamodelEnumToSchemaEnum, - Document_2 as Document, - Mappings, - OtherOperationMappings, - DatamodelEnum, - SchemaEnum, - EnumValue, - Datamodel, - uniqueIndex, - PrimaryKey, - Model, - FieldKind, - FieldNamespace, - FieldLocation, - Field, - FieldDefault, - FieldDefaultScalar, - Index, - IndexType, - IndexField, - SortOrder, - Schema, - Query, - QueryOutput, - TypeRef, - InputTypeRef, - SchemaArg, - OutputType, - SchemaField, - OutputTypeRef, - Deprecation, - InputType, - FieldRefType, - FieldRefAllowType, - ModelMapping, - ModelAction - } -} - -declare namespace DMMF_2 { - export { - datamodelEnumToSchemaEnum, - Document_2 as Document, - Mappings, - OtherOperationMappings, - DatamodelEnum, - SchemaEnum, - EnumValue, - Datamodel, - uniqueIndex, - PrimaryKey, - Model, - FieldKind, - FieldNamespace, - FieldLocation, - Field, - FieldDefault, - FieldDefaultScalar, - Index, - IndexType, - IndexField, - SortOrder, - Schema, - Query, - QueryOutput, - TypeRef, - InputTypeRef, - SchemaArg, - OutputType, - SchemaField, - OutputTypeRef, - Deprecation, - InputType, - FieldRefType, - FieldRefAllowType, - ModelMapping, - ModelAction - } -} - -export declare function dmmfToRuntimeDataModel(dmmfDataModel: DMMF_2.Datamodel): RuntimeDataModel; - -declare type Document_2 = ReadonlyDeep_2<{ - datamodel: Datamodel; - schema: Schema; - mappings: Mappings; -}>; - -/** - * A generic driver adapter factory that allows the user to instantiate a - * driver adapter. The query and result types are specific to the adapter. - */ -declare interface DriverAdapterFactory extends AdapterInfo { - /** - * Instantiate a driver adapter. - */ - connect(): Promise>; -} - -declare type DynamicArgType = ArgType | { - arity: 'tuple'; - elements: ArgType[]; -}; - -/** Client */ -export declare type DynamicClientExtensionArgs> = { - [P in keyof C_]: unknown; -} & { - [K: symbol]: { - ctx: Optional, ITXClientDenyList> & { - $parent: Optional, ITXClientDenyList>; - }; - }; -}; - -export declare type DynamicClientExtensionThis> = { - [P in keyof ExtArgs['client']]: Return; -} & { - [P in Exclude]: DynamicModelExtensionThis, ExtArgs>; -} & { - [P in Exclude]: P extends keyof ClientOtherOps ? ClientOtherOps[P] : never; -} & { - [P in Exclude]: DynamicClientExtensionThisBuiltin[P]; -} & { - [K: symbol]: { - types: TypeMap['other']; - }; -}; - -export declare type DynamicClientExtensionThisBuiltin> = { - $extends: ExtendsHook<'extends', TypeMapCb, ExtArgs, Call>; - $transaction

[]>(arg: [...P], options?: { - isolationLevel?: TypeMap['meta']['txIsolationLevel']; - }): Promise>; - $transaction(fn: (client: Omit, ITXClientDenyList>) => Promise, options?: { - maxWait?: number; - timeout?: number; - isolationLevel?: TypeMap['meta']['txIsolationLevel']; - }): Promise; - $disconnect(): Promise; - $connect(): Promise; -}; - -/** Model */ -export declare type DynamicModelExtensionArgs> = { - [K in keyof M_]: K extends '$allModels' ? { - [P in keyof M_[K]]?: unknown; - } & { - [K: symbol]: {}; - } : K extends TypeMap['meta']['modelProps'] ? { - [P in keyof M_[K]]?: unknown; - } & { - [K: symbol]: { - ctx: DynamicModelExtensionThis, ExtArgs> & { - $parent: DynamicClientExtensionThis; - } & { - $name: ModelKey; - } & { - /** - * @deprecated Use `$name` instead. - */ - name: ModelKey; - }; - }; - } : never; -}; - -export declare type DynamicModelExtensionFluentApi = { - [K in keyof TypeMap['model'][M]['payload']['objects']]: (args?: Exact>) => PrismaPromise, [K]> | Null> & DynamicModelExtensionFluentApi>; -}; - -export declare type DynamicModelExtensionFnResult = P extends FluentOperation ? DynamicModelExtensionFluentApi & PrismaPromise | Null> : PrismaPromise>; - -export declare type DynamicModelExtensionFnResultBase = GetResult; - -export declare type DynamicModelExtensionFnResultNull

= P extends 'findUnique' | 'findFirst' ? null : never; - -export declare type DynamicModelExtensionOperationFn = {} extends TypeMap['model'][M]['operations'][P]['args'] ? (args?: Exact) => DynamicModelExtensionFnResult> : (args: Exact) => DynamicModelExtensionFnResult>; - -export declare type DynamicModelExtensionThis> = { - [P in keyof ExtArgs['model'][Uncapitalize]]: Return][P]>; -} & { - [P in Exclude]>]: DynamicModelExtensionOperationFn; -} & { - [P in Exclude<'fields', keyof ExtArgs['model'][Uncapitalize]>]: TypeMap['model'][M]['fields']; -} & { - [K: symbol]: { - types: TypeMap['model'][M]; - }; -}; - -/** Query */ -export declare type DynamicQueryExtensionArgs = { - [K in keyof Q_]: K extends '$allOperations' ? (args: { - model?: string; - operation: string; - args: any; - query: (args: any) => PrismaPromise; - }) => Promise : K extends '$allModels' ? { - [P in keyof Q_[K] | keyof TypeMap['model'][keyof TypeMap['model']]['operations'] | '$allOperations']?: P extends '$allOperations' ? DynamicQueryExtensionCb : P extends keyof TypeMap['model'][keyof TypeMap['model']]['operations'] ? DynamicQueryExtensionCb : never; - } : K extends TypeMap['meta']['modelProps'] ? { - [P in keyof Q_[K] | keyof TypeMap['model'][ModelKey]['operations'] | '$allOperations']?: P extends '$allOperations' ? DynamicQueryExtensionCb, keyof TypeMap['model'][ModelKey]['operations']> : P extends keyof TypeMap['model'][ModelKey]['operations'] ? DynamicQueryExtensionCb, P> : never; - } : K extends keyof TypeMap['other']['operations'] ? DynamicQueryExtensionCb<[TypeMap], 0, 'other', K> : never; -}; - -export declare type DynamicQueryExtensionCb = >(args: A) => Promise; - -export declare type DynamicQueryExtensionCbArgs = (_1 extends unknown ? _2 extends unknown ? { - args: DynamicQueryExtensionCbArgsArgs; - model: _0 extends 0 ? undefined : _1; - operation: _2; - query: >(args: A) => PrismaPromise; -} : never : never) & { - query: (args: DynamicQueryExtensionCbArgsArgs) => PrismaPromise; -}; - -export declare type DynamicQueryExtensionCbArgsArgs = _2 extends '$queryRaw' | '$executeRaw' ? Sql : TypeMap[_0][_1]['operations'][_2]['args']; - -/** Result */ -export declare type DynamicResultExtensionArgs = { - [K in keyof R_]: { - [P in keyof R_[K]]?: { - needs?: DynamicResultExtensionNeeds, R_[K][P]>; - compute(data: DynamicResultExtensionData, R_[K][P]>): any; - }; - }; -}; - -export declare type DynamicResultExtensionData = GetFindResult; - -export declare type DynamicResultExtensionNeeds = { - [K in keyof S]: K extends keyof TypeMap['model'][M]['payload']['scalars'] ? S[K] : never; -} & { - [N in keyof TypeMap['model'][M]['payload']['scalars']]?: boolean; -}; - -/** - * Placeholder value for "no text". - */ -export declare const empty: Sql; - -export declare type EmptyToUnknown = T; - -declare interface Engine { - /** The name of the engine. This is meant to be consumed externally */ - readonly name: string; - onBeforeExit(callback: () => Promise): void; - start(): Promise; - stop(): Promise; - version(forceRun?: boolean): Promise | string; - request(query: JsonQuery, options: RequestOptions): Promise>; - requestBatch(queries: JsonQuery[], options: RequestBatchOptions): Promise[]>; - transaction(action: 'start', headers: Transaction_2.TransactionHeaders, options: Transaction_2.Options): Promise>; - transaction(action: 'commit', headers: Transaction_2.TransactionHeaders, info: Transaction_2.InteractiveTransactionInfo): Promise; - transaction(action: 'rollback', headers: Transaction_2.TransactionHeaders, info: Transaction_2.InteractiveTransactionInfo): Promise; - metrics(options: MetricsOptionsJson): Promise; - metrics(options: MetricsOptionsPrometheus): Promise; - applyPendingMigrations(): Promise; -} - -declare interface EngineConfig { - cwd: string; - dirname: string; - enableDebugLogs?: boolean; - allowTriggerPanic?: boolean; - prismaPath?: string; - generator?: GeneratorConfig; - /** - * @remarks this field is used internally by Policy, do not rename or remove - */ - overrideDatasources: Datasources; - showColors?: boolean; - logQueries?: boolean; - logLevel?: 'info' | 'warn'; - env: Record; - flags?: string[]; - clientVersion: string; - engineVersion: string; - previewFeatures?: string[]; - engineEndpoint?: string; - activeProvider?: string; - logEmitter: LogEmitter; - transactionOptions: Transaction_2.Options; - /** - * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale`. - * If set, this is only used in the library engine, and all queries would be performed through it, - * rather than Prisma's Rust drivers. - * @remarks only used by LibraryEngine.ts - */ - adapter?: SqlDriverAdapterFactory; - /** - * The contents of the schema encoded into a string - */ - inlineSchema: string; - /** - * The contents of the datasource url saved in a string - * @remarks only used by DataProxyEngine.ts - * @remarks this field is used internally by Policy, do not rename or remove - */ - inlineDatasources: GetPrismaClientConfig['inlineDatasources']; - /** - * The string hash that was produced for a given schema - * @remarks only used by DataProxyEngine.ts - */ - inlineSchemaHash: string; - /** - * The helper for interaction with OTEL tracing - * @remarks enabling is determined by the client and @prisma/instrumentation package - */ - tracingHelper: TracingHelper; - /** - * Information about whether we have not found a schema.prisma file in the - * default location, and that we fell back to finding the schema.prisma file - * in the current working directory. This usually means it has been bundled. - */ - isBundled?: boolean; - /** - * Web Assembly module loading configuration - */ - engineWasm?: EngineWasmLoadingConfig; - compilerWasm?: CompilerWasmLoadingConfig; - /** - * Allows Accelerate to use runtime utilities from the client. These are - * necessary for the AccelerateEngine to function correctly. - */ - accelerateUtils?: { - resolveDatasourceUrl: typeof resolveDatasourceUrl; - getBatchRequestPayload: typeof getBatchRequestPayload; - prismaGraphQLToJSError: typeof prismaGraphQLToJSError; - PrismaClientUnknownRequestError: typeof PrismaClientUnknownRequestError; - PrismaClientInitializationError: typeof PrismaClientInitializationError; - PrismaClientKnownRequestError: typeof PrismaClientKnownRequestError; - debug: (...args: any[]) => void; - engineVersion: string; - clientVersion: string; - }; -} - -declare type EngineEvent = E extends QueryEventType ? QueryEvent : LogEvent; - -declare type EngineEventType = QueryEventType | LogEventType; - -declare type EngineSpan = { - id: EngineSpanId; - parentId: string | null; - name: string; - startTime: HrTime; - endTime: HrTime; - kind: EngineSpanKind; - attributes?: Record; - links?: EngineSpanId[]; -}; - -declare type EngineSpanId = string; - -declare type EngineSpanKind = 'client' | 'internal'; - -declare type EngineWasmLoadingConfig = { - /** - * WASM-bindgen runtime for corresponding module - */ - getRuntime: () => Promise<{ - __wbg_set_wasm(exports: unknown): void; - QueryEngine: QueryEngineConstructor; - }>; - /** - * Loads the raw wasm module for the wasm query engine. This configuration is - * generated specifically for each type of client, eg. Node.js client and Edge - * clients will have different implementations. - * @remarks this is a callback on purpose, we only load the wasm if needed. - * @remarks only used by LibraryEngine - */ - getQueryEngineWasmModule: () => Promise; -}; - -declare type EnumValue = ReadonlyDeep_2<{ - name: string; - dbName: string | null; -}>; - -declare type EnvPaths = { - rootEnvPath: string | null; - schemaEnvPath: string | undefined; -}; - -declare interface EnvValue { - fromEnvVar: null | string; - value: null | string; -} - -export declare type Equals = (() => T extends A ? 1 : 2) extends (() => T extends B ? 1 : 2) ? 1 : 0; - -declare type Error_2 = MappedError & { - originalCode?: string; - originalMessage?: string; -}; - -declare type ErrorCapturingFunction = T extends (...args: infer A) => Promise ? (...args: A) => Promise>> : T extends (...args: infer A) => infer R ? (...args: A) => Result_4> : T; - -declare type ErrorCapturingInterface = { - [K in keyof T]: ErrorCapturingFunction; -}; - -declare interface ErrorCapturingSqlDriverAdapter extends ErrorCapturingInterface { - readonly errorRegistry: ErrorRegistry; -} - -declare type ErrorFormat = 'pretty' | 'colorless' | 'minimal'; - -declare type ErrorRecord = { - error: unknown; -}; - -declare interface ErrorRegistry { - consumeError(id: number): ErrorRecord | undefined; -} - -declare interface ErrorWithBatchIndex { - batchRequestIdx?: number; -} - -declare type EventCallback = [E] extends ['beforeExit'] ? () => Promise : [E] extends [LogLevel] ? (event: EngineEvent) => void : never; - -export declare type Exact = (A extends unknown ? (W extends A ? { - [K in keyof A]: Exact; -} : W) : never) | (A extends Narrowable ? A : never); - -/** - * Defines Exception. - * - * string or an object with one of (message or name or code) and optional stack - */ -declare type Exception = ExceptionWithCode | ExceptionWithMessage | ExceptionWithName | string; - -declare interface ExceptionWithCode { - code: string | number; - name?: string; - message?: string; - stack?: string; -} - -declare interface ExceptionWithMessage { - code?: string | number; - message: string; - name?: string; - stack?: string; -} - -declare interface ExceptionWithName { - code?: string | number; - message?: string; - name: string; - stack?: string; -} - -declare type ExtendedEventType = LogLevel | 'beforeExit'; - -declare type ExtendedSpanOptions = SpanOptions & { - /** The name of the span */ - name: string; - internal?: boolean; - /** Whether it propagates context (?=true) */ - active?: boolean; - /** The context to append the span to */ - context?: Context; -}; - -/** $extends, defineExtension */ -export declare interface ExtendsHook, TypeMap extends TypeMapDef = Call> { - extArgs: ExtArgs; - , MergedArgs extends InternalArgs = MergeExtArgs>(extension: ((client: DynamicClientExtensionThis) => { - $extends: { - extArgs: Args; - }; - }) | { - name?: string; - query?: DynamicQueryExtensionArgs; - result?: DynamicResultExtensionArgs & R; - model?: DynamicModelExtensionArgs & M; - client?: DynamicClientExtensionArgs & C; - }): { - extends: DynamicClientExtensionThis, TypeMapCb, MergedArgs>; - define: (client: any) => { - $extends: { - extArgs: Args; - }; - }; - }[Variant]; -} - -export declare type ExtensionArgs = Optional; - -declare namespace Extensions { - export { - defineExtension, - getExtensionContext - } -} -export { Extensions } - -declare namespace Extensions_2 { - export { - InternalArgs, - DefaultArgs, - GetPayloadResultExtensionKeys, - GetPayloadResultExtensionObject, - GetPayloadResult, - GetSelect, - GetOmit, - DynamicQueryExtensionArgs, - DynamicQueryExtensionCb, - DynamicQueryExtensionCbArgs, - DynamicQueryExtensionCbArgsArgs, - DynamicResultExtensionArgs, - DynamicResultExtensionNeeds, - DynamicResultExtensionData, - DynamicModelExtensionArgs, - DynamicModelExtensionThis, - DynamicModelExtensionOperationFn, - DynamicModelExtensionFnResult, - DynamicModelExtensionFnResultBase, - DynamicModelExtensionFluentApi, - DynamicModelExtensionFnResultNull, - DynamicClientExtensionArgs, - DynamicClientExtensionThis, - ClientBuiltInProp, - DynamicClientExtensionThisBuiltin, - ExtendsHook, - MergeExtArgs, - AllModelsToStringIndex, - TypeMapDef, - DevTypeMapDef, - DevTypeMapFnDef, - ClientOptionDef, - ClientOtherOps, - TypeMapCbDef, - ModelKey, - RequiredExtensionArgs as UserArgs - } -} - -export declare type ExtractGlobalOmit = Options extends { - omit: { - [K in ModelName]: infer GlobalOmit; - }; -} ? GlobalOmit : {}; - -declare type Field = ReadonlyDeep_2<{ - kind: FieldKind; - name: string; - isRequired: boolean; - isList: boolean; - isUnique: boolean; - isId: boolean; - isReadOnly: boolean; - isGenerated?: boolean; - isUpdatedAt?: boolean; - /** - * Describes the data type in the same the way it is defined in the Prisma schema: - * BigInt, Boolean, Bytes, DateTime, Decimal, Float, Int, JSON, String, $ModelName - */ - type: string; - /** - * Native database type, if specified. - * For example, `@db.VarChar(191)` is encoded as `['VarChar', ['191']]`, - * `@db.Text` is encoded as `['Text', []]`. - */ - nativeType?: [string, string[]] | null; - dbName?: string | null; - hasDefaultValue: boolean; - default?: FieldDefault | FieldDefaultScalar | FieldDefaultScalar[]; - relationFromFields?: string[]; - relationToFields?: string[]; - relationOnDelete?: string; - relationOnUpdate?: string; - relationName?: string; - documentation?: string; -}>; - -declare type FieldDefault = ReadonlyDeep_2<{ - name: string; - args: Array; -}>; - -declare type FieldDefaultScalar = string | boolean | number; - -declare type FieldInitializer = { - type: 'value'; - value: PrismaValue; -} | { - type: 'lastInsertId'; -}; - -declare type FieldKind = 'scalar' | 'object' | 'enum' | 'unsupported'; - -declare type FieldLocation = 'scalar' | 'inputObjectTypes' | 'outputObjectTypes' | 'enumTypes' | 'fieldRefTypes'; - -declare type FieldNamespace = 'model' | 'prisma'; - -declare type FieldOperation = { - type: 'set'; - value: PrismaValue; -} | { - type: 'add'; - value: PrismaValue; -} | { - type: 'subtract'; - value: PrismaValue; -} | { - type: 'multiply'; - value: PrismaValue; -} | { - type: 'divide'; - value: PrismaValue; -}; - -/** - * A reference to a specific field of a specific model - */ -export declare interface FieldRef { - readonly modelName: Model; - readonly name: string; - readonly typeName: FieldType; - readonly isList: boolean; -} - -declare type FieldRefAllowType = TypeRef<'scalar' | 'enumTypes'>; - -declare type FieldRefType = ReadonlyDeep_2<{ - name: string; - allowTypes: FieldRefAllowType[]; - fields: SchemaArg[]; -}>; - -declare type FieldScalarType = { - type: 'string' | 'int' | 'bigint' | 'float' | 'boolean' | 'json' | 'object' | 'datetime' | 'decimal' | 'unsupported'; -} | { - type: 'enum'; - name: string; -} | { - type: 'bytes'; - encoding: 'array' | 'base64' | 'hex'; -}; - -declare type FieldType = { - arity: Arity; -} & FieldScalarType; - -declare type FluentOperation = 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow' | 'create' | 'update' | 'upsert' | 'delete'; - -export declare interface Fn { - params: Params; - returns: Returns; -} - -declare type Fragment = { - type: 'stringChunk'; - chunk: string; -} | { - type: 'parameter'; -} | { - type: 'parameterTuple'; -} | { - type: 'parameterTupleList'; - itemPrefix: string; - itemSeparator: string; - itemSuffix: string; - groupSeparator: string; -}; - -declare interface GeneratorConfig { - name: string; - output: EnvValue | null; - isCustomOutput?: boolean; - provider: EnvValue; - config: { - /** `output` is a reserved name and will only be available directly at `generator.output` */ - output?: never; - /** `provider` is a reserved name and will only be available directly at `generator.provider` */ - provider?: never; - /** `binaryTargets` is a reserved name and will only be available directly at `generator.binaryTargets` */ - binaryTargets?: never; - /** `previewFeatures` is a reserved name and will only be available directly at `generator.previewFeatures` */ - previewFeatures?: never; - } & { - [key: string]: string | string[] | undefined; - }; - binaryTargets: BinaryTargetsEnvValue[]; - previewFeatures: string[]; - envPaths?: EnvPaths; - sourceFilePath: string; -} - -export declare type GetAggregateResult

= { - [K in keyof A as K extends Aggregate ? K : never]: K extends '_count' ? A[K] extends true ? number : Count : { - [J in keyof A[K] & string]: P['scalars'][J] | null; - }; -}; - -declare function getBatchRequestPayload(batch: JsonQuery[], transaction?: TransactionOptions_2): QueryEngineBatchRequest; - -export declare type GetBatchResult = { - count: number; -}; - -export declare type GetCountResult = A extends { - select: infer S; -} ? (S extends true ? number : Count) : number; - -declare function getExtensionContext(that: T): Context_2; - -export declare type GetFindResult

= Equals extends 1 ? DefaultSelection : A extends { - select: infer S extends object; -} & Record | { - include: infer I extends object; -} & Record ? { - [K in keyof S | keyof I as (S & I)[K] extends false | undefined | Skip | null ? never : K]: (S & I)[K] extends object ? P extends SelectablePayloadFields ? O extends OperationPayload ? GetFindResult[] : never : P extends SelectablePayloadFields ? O extends OperationPayload ? GetFindResult | SelectField & null : never : K extends '_count' ? Count> : never : P extends SelectablePayloadFields ? O extends OperationPayload ? DefaultSelection[] : never : P extends SelectablePayloadFields ? O extends OperationPayload ? DefaultSelection | SelectField & null : never : P extends { - scalars: { - [k in K]: infer O; - }; - } ? O : K extends '_count' ? Count : never; -} & (A extends { - include: any; -} & Record ? DefaultSelection : unknown) : DefaultSelection; - -export declare type GetGroupByResult

= A extends { - by: string[]; -} ? Array & { - [K in A['by'][number]]: P['scalars'][K]; -}> : A extends { - by: string; -} ? Array & { - [K in A['by']]: P['scalars'][K]; -}> : {}[]; - -export declare type GetOmit = { - [K in (string extends keyof R ? never : keyof R) | BaseKeys]?: boolean | ExtraType; -}; - -export declare type GetPayloadResult, R extends InternalArgs['result'][string]> = Omit> & GetPayloadResultExtensionObject; - -export declare type GetPayloadResultExtensionKeys = KR; - -export declare type GetPayloadResultExtensionObject = { - [K in GetPayloadResultExtensionKeys]: R[K] extends () => { - compute: (...args: any) => infer C; - } ? C : never; -}; - -export declare function getPrismaClient(config: GetPrismaClientConfig): { - new (optionsArg?: PrismaClientOptions): { - _originalClient: any; - _runtimeDataModel: RuntimeDataModel; - _requestHandler: RequestHandler; - _connectionPromise?: Promise | undefined; - _disconnectionPromise?: Promise | undefined; - _engineConfig: EngineConfig; - _accelerateEngineConfig: AccelerateEngineConfig; - _clientVersion: string; - _errorFormat: ErrorFormat; - _tracingHelper: TracingHelper; - _previewFeatures: string[]; - _activeProvider: string; - _globalOmit?: GlobalOmitOptions | undefined; - _extensions: MergedExtensionsList; - /** - * @remarks This is used internally by Policy, do not rename or remove - */ - _engine: Engine; - /** - * A fully constructed/applied Client that references the parent - * PrismaClient. This is used for Client extensions only. - */ - _appliedParent: any; - _createPrismaPromise: PrismaPromiseFactory; - $on(eventType: E, callback: EventCallback): any; - $connect(): Promise; - /** - * Disconnect from the database - */ - $disconnect(): Promise; - /** - * Executes a raw query and always returns a number - */ - $executeRawInternal(transaction: PrismaPromiseTransaction | undefined, clientMethod: string, args: RawQueryArgs, middlewareArgsMapper?: MiddlewareArgsMapper): Promise; - /** - * Executes a raw query provided through a safe tag function - * @see https://github.com/prisma/prisma/issues/7142 - * - * @param query - * @param values - * @returns - */ - $executeRaw(query: TemplateStringsArray | Sql, ...values: any[]): PrismaPromise_2; - /** - * Unsafe counterpart of `$executeRaw` that is susceptible to SQL injections - * @see https://github.com/prisma/prisma/issues/7142 - * - * @param query - * @param values - * @returns - */ - $executeRawUnsafe(query: string, ...values: RawValue[]): PrismaPromise_2; - /** - * Executes a raw command only for MongoDB - * - * @param command - * @returns - */ - $runCommandRaw(command: Record): PrismaPromise_2; - /** - * Executes a raw query and returns selected data - */ - $queryRawInternal(transaction: PrismaPromiseTransaction | undefined, clientMethod: string, args: RawQueryArgs, middlewareArgsMapper?: MiddlewareArgsMapper): Promise; - /** - * Executes a raw query provided through a safe tag function - * @see https://github.com/prisma/prisma/issues/7142 - * - * @param query - * @param values - * @returns - */ - $queryRaw(query: TemplateStringsArray | Sql, ...values: any[]): PrismaPromise_2; - /** - * Counterpart to $queryRaw, that returns strongly typed results - * @param typedSql - */ - $queryRawTyped(typedSql: UnknownTypedSql): PrismaPromise_2; - /** - * Unsafe counterpart of `$queryRaw` that is susceptible to SQL injections - * @see https://github.com/prisma/prisma/issues/7142 - * - * @param query - * @param values - * @returns - */ - $queryRawUnsafe(query: string, ...values: RawValue[]): PrismaPromise_2; - /** - * Execute a batch of requests in a transaction - * @param requests - * @param options - */ - _transactionWithArray({ promises, options, }: { - promises: Array>; - options?: BatchTransactionOptions; - }): Promise; - /** - * Perform a long-running transaction - * @param callback - * @param options - * @returns - */ - _transactionWithCallback({ callback, options, }: { - callback: (client: Client) => Promise; - options?: Options; - }): Promise; - _createItxClient(transaction: PrismaPromiseInteractiveTransaction): Client; - /** - * Execute queries within a transaction - * @param input a callback or a query list - * @param options to set timeouts (callback) - * @returns - */ - $transaction(input: any, options?: any): Promise; - /** - * Runs the middlewares over params before executing a request - * @param internalParams - * @returns - */ - _request(internalParams: InternalRequestParams): Promise; - _executeRequest({ args, clientMethod, dataPath, callsite, action, model, argsMapper, transaction, unpacker, otelParentCtx, customDataProxyFetch, }: InternalRequestParams): Promise; - $metrics: MetricsClient; - /** - * Shortcut for checking a preview flag - * @param feature preview flag - * @returns - */ - _hasPreviewFlag(feature: string): boolean; - $applyPendingMigrations(): Promise; - $extends: typeof $extends; - readonly [Symbol.toStringTag]: string; - }; -}; - -/** - * Config that is stored into the generated client. When the generated client is - * loaded, this same config is passed to {@link getPrismaClient} which creates a - * closure with that config around a non-instantiated [[PrismaClient]]. - */ -export declare type GetPrismaClientConfig = { - runtimeDataModel: RuntimeDataModel; - generator?: GeneratorConfig; - relativeEnvPaths?: { - rootEnvPath?: string | null; - schemaEnvPath?: string | null; - }; - relativePath: string; - dirname: string; - clientVersion: string; - engineVersion: string; - datasourceNames: string[]; - activeProvider: ActiveConnectorType; - /** - * The contents of the schema encoded into a string - * @remarks only used for the purpose of data proxy - */ - inlineSchema: string; - /** - * A special env object just for the data proxy edge runtime. - * Allows bundlers to inject their own env variables (Vercel). - * Allows platforms to declare global variables as env (Workers). - * @remarks only used for the purpose of data proxy - */ - injectableEdgeEnv?: () => LoadedEnv; - /** - * The contents of the datasource url saved in a string. - * This can either be an env var name or connection string. - * It is needed by the client to connect to the Data Proxy. - * @remarks only used for the purpose of data proxy - */ - inlineDatasources: { - [name in string]: { - url: EnvValue; - }; - }; - /** - * The string hash that was produced for a given schema - * @remarks only used for the purpose of data proxy - */ - inlineSchemaHash: string; - /** - * A marker to indicate that the client was not generated via `prisma - * generate` but was generated via `generate --postinstall` script instead. - * @remarks used to error for Vercel/Netlify for schema caching issues - */ - postinstall?: boolean; - /** - * Information about the CI where the Prisma Client has been generated. The - * name of the CI environment is stored at generation time because CI - * information is not always available at runtime. Moreover, the edge client - * has no notion of environment variables, so this works around that. - * @remarks used to error for Vercel/Netlify for schema caching issues - */ - ciName?: string; - /** - * Information about whether we have not found a schema.prisma file in the - * default location, and that we fell back to finding the schema.prisma file - * in the current working directory. This usually means it has been bundled. - */ - isBundled?: boolean; - /** - * A boolean that is `false` when the client was generated with --no-engine. At - * runtime, this means the client will be bound to be using the Data Proxy. - */ - copyEngine?: boolean; - /** - * Optional wasm loading configuration - */ - engineWasm?: EngineWasmLoadingConfig; - compilerWasm?: CompilerWasmLoadingConfig; -}; - -export declare type GetResult = { - findUnique: GetFindResult | null; - findUniqueOrThrow: GetFindResult; - findFirst: GetFindResult | null; - findFirstOrThrow: GetFindResult; - findMany: GetFindResult[]; - create: GetFindResult; - createMany: GetBatchResult; - createManyAndReturn: GetFindResult[]; - update: GetFindResult; - updateMany: GetBatchResult; - updateManyAndReturn: GetFindResult[]; - upsert: GetFindResult; - delete: GetFindResult; - deleteMany: GetBatchResult; - aggregate: GetAggregateResult; - count: GetCountResult; - groupBy: GetGroupByResult; - $queryRaw: unknown; - $queryRawTyped: unknown; - $executeRaw: number; - $queryRawUnsafe: unknown; - $executeRawUnsafe: number; - $runCommandRaw: JsonObject; - findRaw: JsonObject; - aggregateRaw: JsonObject; -}[OperationName]; - -export declare function getRuntime(): GetRuntimeOutput; - -declare type GetRuntimeOutput = { - id: RuntimeName; - prettyName: string; - isEdge: boolean; -}; - -export declare type GetSelect, R extends InternalArgs['result'][string], KR extends keyof R = string extends keyof R ? never : keyof R> = { - [K in KR | keyof Base]?: K extends KR ? boolean : Base[K]; -}; - -declare type GlobalOmitOptions = { - [modelName: string]: { - [fieldName: string]: boolean; - }; -}; - -declare type HandleErrorParams = { - args: JsArgs; - error: any; - clientMethod: string; - callsite?: CallSite; - transaction?: PrismaPromiseTransaction; - modelName?: string; - globalOmit?: GlobalOmitOptions; -}; - -declare type HrTime = [number, number]; - -/** - * Defines High-Resolution Time. - * - * The first number, HrTime[0], is UNIX Epoch time in seconds since 00:00:00 UTC on 1 January 1970. - * The second number, HrTime[1], represents the partial second elapsed since Unix Epoch time represented by first number in nanoseconds. - * For example, 2021-01-01T12:30:10.150Z in UNIX Epoch time in milliseconds is represented as 1609504210150. - * The first number is calculated by converting and truncating the Epoch time in milliseconds to seconds: - * HrTime[0] = Math.trunc(1609504210150 / 1000) = 1609504210. - * The second number is calculated by converting the digits after the decimal point of the subtraction, (1609504210150 / 1000) - HrTime[0], to nanoseconds: - * HrTime[1] = Number((1609504210.150 - HrTime[0]).toFixed(9)) * 1e9 = 150000000. - * This is represented in HrTime format as [1609504210, 150000000]. - */ -declare type HrTime_2 = [number, number]; - -declare type Index = ReadonlyDeep_2<{ - model: string; - type: IndexType; - isDefinedOnField: boolean; - name?: string; - dbName?: string; - algorithm?: string; - clustered?: boolean; - fields: IndexField[]; -}>; - -declare type IndexField = ReadonlyDeep_2<{ - name: string; - sortOrder?: SortOrder; - length?: number; - operatorClass?: string; -}>; - -declare type IndexType = 'id' | 'normal' | 'unique' | 'fulltext'; - -declare type InMemoryOps = { - pagination: Pagination | null; - distinct: string[] | null; - reverse: boolean; - linkingFields: string[] | null; - nested: Record; -}; - -/** - * Matches a JSON array. - * Unlike \`JsonArray\`, readonly arrays are assignable to this type. - */ -export declare interface InputJsonArray extends ReadonlyArray { -} - -/** - * Matches a JSON object. - * Unlike \`JsonObject\`, this type allows undefined and read-only properties. - */ -export declare type InputJsonObject = { - readonly [Key in string]?: InputJsonValue | null; -}; - -/** - * Matches any valid value that can be used as an input for operations like - * create and update as the value of a JSON field. Unlike \`JsonValue\`, this - * type allows read-only arrays and read-only object properties and disallows - * \`null\` at the top level. - * - * \`null\` cannot be used as the value of a JSON field because its meaning - * would be ambiguous. Use \`Prisma.JsonNull\` to store the JSON null value or - * \`Prisma.DbNull\` to clear the JSON value and set the field to the database - * NULL value instead. - * - * @see https://www.prisma.io/docs/concepts/components/prisma-client/working-with-fields/working-with-json-fields#filtering-by-null-values - */ -export declare type InputJsonValue = string | number | boolean | InputJsonObject | InputJsonArray | { - toJSON(): unknown; -}; - -declare type InputType = ReadonlyDeep_2<{ - name: string; - constraints: { - maxNumFields: number | null; - minNumFields: number | null; - fields?: string[]; - }; - meta?: { - source?: string; - grouping?: string; - }; - fields: SchemaArg[]; -}>; - -declare type InputTypeRef = TypeRef<'scalar' | 'inputObjectTypes' | 'enumTypes' | 'fieldRefTypes'>; - -declare type InteractiveTransactionInfo = { - /** - * Transaction ID returned by the query engine. - */ - id: string; - /** - * Arbitrary payload the meaning of which depends on the `Engine` implementation. - * For example, `DataProxyEngine` needs to associate different API endpoints with transactions. - * In `LibraryEngine` and `BinaryEngine` it is currently not used. - */ - payload: Payload; -}; - -declare type InteractiveTransactionOptions = Transaction_2.InteractiveTransactionInfo; - -export declare type InternalArgs = { - result: { - [K in keyof R]: { - [P in keyof R[K]]: () => R[K][P]; - }; - }; - model: { - [K in keyof M]: { - [P in keyof M[K]]: () => M[K][P]; - }; - }; - query: { - [K in keyof Q]: { - [P in keyof Q[K]]: () => Q[K][P]; - }; - }; - client: { - [K in keyof C]: () => C[K]; - }; -}; - -declare type InternalRequestParams = { - /** - * The original client method being called. - * Even though the rootField / operation can be changed, - * this method stays as it is, as it's what the user's - * code looks like - */ - clientMethod: string; - /** - * Name of js model that triggered the request. Might be used - * for warnings or error messages - */ - jsModelName?: string; - callsite?: CallSite; - transaction?: PrismaPromiseTransaction; - unpacker?: Unpacker; - otelParentCtx?: Context; - /** Used to "desugar" a user input into an "expanded" one */ - argsMapper?: (args?: UserArgs_2) => UserArgs_2; - /** Used to convert args for middleware and back */ - middlewareArgsMapper?: MiddlewareArgsMapper; - /** Used for Accelerate client extension via Data Proxy */ - customDataProxyFetch?: AccelerateExtensionFetchDecorator; -} & Omit; - -declare type IsolationLevel = 'READ UNCOMMITTED' | 'READ COMMITTED' | 'REPEATABLE READ' | 'SNAPSHOT' | 'SERIALIZABLE'; - -declare type IsolationLevel_2 = 'ReadUncommitted' | 'ReadCommitted' | 'RepeatableRead' | 'Snapshot' | 'Serializable'; - -declare function isSkip(value: unknown): value is Skip; - -export declare function isTypedSql(value: unknown): value is UnknownTypedSql; - -export declare type ITXClientDenyList = (typeof denylist)[number]; - -export declare const itxClientDenyList: readonly (string | symbol)[]; - -declare interface Job { - resolve: (data: any) => void; - reject: (data: any) => void; - request: any; -} - -/** - * Create a SQL query for a list of values. - */ -export declare function join(values: readonly RawValue[], separator?: string, prefix?: string, suffix?: string): Sql; - -declare type JoinExpression = { - child: QueryPlanNode; - on: [left: string, right: string][]; - parentField: string; - isRelationUnique: boolean; -}; - -export declare type JsArgs = { - select?: Selection_2; - include?: Selection_2; - omit?: Omission; - [argName: string]: JsInputValue; -}; - -export declare type JsInputValue = null | undefined | string | number | boolean | bigint | Uint8Array | Date | DecimalJsLike | ObjectEnumValue | RawParameters | JsonConvertible | FieldRef | JsInputValue[] | Skip | { - [key: string]: JsInputValue; -}; - -declare type JsonArgumentValue = number | string | boolean | null | RawTaggedValue | JsonArgumentValue[] | { - [key: string]: JsonArgumentValue; -}; - -/** - * From https://github.com/sindresorhus/type-fest/ - * Matches a JSON array. - */ -export declare interface JsonArray extends Array { -} - -export declare type JsonBatchQuery = { - batch: JsonQuery[]; - transaction?: { - isolationLevel?: IsolationLevel_2; - }; -}; - -export declare interface JsonConvertible { - toJSON(): unknown; -} - -declare type JsonFieldSelection = { - arguments?: Record | RawTaggedValue; - selection: JsonSelectionSet; -}; - -declare class JsonNull extends NullTypesEnumValue { - #private; -} - -/** - * From https://github.com/sindresorhus/type-fest/ - * Matches a JSON object. - * This type can be useful to enforce some input to be JSON-compatible or as a super-type to be extended from. - */ -export declare type JsonObject = { - [Key in string]?: JsonValue; -}; - -export declare type JsonQuery = { - modelName?: string; - action: JsonQueryAction; - query: JsonFieldSelection; -}; - -declare type JsonQueryAction = 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow' | 'findMany' | 'createOne' | 'createMany' | 'createManyAndReturn' | 'updateOne' | 'updateMany' | 'updateManyAndReturn' | 'deleteOne' | 'deleteMany' | 'upsertOne' | 'aggregate' | 'groupBy' | 'executeRaw' | 'queryRaw' | 'runCommandRaw' | 'findRaw' | 'aggregateRaw'; - -declare type JsonSelectionSet = { - $scalars?: boolean; - $composites?: boolean; -} & { - [fieldName: string]: boolean | JsonFieldSelection; -}; - -/** - * From https://github.com/sindresorhus/type-fest/ - * Matches any valid JSON value. - */ -export declare type JsonValue = string | number | boolean | JsonObject | JsonArray | null; - -export declare type JsOutputValue = null | string | number | boolean | bigint | Uint8Array | Date | Decimal | JsOutputValue[] | { - [key: string]: JsOutputValue; -}; - -export declare type JsPromise = Promise & {}; - -declare type KnownErrorParams = { - code: string; - clientVersion: string; - meta?: Record; - batchRequestIdx?: number; -}; - -/** - * A pointer from the current {@link Span} to another span in the same trace or - * in a different trace. - * Few examples of Link usage. - * 1. Batch Processing: A batch of elements may contain elements associated - * with one or more traces/spans. Since there can only be one parent - * SpanContext, Link is used to keep reference to SpanContext of all - * elements in the batch. - * 2. Public Endpoint: A SpanContext in incoming client request on a public - * endpoint is untrusted from service provider perspective. In such case it - * is advisable to start a new trace with appropriate sampling decision. - * However, it is desirable to associate incoming SpanContext to new trace - * initiated on service provider side so two traces (from Client and from - * Service Provider) can be correlated. - */ -declare interface Link { - /** The {@link SpanContext} of a linked span. */ - context: SpanContext; - /** A set of {@link SpanAttributes} on the link. */ - attributes?: SpanAttributes; - /** Count of attributes of the link that were dropped due to collection limits */ - droppedAttributesCount?: number; -} - -declare type LoadedEnv = { - message?: string; - parsed: { - [x: string]: string; - }; -} | undefined; - -declare type LocationInFile = { - fileName: string; - lineNumber: number | null; - columnNumber: number | null; -}; - -declare type LogDefinition = { - level: LogLevel; - emit: 'stdout' | 'event'; -}; - -/** - * Typings for the events we emit. - * - * @remarks - * If this is updated, our edge runtime shim needs to be updated as well. - */ -declare type LogEmitter = { - on(event: E, listener: (event: EngineEvent) => void): LogEmitter; - emit(event: QueryEventType, payload: QueryEvent): boolean; - emit(event: LogEventType, payload: LogEvent): boolean; -}; - -declare type LogEvent = { - timestamp: Date; - message: string; - target: string; -}; - -declare type LogEventType = 'info' | 'warn' | 'error'; - -declare type LogLevel = 'info' | 'query' | 'warn' | 'error'; - -/** - * Generates more strict variant of an enum which, unlike regular enum, - * throws on non-existing property access. This can be useful in following situations: - * - we have an API, that accepts both `undefined` and `SomeEnumType` as an input - * - enum values are generated dynamically from DMMF. - * - * In that case, if using normal enums and no compile-time typechecking, using non-existing property - * will result in `undefined` value being used, which will be accepted. Using strict enum - * in this case will help to have a runtime exception, telling you that you are probably doing something wrong. - * - * Note: if you need to check for existence of a value in the enum you can still use either - * `in` operator or `hasOwnProperty` function. - * - * @param definition - * @returns - */ -export declare function makeStrictEnum>(definition: T): T; - -export declare function makeTypedQueryFactory(sql: string): (...values: any[]) => TypedSql; - -declare type MappedError = { - kind: 'GenericJs'; - id: number; -} | { - kind: 'UnsupportedNativeDataType'; - type: string; -} | { - kind: 'InvalidIsolationLevel'; - level: string; -} | { - kind: 'LengthMismatch'; - column?: string; -} | { - kind: 'UniqueConstraintViolation'; - constraint?: { - fields: string[]; - } | { - index: string; - } | { - foreignKey: {}; - }; -} | { - kind: 'NullConstraintViolation'; - constraint?: { - fields: string[]; - } | { - index: string; - } | { - foreignKey: {}; - }; -} | { - kind: 'ForeignKeyConstraintViolation'; - constraint?: { - fields: string[]; - } | { - index: string; - } | { - foreignKey: {}; - }; -} | { - kind: 'DatabaseNotReachable'; - host?: string; - port?: number; -} | { - kind: 'DatabaseDoesNotExist'; - db?: string; -} | { - kind: 'DatabaseAlreadyExists'; - db?: string; -} | { - kind: 'DatabaseAccessDenied'; - db?: string; -} | { - kind: 'ConnectionClosed'; -} | { - kind: 'TlsConnectionError'; - reason: string; -} | { - kind: 'AuthenticationFailed'; - user?: string; -} | { - kind: 'TransactionWriteConflict'; -} | { - kind: 'TableDoesNotExist'; - table?: string; -} | { - kind: 'ColumnNotFound'; - column?: string; -} | { - kind: 'TooManyConnections'; - cause: string; -} | { - kind: 'ValueOutOfRange'; - cause: string; -} | { - kind: 'MissingFullTextSearchIndex'; -} | { - kind: 'SocketTimeout'; -} | { - kind: 'InconsistentColumnData'; - cause: string; -} | { - kind: 'TransactionAlreadyClosed'; - cause: string; -} | { - kind: 'postgres'; - code: string; - severity: string; - message: string; - detail: string | undefined; - column: string | undefined; - hint: string | undefined; -} | { - kind: 'mysql'; - code: number; - message: string; - state: string; -} | { - kind: 'sqlite'; - /** - * Sqlite extended error code: https://www.sqlite.org/rescode.html - */ - extendedCode: number; - message: string; -} | { - kind: 'mssql'; - code: number; - message: string; -}; - -declare type Mappings = ReadonlyDeep_2<{ - modelOperations: ModelMapping[]; - otherOperations: { - read: string[]; - write: string[]; - }; -}>; - -/** - * Class that holds the list of all extensions, applied to particular instance, - * as well as resolved versions of the components that need to apply on - * different levels. Main idea of this class: avoid re-resolving as much of the - * stuff as possible when new extensions are added while also delaying the - * resolve until the point it is actually needed. For example, computed fields - * of the model won't be resolved unless the model is actually queried. Neither - * adding extensions with `client` component only cause other components to - * recompute. - */ -declare class MergedExtensionsList { - private head?; - private constructor(); - static empty(): MergedExtensionsList; - static single(extension: ExtensionArgs): MergedExtensionsList; - isEmpty(): boolean; - append(extension: ExtensionArgs): MergedExtensionsList; - getAllComputedFields(dmmfModelName: string): ComputedFieldsMap | undefined; - getAllClientExtensions(): ClientArg | undefined; - getAllModelExtensions(dmmfModelName: string): ModelArg | undefined; - getAllQueryCallbacks(jsModelName: string, operation: string): any; - getAllBatchQueryCallbacks(): BatchQueryOptionsCb[]; -} - -export declare type MergeExtArgs, Args extends Record> = ComputeDeep & AllModelsToStringIndex>; - -export declare type Metric = { - key: string; - value: T; - labels: Record; - description: string; -}; - -export declare type MetricHistogram = { - buckets: MetricHistogramBucket[]; - sum: number; - count: number; -}; - -export declare type MetricHistogramBucket = [maxValue: number, count: number]; - -export declare type Metrics = { - counters: Metric[]; - gauges: Metric[]; - histograms: Metric[]; -}; - -export declare class MetricsClient { - private _client; - constructor(client: Client); - /** - * Returns all metrics gathered up to this point in prometheus format. - * Result of this call can be exposed directly to prometheus scraping endpoint - * - * @param options - * @returns - */ - prometheus(options?: MetricsOptions): Promise; - /** - * Returns all metrics gathered up to this point in prometheus format. - * - * @param options - * @returns - */ - json(options?: MetricsOptions): Promise; -} - -declare type MetricsOptions = { - /** - * Labels to add to every metrics in key-value format - */ - globalLabels?: Record; -}; - -declare type MetricsOptionsCommon = { - globalLabels?: Record; -}; - -declare type MetricsOptionsJson = { - format: 'json'; -} & MetricsOptionsCommon; - -declare type MetricsOptionsPrometheus = { - format: 'prometheus'; -} & MetricsOptionsCommon; - -declare type MiddlewareArgsMapper = { - requestArgsToMiddlewareArgs(requestArgs: RequestArgs): MiddlewareArgs; - middlewareArgsToRequestArgs(middlewareArgs: MiddlewareArgs): RequestArgs; -}; - -declare type Model = ReadonlyDeep_2<{ - name: string; - dbName: string | null; - schema: string | null; - fields: Field[]; - uniqueFields: string[][]; - uniqueIndexes: uniqueIndex[]; - documentation?: string; - primaryKey: PrimaryKey | null; - isGenerated?: boolean; -}>; - -declare enum ModelAction { - findUnique = "findUnique", - findUniqueOrThrow = "findUniqueOrThrow", - findFirst = "findFirst", - findFirstOrThrow = "findFirstOrThrow", - findMany = "findMany", - create = "create", - createMany = "createMany", - createManyAndReturn = "createManyAndReturn", - update = "update", - updateMany = "updateMany", - updateManyAndReturn = "updateManyAndReturn", - upsert = "upsert", - delete = "delete", - deleteMany = "deleteMany", - groupBy = "groupBy", - count = "count",// TODO: count does not actually exist in DMMF - aggregate = "aggregate", - findRaw = "findRaw", - aggregateRaw = "aggregateRaw" -} - -export declare type ModelArg = { - [MethodName in string]: unknown; -}; - -export declare type ModelArgs = { - model: { - [ModelName in string]: ModelArg; - }; -}; - -export declare type ModelKey = M extends keyof TypeMap['model'] ? M : Capitalize; - -declare type ModelMapping = ReadonlyDeep_2<{ - model: string; - plural: string; - findUnique?: string | null; - findUniqueOrThrow?: string | null; - findFirst?: string | null; - findFirstOrThrow?: string | null; - findMany?: string | null; - create?: string | null; - createMany?: string | null; - createManyAndReturn?: string | null; - update?: string | null; - updateMany?: string | null; - updateManyAndReturn?: string | null; - upsert?: string | null; - delete?: string | null; - deleteMany?: string | null; - aggregate?: string | null; - groupBy?: string | null; - count?: string | null; - findRaw?: string | null; - aggregateRaw?: string | null; -}>; - -export declare type ModelQueryOptionsCb = (args: ModelQueryOptionsCbArgs) => Promise; - -export declare type ModelQueryOptionsCbArgs = { - model: string; - operation: string; - args: JsArgs; - query: (args: JsArgs) => Promise; -}; - -declare type MultiBatchResponse = { - type: 'multi'; - plans: QueryPlanNode[]; -}; - -export declare type NameArgs = { - name?: string; -}; - -export declare type Narrow = { - [K in keyof A]: A[K] extends Function ? A[K] : Narrow; -} | (A extends Narrowable ? A : never); - -export declare type Narrowable = string | number | bigint | boolean | []; - -export declare type NeverToUnknown = [T] extends [never] ? unknown : T; - -declare class NullTypesEnumValue extends ObjectEnumValue { - _getNamespace(): string; -} - -/** - * Base class for unique values of object-valued enums. - */ -export declare abstract class ObjectEnumValue { - constructor(arg?: symbol); - abstract _getNamespace(): string; - _getName(): string; - toString(): string; -} - -export declare const objectEnumValues: { - classes: { - DbNull: typeof DbNull; - JsonNull: typeof JsonNull; - AnyNull: typeof AnyNull; - }; - instances: { - DbNull: DbNull; - JsonNull: JsonNull; - AnyNull: AnyNull; - }; -}; - -declare const officialPrismaAdapters: readonly ["@prisma/adapter-planetscale", "@prisma/adapter-neon", "@prisma/adapter-libsql", "@prisma/adapter-better-sqlite3", "@prisma/adapter-d1", "@prisma/adapter-pg", "@prisma/adapter-mssql", "@prisma/adapter-mariadb"]; - -export declare type Omission = Record; - -declare type Omit_2 = { - [P in keyof T as P extends K ? never : P]: T[P]; -}; -export { Omit_2 as Omit } - -export declare type OmitValue = Key extends keyof Omit ? Omit[Key] : false; - -export declare type Operation = 'findFirst' | 'findFirstOrThrow' | 'findUnique' | 'findUniqueOrThrow' | 'findMany' | 'create' | 'createMany' | 'createManyAndReturn' | 'update' | 'updateMany' | 'updateManyAndReturn' | 'upsert' | 'delete' | 'deleteMany' | 'aggregate' | 'count' | 'groupBy' | '$queryRaw' | '$executeRaw' | '$queryRawUnsafe' | '$executeRawUnsafe' | 'findRaw' | 'aggregateRaw' | '$runCommandRaw'; - -export declare type OperationPayload = { - name: string; - scalars: { - [ScalarName in string]: unknown; - }; - objects: { - [ObjectName in string]: unknown; - }; - composites: { - [CompositeName in string]: unknown; - }; -}; - -export declare type Optional = { - [P in K & keyof O]?: O[P]; -} & { - [P in Exclude]: O[P]; -}; - -export declare type OptionalFlat = { - [K in keyof T]?: T[K]; -}; - -export declare type OptionalKeys = { - [K in keyof O]-?: {} extends Pick_2 ? K : never; -}[keyof O]; - -declare type Options = { - /** Timeout for starting the transaction */ - maxWait?: number; - /** Timeout for the transaction body */ - timeout?: number; - /** Transaction isolation level */ - isolationLevel?: IsolationLevel_2; -}; - -declare type Options_2 = { - clientVersion: string; -}; - -export declare type Or = { - 0: { - 0: 0; - 1: 1; - }; - 1: { - 0: 1; - 1: 1; - }; -}[A][B]; - -declare type OtherOperationMappings = ReadonlyDeep_2<{ - read: string[]; - write: string[]; -}>; - -declare type OutputType = ReadonlyDeep_2<{ - name: string; - fields: SchemaField[]; -}>; - -declare type OutputTypeRef = TypeRef<'scalar' | 'outputObjectTypes' | 'enumTypes'>; - -declare type Pagination = { - cursor: Record | null; - take: number | null; - skip: number | null; -}; - -export declare function Param<$Type, $Value extends string>(name: $Value): Param<$Type, $Value>; - -export declare type Param = { - readonly name: $Value; -}; - -export declare type PatchFlat = O1 & Omit_2; - -export declare type Path = O extends unknown ? P extends [infer K, ...infer R] ? K extends keyof O ? Path : Default : O : never; - -export declare type Payload = T extends { - [K: symbol]: { - types: { - payload: any; - }; - }; -} ? T[symbol]['types']['payload'] : any; - -export declare type PayloadToResult = RenameAndNestPayloadKeys

> = { - [K in keyof O]?: O[K][K] extends any[] ? PayloadToResult[] : O[K][K] extends object ? PayloadToResult : O[K][K]; -}; - -declare type Pick_2 = { - [P in keyof T as P extends K ? P : never]: T[P]; -}; -export { Pick_2 as Pick } - -declare interface PlaceholderFormat { - prefix: string; - hasNumbering: boolean; -} - -declare type PrimaryKey = ReadonlyDeep_2<{ - name: string | null; - fields: string[]; -}>; - -export declare class PrismaClientInitializationError extends Error { - clientVersion: string; - errorCode?: string; - retryable?: boolean; - constructor(message: string, clientVersion: string, errorCode?: string); - get [Symbol.toStringTag](): string; -} - -export declare class PrismaClientKnownRequestError extends Error implements ErrorWithBatchIndex { - code: string; - meta?: Record; - clientVersion: string; - batchRequestIdx?: number; - constructor(message: string, { code, clientVersion, meta, batchRequestIdx }: KnownErrorParams); - get [Symbol.toStringTag](): string; -} - -export declare type PrismaClientOptions = { - /** - * Overwrites the primary datasource url from your schema.prisma file - */ - datasourceUrl?: string; - /** - * Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale. - */ - adapter?: SqlDriverAdapterFactory | null; - /** - * Overwrites the datasource url from your schema.prisma file - */ - datasources?: Datasources; - /** - * @default "colorless" - */ - errorFormat?: ErrorFormat; - /** - * The default values for Transaction options - * maxWait ?= 2000 - * timeout ?= 5000 - */ - transactionOptions?: Transaction_2.Options; - /** - * @example - * \`\`\` - * // Defaults to stdout - * log: ['query', 'info', 'warn'] - * - * // Emit as events - * log: [ - * { emit: 'stdout', level: 'query' }, - * { emit: 'stdout', level: 'info' }, - * { emit: 'stdout', level: 'warn' } - * ] - * \`\`\` - * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option). - */ - log?: Array; - omit?: GlobalOmitOptions; - /** - * @internal - * You probably don't want to use this. \`__internal\` is used by internal tooling. - */ - __internal?: { - debug?: boolean; - engine?: { - cwd?: string; - binaryPath?: string; - endpoint?: string; - allowTriggerPanic?: boolean; - }; - /** This can be used for testing purposes */ - configOverride?: (config: GetPrismaClientConfig) => GetPrismaClientConfig; - }; -}; - -export declare class PrismaClientRustPanicError extends Error { - clientVersion: string; - constructor(message: string, clientVersion: string); - get [Symbol.toStringTag](): string; -} - -export declare class PrismaClientUnknownRequestError extends Error implements ErrorWithBatchIndex { - clientVersion: string; - batchRequestIdx?: number; - constructor(message: string, { clientVersion, batchRequestIdx }: UnknownErrorParams); - get [Symbol.toStringTag](): string; -} - -export declare class PrismaClientValidationError extends Error { - name: string; - clientVersion: string; - constructor(message: string, { clientVersion }: Options_2); - get [Symbol.toStringTag](): string; -} - -declare function prismaGraphQLToJSError({ error, user_facing_error }: RequestError, clientVersion: string, activeProvider: string): PrismaClientKnownRequestError | PrismaClientUnknownRequestError; - -declare type PrismaOperationSpec = { - args: TArgs; - action: TAction; - model: string; -}; - -export declare interface PrismaPromise extends Promise { - [Symbol.toStringTag]: 'PrismaPromise'; -} - -/** - * Prisma's `Promise` that is backwards-compatible. All additions on top of the - * original `Promise` are optional so that it can be backwards-compatible. - * @see [[createPrismaPromise]] - */ -declare interface PrismaPromise_2 = any> extends Promise { - get spec(): TSpec; - /** - * Extension of the original `.then` function - * @param onfulfilled same as regular promises - * @param onrejected same as regular promises - * @param transaction transaction options - */ - then(onfulfilled?: (value: TResult) => R1 | PromiseLike, onrejected?: (error: unknown) => R2 | PromiseLike, transaction?: PrismaPromiseTransaction): Promise; - /** - * Extension of the original `.catch` function - * @param onrejected same as regular promises - * @param transaction transaction options - */ - catch(onrejected?: ((reason: any) => R | PromiseLike) | undefined | null, transaction?: PrismaPromiseTransaction): Promise; - /** - * Extension of the original `.finally` function - * @param onfinally same as regular promises - * @param transaction transaction options - */ - finally(onfinally?: (() => void) | undefined | null, transaction?: PrismaPromiseTransaction): Promise; - /** - * Called when executing a batch of regular tx - * @param transaction transaction options for batch tx - */ - requestTransaction?(transaction: PrismaPromiseBatchTransaction): PromiseLike; -} - -declare type PrismaPromiseBatchTransaction = { - kind: 'batch'; - id: number; - isolationLevel?: IsolationLevel_2; - index: number; - lock: PromiseLike; -}; - -declare type PrismaPromiseCallback = (transaction?: PrismaPromiseTransaction) => Promise; - -/** - * Creates a [[PrismaPromise]]. It is Prisma's implementation of `Promise` which - * is essentially a proxy for `Promise`. All the transaction-compatible client - * methods return one, this allows for pre-preparing queries without executing - * them until `.then` is called. It's the foundation of Prisma's query batching. - * @param callback that will be wrapped within our promise implementation - * @see [[PrismaPromise]] - * @returns - */ -declare type PrismaPromiseFactory = >(callback: PrismaPromiseCallback, op?: T) => PrismaPromise_2; - -declare type PrismaPromiseInteractiveTransaction = { - kind: 'itx'; - id: string; - payload: PayloadType; -}; - -declare type PrismaPromiseTransaction = PrismaPromiseBatchTransaction | PrismaPromiseInteractiveTransaction; - -declare type PrismaValue = string | boolean | number | PrismaValue[] | null | Record | PrismaValuePlaceholder | PrismaValueGenerator; - -declare type PrismaValueGenerator = { - prisma__type: 'generatorCall'; - prisma__value: { - name: string; - args: PrismaValue[]; - }; -}; - -declare type PrismaValuePlaceholder = { - prisma__type: 'param'; - prisma__value: { - name: string; - type: string; - }; -}; - -export declare const PrivateResultType: unique symbol; - -declare type Provider = 'mysql' | 'postgres' | 'sqlite' | 'sqlserver'; - -declare namespace Public { - export { - validator - } -} -export { Public } - -declare namespace Public_2 { - export { - Args, - Result, - Payload, - PrismaPromise, - Operation, - Exact - } -} - -declare type Query = ReadonlyDeep_2<{ - name: string; - args: SchemaArg[]; - output: QueryOutput; -}>; - -declare interface Queryable extends AdapterInfo { - /** - * Execute a query and return its result. - */ - queryRaw(params: Query): Promise; - /** - * Execute a query and return the number of affected rows. - */ - executeRaw(params: Query): Promise; -} - -declare type QueryCompiler = { - compile(request: string): {}; - compileBatch(batchRequest: string): BatchResponse; - free(): void; -}; - -declare interface QueryCompilerConstructor { - new (options: QueryCompilerOptions): QueryCompiler; -} - -declare type QueryCompilerOptions = { - datamodel: string; - provider: Provider; - connectionInfo: ConnectionInfo; -}; - -declare type QueryEngineBatchGraphQLRequest = { - batch: QueryEngineRequest[]; - transaction?: boolean; - isolationLevel?: IsolationLevel_2; -}; - -declare type QueryEngineBatchRequest = QueryEngineBatchGraphQLRequest | JsonBatchQuery; - -declare type QueryEngineConfig = { - datamodel: string; - configDir: string; - logQueries: boolean; - ignoreEnvVarErrors: boolean; - datasourceOverrides: Record; - env: Record; - logLevel: QueryEngineLogLevel; - engineProtocol: QueryEngineProtocol; - enableTracing: boolean; -}; - -declare interface QueryEngineConstructor { - new (config: QueryEngineConfig, logger: (log: string) => void, adapter?: ErrorCapturingSqlDriverAdapter): QueryEngineInstance; -} - -declare type QueryEngineInstance = { - connect(headers: string, requestId: string): Promise; - disconnect(headers: string, requestId: string): Promise; - /** - * Frees any resources allocated by the engine's WASM instance. This method is automatically created by WASM bindgen. - * Noop for other engines. - */ - free?(): void; - /** - * @param requestStr JSON.stringified `QueryEngineRequest | QueryEngineBatchRequest` - * @param headersStr JSON.stringified `QueryEngineRequestHeaders` - */ - query(requestStr: string, headersStr: string, transactionId: string | undefined, requestId: string): Promise; - sdlSchema?(): Promise; - startTransaction(options: string, traceHeaders: string, requestId: string): Promise; - commitTransaction(id: string, traceHeaders: string, requestId: string): Promise; - rollbackTransaction(id: string, traceHeaders: string, requestId: string): Promise; - metrics?(options: string): Promise; - applyPendingMigrations?(): Promise; - trace(requestId: string): Promise; -}; - -declare type QueryEngineLogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'off'; - -declare type QueryEngineProtocol = 'graphql' | 'json'; - -declare type QueryEngineRequest = { - query: string; - variables: Object; -}; - -declare type QueryEngineResultData = { - data: T; -}; - -declare type QueryEvent = { - timestamp: Date; - query: string; - params: string; - duration: number; - target: string; -}; - -declare type QueryEventType = 'query'; - -declare type QueryIntrospectionBuiltinType = 'int' | 'bigint' | 'float' | 'double' | 'string' | 'enum' | 'bytes' | 'bool' | 'char' | 'decimal' | 'json' | 'xml' | 'uuid' | 'datetime' | 'date' | 'time' | 'int-array' | 'bigint-array' | 'float-array' | 'double-array' | 'string-array' | 'char-array' | 'bytes-array' | 'bool-array' | 'decimal-array' | 'json-array' | 'xml-array' | 'uuid-array' | 'datetime-array' | 'date-array' | 'time-array' | 'null' | 'unknown'; - -declare type QueryMiddlewareParams = { - /** The model this is executed on */ - model?: string; - /** The action that is being handled */ - action: Action; - /** TODO what is this */ - dataPath: string[]; - /** TODO what is this */ - runInTransaction: boolean; - args?: UserArgs_2; -}; - -export declare type QueryOptions = { - query: { - [ModelName in string]: { - [ModelAction in string]: ModelQueryOptionsCb; - } | QueryOptionsCb; - }; -}; - -export declare type QueryOptionsCb = (args: QueryOptionsCbArgs) => Promise; - -export declare type QueryOptionsCbArgs = { - model?: string; - operation: string; - args: JsArgs | RawQueryArgs; - query: (args: JsArgs | RawQueryArgs) => Promise; -}; - -declare type QueryOutput = ReadonlyDeep_2<{ - name: string; - isRequired: boolean; - isList: boolean; -}>; - -declare type QueryPlanBinding = { - name: string; - expr: QueryPlanNode; -}; - -declare type QueryPlanDbQuery = { - type: 'rawSql'; - sql: string; - args: PrismaValue[]; - argTypes: ArgType[]; -} | { - type: 'templateSql'; - fragments: Fragment[]; - placeholderFormat: PlaceholderFormat; - args: PrismaValue[]; - argTypes: DynamicArgType[]; - chunkable: boolean; -}; - -declare type QueryPlanNode = { - type: 'value'; - args: PrismaValue; -} | { - type: 'seq'; - args: QueryPlanNode[]; -} | { - type: 'get'; - args: { - name: string; - }; -} | { - type: 'let'; - args: { - bindings: QueryPlanBinding[]; - expr: QueryPlanNode; - }; -} | { - type: 'getFirstNonEmpty'; - args: { - names: string[]; - }; -} | { - type: 'query'; - args: QueryPlanDbQuery; -} | { - type: 'execute'; - args: QueryPlanDbQuery; -} | { - type: 'reverse'; - args: QueryPlanNode; -} | { - type: 'sum'; - args: QueryPlanNode[]; -} | { - type: 'concat'; - args: QueryPlanNode[]; -} | { - type: 'unique'; - args: QueryPlanNode; -} | { - type: 'required'; - args: QueryPlanNode; -} | { - type: 'join'; - args: { - parent: QueryPlanNode; - children: JoinExpression[]; - }; -} | { - type: 'mapField'; - args: { - field: string; - records: QueryPlanNode; - }; -} | { - type: 'transaction'; - args: QueryPlanNode; -} | { - type: 'dataMap'; - args: { - expr: QueryPlanNode; - structure: ResultNode; - enums: Record>; - }; -} | { - type: 'validate'; - args: { - expr: QueryPlanNode; - rules: DataRule[]; - } & ValidationError; -} | { - type: 'if'; - args: { - value: QueryPlanNode; - rule: DataRule; - then: QueryPlanNode; - else: QueryPlanNode; - }; -} | { - type: 'unit'; -} | { - type: 'diff'; - args: { - from: QueryPlanNode; - to: QueryPlanNode; - fields: string[]; - }; -} | { - type: 'initializeRecord'; - args: { - expr: QueryPlanNode; - fields: Record; - }; -} | { - type: 'mapRecord'; - args: { - expr: QueryPlanNode; - fields: Record; - }; -} | { - type: 'process'; - args: { - expr: QueryPlanNode; - operations: InMemoryOps; - }; -}; - -/** - * Create raw SQL statement. - */ -export declare function raw(value: string): Sql; - -export declare type RawParameters = { - __prismaRawParameters__: true; - values: string; -}; - -export declare type RawQueryArgs = Sql | UnknownTypedSql | [query: string, ...values: RawValue[]]; - -declare type RawResponse = { - columns: string[]; - types: QueryIntrospectionBuiltinType[]; - rows: unknown[][]; -}; - -declare type RawTaggedValue = { - $type: 'Raw'; - value: unknown; -}; - -/** - * Supported value or SQL instance. - */ -export declare type RawValue = Value | Sql; - -export declare type ReadonlyDeep = { - readonly [K in keyof T]: ReadonlyDeep; -}; - -declare type ReadonlyDeep_2 = { - +readonly [K in keyof O]: ReadonlyDeep_2; -}; - -declare type Record_2 = { - [P in T]: U; -}; -export { Record_2 as Record } - -export declare type RenameAndNestPayloadKeys

= { - [K in keyof P as K extends 'scalars' | 'objects' | 'composites' ? keyof P[K] : never]: P[K]; -}; - -declare type RequestBatchOptions = { - transaction?: TransactionOptions_2; - traceparent?: string; - numTry?: number; - containsWrite: boolean; - customDataProxyFetch?: AccelerateExtensionFetchDecorator; -}; - -declare interface RequestError { - error: string; - user_facing_error: { - is_panic: boolean; - message: string; - meta?: Record; - error_code?: string; - batch_request_idx?: number; - }; -} - -declare class RequestHandler { - client: Client; - dataloader: DataLoader; - private logEmitter?; - constructor(client: Client, logEmitter?: LogEmitter); - request(params: RequestParams): Promise; - mapQueryEngineResult({ dataPath, unpacker }: RequestParams, response: QueryEngineResultData): any; - /** - * Handles the error and logs it, logging the error is done synchronously waiting for the event - * handlers to finish. - */ - handleAndLogRequestError(params: HandleErrorParams): never; - handleRequestError({ error, clientMethod, callsite, transaction, args, modelName, globalOmit, }: HandleErrorParams): never; - sanitizeMessage(message: any): any; - unpack(data: unknown, dataPath: string[], unpacker?: Unpacker): any; - get [Symbol.toStringTag](): string; -} - -declare type RequestOptions = { - traceparent?: string; - numTry?: number; - interactiveTransaction?: InteractiveTransactionOptions; - isWrite: boolean; - customDataProxyFetch?: AccelerateExtensionFetchDecorator; -}; - -declare type RequestParams = { - modelName?: string; - action: Action; - protocolQuery: JsonQuery; - dataPath: string[]; - clientMethod: string; - callsite?: CallSite; - transaction?: PrismaPromiseTransaction; - extensions: MergedExtensionsList; - args?: any; - headers?: Record; - unpacker?: Unpacker; - otelParentCtx?: Context; - otelChildCtx?: Context; - globalOmit?: GlobalOmitOptions; - customDataProxyFetch?: AccelerateExtensionFetchDecorator; -}; - -declare type RequiredExtensionArgs = NameArgs & ResultArgs & ModelArgs & ClientArgs & QueryOptions; -export { RequiredExtensionArgs } -export { RequiredExtensionArgs as UserArgs } - -export declare type RequiredKeys = { - [K in keyof O]-?: {} extends Pick_2 ? never : K; -}[keyof O]; - -declare function resolveDatasourceUrl({ inlineDatasources, overrideDatasources, env, clientVersion, }: { - inlineDatasources: GetPrismaClientConfig['inlineDatasources']; - overrideDatasources: Datasources; - env: Record; - clientVersion: string; -}): string; - -export declare type Result = T extends { - [K: symbol]: { - types: { - payload: any; - }; - }; -} ? GetResult : GetResult<{ - composites: {}; - objects: {}; - scalars: {}; - name: ''; -}, {}, F>; - -export declare type Result_2 = Result; - -declare namespace Result_3 { - export { - Count, - GetFindResult, - SelectablePayloadFields, - SelectField, - DefaultSelection, - UnwrapPayload, - ApplyOmit, - OmitValue, - GetCountResult, - Aggregate, - GetAggregateResult, - GetBatchResult, - GetGroupByResult, - GetResult, - ExtractGlobalOmit - } -} - -declare type Result_4 = { - map(fn: (value: T) => U): Result_4; - flatMap(fn: (value: T) => Result_4): Result_4; -} & ({ - readonly ok: true; - readonly value: T; -} | { - readonly ok: false; - readonly error: Error_2; -}); - -export declare type ResultArg = { - [FieldName in string]: ResultFieldDefinition; -}; - -export declare type ResultArgs = { - result: { - [ModelName in string]: ResultArg; - }; -}; - -export declare type ResultArgsFieldCompute = (model: any) => unknown; - -export declare type ResultFieldDefinition = { - needs?: { - [FieldName in string]: boolean; - }; - compute: ResultArgsFieldCompute; -}; - -declare type ResultNode = { - type: 'affectedRows'; -} | { - type: 'object'; - fields: Record; - serializedName: string | null; - skipNulls: boolean; -} | { - type: 'field'; - dbName: string; - fieldType: FieldType; -}; - -export declare type Return = T extends (...args: any[]) => infer R ? R : T; - -export declare type RuntimeDataModel = { - readonly models: Record; - readonly enums: Record; - readonly types: Record; -}; - -declare type RuntimeEnum = Omit; - -declare type RuntimeModel = Omit; - -declare type RuntimeName = 'workerd' | 'deno' | 'netlify' | 'node' | 'bun' | 'edge-light' | ''; - -declare type Schema = ReadonlyDeep_2<{ - rootQueryType?: string; - rootMutationType?: string; - inputObjectTypes: { - model?: InputType[]; - prisma?: InputType[]; - }; - outputObjectTypes: { - model: OutputType[]; - prisma: OutputType[]; - }; - enumTypes: { - model?: SchemaEnum[]; - prisma: SchemaEnum[]; - }; - fieldRefTypes: { - prisma?: FieldRefType[]; - }; -}>; - -declare type SchemaArg = ReadonlyDeep_2<{ - name: string; - comment?: string; - isNullable: boolean; - isRequired: boolean; - inputTypes: InputTypeRef[]; - requiresOtherFields?: string[]; - deprecation?: Deprecation; -}>; - -declare type SchemaEnum = ReadonlyDeep_2<{ - name: string; - values: string[]; -}>; - -declare type SchemaField = ReadonlyDeep_2<{ - name: string; - isNullable?: boolean; - outputType: OutputTypeRef; - args: SchemaArg[]; - deprecation?: Deprecation; - documentation?: string; -}>; - -export declare type Select = T extends U ? T : never; - -export declare type SelectablePayloadFields = { - objects: { - [k in K]: O; - }; -} | { - composites: { - [k in K]: O; - }; -}; - -export declare type SelectField

, K extends PropertyKey> = P extends { - objects: Record; -} ? P['objects'][K] : P extends { - composites: Record; -} ? P['composites'][K] : never; - -declare type Selection_2 = Record; -export { Selection_2 as Selection } - -export declare function serializeJsonQuery({ modelName, action, args, runtimeDataModel, extensions, callsite, clientMethod, errorFormat, clientVersion, previewFeatures, globalOmit, }: SerializeParams): JsonQuery; - -declare type SerializeParams = { - runtimeDataModel: RuntimeDataModel; - modelName?: string; - action: Action; - args?: JsArgs; - extensions?: MergedExtensionsList; - callsite?: CallSite; - clientMethod: string; - clientVersion: string; - errorFormat: ErrorFormat; - previewFeatures: string[]; - globalOmit?: GlobalOmitOptions; -}; - -declare class Skip { - constructor(param?: symbol); - ifUndefined(value: T | undefined): T | Skip; -} - -export declare const skip: Skip; - -declare type SortOrder = 'asc' | 'desc'; - -/** - * An interface that represents a span. A span represents a single operation - * within a trace. Examples of span might include remote procedure calls or a - * in-process function calls to sub-components. A Trace has a single, top-level - * "root" Span that in turn may have zero or more child Spans, which in turn - * may have children. - * - * Spans are created by the {@link Tracer.startSpan} method. - */ -declare interface Span { - /** - * Returns the {@link SpanContext} object associated with this Span. - * - * Get an immutable, serializable identifier for this span that can be used - * to create new child spans. Returned SpanContext is usable even after the - * span ends. - * - * @returns the SpanContext object associated with this Span. - */ - spanContext(): SpanContext; - /** - * Sets an attribute to the span. - * - * Sets a single Attribute with the key and value passed as arguments. - * - * @param key the key for this attribute. - * @param value the value for this attribute. Setting a value null or - * undefined is invalid and will result in undefined behavior. - */ - setAttribute(key: string, value: SpanAttributeValue): this; - /** - * Sets attributes to the span. - * - * @param attributes the attributes that will be added. - * null or undefined attribute values - * are invalid and will result in undefined behavior. - */ - setAttributes(attributes: SpanAttributes): this; - /** - * Adds an event to the Span. - * - * @param name the name of the event. - * @param [attributesOrStartTime] the attributes that will be added; these are - * associated with this event. Can be also a start time - * if type is {@type TimeInput} and 3rd param is undefined - * @param [startTime] start time of the event. - */ - addEvent(name: string, attributesOrStartTime?: SpanAttributes | TimeInput, startTime?: TimeInput): this; - /** - * Adds a single link to the span. - * - * Links added after the creation will not affect the sampling decision. - * It is preferred span links be added at span creation. - * - * @param link the link to add. - */ - addLink(link: Link): this; - /** - * Adds multiple links to the span. - * - * Links added after the creation will not affect the sampling decision. - * It is preferred span links be added at span creation. - * - * @param links the links to add. - */ - addLinks(links: Link[]): this; - /** - * Sets a status to the span. If used, this will override the default Span - * status. Default is {@link SpanStatusCode.UNSET}. SetStatus overrides the value - * of previous calls to SetStatus on the Span. - * - * @param status the SpanStatus to set. - */ - setStatus(status: SpanStatus): this; - /** - * Updates the Span name. - * - * This will override the name provided via {@link Tracer.startSpan}. - * - * Upon this update, any sampling behavior based on Span name will depend on - * the implementation. - * - * @param name the Span name. - */ - updateName(name: string): this; - /** - * Marks the end of Span execution. - * - * Call to End of a Span MUST not have any effects on child spans. Those may - * still be running and can be ended later. - * - * Do not return `this`. The Span generally should not be used after it - * is ended so chaining is not desired in this context. - * - * @param [endTime] the time to set as Span's end time. If not provided, - * use the current time as the span's end time. - */ - end(endTime?: TimeInput): void; - /** - * Returns the flag whether this span will be recorded. - * - * @returns true if this Span is active and recording information like events - * with the `AddEvent` operation and attributes using `setAttributes`. - */ - isRecording(): boolean; - /** - * Sets exception as a span event - * @param exception the exception the only accepted values are string or Error - * @param [time] the time to set as Span's event time. If not provided, - * use the current time. - */ - recordException(exception: Exception, time?: TimeInput): void; -} - -/** - * @deprecated please use {@link Attributes} - */ -declare type SpanAttributes = Attributes; - -/** - * @deprecated please use {@link AttributeValue} - */ -declare type SpanAttributeValue = AttributeValue; - -declare type SpanCallback = (span?: Span, context?: Context) => R; - -/** - * A SpanContext represents the portion of a {@link Span} which must be - * serialized and propagated along side of a {@link Baggage}. - */ -declare interface SpanContext { - /** - * The ID of the trace that this span belongs to. It is worldwide unique - * with practically sufficient probability by being made as 16 randomly - * generated bytes, encoded as a 32 lowercase hex characters corresponding to - * 128 bits. - */ - traceId: string; - /** - * The ID of the Span. It is globally unique with practically sufficient - * probability by being made as 8 randomly generated bytes, encoded as a 16 - * lowercase hex characters corresponding to 64 bits. - */ - spanId: string; - /** - * Only true if the SpanContext was propagated from a remote parent. - */ - isRemote?: boolean; - /** - * Trace flags to propagate. - * - * It is represented as 1 byte (bitmap). Bit to represent whether trace is - * sampled or not. When set, the least significant bit documents that the - * caller may have recorded trace data. A caller who does not record trace - * data out-of-band leaves this flag unset. - * - * see {@link TraceFlags} for valid flag values. - */ - traceFlags: number; - /** - * Tracing-system-specific info to propagate. - * - * The tracestate field value is a `list` as defined below. The `list` is a - * series of `list-members` separated by commas `,`, and a list-member is a - * key/value pair separated by an equals sign `=`. Spaces and horizontal tabs - * surrounding `list-members` are ignored. There can be a maximum of 32 - * `list-members` in a `list`. - * More Info: https://www.w3.org/TR/trace-context/#tracestate-field - * - * Examples: - * Single tracing system (generic format): - * tracestate: rojo=00f067aa0ba902b7 - * Multiple tracing systems (with different formatting): - * tracestate: rojo=00f067aa0ba902b7,congo=t61rcWkgMzE - */ - traceState?: TraceState; -} - -declare enum SpanKind { - /** Default value. Indicates that the span is used internally. */ - INTERNAL = 0, - /** - * Indicates that the span covers server-side handling of an RPC or other - * remote request. - */ - SERVER = 1, - /** - * Indicates that the span covers the client-side wrapper around an RPC or - * other remote request. - */ - CLIENT = 2, - /** - * Indicates that the span describes producer sending a message to a - * broker. Unlike client and server, there is no direct critical path latency - * relationship between producer and consumer spans. - */ - PRODUCER = 3, - /** - * Indicates that the span describes consumer receiving a message from a - * broker. Unlike client and server, there is no direct critical path latency - * relationship between producer and consumer spans. - */ - CONSUMER = 4 -} - -/** - * Options needed for span creation - */ -declare interface SpanOptions { - /** - * The SpanKind of a span - * @default {@link SpanKind.INTERNAL} - */ - kind?: SpanKind; - /** A span's attributes */ - attributes?: SpanAttributes; - /** {@link Link}s span to other spans */ - links?: Link[]; - /** A manually specified start time for the created `Span` object. */ - startTime?: TimeInput; - /** The new span should be a root span. (Ignore parent from context). */ - root?: boolean; -} - -declare interface SpanStatus { - /** The status code of this message. */ - code: SpanStatusCode; - /** A developer-facing error message. */ - message?: string; -} - -/** - * An enumeration of status codes. - */ -declare enum SpanStatusCode { - /** - * The default status. - */ - UNSET = 0, - /** - * The operation has been validated by an Application developer or - * Operator to have completed successfully. - */ - OK = 1, - /** - * The operation contains an error. - */ - ERROR = 2 -} - -/** - * A SQL instance can be nested within each other to build SQL strings. - */ -export declare class Sql { - readonly values: Value[]; - readonly strings: string[]; - constructor(rawStrings: readonly string[], rawValues: readonly RawValue[]); - get sql(): string; - get statement(): string; - get text(): string; - inspect(): { - sql: string; - statement: string; - text: string; - values: unknown[]; - }; -} - -declare interface SqlDriverAdapter extends SqlQueryable { - /** - * Execute multiple SQL statements separated by semicolon. - */ - executeScript(script: string): Promise; - /** - * Start new transaction. - */ - startTransaction(isolationLevel?: IsolationLevel): Promise; - /** - * Optional method that returns extra connection info - */ - getConnectionInfo?(): ConnectionInfo; - /** - * Dispose of the connection and release any resources. - */ - dispose(): Promise; -} - -export declare interface SqlDriverAdapterFactory extends DriverAdapterFactory { - connect(): Promise; -} - -declare type SqlQuery = { - sql: string; - args: Array; - argTypes: Array; -}; - -declare interface SqlQueryable extends Queryable { -} - -declare interface SqlResultSet { - /** - * List of column types appearing in a database query, in the same order as `columnNames`. - * They are used within the Query Engine to convert values from JS to Quaint values. - */ - columnTypes: Array; - /** - * List of column names appearing in a database query, in the same order as `columnTypes`. - */ - columnNames: Array; - /** - * List of rows retrieved from a database query. - * Each row is a list of values, whose length matches `columnNames` and `columnTypes`. - */ - rows: Array>; - /** - * The last ID of an `INSERT` statement, if any. - * This is required for `AUTO_INCREMENT` columns in databases based on MySQL and SQLite. - */ - lastInsertId?: string; -} - -/** - * Create a SQL object from a template string. - */ -export declare function sqltag(strings: readonly string[], ...values: readonly RawValue[]): Sql; - -/** - * Defines TimeInput. - * - * hrtime, epoch milliseconds, performance.now() or Date - */ -declare type TimeInput = HrTime_2 | number | Date; - -export declare type ToTuple = T extends any[] ? T : [T]; - -declare interface TraceState { - /** - * Create a new TraceState which inherits from this TraceState and has the - * given key set. - * The new entry will always be added in the front of the list of states. - * - * @param key key of the TraceState entry. - * @param value value of the TraceState entry. - */ - set(key: string, value: string): TraceState; - /** - * Return a new TraceState which inherits from this TraceState but does not - * contain the given key. - * - * @param key the key for the TraceState entry to be removed. - */ - unset(key: string): TraceState; - /** - * Returns the value to which the specified key is mapped, or `undefined` if - * this map contains no mapping for the key. - * - * @param key with which the specified value is to be associated. - * @returns the value to which the specified key is mapped, or `undefined` if - * this map contains no mapping for the key. - */ - get(key: string): string | undefined; - /** - * Serializes the TraceState to a `list` as defined below. The `list` is a - * series of `list-members` separated by commas `,`, and a list-member is a - * key/value pair separated by an equals sign `=`. Spaces and horizontal tabs - * surrounding `list-members` are ignored. There can be a maximum of 32 - * `list-members` in a `list`. - * - * @returns the serialized string. - */ - serialize(): string; -} - -declare interface TracingHelper { - isEnabled(): boolean; - getTraceParent(context?: Context): string; - dispatchEngineSpans(spans: EngineSpan[]): void; - getActiveContext(): Context | undefined; - runInChildSpan(nameOrOptions: string | ExtendedSpanOptions, callback: SpanCallback): R; -} - -declare interface Transaction extends AdapterInfo, SqlQueryable { - /** - * Transaction options. - */ - readonly options: TransactionOptions; - /** - * Commit the transaction. - */ - commit(): Promise; - /** - * Roll back the transaction. - */ - rollback(): Promise; -} - -declare namespace Transaction_2 { - export { - Options, - IsolationLevel_2 as IsolationLevel, - InteractiveTransactionInfo, - TransactionHeaders - } -} - -declare type TransactionHeaders = { - traceparent?: string; -}; - -declare type TransactionOptions = { - usePhantomQuery: boolean; -}; - -declare type TransactionOptions_2 = { - kind: 'itx'; - options: InteractiveTransactionOptions; -} | { - kind: 'batch'; - options: BatchTransactionOptions; -}; - -export declare class TypedSql { - [PrivateResultType]: Result; - constructor(sql: string, values: Values); - get sql(): string; - get values(): Values; -} - -export declare type TypeMapCbDef = Fn<{ - extArgs: InternalArgs; -}, TypeMapDef>; - -/** Shared */ -export declare type TypeMapDef = Record; - -declare type TypeRef = { - isList: boolean; - type: string; - location: AllowedLocations; - namespace?: FieldNamespace; -}; - -declare namespace Types { - export { - Result_3 as Result, - Extensions_2 as Extensions, - Utils, - Public_2 as Public, - isSkip, - Skip, - skip, - UnknownTypedSql, - OperationPayload as Payload - } -} -export { Types } - -declare type uniqueIndex = ReadonlyDeep_2<{ - name: string; - fields: string[]; -}>; - -declare type UnknownErrorParams = { - clientVersion: string; - batchRequestIdx?: number; -}; - -export declare type UnknownTypedSql = TypedSql; - -declare type Unpacker = (data: any) => any; - -export declare type UnwrapPayload

= {} extends P ? unknown : { - [K in keyof P]: P[K] extends { - scalars: infer S; - composites: infer C; - }[] ? Array> : P[K] extends { - scalars: infer S; - composites: infer C; - } | null ? S & UnwrapPayload | Select : never; -}; - -export declare type UnwrapPromise

= P extends Promise ? R : P; - -export declare type UnwrapTuple = { - [K in keyof Tuple]: K extends `${number}` ? Tuple[K] extends PrismaPromise ? X : UnwrapPromise : UnwrapPromise; -}; - -/** - * Input that flows from the user into the Client. - */ -declare type UserArgs_2 = any; - -declare namespace Utils { - export { - EmptyToUnknown, - NeverToUnknown, - PatchFlat, - Omit_2 as Omit, - Pick_2 as Pick, - ComputeDeep, - Compute, - OptionalFlat, - ReadonlyDeep, - Narrowable, - Narrow, - Exact, - Cast, - Record_2 as Record, - UnwrapPromise, - UnwrapTuple, - Path, - Fn, - Call, - RequiredKeys, - OptionalKeys, - Optional, - Return, - ToTuple, - RenameAndNestPayloadKeys, - PayloadToResult, - Select, - Equals, - Or, - JsPromise - } -} - -declare type ValidationError = { - error_identifier: 'RELATION_VIOLATION'; - context: { - relation: string; - modelA: string; - modelB: string; - }; -} | { - error_identifier: 'MISSING_RELATED_RECORD'; - context: { - model: string; - relation: string; - relationType: string; - operation: string; - neededFor?: string; - }; -} | { - error_identifier: 'MISSING_RECORD'; - context: { - operation: string; - }; -} | { - error_identifier: 'INCOMPLETE_CONNECT_INPUT'; - context: { - expectedRows: number; - }; -} | { - error_identifier: 'INCOMPLETE_CONNECT_OUTPUT'; - context: { - expectedRows: number; - relation: string; - relationType: string; - }; -} | { - error_identifier: 'RECORDS_NOT_CONNECTED'; - context: { - relation: string; - parent: string; - child: string; - }; -}; - -declare function validator(): (select: Exact) => S; - -declare function validator, O extends keyof C[M] & Operation>(client: C, model: M, operation: O): (select: Exact>) => S; - -declare function validator, O extends keyof C[M] & Operation, P extends keyof Args>(client: C, model: M, operation: O, prop: P): (select: Exact[P]>) => S; - -/** - * Values supported by SQL engine. - */ -export declare type Value = unknown; - -export declare function warnEnvConflicts(envPaths: any): void; - -export declare const warnOnce: (key: string, message: string, ...args: unknown[]) => void; - -export { } diff --git a/frontend/generated/prisma/runtime/library.js b/frontend/generated/prisma/runtime/library.js deleted file mode 100644 index deb2352..0000000 --- a/frontend/generated/prisma/runtime/library.js +++ /dev/null @@ -1,147 +0,0 @@ - -/* !!! This is code generated by Prisma. Do not edit directly. !!! -/* eslint-disable */ -// biome-ignore-all lint: generated file -"use strict";var yu=Object.create;var jt=Object.defineProperty;var bu=Object.getOwnPropertyDescriptor;var Eu=Object.getOwnPropertyNames;var wu=Object.getPrototypeOf,xu=Object.prototype.hasOwnProperty;var Do=(e,r)=>()=>(e&&(r=e(e=0)),r);var ue=(e,r)=>()=>(r||e((r={exports:{}}).exports,r),r.exports),tr=(e,r)=>{for(var t in r)jt(e,t,{get:r[t],enumerable:!0})},Oo=(e,r,t,n)=>{if(r&&typeof r=="object"||typeof r=="function")for(let i of Eu(r))!xu.call(e,i)&&i!==t&&jt(e,i,{get:()=>r[i],enumerable:!(n=bu(r,i))||n.enumerable});return e};var O=(e,r,t)=>(t=e!=null?yu(wu(e)):{},Oo(r||!e||!e.__esModule?jt(t,"default",{value:e,enumerable:!0}):t,e)),vu=e=>Oo(jt({},"__esModule",{value:!0}),e);var hi=ue((_g,is)=>{"use strict";is.exports=(e,r=process.argv)=>{let t=e.startsWith("-")?"":e.length===1?"-":"--",n=r.indexOf(t+e),i=r.indexOf("--");return n!==-1&&(i===-1||n{"use strict";var Fc=require("node:os"),os=require("node:tty"),de=hi(),{env:G}=process,Qe;de("no-color")||de("no-colors")||de("color=false")||de("color=never")?Qe=0:(de("color")||de("colors")||de("color=true")||de("color=always"))&&(Qe=1);"FORCE_COLOR"in G&&(G.FORCE_COLOR==="true"?Qe=1:G.FORCE_COLOR==="false"?Qe=0:Qe=G.FORCE_COLOR.length===0?1:Math.min(parseInt(G.FORCE_COLOR,10),3));function yi(e){return e===0?!1:{level:e,hasBasic:!0,has256:e>=2,has16m:e>=3}}function bi(e,r){if(Qe===0)return 0;if(de("color=16m")||de("color=full")||de("color=truecolor"))return 3;if(de("color=256"))return 2;if(e&&!r&&Qe===void 0)return 0;let t=Qe||0;if(G.TERM==="dumb")return t;if(process.platform==="win32"){let n=Fc.release().split(".");return Number(n[0])>=10&&Number(n[2])>=10586?Number(n[2])>=14931?3:2:1}if("CI"in G)return["TRAVIS","CIRCLECI","APPVEYOR","GITLAB_CI","GITHUB_ACTIONS","BUILDKITE"].some(n=>n in G)||G.CI_NAME==="codeship"?1:t;if("TEAMCITY_VERSION"in G)return/^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(G.TEAMCITY_VERSION)?1:0;if(G.COLORTERM==="truecolor")return 3;if("TERM_PROGRAM"in G){let n=parseInt((G.TERM_PROGRAM_VERSION||"").split(".")[0],10);switch(G.TERM_PROGRAM){case"iTerm.app":return n>=3?3:2;case"Apple_Terminal":return 2}}return/-256(color)?$/i.test(G.TERM)?2:/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(G.TERM)||"COLORTERM"in G?1:t}function Mc(e){let r=bi(e,e&&e.isTTY);return yi(r)}ss.exports={supportsColor:Mc,stdout:yi(bi(!0,os.isatty(1))),stderr:yi(bi(!0,os.isatty(2)))}});var cs=ue((Lg,us)=>{"use strict";var $c=as(),br=hi();function ls(e){if(/^\d{3,4}$/.test(e)){let t=/(\d{1,2})(\d{2})/.exec(e)||[];return{major:0,minor:parseInt(t[1],10),patch:parseInt(t[2],10)}}let r=(e||"").split(".").map(t=>parseInt(t,10));return{major:r[0],minor:r[1],patch:r[2]}}function Ei(e){let{CI:r,FORCE_HYPERLINK:t,NETLIFY:n,TEAMCITY_VERSION:i,TERM_PROGRAM:o,TERM_PROGRAM_VERSION:s,VTE_VERSION:a,TERM:l}=process.env;if(t)return!(t.length>0&&parseInt(t,10)===0);if(br("no-hyperlink")||br("no-hyperlinks")||br("hyperlink=false")||br("hyperlink=never"))return!1;if(br("hyperlink=true")||br("hyperlink=always")||n)return!0;if(!$c.supportsColor(e)||e&&!e.isTTY)return!1;if("WT_SESSION"in process.env)return!0;if(process.platform==="win32"||r||i)return!1;if(o){let u=ls(s||"");switch(o){case"iTerm.app":return u.major===3?u.minor>=1:u.major>3;case"WezTerm":return u.major>=20200620;case"vscode":return u.major>1||u.major===1&&u.minor>=72;case"ghostty":return!0}}if(a){if(a==="0.50.0")return!1;let u=ls(a);return u.major>0||u.minor>=50}switch(l){case"alacritty":return!0}return!1}us.exports={supportsHyperlink:Ei,stdout:Ei(process.stdout),stderr:Ei(process.stderr)}});var ps=ue((Kg,qc)=>{qc.exports={name:"@prisma/internals",version:"6.19.1",description:"This package is intended for Prisma's internal use",main:"dist/index.js",types:"dist/index.d.ts",repository:{type:"git",url:"https://github.com/prisma/prisma.git",directory:"packages/internals"},homepage:"https://www.prisma.io",author:"Tim Suchanek ",bugs:"https://github.com/prisma/prisma/issues",license:"Apache-2.0",scripts:{dev:"DEV=true tsx helpers/build.ts",build:"tsx helpers/build.ts",test:"dotenv -e ../../.db.env -- jest --silent",prepublishOnly:"pnpm run build"},files:["README.md","dist","!**/libquery_engine*","!dist/get-generators/engines/*","scripts"],devDependencies:{"@babel/helper-validator-identifier":"7.25.9","@opentelemetry/api":"1.9.0","@swc/core":"1.11.5","@swc/jest":"0.2.37","@types/babel__helper-validator-identifier":"7.15.2","@types/jest":"29.5.14","@types/node":"18.19.76","@types/resolve":"1.20.6",archiver:"6.0.2","checkpoint-client":"1.1.33","cli-truncate":"4.0.0",dotenv:"16.5.0",empathic:"2.0.0","escape-string-regexp":"5.0.0",execa:"8.0.1","fast-glob":"3.3.3","find-up":"7.0.0","fp-ts":"2.16.9","fs-extra":"11.3.0","global-directory":"4.0.0",globby:"11.1.0","identifier-regex":"1.0.0","indent-string":"4.0.0","is-windows":"1.0.2","is-wsl":"3.1.0",jest:"29.7.0","jest-junit":"16.0.0",kleur:"4.1.5","mock-stdin":"1.0.0","new-github-issue-url":"0.2.1","node-fetch":"3.3.2","npm-packlist":"5.1.3",open:"7.4.2","p-map":"4.0.0",resolve:"1.22.10","string-width":"7.2.0","strip-indent":"4.0.0","temp-dir":"2.0.0",tempy:"1.0.1","terminal-link":"4.0.0",tmp:"0.2.3","ts-pattern":"5.6.2","ts-toolbelt":"9.6.0",typescript:"5.4.5",yarn:"1.22.22"},dependencies:{"@prisma/config":"workspace:*","@prisma/debug":"workspace:*","@prisma/dmmf":"workspace:*","@prisma/driver-adapter-utils":"workspace:*","@prisma/engines":"workspace:*","@prisma/fetch-engine":"workspace:*","@prisma/generator":"workspace:*","@prisma/generator-helper":"workspace:*","@prisma/get-platform":"workspace:*","@prisma/prisma-schema-wasm":"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7","@prisma/schema-engine-wasm":"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7","@prisma/schema-files-loader":"workspace:*",arg:"5.0.2",prompts:"2.4.2"},peerDependencies:{typescript:">=5.1.0"},peerDependenciesMeta:{typescript:{optional:!0}},sideEffects:!1}});var Ti=ue((gh,Qc)=>{Qc.exports={name:"@prisma/engines-version",version:"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7",main:"index.js",types:"index.d.ts",license:"Apache-2.0",author:"Tim Suchanek ",prisma:{enginesVersion:"c2990dca591cba766e3b7ef5d9e8a84796e47ab7"},repository:{type:"git",url:"https://github.com/prisma/engines-wrapper.git",directory:"packages/engines-version"},devDependencies:{"@types/node":"18.19.76",typescript:"4.9.5"},files:["index.js","index.d.ts"],scripts:{build:"tsc -d"}}});var on=ue(nn=>{"use strict";Object.defineProperty(nn,"__esModule",{value:!0});nn.enginesVersion=void 0;nn.enginesVersion=Ti().prisma.enginesVersion});var hs=ue((Ih,gs)=>{"use strict";gs.exports=e=>{let r=e.match(/^[ \t]*(?=\S)/gm);return r?r.reduce((t,n)=>Math.min(t,n.length),1/0):0}});var Di=ue((kh,Es)=>{"use strict";Es.exports=(e,r=1,t)=>{if(t={indent:" ",includeEmptyLines:!1,...t},typeof e!="string")throw new TypeError(`Expected \`input\` to be a \`string\`, got \`${typeof e}\``);if(typeof r!="number")throw new TypeError(`Expected \`count\` to be a \`number\`, got \`${typeof r}\``);if(typeof t.indent!="string")throw new TypeError(`Expected \`options.indent\` to be a \`string\`, got \`${typeof t.indent}\``);if(r===0)return e;let n=t.includeEmptyLines?/^/gm:/^(?!\s*$)/gm;return e.replace(n,t.indent.repeat(r))}});var vs=ue((jh,tp)=>{tp.exports={name:"dotenv",version:"16.5.0",description:"Loads environment variables from .env file",main:"lib/main.js",types:"lib/main.d.ts",exports:{".":{types:"./lib/main.d.ts",require:"./lib/main.js",default:"./lib/main.js"},"./config":"./config.js","./config.js":"./config.js","./lib/env-options":"./lib/env-options.js","./lib/env-options.js":"./lib/env-options.js","./lib/cli-options":"./lib/cli-options.js","./lib/cli-options.js":"./lib/cli-options.js","./package.json":"./package.json"},scripts:{"dts-check":"tsc --project tests/types/tsconfig.json",lint:"standard",pretest:"npm run lint && npm run dts-check",test:"tap run --allow-empty-coverage --disable-coverage --timeout=60000","test:coverage":"tap run --show-full-coverage --timeout=60000 --coverage-report=lcov",prerelease:"npm test",release:"standard-version"},repository:{type:"git",url:"git://github.com/motdotla/dotenv.git"},homepage:"https://github.com/motdotla/dotenv#readme",funding:"https://dotenvx.com",keywords:["dotenv","env",".env","environment","variables","config","settings"],readmeFilename:"README.md",license:"BSD-2-Clause",devDependencies:{"@types/node":"^18.11.3",decache:"^4.6.2",sinon:"^14.0.1",standard:"^17.0.0","standard-version":"^9.5.0",tap:"^19.2.0",typescript:"^4.8.4"},engines:{node:">=12"},browser:{fs:!1}}});var As=ue((Bh,_e)=>{"use strict";var Fi=require("node:fs"),Mi=require("node:path"),np=require("node:os"),ip=require("node:crypto"),op=vs(),Ts=op.version,sp=/(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;function ap(e){let r={},t=e.toString();t=t.replace(/\r\n?/mg,` -`);let n;for(;(n=sp.exec(t))!=null;){let i=n[1],o=n[2]||"";o=o.trim();let s=o[0];o=o.replace(/^(['"`])([\s\S]*)\1$/mg,"$2"),s==='"'&&(o=o.replace(/\\n/g,` -`),o=o.replace(/\\r/g,"\r")),r[i]=o}return r}function lp(e){let r=Rs(e),t=B.configDotenv({path:r});if(!t.parsed){let s=new Error(`MISSING_DATA: Cannot parse ${r} for an unknown reason`);throw s.code="MISSING_DATA",s}let n=Ss(e).split(","),i=n.length,o;for(let s=0;s=i)throw a}return B.parse(o)}function up(e){console.log(`[dotenv@${Ts}][WARN] ${e}`)}function ot(e){console.log(`[dotenv@${Ts}][DEBUG] ${e}`)}function Ss(e){return e&&e.DOTENV_KEY&&e.DOTENV_KEY.length>0?e.DOTENV_KEY:process.env.DOTENV_KEY&&process.env.DOTENV_KEY.length>0?process.env.DOTENV_KEY:""}function cp(e,r){let t;try{t=new URL(r)}catch(a){if(a.code==="ERR_INVALID_URL"){let l=new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");throw l.code="INVALID_DOTENV_KEY",l}throw a}let n=t.password;if(!n){let a=new Error("INVALID_DOTENV_KEY: Missing key part");throw a.code="INVALID_DOTENV_KEY",a}let i=t.searchParams.get("environment");if(!i){let a=new Error("INVALID_DOTENV_KEY: Missing environment part");throw a.code="INVALID_DOTENV_KEY",a}let o=`DOTENV_VAULT_${i.toUpperCase()}`,s=e.parsed[o];if(!s){let a=new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${o} in your .env.vault file.`);throw a.code="NOT_FOUND_DOTENV_ENVIRONMENT",a}return{ciphertext:s,key:n}}function Rs(e){let r=null;if(e&&e.path&&e.path.length>0)if(Array.isArray(e.path))for(let t of e.path)Fi.existsSync(t)&&(r=t.endsWith(".vault")?t:`${t}.vault`);else r=e.path.endsWith(".vault")?e.path:`${e.path}.vault`;else r=Mi.resolve(process.cwd(),".env.vault");return Fi.existsSync(r)?r:null}function Ps(e){return e[0]==="~"?Mi.join(np.homedir(),e.slice(1)):e}function pp(e){!!(e&&e.debug)&&ot("Loading env from encrypted .env.vault");let t=B._parseVault(e),n=process.env;return e&&e.processEnv!=null&&(n=e.processEnv),B.populate(n,t,e),{parsed:t}}function dp(e){let r=Mi.resolve(process.cwd(),".env"),t="utf8",n=!!(e&&e.debug);e&&e.encoding?t=e.encoding:n&&ot("No encoding is specified. UTF-8 is used by default");let i=[r];if(e&&e.path)if(!Array.isArray(e.path))i=[Ps(e.path)];else{i=[];for(let l of e.path)i.push(Ps(l))}let o,s={};for(let l of i)try{let u=B.parse(Fi.readFileSync(l,{encoding:t}));B.populate(s,u,e)}catch(u){n&&ot(`Failed to load ${l} ${u.message}`),o=u}let a=process.env;return e&&e.processEnv!=null&&(a=e.processEnv),B.populate(a,s,e),o?{parsed:s,error:o}:{parsed:s}}function mp(e){if(Ss(e).length===0)return B.configDotenv(e);let r=Rs(e);return r?B._configVault(e):(up(`You set DOTENV_KEY but you are missing a .env.vault file at ${r}. Did you forget to build it?`),B.configDotenv(e))}function fp(e,r){let t=Buffer.from(r.slice(-64),"hex"),n=Buffer.from(e,"base64"),i=n.subarray(0,12),o=n.subarray(-16);n=n.subarray(12,-16);try{let s=ip.createDecipheriv("aes-256-gcm",t,i);return s.setAuthTag(o),`${s.update(n)}${s.final()}`}catch(s){let a=s instanceof RangeError,l=s.message==="Invalid key length",u=s.message==="Unsupported state or unable to authenticate data";if(a||l){let c=new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");throw c.code="INVALID_DOTENV_KEY",c}else if(u){let c=new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");throw c.code="DECRYPTION_FAILED",c}else throw s}}function gp(e,r,t={}){let n=!!(t&&t.debug),i=!!(t&&t.override);if(typeof r!="object"){let o=new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");throw o.code="OBJECT_REQUIRED",o}for(let o of Object.keys(r))Object.prototype.hasOwnProperty.call(e,o)?(i===!0&&(e[o]=r[o]),n&&ot(i===!0?`"${o}" is already defined and WAS overwritten`:`"${o}" is already defined and was NOT overwritten`)):e[o]=r[o]}var B={configDotenv:dp,_configVault:pp,_parseVault:lp,config:mp,decrypt:fp,parse:ap,populate:gp};_e.exports.configDotenv=B.configDotenv;_e.exports._configVault=B._configVault;_e.exports._parseVault=B._parseVault;_e.exports.config=B.config;_e.exports.decrypt=B.decrypt;_e.exports.parse=B.parse;_e.exports.populate=B.populate;_e.exports=B});var Os=ue((Kh,cn)=>{"use strict";cn.exports=(e={})=>{let r;if(e.repoUrl)r=e.repoUrl;else if(e.user&&e.repo)r=`https://github.com/${e.user}/${e.repo}`;else throw new Error("You need to specify either the `repoUrl` option or both the `user` and `repo` options");let t=new URL(`${r}/issues/new`),n=["body","title","labels","template","milestone","assignee","projects"];for(let i of n){let o=e[i];if(o!==void 0){if(i==="labels"||i==="projects"){if(!Array.isArray(o))throw new TypeError(`The \`${i}\` option should be an array`);o=o.join(",")}t.searchParams.set(i,o)}}return t.toString()};cn.exports.default=cn.exports});var Ki=ue((vb,ea)=>{"use strict";ea.exports=function(){function e(r,t,n,i,o){return rn?n+1:r+1:i===o?t:t+1}return function(r,t){if(r===t)return 0;if(r.length>t.length){var n=r;r=t,t=n}for(var i=r.length,o=t.length;i>0&&r.charCodeAt(i-1)===t.charCodeAt(o-1);)i--,o--;for(var s=0;s{"use strict"});var sa=Do(()=>{"use strict"});var jf={};tr(jf,{DMMF:()=>ct,Debug:()=>N,Decimal:()=>Fe,Extensions:()=>ni,MetricsClient:()=>Lr,PrismaClientInitializationError:()=>P,PrismaClientKnownRequestError:()=>z,PrismaClientRustPanicError:()=>ae,PrismaClientUnknownRequestError:()=>V,PrismaClientValidationError:()=>Z,Public:()=>ii,Sql:()=>ie,createParam:()=>va,defineDmmfProperty:()=>Ca,deserializeJsonResponse:()=>Vr,deserializeRawResult:()=>Xn,dmmfToRuntimeDataModel:()=>Ns,empty:()=>Oa,getPrismaClient:()=>fu,getRuntime:()=>Kn,join:()=>Da,makeStrictEnum:()=>gu,makeTypedQueryFactory:()=>Ia,objectEnumValues:()=>On,raw:()=>no,serializeJsonQuery:()=>$n,skip:()=>Mn,sqltag:()=>io,warnEnvConflicts:()=>hu,warnOnce:()=>at});module.exports=vu(jf);var ni={};tr(ni,{defineExtension:()=>ko,getExtensionContext:()=>_o});function ko(e){return typeof e=="function"?e:r=>r.$extends(e)}function _o(e){return e}var ii={};tr(ii,{validator:()=>No});function No(...e){return r=>r}var Bt={};tr(Bt,{$:()=>qo,bgBlack:()=>ku,bgBlue:()=>Fu,bgCyan:()=>$u,bgGreen:()=>Nu,bgMagenta:()=>Mu,bgRed:()=>_u,bgWhite:()=>qu,bgYellow:()=>Lu,black:()=>Cu,blue:()=>nr,bold:()=>W,cyan:()=>De,dim:()=>Ce,gray:()=>Hr,green:()=>qe,grey:()=>Ou,hidden:()=>Ru,inverse:()=>Su,italic:()=>Tu,magenta:()=>Iu,red:()=>ce,reset:()=>Pu,strikethrough:()=>Au,underline:()=>Y,white:()=>Du,yellow:()=>Ie});var oi,Lo,Fo,Mo,$o=!0;typeof process<"u"&&({FORCE_COLOR:oi,NODE_DISABLE_COLORS:Lo,NO_COLOR:Fo,TERM:Mo}=process.env||{},$o=process.stdout&&process.stdout.isTTY);var qo={enabled:!Lo&&Fo==null&&Mo!=="dumb"&&(oi!=null&&oi!=="0"||$o)};function F(e,r){let t=new RegExp(`\\x1b\\[${r}m`,"g"),n=`\x1B[${e}m`,i=`\x1B[${r}m`;return function(o){return!qo.enabled||o==null?o:n+(~(""+o).indexOf(i)?o.replace(t,i+n):o)+i}}var Pu=F(0,0),W=F(1,22),Ce=F(2,22),Tu=F(3,23),Y=F(4,24),Su=F(7,27),Ru=F(8,28),Au=F(9,29),Cu=F(30,39),ce=F(31,39),qe=F(32,39),Ie=F(33,39),nr=F(34,39),Iu=F(35,39),De=F(36,39),Du=F(37,39),Hr=F(90,39),Ou=F(90,39),ku=F(40,49),_u=F(41,49),Nu=F(42,49),Lu=F(43,49),Fu=F(44,49),Mu=F(45,49),$u=F(46,49),qu=F(47,49);var Vu=100,Vo=["green","yellow","blue","magenta","cyan","red"],Yr=[],jo=Date.now(),ju=0,si=typeof process<"u"?process.env:{};globalThis.DEBUG??=si.DEBUG??"";globalThis.DEBUG_COLORS??=si.DEBUG_COLORS?si.DEBUG_COLORS==="true":!0;var zr={enable(e){typeof e=="string"&&(globalThis.DEBUG=e)},disable(){let e=globalThis.DEBUG;return globalThis.DEBUG="",e},enabled(e){let r=globalThis.DEBUG.split(",").map(i=>i.replace(/[.+?^${}()|[\]\\]/g,"\\$&")),t=r.some(i=>i===""||i[0]==="-"?!1:e.match(RegExp(i.split("*").join(".*")+"$"))),n=r.some(i=>i===""||i[0]!=="-"?!1:e.match(RegExp(i.slice(1).split("*").join(".*")+"$")));return t&&!n},log:(...e)=>{let[r,t,...n]=e;(console.warn??console.log)(`${r} ${t}`,...n)},formatters:{}};function Bu(e){let r={color:Vo[ju++%Vo.length],enabled:zr.enabled(e),namespace:e,log:zr.log,extend:()=>{}},t=(...n)=>{let{enabled:i,namespace:o,color:s,log:a}=r;if(n.length!==0&&Yr.push([o,...n]),Yr.length>Vu&&Yr.shift(),zr.enabled(o)||i){let l=n.map(c=>typeof c=="string"?c:Uu(c)),u=`+${Date.now()-jo}ms`;jo=Date.now(),globalThis.DEBUG_COLORS?a(Bt[s](W(o)),...l,Bt[s](u)):a(o,...l,u)}};return new Proxy(t,{get:(n,i)=>r[i],set:(n,i,o)=>r[i]=o})}var N=new Proxy(Bu,{get:(e,r)=>zr[r],set:(e,r,t)=>zr[r]=t});function Uu(e,r=2){let t=new Set;return JSON.stringify(e,(n,i)=>{if(typeof i=="object"&&i!==null){if(t.has(i))return"[Circular *]";t.add(i)}else if(typeof i=="bigint")return i.toString();return i},r)}function Bo(e=7500){let r=Yr.map(([t,...n])=>`${t} ${n.map(i=>typeof i=="string"?i:JSON.stringify(i)).join(" ")}`).join(` -`);return r.length!!(e&&typeof e=="object"),Qt=e=>e&&!!e[Oe],Ee=(e,r,t)=>{if(Qt(e)){let n=e[Oe](),{matched:i,selections:o}=n.match(r);return i&&o&&Object.keys(o).forEach(s=>t(s,o[s])),i}if(ui(e)){if(!ui(r))return!1;if(Array.isArray(e)){if(!Array.isArray(r))return!1;let n=[],i=[],o=[];for(let s of e.keys()){let a=e[s];Qt(a)&&a[Gu]?o.push(a):o.length?i.push(a):n.push(a)}if(o.length){if(o.length>1)throw new Error("Pattern error: Using `...P.array(...)` several times in a single pattern is not allowed.");if(r.lengthEe(u,s[c],t))&&i.every((u,c)=>Ee(u,a[c],t))&&(o.length===0||Ee(o[0],l,t))}return e.length===r.length&&e.every((s,a)=>Ee(s,r[a],t))}return Reflect.ownKeys(e).every(n=>{let i=e[n];return(n in r||Qt(o=i)&&o[Oe]().matcherType==="optional")&&Ee(i,r[n],t);var o})}return Object.is(r,e)},Ge=e=>{var r,t,n;return ui(e)?Qt(e)?(r=(t=(n=e[Oe]()).getSelectionKeys)==null?void 0:t.call(n))!=null?r:[]:Array.isArray(e)?Zr(e,Ge):Zr(Object.values(e),Ge):[]},Zr=(e,r)=>e.reduce((t,n)=>t.concat(r(n)),[]);function pe(e){return Object.assign(e,{optional:()=>Qu(e),and:r=>q(e,r),or:r=>Wu(e,r),select:r=>r===void 0?Qo(e):Qo(r,e)})}function Qu(e){return pe({[Oe]:()=>({match:r=>{let t={},n=(i,o)=>{t[i]=o};return r===void 0?(Ge(e).forEach(i=>n(i,void 0)),{matched:!0,selections:t}):{matched:Ee(e,r,n),selections:t}},getSelectionKeys:()=>Ge(e),matcherType:"optional"})})}function q(...e){return pe({[Oe]:()=>({match:r=>{let t={},n=(i,o)=>{t[i]=o};return{matched:e.every(i=>Ee(i,r,n)),selections:t}},getSelectionKeys:()=>Zr(e,Ge),matcherType:"and"})})}function Wu(...e){return pe({[Oe]:()=>({match:r=>{let t={},n=(i,o)=>{t[i]=o};return Zr(e,Ge).forEach(i=>n(i,void 0)),{matched:e.some(i=>Ee(i,r,n)),selections:t}},getSelectionKeys:()=>Zr(e,Ge),matcherType:"or"})})}function A(e){return{[Oe]:()=>({match:r=>({matched:!!e(r)})})}}function Qo(...e){let r=typeof e[0]=="string"?e[0]:void 0,t=e.length===2?e[1]:typeof e[0]=="string"?void 0:e[0];return pe({[Oe]:()=>({match:n=>{let i={[r??Wt]:n};return{matched:t===void 0||Ee(t,n,(o,s)=>{i[o]=s}),selections:i}},getSelectionKeys:()=>[r??Wt].concat(t===void 0?[]:Ge(t))})})}function ye(e){return typeof e=="number"}function Ve(e){return typeof e=="string"}function je(e){return typeof e=="bigint"}var eg=pe(A(function(e){return!0}));var Be=e=>Object.assign(pe(e),{startsWith:r=>{return Be(q(e,(t=r,A(n=>Ve(n)&&n.startsWith(t)))));var t},endsWith:r=>{return Be(q(e,(t=r,A(n=>Ve(n)&&n.endsWith(t)))));var t},minLength:r=>Be(q(e,(t=>A(n=>Ve(n)&&n.length>=t))(r))),length:r=>Be(q(e,(t=>A(n=>Ve(n)&&n.length===t))(r))),maxLength:r=>Be(q(e,(t=>A(n=>Ve(n)&&n.length<=t))(r))),includes:r=>{return Be(q(e,(t=r,A(n=>Ve(n)&&n.includes(t)))));var t},regex:r=>{return Be(q(e,(t=r,A(n=>Ve(n)&&!!n.match(t)))));var t}}),rg=Be(A(Ve)),be=e=>Object.assign(pe(e),{between:(r,t)=>be(q(e,((n,i)=>A(o=>ye(o)&&n<=o&&i>=o))(r,t))),lt:r=>be(q(e,(t=>A(n=>ye(n)&&nbe(q(e,(t=>A(n=>ye(n)&&n>t))(r))),lte:r=>be(q(e,(t=>A(n=>ye(n)&&n<=t))(r))),gte:r=>be(q(e,(t=>A(n=>ye(n)&&n>=t))(r))),int:()=>be(q(e,A(r=>ye(r)&&Number.isInteger(r)))),finite:()=>be(q(e,A(r=>ye(r)&&Number.isFinite(r)))),positive:()=>be(q(e,A(r=>ye(r)&&r>0))),negative:()=>be(q(e,A(r=>ye(r)&&r<0)))}),tg=be(A(ye)),Ue=e=>Object.assign(pe(e),{between:(r,t)=>Ue(q(e,((n,i)=>A(o=>je(o)&&n<=o&&i>=o))(r,t))),lt:r=>Ue(q(e,(t=>A(n=>je(n)&&nUe(q(e,(t=>A(n=>je(n)&&n>t))(r))),lte:r=>Ue(q(e,(t=>A(n=>je(n)&&n<=t))(r))),gte:r=>Ue(q(e,(t=>A(n=>je(n)&&n>=t))(r))),positive:()=>Ue(q(e,A(r=>je(r)&&r>0))),negative:()=>Ue(q(e,A(r=>je(r)&&r<0)))}),ng=Ue(A(je)),ig=pe(A(function(e){return typeof e=="boolean"})),og=pe(A(function(e){return typeof e=="symbol"})),sg=pe(A(function(e){return e==null})),ag=pe(A(function(e){return e!=null}));var ci=class extends Error{constructor(r){let t;try{t=JSON.stringify(r)}catch{t=r}super(`Pattern matching error: no pattern matches value ${t}`),this.input=void 0,this.input=r}},pi={matched:!1,value:void 0};function hr(e){return new di(e,pi)}var di=class e{constructor(r,t){this.input=void 0,this.state=void 0,this.input=r,this.state=t}with(...r){if(this.state.matched)return this;let t=r[r.length-1],n=[r[0]],i;r.length===3&&typeof r[1]=="function"?i=r[1]:r.length>2&&n.push(...r.slice(1,r.length-1));let o=!1,s={},a=(u,c)=>{o=!0,s[u]=c},l=!n.some(u=>Ee(u,this.input,a))||i&&!i(this.input)?pi:{matched:!0,value:t(o?Wt in s?s[Wt]:s:this.input,this.input)};return new e(this.input,l)}when(r,t){if(this.state.matched)return this;let n=!!r(this.input);return new e(this.input,n?{matched:!0,value:t(this.input,this.input)}:pi)}otherwise(r){return this.state.matched?this.state.value:r(this.input)}exhaustive(){if(this.state.matched)return this.state.value;throw new ci(this.input)}run(){return this.exhaustive()}returnType(){return this}};var Ho=require("node:util");var Ju={warn:Ie("prisma:warn")},Ku={warn:()=>!process.env.PRISMA_DISABLE_WARNINGS};function Jt(e,...r){Ku.warn()&&console.warn(`${Ju.warn} ${e}`,...r)}var Hu=(0,Ho.promisify)(Ko.default.exec),ee=gr("prisma:get-platform"),Yu=["1.0.x","1.1.x","3.0.x"];async function Yo(){let e=Ht.default.platform(),r=process.arch;if(e==="freebsd"){let s=await Yt("freebsd-version");if(s&&s.trim().length>0){let l=/^(\d+)\.?/.exec(s);if(l)return{platform:"freebsd",targetDistro:`freebsd${l[1]}`,arch:r}}}if(e!=="linux")return{platform:e,arch:r};let t=await Zu(),n=await sc(),i=ec({arch:r,archFromUname:n,familyDistro:t.familyDistro}),{libssl:o}=await rc(i);return{platform:"linux",libssl:o,arch:r,archFromUname:n,...t}}function zu(e){let r=/^ID="?([^"\n]*)"?$/im,t=/^ID_LIKE="?([^"\n]*)"?$/im,n=r.exec(e),i=n&&n[1]&&n[1].toLowerCase()||"",o=t.exec(e),s=o&&o[1]&&o[1].toLowerCase()||"",a=hr({id:i,idLike:s}).with({id:"alpine"},({id:l})=>({targetDistro:"musl",familyDistro:l,originalDistro:l})).with({id:"raspbian"},({id:l})=>({targetDistro:"arm",familyDistro:"debian",originalDistro:l})).with({id:"nixos"},({id:l})=>({targetDistro:"nixos",originalDistro:l,familyDistro:"nixos"})).with({id:"debian"},{id:"ubuntu"},({id:l})=>({targetDistro:"debian",familyDistro:"debian",originalDistro:l})).with({id:"rhel"},{id:"centos"},{id:"fedora"},({id:l})=>({targetDistro:"rhel",familyDistro:"rhel",originalDistro:l})).when(({idLike:l})=>l.includes("debian")||l.includes("ubuntu"),({id:l})=>({targetDistro:"debian",familyDistro:"debian",originalDistro:l})).when(({idLike:l})=>i==="arch"||l.includes("arch"),({id:l})=>({targetDistro:"debian",familyDistro:"arch",originalDistro:l})).when(({idLike:l})=>l.includes("centos")||l.includes("fedora")||l.includes("rhel")||l.includes("suse"),({id:l})=>({targetDistro:"rhel",familyDistro:"rhel",originalDistro:l})).otherwise(({id:l})=>({targetDistro:void 0,familyDistro:void 0,originalDistro:l}));return ee(`Found distro info: -${JSON.stringify(a,null,2)}`),a}async function Zu(){let e="/etc/os-release";try{let r=await mi.default.readFile(e,{encoding:"utf-8"});return zu(r)}catch{return{targetDistro:void 0,familyDistro:void 0,originalDistro:void 0}}}function Xu(e){let r=/^OpenSSL\s(\d+\.\d+)\.\d+/.exec(e);if(r){let t=`${r[1]}.x`;return zo(t)}}function Wo(e){let r=/libssl\.so\.(\d)(\.\d)?/.exec(e);if(r){let t=`${r[1]}${r[2]??".0"}.x`;return zo(t)}}function zo(e){let r=(()=>{if(Xo(e))return e;let t=e.split(".");return t[1]="0",t.join(".")})();if(Yu.includes(r))return r}function ec(e){return hr(e).with({familyDistro:"musl"},()=>(ee('Trying platform-specific paths for "alpine"'),["/lib","/usr/lib"])).with({familyDistro:"debian"},({archFromUname:r})=>(ee('Trying platform-specific paths for "debian" (and "ubuntu")'),[`/usr/lib/${r}-linux-gnu`,`/lib/${r}-linux-gnu`])).with({familyDistro:"rhel"},()=>(ee('Trying platform-specific paths for "rhel"'),["/lib64","/usr/lib64"])).otherwise(({familyDistro:r,arch:t,archFromUname:n})=>(ee(`Don't know any platform-specific paths for "${r}" on ${t} (${n})`),[]))}async function rc(e){let r='grep -v "libssl.so.0"',t=await Jo(e);if(t){ee(`Found libssl.so file using platform-specific paths: ${t}`);let o=Wo(t);if(ee(`The parsed libssl version is: ${o}`),o)return{libssl:o,strategy:"libssl-specific-path"}}ee('Falling back to "ldconfig" and other generic paths');let n=await Yt(`ldconfig -p | sed "s/.*=>s*//" | sed "s|.*/||" | grep libssl | sort | ${r}`);if(n||(n=await Jo(["/lib64","/usr/lib64","/lib","/usr/lib"])),n){ee(`Found libssl.so file using "ldconfig" or other generic paths: ${n}`);let o=Wo(n);if(ee(`The parsed libssl version is: ${o}`),o)return{libssl:o,strategy:"ldconfig"}}let i=await Yt("openssl version -v");if(i){ee(`Found openssl binary with version: ${i}`);let o=Xu(i);if(ee(`The parsed openssl version is: ${o}`),o)return{libssl:o,strategy:"openssl-binary"}}return ee("Couldn't find any version of libssl or OpenSSL in the system"),{}}async function Jo(e){for(let r of e){let t=await tc(r);if(t)return t}}async function tc(e){try{return(await mi.default.readdir(e)).find(t=>t.startsWith("libssl.so.")&&!t.startsWith("libssl.so.0"))}catch(r){if(r.code==="ENOENT")return;throw r}}async function ir(){let{binaryTarget:e}=await Zo();return e}function nc(e){return e.binaryTarget!==void 0}async function fi(){let{memoized:e,...r}=await Zo();return r}var Kt={};async function Zo(){if(nc(Kt))return Promise.resolve({...Kt,memoized:!0});let e=await Yo(),r=ic(e);return Kt={...e,binaryTarget:r},{...Kt,memoized:!1}}function ic(e){let{platform:r,arch:t,archFromUname:n,libssl:i,targetDistro:o,familyDistro:s,originalDistro:a}=e;r==="linux"&&!["x64","arm64"].includes(t)&&Jt(`Prisma only officially supports Linux on amd64 (x86_64) and arm64 (aarch64) system architectures (detected "${t}" instead). If you are using your own custom Prisma engines, you can ignore this warning, as long as you've compiled the engines for your system architecture "${n}".`);let l="1.1.x";if(r==="linux"&&i===void 0){let c=hr({familyDistro:s}).with({familyDistro:"debian"},()=>"Please manually install OpenSSL via `apt-get update -y && apt-get install -y openssl` and try installing Prisma again. If you're running Prisma on Docker, add this command to your Dockerfile, or switch to an image that already has OpenSSL installed.").otherwise(()=>"Please manually install OpenSSL and try installing Prisma again.");Jt(`Prisma failed to detect the libssl/openssl version to use, and may not work as expected. Defaulting to "openssl-${l}". -${c}`)}let u="debian";if(r==="linux"&&o===void 0&&ee(`Distro is "${a}". Falling back to Prisma engines built for "${u}".`),r==="darwin"&&t==="arm64")return"darwin-arm64";if(r==="darwin")return"darwin";if(r==="win32")return"windows";if(r==="freebsd")return o;if(r==="openbsd")return"openbsd";if(r==="netbsd")return"netbsd";if(r==="linux"&&o==="nixos")return"linux-nixos";if(r==="linux"&&t==="arm64")return`${o==="musl"?"linux-musl-arm64":"linux-arm64"}-openssl-${i||l}`;if(r==="linux"&&t==="arm")return`linux-arm-openssl-${i||l}`;if(r==="linux"&&o==="musl"){let c="linux-musl";return!i||Xo(i)?c:`${c}-openssl-${i}`}return r==="linux"&&o&&i?`${o}-openssl-${i}`:(r!=="linux"&&Jt(`Prisma detected unknown OS "${r}" and may not work as expected. Defaulting to "linux".`),i?`${u}-openssl-${i}`:o?`${o}-openssl-${l}`:`${u}-openssl-${l}`)}async function oc(e){try{return await e()}catch{return}}function Yt(e){return oc(async()=>{let r=await Hu(e);return ee(`Command "${e}" successfully returned "${r.stdout}"`),r.stdout})}async function sc(){return typeof Ht.default.machine=="function"?Ht.default.machine():(await Yt("uname -m"))?.trim()}function Xo(e){return e.startsWith("1.")}var Xt={};tr(Xt,{beep:()=>kc,clearScreen:()=>Cc,clearTerminal:()=>Ic,cursorBackward:()=>mc,cursorDown:()=>pc,cursorForward:()=>dc,cursorGetPosition:()=>hc,cursorHide:()=>Ec,cursorLeft:()=>ts,cursorMove:()=>cc,cursorNextLine:()=>yc,cursorPrevLine:()=>bc,cursorRestorePosition:()=>gc,cursorSavePosition:()=>fc,cursorShow:()=>wc,cursorTo:()=>uc,cursorUp:()=>rs,enterAlternativeScreen:()=>Dc,eraseDown:()=>Tc,eraseEndLine:()=>vc,eraseLine:()=>ns,eraseLines:()=>xc,eraseScreen:()=>gi,eraseStartLine:()=>Pc,eraseUp:()=>Sc,exitAlternativeScreen:()=>Oc,iTerm:()=>Lc,image:()=>Nc,link:()=>_c,scrollDown:()=>Ac,scrollUp:()=>Rc});var Zt=O(require("node:process"),1);var zt=globalThis.window?.document!==void 0,gg=globalThis.process?.versions?.node!==void 0,hg=globalThis.process?.versions?.bun!==void 0,yg=globalThis.Deno?.version?.deno!==void 0,bg=globalThis.process?.versions?.electron!==void 0,Eg=globalThis.navigator?.userAgent?.includes("jsdom")===!0,wg=typeof WorkerGlobalScope<"u"&&globalThis instanceof WorkerGlobalScope,xg=typeof DedicatedWorkerGlobalScope<"u"&&globalThis instanceof DedicatedWorkerGlobalScope,vg=typeof SharedWorkerGlobalScope<"u"&&globalThis instanceof SharedWorkerGlobalScope,Pg=typeof ServiceWorkerGlobalScope<"u"&&globalThis instanceof ServiceWorkerGlobalScope,Xr=globalThis.navigator?.userAgentData?.platform,Tg=Xr==="macOS"||globalThis.navigator?.platform==="MacIntel"||globalThis.navigator?.userAgent?.includes(" Mac ")===!0||globalThis.process?.platform==="darwin",Sg=Xr==="Windows"||globalThis.navigator?.platform==="Win32"||globalThis.process?.platform==="win32",Rg=Xr==="Linux"||globalThis.navigator?.platform?.startsWith("Linux")===!0||globalThis.navigator?.userAgent?.includes(" Linux ")===!0||globalThis.process?.platform==="linux",Ag=Xr==="iOS"||globalThis.navigator?.platform==="MacIntel"&&globalThis.navigator?.maxTouchPoints>1||/iPad|iPhone|iPod/.test(globalThis.navigator?.platform),Cg=Xr==="Android"||globalThis.navigator?.platform==="Android"||globalThis.navigator?.userAgent?.includes(" Android ")===!0||globalThis.process?.platform==="android";var C="\x1B[",rt="\x1B]",yr="\x07",et=";",es=!zt&&Zt.default.env.TERM_PROGRAM==="Apple_Terminal",ac=!zt&&Zt.default.platform==="win32",lc=zt?()=>{throw new Error("`process.cwd()` only works in Node.js, not the browser.")}:Zt.default.cwd,uc=(e,r)=>{if(typeof e!="number")throw new TypeError("The `x` argument is required");return typeof r!="number"?C+(e+1)+"G":C+(r+1)+et+(e+1)+"H"},cc=(e,r)=>{if(typeof e!="number")throw new TypeError("The `x` argument is required");let t="";return e<0?t+=C+-e+"D":e>0&&(t+=C+e+"C"),r<0?t+=C+-r+"A":r>0&&(t+=C+r+"B"),t},rs=(e=1)=>C+e+"A",pc=(e=1)=>C+e+"B",dc=(e=1)=>C+e+"C",mc=(e=1)=>C+e+"D",ts=C+"G",fc=es?"\x1B7":C+"s",gc=es?"\x1B8":C+"u",hc=C+"6n",yc=C+"E",bc=C+"F",Ec=C+"?25l",wc=C+"?25h",xc=e=>{let r="";for(let t=0;t[rt,"8",et,et,r,yr,e,rt,"8",et,et,yr].join(""),Nc=(e,r={})=>{let t=`${rt}1337;File=inline=1`;return r.width&&(t+=`;width=${r.width}`),r.height&&(t+=`;height=${r.height}`),r.preserveAspectRatio===!1&&(t+=";preserveAspectRatio=0"),t+":"+Buffer.from(e).toString("base64")+yr},Lc={setCwd:(e=lc())=>`${rt}50;CurrentDir=${e}${yr}`,annotation(e,r={}){let t=`${rt}1337;`,n=r.x!==void 0,i=r.y!==void 0;if((n||i)&&!(n&&i&&r.length!==void 0))throw new Error("`x`, `y` and `length` must be defined when `x` or `y` is defined");return e=e.replaceAll("|",""),t+=r.isHidden?"AddHiddenAnnotation=":"AddAnnotation=",r.length>0?t+=(n?[e,r.length,r.x,r.y]:[r.length,e]).join("|"):t+=e,t+yr}};var en=O(cs(),1);function or(e,r,{target:t="stdout",...n}={}){return en.default[t]?Xt.link(e,r):n.fallback===!1?e:typeof n.fallback=="function"?n.fallback(e,r):`${e} (\u200B${r}\u200B)`}or.isSupported=en.default.stdout;or.stderr=(e,r,t={})=>or(e,r,{target:"stderr",...t});or.stderr.isSupported=en.default.stderr;function wi(e){return or(e,e,{fallback:Y})}var Vc=ps(),xi=Vc.version;function Er(e){let r=jc();return r||(e?.config.engineType==="library"?"library":e?.config.engineType==="binary"?"binary":e?.config.engineType==="client"?"client":Bc())}function jc(){let e=process.env.PRISMA_CLIENT_ENGINE_TYPE;return e==="library"?"library":e==="binary"?"binary":e==="client"?"client":void 0}function Bc(){return"library"}function vi(e){return e.name==="DriverAdapterError"&&typeof e.cause=="object"}function rn(e){return{ok:!0,value:e,map(r){return rn(r(e))},flatMap(r){return r(e)}}}function sr(e){return{ok:!1,error:e,map(){return sr(e)},flatMap(){return sr(e)}}}var ds=N("driver-adapter-utils"),Pi=class{registeredErrors=[];consumeError(r){return this.registeredErrors[r]}registerNewError(r){let t=0;for(;this.registeredErrors[t]!==void 0;)t++;return this.registeredErrors[t]={error:r},t}};var tn=(e,r=new Pi)=>{let t={adapterName:e.adapterName,errorRegistry:r,queryRaw:ke(r,e.queryRaw.bind(e)),executeRaw:ke(r,e.executeRaw.bind(e)),executeScript:ke(r,e.executeScript.bind(e)),dispose:ke(r,e.dispose.bind(e)),provider:e.provider,startTransaction:async(...n)=>(await ke(r,e.startTransaction.bind(e))(...n)).map(o=>Uc(r,o))};return e.getConnectionInfo&&(t.getConnectionInfo=Gc(r,e.getConnectionInfo.bind(e))),t},Uc=(e,r)=>({adapterName:r.adapterName,provider:r.provider,options:r.options,queryRaw:ke(e,r.queryRaw.bind(r)),executeRaw:ke(e,r.executeRaw.bind(r)),commit:ke(e,r.commit.bind(r)),rollback:ke(e,r.rollback.bind(r))});function ke(e,r){return async(...t)=>{try{return rn(await r(...t))}catch(n){if(ds("[error@wrapAsync]",n),vi(n))return sr(n.cause);let i=e.registerNewError(n);return sr({kind:"GenericJs",id:i})}}}function Gc(e,r){return(...t)=>{try{return rn(r(...t))}catch(n){if(ds("[error@wrapSync]",n),vi(n))return sr(n.cause);let i=e.registerNewError(n);return sr({kind:"GenericJs",id:i})}}}var Wc=O(on());var M=O(require("node:path")),Jc=O(on()),wh=N("prisma:engines");function ms(){return M.default.join(__dirname,"../")}var xh="libquery-engine";M.default.join(__dirname,"../query-engine-darwin");M.default.join(__dirname,"../query-engine-darwin-arm64");M.default.join(__dirname,"../query-engine-debian-openssl-1.0.x");M.default.join(__dirname,"../query-engine-debian-openssl-1.1.x");M.default.join(__dirname,"../query-engine-debian-openssl-3.0.x");M.default.join(__dirname,"../query-engine-linux-static-x64");M.default.join(__dirname,"../query-engine-linux-static-arm64");M.default.join(__dirname,"../query-engine-rhel-openssl-1.0.x");M.default.join(__dirname,"../query-engine-rhel-openssl-1.1.x");M.default.join(__dirname,"../query-engine-rhel-openssl-3.0.x");M.default.join(__dirname,"../libquery_engine-darwin.dylib.node");M.default.join(__dirname,"../libquery_engine-darwin-arm64.dylib.node");M.default.join(__dirname,"../libquery_engine-debian-openssl-1.0.x.so.node");M.default.join(__dirname,"../libquery_engine-debian-openssl-1.1.x.so.node");M.default.join(__dirname,"../libquery_engine-debian-openssl-3.0.x.so.node");M.default.join(__dirname,"../libquery_engine-linux-arm64-openssl-1.0.x.so.node");M.default.join(__dirname,"../libquery_engine-linux-arm64-openssl-1.1.x.so.node");M.default.join(__dirname,"../libquery_engine-linux-arm64-openssl-3.0.x.so.node");M.default.join(__dirname,"../libquery_engine-linux-musl.so.node");M.default.join(__dirname,"../libquery_engine-linux-musl-openssl-3.0.x.so.node");M.default.join(__dirname,"../libquery_engine-rhel-openssl-1.0.x.so.node");M.default.join(__dirname,"../libquery_engine-rhel-openssl-1.1.x.so.node");M.default.join(__dirname,"../libquery_engine-rhel-openssl-3.0.x.so.node");M.default.join(__dirname,"../query_engine-windows.dll.node");var Si=O(require("node:fs")),fs=gr("chmodPlusX");function Ri(e){if(process.platform==="win32")return;let r=Si.default.statSync(e),t=r.mode|64|8|1;if(r.mode===t){fs(`Execution permissions of ${e} are fine`);return}let n=t.toString(8).slice(-3);fs(`Have to call chmodPlusX on ${e}`),Si.default.chmodSync(e,n)}function Ai(e){let r=e.e,t=a=>`Prisma cannot find the required \`${a}\` system library in your system`,n=r.message.includes("cannot open shared object file"),i=`Please refer to the documentation about Prisma's system requirements: ${wi("https://pris.ly/d/system-requirements")}`,o=`Unable to require(\`${Ce(e.id)}\`).`,s=hr({message:r.message,code:r.code}).with({code:"ENOENT"},()=>"File does not exist.").when(({message:a})=>n&&a.includes("libz"),()=>`${t("libz")}. Please install it and try again.`).when(({message:a})=>n&&a.includes("libgcc_s"),()=>`${t("libgcc_s")}. Please install it and try again.`).when(({message:a})=>n&&a.includes("libssl"),()=>{let a=e.platformInfo.libssl?`openssl-${e.platformInfo.libssl}`:"openssl";return`${t("libssl")}. Please install ${a} and try again.`}).when(({message:a})=>a.includes("GLIBC"),()=>`Prisma has detected an incompatible version of the \`glibc\` C standard library installed in your system. This probably means your system may be too old to run Prisma. ${i}`).when(({message:a})=>e.platformInfo.platform==="linux"&&a.includes("symbol not found"),()=>`The Prisma engines are not compatible with your system ${e.platformInfo.originalDistro} on (${e.platformInfo.archFromUname}) which uses the \`${e.platformInfo.binaryTarget}\` binaryTarget by default. ${i}`).otherwise(()=>`The Prisma engines do not seem to be compatible with your system. ${i}`);return`${o} -${s} - -Details: ${r.message}`}var ys=O(hs(),1);function Ci(e){let r=(0,ys.default)(e);if(r===0)return e;let t=new RegExp(`^[ \\t]{${r}}`,"gm");return e.replace(t,"")}var bs="prisma+postgres",sn=`${bs}:`;function an(e){return e?.toString().startsWith(`${sn}//`)??!1}function Ii(e){if(!an(e))return!1;let{host:r}=new URL(e);return r.includes("localhost")||r.includes("127.0.0.1")||r.includes("[::1]")}var ws=O(Di());function ki(e){return String(new Oi(e))}var Oi=class{constructor(r){this.config=r}toString(){let{config:r}=this,t=r.provider.fromEnvVar?`env("${r.provider.fromEnvVar}")`:r.provider.value,n=JSON.parse(JSON.stringify({provider:t,binaryTargets:Kc(r.binaryTargets)}));return`generator ${r.name} { -${(0,ws.default)(Hc(n),2)} -}`}};function Kc(e){let r;if(e.length>0){let t=e.find(n=>n.fromEnvVar!==null);t?r=`env("${t.fromEnvVar}")`:r=e.map(n=>n.native?"native":n.value)}else r=void 0;return r}function Hc(e){let r=Object.keys(e).reduce((t,n)=>Math.max(t,n.length),0);return Object.entries(e).map(([t,n])=>`${t.padEnd(r)} = ${Yc(n)}`).join(` -`)}function Yc(e){return JSON.parse(JSON.stringify(e,(r,t)=>Array.isArray(t)?`[${t.map(n=>JSON.stringify(n)).join(", ")}]`:JSON.stringify(t)))}var nt={};tr(nt,{error:()=>Xc,info:()=>Zc,log:()=>zc,query:()=>ep,should:()=>xs,tags:()=>tt,warn:()=>_i});var tt={error:ce("prisma:error"),warn:Ie("prisma:warn"),info:De("prisma:info"),query:nr("prisma:query")},xs={warn:()=>!process.env.PRISMA_DISABLE_WARNINGS};function zc(...e){console.log(...e)}function _i(e,...r){xs.warn()&&console.warn(`${tt.warn} ${e}`,...r)}function Zc(e,...r){console.info(`${tt.info} ${e}`,...r)}function Xc(e,...r){console.error(`${tt.error} ${e}`,...r)}function ep(e,...r){console.log(`${tt.query} ${e}`,...r)}function ln(e,r){if(!e)throw new Error(`${r}. This should never happen. If you see this error, please, open an issue at https://pris.ly/prisma-prisma-bug-report`)}function ar(e,r){throw new Error(r)}function Ni({onlyFirst:e=!1}={}){let t=["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?(?:\\u0007|\\u001B\\u005C|\\u009C))","(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"].join("|");return new RegExp(t,e?void 0:"g")}var rp=Ni();function wr(e){if(typeof e!="string")throw new TypeError(`Expected a \`string\`, got \`${typeof e}\``);return e.replace(rp,"")}var it=O(require("node:path"));function Li(e){return it.default.sep===it.default.posix.sep?e:e.split(it.default.sep).join(it.default.posix.sep)}var qi=O(As()),un=O(require("node:fs"));var xr=O(require("node:path"));function Cs(e){let r=e.ignoreProcessEnv?{}:process.env,t=n=>n.match(/(.?\${(?:[a-zA-Z0-9_]+)?})/g)?.reduce(function(o,s){let a=/(.?)\${([a-zA-Z0-9_]+)?}/g.exec(s);if(!a)return o;let l=a[1],u,c;if(l==="\\")c=a[0],u=c.replace("\\$","$");else{let p=a[2];c=a[0].substring(l.length),u=Object.hasOwnProperty.call(r,p)?r[p]:e.parsed[p]||"",u=t(u)}return o.replace(c,u)},n)??n;for(let n in e.parsed){let i=Object.hasOwnProperty.call(r,n)?r[n]:e.parsed[n];e.parsed[n]=t(i)}for(let n in e.parsed)r[n]=e.parsed[n];return e}var $i=gr("prisma:tryLoadEnv");function st({rootEnvPath:e,schemaEnvPath:r},t={conflictCheck:"none"}){let n=Is(e);t.conflictCheck!=="none"&&hp(n,r,t.conflictCheck);let i=null;return Ds(n?.path,r)||(i=Is(r)),!n&&!i&&$i("No Environment variables loaded"),i?.dotenvResult.error?console.error(ce(W("Schema Env Error: "))+i.dotenvResult.error):{message:[n?.message,i?.message].filter(Boolean).join(` -`),parsed:{...n?.dotenvResult?.parsed,...i?.dotenvResult?.parsed}}}function hp(e,r,t){let n=e?.dotenvResult.parsed,i=!Ds(e?.path,r);if(n&&r&&i&&un.default.existsSync(r)){let o=qi.default.parse(un.default.readFileSync(r)),s=[];for(let a in o)n[a]===o[a]&&s.push(a);if(s.length>0){let a=xr.default.relative(process.cwd(),e.path),l=xr.default.relative(process.cwd(),r);if(t==="error"){let u=`There is a conflict between env var${s.length>1?"s":""} in ${Y(a)} and ${Y(l)} -Conflicting env vars: -${s.map(c=>` ${W(c)}`).join(` -`)} - -We suggest to move the contents of ${Y(l)} to ${Y(a)} to consolidate your env vars. -`;throw new Error(u)}else if(t==="warn"){let u=`Conflict for env var${s.length>1?"s":""} ${s.map(c=>W(c)).join(", ")} in ${Y(a)} and ${Y(l)} -Env vars from ${Y(l)} overwrite the ones from ${Y(a)} - `;console.warn(`${Ie("warn(prisma)")} ${u}`)}}}}function Is(e){if(yp(e)){$i(`Environment variables loaded from ${e}`);let r=qi.default.config({path:e,debug:process.env.DOTENV_CONFIG_DEBUG?!0:void 0});return{dotenvResult:Cs(r),message:Ce(`Environment variables loaded from ${xr.default.relative(process.cwd(),e)}`),path:e}}else $i(`Environment variables not found at ${e}`);return null}function Ds(e,r){return e&&r&&xr.default.resolve(e)===xr.default.resolve(r)}function yp(e){return!!(e&&un.default.existsSync(e))}function Vi(e,r){return Object.prototype.hasOwnProperty.call(e,r)}function pn(e,r){let t={};for(let n of Object.keys(e))t[n]=r(e[n],n);return t}function ji(e,r){if(e.length===0)return;let t=e[0];for(let n=1;n{ks.has(e)||(ks.add(e),_i(r,...t))};var P=class e extends Error{clientVersion;errorCode;retryable;constructor(r,t,n){super(r),this.name="PrismaClientInitializationError",this.clientVersion=t,this.errorCode=n,Error.captureStackTrace(e)}get[Symbol.toStringTag](){return"PrismaClientInitializationError"}};x(P,"PrismaClientInitializationError");var z=class extends Error{code;meta;clientVersion;batchRequestIdx;constructor(r,{code:t,clientVersion:n,meta:i,batchRequestIdx:o}){super(r),this.name="PrismaClientKnownRequestError",this.code=t,this.clientVersion=n,this.meta=i,Object.defineProperty(this,"batchRequestIdx",{value:o,enumerable:!1,writable:!0})}get[Symbol.toStringTag](){return"PrismaClientKnownRequestError"}};x(z,"PrismaClientKnownRequestError");var ae=class extends Error{clientVersion;constructor(r,t){super(r),this.name="PrismaClientRustPanicError",this.clientVersion=t}get[Symbol.toStringTag](){return"PrismaClientRustPanicError"}};x(ae,"PrismaClientRustPanicError");var V=class extends Error{clientVersion;batchRequestIdx;constructor(r,{clientVersion:t,batchRequestIdx:n}){super(r),this.name="PrismaClientUnknownRequestError",this.clientVersion=t,Object.defineProperty(this,"batchRequestIdx",{value:n,writable:!0,enumerable:!1})}get[Symbol.toStringTag](){return"PrismaClientUnknownRequestError"}};x(V,"PrismaClientUnknownRequestError");var Z=class extends Error{name="PrismaClientValidationError";clientVersion;constructor(r,{clientVersion:t}){super(r),this.clientVersion=t}get[Symbol.toStringTag](){return"PrismaClientValidationError"}};x(Z,"PrismaClientValidationError");var we=class{_map=new Map;get(r){return this._map.get(r)?.value}set(r,t){this._map.set(r,{value:t})}getOrCreate(r,t){let n=this._map.get(r);if(n)return n.value;let i=t();return this.set(r,i),i}};function We(e){return e.substring(0,1).toLowerCase()+e.substring(1)}function _s(e,r){let t={};for(let n of e){let i=n[r];t[i]=n}return t}function lt(e){let r;return{get(){return r||(r={value:e()}),r.value}}}function Ns(e){return{models:Bi(e.models),enums:Bi(e.enums),types:Bi(e.types)}}function Bi(e){let r={};for(let{name:t,...n}of e)r[t]=n;return r}function vr(e){return e instanceof Date||Object.prototype.toString.call(e)==="[object Date]"}function mn(e){return e.toString()!=="Invalid Date"}var Pr=9e15,Ye=1e9,Ui="0123456789abcdef",hn="2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058",yn="3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789",Gi={precision:20,rounding:4,modulo:1,toExpNeg:-7,toExpPos:21,minE:-Pr,maxE:Pr,crypto:!1},$s,Ne,w=!0,En="[DecimalError] ",He=En+"Invalid argument: ",qs=En+"Precision limit exceeded",Vs=En+"crypto unavailable",js="[object Decimal]",X=Math.floor,U=Math.pow,bp=/^0b([01]+(\.[01]*)?|\.[01]+)(p[+-]?\d+)?$/i,Ep=/^0x([0-9a-f]+(\.[0-9a-f]*)?|\.[0-9a-f]+)(p[+-]?\d+)?$/i,wp=/^0o([0-7]+(\.[0-7]*)?|\.[0-7]+)(p[+-]?\d+)?$/i,Bs=/^(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i,fe=1e7,E=7,xp=9007199254740991,vp=hn.length-1,Qi=yn.length-1,m={toStringTag:js};m.absoluteValue=m.abs=function(){var e=new this.constructor(this);return e.s<0&&(e.s=1),y(e)};m.ceil=function(){return y(new this.constructor(this),this.e+1,2)};m.clampedTo=m.clamp=function(e,r){var t,n=this,i=n.constructor;if(e=new i(e),r=new i(r),!e.s||!r.s)return new i(NaN);if(e.gt(r))throw Error(He+r);return t=n.cmp(e),t<0?e:n.cmp(r)>0?r:new i(n)};m.comparedTo=m.cmp=function(e){var r,t,n,i,o=this,s=o.d,a=(e=new o.constructor(e)).d,l=o.s,u=e.s;if(!s||!a)return!l||!u?NaN:l!==u?l:s===a?0:!s^l<0?1:-1;if(!s[0]||!a[0])return s[0]?l:a[0]?-u:0;if(l!==u)return l;if(o.e!==e.e)return o.e>e.e^l<0?1:-1;for(n=s.length,i=a.length,r=0,t=na[r]^l<0?1:-1;return n===i?0:n>i^l<0?1:-1};m.cosine=m.cos=function(){var e,r,t=this,n=t.constructor;return t.d?t.d[0]?(e=n.precision,r=n.rounding,n.precision=e+Math.max(t.e,t.sd())+E,n.rounding=1,t=Pp(n,Js(n,t)),n.precision=e,n.rounding=r,y(Ne==2||Ne==3?t.neg():t,e,r,!0)):new n(1):new n(NaN)};m.cubeRoot=m.cbrt=function(){var e,r,t,n,i,o,s,a,l,u,c=this,p=c.constructor;if(!c.isFinite()||c.isZero())return new p(c);for(w=!1,o=c.s*U(c.s*c,1/3),!o||Math.abs(o)==1/0?(t=J(c.d),e=c.e,(o=(e-t.length+1)%3)&&(t+=o==1||o==-2?"0":"00"),o=U(t,1/3),e=X((e+1)/3)-(e%3==(e<0?-1:2)),o==1/0?t="5e"+e:(t=o.toExponential(),t=t.slice(0,t.indexOf("e")+1)+e),n=new p(t),n.s=c.s):n=new p(o.toString()),s=(e=p.precision)+3;;)if(a=n,l=a.times(a).times(a),u=l.plus(c),n=L(u.plus(c).times(a),u.plus(l),s+2,1),J(a.d).slice(0,s)===(t=J(n.d)).slice(0,s))if(t=t.slice(s-3,s+1),t=="9999"||!i&&t=="4999"){if(!i&&(y(a,e+1,0),a.times(a).times(a).eq(c))){n=a;break}s+=4,i=1}else{(!+t||!+t.slice(1)&&t.charAt(0)=="5")&&(y(n,e+1,1),r=!n.times(n).times(n).eq(c));break}return w=!0,y(n,e,p.rounding,r)};m.decimalPlaces=m.dp=function(){var e,r=this.d,t=NaN;if(r){if(e=r.length-1,t=(e-X(this.e/E))*E,e=r[e],e)for(;e%10==0;e/=10)t--;t<0&&(t=0)}return t};m.dividedBy=m.div=function(e){return L(this,new this.constructor(e))};m.dividedToIntegerBy=m.divToInt=function(e){var r=this,t=r.constructor;return y(L(r,new t(e),0,1,1),t.precision,t.rounding)};m.equals=m.eq=function(e){return this.cmp(e)===0};m.floor=function(){return y(new this.constructor(this),this.e+1,3)};m.greaterThan=m.gt=function(e){return this.cmp(e)>0};m.greaterThanOrEqualTo=m.gte=function(e){var r=this.cmp(e);return r==1||r===0};m.hyperbolicCosine=m.cosh=function(){var e,r,t,n,i,o=this,s=o.constructor,a=new s(1);if(!o.isFinite())return new s(o.s?1/0:NaN);if(o.isZero())return a;t=s.precision,n=s.rounding,s.precision=t+Math.max(o.e,o.sd())+4,s.rounding=1,i=o.d.length,i<32?(e=Math.ceil(i/3),r=(1/xn(4,e)).toString()):(e=16,r="2.3283064365386962890625e-10"),o=Tr(s,1,o.times(r),new s(1),!0);for(var l,u=e,c=new s(8);u--;)l=o.times(o),o=a.minus(l.times(c.minus(l.times(c))));return y(o,s.precision=t,s.rounding=n,!0)};m.hyperbolicSine=m.sinh=function(){var e,r,t,n,i=this,o=i.constructor;if(!i.isFinite()||i.isZero())return new o(i);if(r=o.precision,t=o.rounding,o.precision=r+Math.max(i.e,i.sd())+4,o.rounding=1,n=i.d.length,n<3)i=Tr(o,2,i,i,!0);else{e=1.4*Math.sqrt(n),e=e>16?16:e|0,i=i.times(1/xn(5,e)),i=Tr(o,2,i,i,!0);for(var s,a=new o(5),l=new o(16),u=new o(20);e--;)s=i.times(i),i=i.times(a.plus(s.times(l.times(s).plus(u))))}return o.precision=r,o.rounding=t,y(i,r,t,!0)};m.hyperbolicTangent=m.tanh=function(){var e,r,t=this,n=t.constructor;return t.isFinite()?t.isZero()?new n(t):(e=n.precision,r=n.rounding,n.precision=e+7,n.rounding=1,L(t.sinh(),t.cosh(),n.precision=e,n.rounding=r)):new n(t.s)};m.inverseCosine=m.acos=function(){var e=this,r=e.constructor,t=e.abs().cmp(1),n=r.precision,i=r.rounding;return t!==-1?t===0?e.isNeg()?xe(r,n,i):new r(0):new r(NaN):e.isZero()?xe(r,n+4,i).times(.5):(r.precision=n+6,r.rounding=1,e=new r(1).minus(e).div(e.plus(1)).sqrt().atan(),r.precision=n,r.rounding=i,e.times(2))};m.inverseHyperbolicCosine=m.acosh=function(){var e,r,t=this,n=t.constructor;return t.lte(1)?new n(t.eq(1)?0:NaN):t.isFinite()?(e=n.precision,r=n.rounding,n.precision=e+Math.max(Math.abs(t.e),t.sd())+4,n.rounding=1,w=!1,t=t.times(t).minus(1).sqrt().plus(t),w=!0,n.precision=e,n.rounding=r,t.ln()):new n(t)};m.inverseHyperbolicSine=m.asinh=function(){var e,r,t=this,n=t.constructor;return!t.isFinite()||t.isZero()?new n(t):(e=n.precision,r=n.rounding,n.precision=e+2*Math.max(Math.abs(t.e),t.sd())+6,n.rounding=1,w=!1,t=t.times(t).plus(1).sqrt().plus(t),w=!0,n.precision=e,n.rounding=r,t.ln())};m.inverseHyperbolicTangent=m.atanh=function(){var e,r,t,n,i=this,o=i.constructor;return i.isFinite()?i.e>=0?new o(i.abs().eq(1)?i.s/0:i.isZero()?i:NaN):(e=o.precision,r=o.rounding,n=i.sd(),Math.max(n,e)<2*-i.e-1?y(new o(i),e,r,!0):(o.precision=t=n-i.e,i=L(i.plus(1),new o(1).minus(i),t+e,1),o.precision=e+4,o.rounding=1,i=i.ln(),o.precision=e,o.rounding=r,i.times(.5))):new o(NaN)};m.inverseSine=m.asin=function(){var e,r,t,n,i=this,o=i.constructor;return i.isZero()?new o(i):(r=i.abs().cmp(1),t=o.precision,n=o.rounding,r!==-1?r===0?(e=xe(o,t+4,n).times(.5),e.s=i.s,e):new o(NaN):(o.precision=t+6,o.rounding=1,i=i.div(new o(1).minus(i.times(i)).sqrt().plus(1)).atan(),o.precision=t,o.rounding=n,i.times(2)))};m.inverseTangent=m.atan=function(){var e,r,t,n,i,o,s,a,l,u=this,c=u.constructor,p=c.precision,d=c.rounding;if(u.isFinite()){if(u.isZero())return new c(u);if(u.abs().eq(1)&&p+4<=Qi)return s=xe(c,p+4,d).times(.25),s.s=u.s,s}else{if(!u.s)return new c(NaN);if(p+4<=Qi)return s=xe(c,p+4,d).times(.5),s.s=u.s,s}for(c.precision=a=p+10,c.rounding=1,t=Math.min(28,a/E+2|0),e=t;e;--e)u=u.div(u.times(u).plus(1).sqrt().plus(1));for(w=!1,r=Math.ceil(a/E),n=1,l=u.times(u),s=new c(u),i=u;e!==-1;)if(i=i.times(l),o=s.minus(i.div(n+=2)),i=i.times(l),s=o.plus(i.div(n+=2)),s.d[r]!==void 0)for(e=r;s.d[e]===o.d[e]&&e--;);return t&&(s=s.times(2<this.d.length-2};m.isNaN=function(){return!this.s};m.isNegative=m.isNeg=function(){return this.s<0};m.isPositive=m.isPos=function(){return this.s>0};m.isZero=function(){return!!this.d&&this.d[0]===0};m.lessThan=m.lt=function(e){return this.cmp(e)<0};m.lessThanOrEqualTo=m.lte=function(e){return this.cmp(e)<1};m.logarithm=m.log=function(e){var r,t,n,i,o,s,a,l,u=this,c=u.constructor,p=c.precision,d=c.rounding,f=5;if(e==null)e=new c(10),r=!0;else{if(e=new c(e),t=e.d,e.s<0||!t||!t[0]||e.eq(1))return new c(NaN);r=e.eq(10)}if(t=u.d,u.s<0||!t||!t[0]||u.eq(1))return new c(t&&!t[0]?-1/0:u.s!=1?NaN:t?0:1/0);if(r)if(t.length>1)o=!0;else{for(i=t[0];i%10===0;)i/=10;o=i!==1}if(w=!1,a=p+f,s=Ke(u,a),n=r?bn(c,a+10):Ke(e,a),l=L(s,n,a,1),ut(l.d,i=p,d))do if(a+=10,s=Ke(u,a),n=r?bn(c,a+10):Ke(e,a),l=L(s,n,a,1),!o){+J(l.d).slice(i+1,i+15)+1==1e14&&(l=y(l,p+1,0));break}while(ut(l.d,i+=10,d));return w=!0,y(l,p,d)};m.minus=m.sub=function(e){var r,t,n,i,o,s,a,l,u,c,p,d,f=this,h=f.constructor;if(e=new h(e),!f.d||!e.d)return!f.s||!e.s?e=new h(NaN):f.d?e.s=-e.s:e=new h(e.d||f.s!==e.s?f:NaN),e;if(f.s!=e.s)return e.s=-e.s,f.plus(e);if(u=f.d,d=e.d,a=h.precision,l=h.rounding,!u[0]||!d[0]){if(d[0])e.s=-e.s;else if(u[0])e=new h(f);else return new h(l===3?-0:0);return w?y(e,a,l):e}if(t=X(e.e/E),c=X(f.e/E),u=u.slice(),o=c-t,o){for(p=o<0,p?(r=u,o=-o,s=d.length):(r=d,t=c,s=u.length),n=Math.max(Math.ceil(a/E),s)+2,o>n&&(o=n,r.length=1),r.reverse(),n=o;n--;)r.push(0);r.reverse()}else{for(n=u.length,s=d.length,p=n0;--n)u[s++]=0;for(n=d.length;n>o;){if(u[--n]s?o+1:s+1,i>s&&(i=s,t.length=1),t.reverse();i--;)t.push(0);t.reverse()}for(s=u.length,i=c.length,s-i<0&&(i=s,t=c,c=u,u=t),r=0;i;)r=(u[--i]=u[i]+c[i]+r)/fe|0,u[i]%=fe;for(r&&(u.unshift(r),++n),s=u.length;u[--s]==0;)u.pop();return e.d=u,e.e=wn(u,n),w?y(e,a,l):e};m.precision=m.sd=function(e){var r,t=this;if(e!==void 0&&e!==!!e&&e!==1&&e!==0)throw Error(He+e);return t.d?(r=Us(t.d),e&&t.e+1>r&&(r=t.e+1)):r=NaN,r};m.round=function(){var e=this,r=e.constructor;return y(new r(e),e.e+1,r.rounding)};m.sine=m.sin=function(){var e,r,t=this,n=t.constructor;return t.isFinite()?t.isZero()?new n(t):(e=n.precision,r=n.rounding,n.precision=e+Math.max(t.e,t.sd())+E,n.rounding=1,t=Sp(n,Js(n,t)),n.precision=e,n.rounding=r,y(Ne>2?t.neg():t,e,r,!0)):new n(NaN)};m.squareRoot=m.sqrt=function(){var e,r,t,n,i,o,s=this,a=s.d,l=s.e,u=s.s,c=s.constructor;if(u!==1||!a||!a[0])return new c(!u||u<0&&(!a||a[0])?NaN:a?s:1/0);for(w=!1,u=Math.sqrt(+s),u==0||u==1/0?(r=J(a),(r.length+l)%2==0&&(r+="0"),u=Math.sqrt(r),l=X((l+1)/2)-(l<0||l%2),u==1/0?r="5e"+l:(r=u.toExponential(),r=r.slice(0,r.indexOf("e")+1)+l),n=new c(r)):n=new c(u.toString()),t=(l=c.precision)+3;;)if(o=n,n=o.plus(L(s,o,t+2,1)).times(.5),J(o.d).slice(0,t)===(r=J(n.d)).slice(0,t))if(r=r.slice(t-3,t+1),r=="9999"||!i&&r=="4999"){if(!i&&(y(o,l+1,0),o.times(o).eq(s))){n=o;break}t+=4,i=1}else{(!+r||!+r.slice(1)&&r.charAt(0)=="5")&&(y(n,l+1,1),e=!n.times(n).eq(s));break}return w=!0,y(n,l,c.rounding,e)};m.tangent=m.tan=function(){var e,r,t=this,n=t.constructor;return t.isFinite()?t.isZero()?new n(t):(e=n.precision,r=n.rounding,n.precision=e+10,n.rounding=1,t=t.sin(),t.s=1,t=L(t,new n(1).minus(t.times(t)).sqrt(),e+10,0),n.precision=e,n.rounding=r,y(Ne==2||Ne==4?t.neg():t,e,r,!0)):new n(NaN)};m.times=m.mul=function(e){var r,t,n,i,o,s,a,l,u,c=this,p=c.constructor,d=c.d,f=(e=new p(e)).d;if(e.s*=c.s,!d||!d[0]||!f||!f[0])return new p(!e.s||d&&!d[0]&&!f||f&&!f[0]&&!d?NaN:!d||!f?e.s/0:e.s*0);for(t=X(c.e/E)+X(e.e/E),l=d.length,u=f.length,l=0;){for(r=0,i=l+n;i>n;)a=o[i]+f[n]*d[i-n-1]+r,o[i--]=a%fe|0,r=a/fe|0;o[i]=(o[i]+r)%fe|0}for(;!o[--s];)o.pop();return r?++t:o.shift(),e.d=o,e.e=wn(o,t),w?y(e,p.precision,p.rounding):e};m.toBinary=function(e,r){return Ji(this,2,e,r)};m.toDecimalPlaces=m.toDP=function(e,r){var t=this,n=t.constructor;return t=new n(t),e===void 0?t:(ne(e,0,Ye),r===void 0?r=n.rounding:ne(r,0,8),y(t,e+t.e+1,r))};m.toExponential=function(e,r){var t,n=this,i=n.constructor;return e===void 0?t=ve(n,!0):(ne(e,0,Ye),r===void 0?r=i.rounding:ne(r,0,8),n=y(new i(n),e+1,r),t=ve(n,!0,e+1)),n.isNeg()&&!n.isZero()?"-"+t:t};m.toFixed=function(e,r){var t,n,i=this,o=i.constructor;return e===void 0?t=ve(i):(ne(e,0,Ye),r===void 0?r=o.rounding:ne(r,0,8),n=y(new o(i),e+i.e+1,r),t=ve(n,!1,e+n.e+1)),i.isNeg()&&!i.isZero()?"-"+t:t};m.toFraction=function(e){var r,t,n,i,o,s,a,l,u,c,p,d,f=this,h=f.d,g=f.constructor;if(!h)return new g(f);if(u=t=new g(1),n=l=new g(0),r=new g(n),o=r.e=Us(h)-f.e-1,s=o%E,r.d[0]=U(10,s<0?E+s:s),e==null)e=o>0?r:u;else{if(a=new g(e),!a.isInt()||a.lt(u))throw Error(He+a);e=a.gt(r)?o>0?r:u:a}for(w=!1,a=new g(J(h)),c=g.precision,g.precision=o=h.length*E*2;p=L(a,r,0,1,1),i=t.plus(p.times(n)),i.cmp(e)!=1;)t=n,n=i,i=u,u=l.plus(p.times(i)),l=i,i=r,r=a.minus(p.times(i)),a=i;return i=L(e.minus(t),n,0,1,1),l=l.plus(i.times(u)),t=t.plus(i.times(n)),l.s=u.s=f.s,d=L(u,n,o,1).minus(f).abs().cmp(L(l,t,o,1).minus(f).abs())<1?[u,n]:[l,t],g.precision=c,w=!0,d};m.toHexadecimal=m.toHex=function(e,r){return Ji(this,16,e,r)};m.toNearest=function(e,r){var t=this,n=t.constructor;if(t=new n(t),e==null){if(!t.d)return t;e=new n(1),r=n.rounding}else{if(e=new n(e),r===void 0?r=n.rounding:ne(r,0,8),!t.d)return e.s?t:e;if(!e.d)return e.s&&(e.s=t.s),e}return e.d[0]?(w=!1,t=L(t,e,0,r,1).times(e),w=!0,y(t)):(e.s=t.s,t=e),t};m.toNumber=function(){return+this};m.toOctal=function(e,r){return Ji(this,8,e,r)};m.toPower=m.pow=function(e){var r,t,n,i,o,s,a=this,l=a.constructor,u=+(e=new l(e));if(!a.d||!e.d||!a.d[0]||!e.d[0])return new l(U(+a,u));if(a=new l(a),a.eq(1))return a;if(n=l.precision,o=l.rounding,e.eq(1))return y(a,n,o);if(r=X(e.e/E),r>=e.d.length-1&&(t=u<0?-u:u)<=xp)return i=Gs(l,a,t,n),e.s<0?new l(1).div(i):y(i,n,o);if(s=a.s,s<0){if(rl.maxE+1||r0?s/0:0):(w=!1,l.rounding=a.s=1,t=Math.min(12,(r+"").length),i=Wi(e.times(Ke(a,n+t)),n),i.d&&(i=y(i,n+5,1),ut(i.d,n,o)&&(r=n+10,i=y(Wi(e.times(Ke(a,r+t)),r),r+5,1),+J(i.d).slice(n+1,n+15)+1==1e14&&(i=y(i,n+1,0)))),i.s=s,w=!0,l.rounding=o,y(i,n,o))};m.toPrecision=function(e,r){var t,n=this,i=n.constructor;return e===void 0?t=ve(n,n.e<=i.toExpNeg||n.e>=i.toExpPos):(ne(e,1,Ye),r===void 0?r=i.rounding:ne(r,0,8),n=y(new i(n),e,r),t=ve(n,e<=n.e||n.e<=i.toExpNeg,e)),n.isNeg()&&!n.isZero()?"-"+t:t};m.toSignificantDigits=m.toSD=function(e,r){var t=this,n=t.constructor;return e===void 0?(e=n.precision,r=n.rounding):(ne(e,1,Ye),r===void 0?r=n.rounding:ne(r,0,8)),y(new n(t),e,r)};m.toString=function(){var e=this,r=e.constructor,t=ve(e,e.e<=r.toExpNeg||e.e>=r.toExpPos);return e.isNeg()&&!e.isZero()?"-"+t:t};m.truncated=m.trunc=function(){return y(new this.constructor(this),this.e+1,1)};m.valueOf=m.toJSON=function(){var e=this,r=e.constructor,t=ve(e,e.e<=r.toExpNeg||e.e>=r.toExpPos);return e.isNeg()?"-"+t:t};function J(e){var r,t,n,i=e.length-1,o="",s=e[0];if(i>0){for(o+=s,r=1;rt)throw Error(He+e)}function ut(e,r,t,n){var i,o,s,a;for(o=e[0];o>=10;o/=10)--r;return--r<0?(r+=E,i=0):(i=Math.ceil((r+1)/E),r%=E),o=U(10,E-r),a=e[i]%o|0,n==null?r<3?(r==0?a=a/100|0:r==1&&(a=a/10|0),s=t<4&&a==99999||t>3&&a==49999||a==5e4||a==0):s=(t<4&&a+1==o||t>3&&a+1==o/2)&&(e[i+1]/o/100|0)==U(10,r-2)-1||(a==o/2||a==0)&&(e[i+1]/o/100|0)==0:r<4?(r==0?a=a/1e3|0:r==1?a=a/100|0:r==2&&(a=a/10|0),s=(n||t<4)&&a==9999||!n&&t>3&&a==4999):s=((n||t<4)&&a+1==o||!n&&t>3&&a+1==o/2)&&(e[i+1]/o/1e3|0)==U(10,r-3)-1,s}function fn(e,r,t){for(var n,i=[0],o,s=0,a=e.length;st-1&&(i[n+1]===void 0&&(i[n+1]=0),i[n+1]+=i[n]/t|0,i[n]%=t)}return i.reverse()}function Pp(e,r){var t,n,i;if(r.isZero())return r;n=r.d.length,n<32?(t=Math.ceil(n/3),i=(1/xn(4,t)).toString()):(t=16,i="2.3283064365386962890625e-10"),e.precision+=t,r=Tr(e,1,r.times(i),new e(1));for(var o=t;o--;){var s=r.times(r);r=s.times(s).minus(s).times(8).plus(1)}return e.precision-=t,r}var L=function(){function e(n,i,o){var s,a=0,l=n.length;for(n=n.slice();l--;)s=n[l]*i+a,n[l]=s%o|0,a=s/o|0;return a&&n.unshift(a),n}function r(n,i,o,s){var a,l;if(o!=s)l=o>s?1:-1;else for(a=l=0;ai[a]?1:-1;break}return l}function t(n,i,o,s){for(var a=0;o--;)n[o]-=a,a=n[o]1;)n.shift()}return function(n,i,o,s,a,l){var u,c,p,d,f,h,g,I,T,S,b,D,me,se,Kr,j,te,Ae,K,fr,Vt=n.constructor,ti=n.s==i.s?1:-1,H=n.d,k=i.d;if(!H||!H[0]||!k||!k[0])return new Vt(!n.s||!i.s||(H?k&&H[0]==k[0]:!k)?NaN:H&&H[0]==0||!k?ti*0:ti/0);for(l?(f=1,c=n.e-i.e):(l=fe,f=E,c=X(n.e/f)-X(i.e/f)),K=k.length,te=H.length,T=new Vt(ti),S=T.d=[],p=0;k[p]==(H[p]||0);p++);if(k[p]>(H[p]||0)&&c--,o==null?(se=o=Vt.precision,s=Vt.rounding):a?se=o+(n.e-i.e)+1:se=o,se<0)S.push(1),h=!0;else{if(se=se/f+2|0,p=0,K==1){for(d=0,k=k[0],se++;(p1&&(k=e(k,d,l),H=e(H,d,l),K=k.length,te=H.length),j=K,b=H.slice(0,K),D=b.length;D=l/2&&++Ae;do d=0,u=r(k,b,K,D),u<0?(me=b[0],K!=D&&(me=me*l+(b[1]||0)),d=me/Ae|0,d>1?(d>=l&&(d=l-1),g=e(k,d,l),I=g.length,D=b.length,u=r(g,b,I,D),u==1&&(d--,t(g,K=10;d/=10)p++;T.e=p+c*f-1,y(T,a?o+T.e+1:o,s,h)}return T}}();function y(e,r,t,n){var i,o,s,a,l,u,c,p,d,f=e.constructor;e:if(r!=null){if(p=e.d,!p)return e;for(i=1,a=p[0];a>=10;a/=10)i++;if(o=r-i,o<0)o+=E,s=r,c=p[d=0],l=c/U(10,i-s-1)%10|0;else if(d=Math.ceil((o+1)/E),a=p.length,d>=a)if(n){for(;a++<=d;)p.push(0);c=l=0,i=1,o%=E,s=o-E+1}else break e;else{for(c=a=p[d],i=1;a>=10;a/=10)i++;o%=E,s=o-E+i,l=s<0?0:c/U(10,i-s-1)%10|0}if(n=n||r<0||p[d+1]!==void 0||(s<0?c:c%U(10,i-s-1)),u=t<4?(l||n)&&(t==0||t==(e.s<0?3:2)):l>5||l==5&&(t==4||n||t==6&&(o>0?s>0?c/U(10,i-s):0:p[d-1])%10&1||t==(e.s<0?8:7)),r<1||!p[0])return p.length=0,u?(r-=e.e+1,p[0]=U(10,(E-r%E)%E),e.e=-r||0):p[0]=e.e=0,e;if(o==0?(p.length=d,a=1,d--):(p.length=d+1,a=U(10,E-o),p[d]=s>0?(c/U(10,i-s)%U(10,s)|0)*a:0),u)for(;;)if(d==0){for(o=1,s=p[0];s>=10;s/=10)o++;for(s=p[0]+=a,a=1;s>=10;s/=10)a++;o!=a&&(e.e++,p[0]==fe&&(p[0]=1));break}else{if(p[d]+=a,p[d]!=fe)break;p[d--]=0,a=1}for(o=p.length;p[--o]===0;)p.pop()}return w&&(e.e>f.maxE?(e.d=null,e.e=NaN):e.e0?o=o.charAt(0)+"."+o.slice(1)+Je(n):s>1&&(o=o.charAt(0)+"."+o.slice(1)),o=o+(e.e<0?"e":"e+")+e.e):i<0?(o="0."+Je(-i-1)+o,t&&(n=t-s)>0&&(o+=Je(n))):i>=s?(o+=Je(i+1-s),t&&(n=t-i-1)>0&&(o=o+"."+Je(n))):((n=i+1)0&&(i+1===s&&(o+="."),o+=Je(n))),o}function wn(e,r){var t=e[0];for(r*=E;t>=10;t/=10)r++;return r}function bn(e,r,t){if(r>vp)throw w=!0,t&&(e.precision=t),Error(qs);return y(new e(hn),r,1,!0)}function xe(e,r,t){if(r>Qi)throw Error(qs);return y(new e(yn),r,t,!0)}function Us(e){var r=e.length-1,t=r*E+1;if(r=e[r],r){for(;r%10==0;r/=10)t--;for(r=e[0];r>=10;r/=10)t++}return t}function Je(e){for(var r="";e--;)r+="0";return r}function Gs(e,r,t,n){var i,o=new e(1),s=Math.ceil(n/E+4);for(w=!1;;){if(t%2&&(o=o.times(r),Fs(o.d,s)&&(i=!0)),t=X(t/2),t===0){t=o.d.length-1,i&&o.d[t]===0&&++o.d[t];break}r=r.times(r),Fs(r.d,s)}return w=!0,o}function Ls(e){return e.d[e.d.length-1]&1}function Qs(e,r,t){for(var n,i,o=new e(r[0]),s=0;++s17)return new d(e.d?e.d[0]?e.s<0?0:1/0:1:e.s?e.s<0?0:e:NaN);for(r==null?(w=!1,l=h):l=r,a=new d(.03125);e.e>-2;)e=e.times(a),p+=5;for(n=Math.log(U(2,p))/Math.LN10*2+5|0,l+=n,t=o=s=new d(1),d.precision=l;;){if(o=y(o.times(e),l,1),t=t.times(++c),a=s.plus(L(o,t,l,1)),J(a.d).slice(0,l)===J(s.d).slice(0,l)){for(i=p;i--;)s=y(s.times(s),l,1);if(r==null)if(u<3&&ut(s.d,l-n,f,u))d.precision=l+=10,t=o=a=new d(1),c=0,u++;else return y(s,d.precision=h,f,w=!0);else return d.precision=h,s}s=a}}function Ke(e,r){var t,n,i,o,s,a,l,u,c,p,d,f=1,h=10,g=e,I=g.d,T=g.constructor,S=T.rounding,b=T.precision;if(g.s<0||!I||!I[0]||!g.e&&I[0]==1&&I.length==1)return new T(I&&!I[0]?-1/0:g.s!=1?NaN:I?0:g);if(r==null?(w=!1,c=b):c=r,T.precision=c+=h,t=J(I),n=t.charAt(0),Math.abs(o=g.e)<15e14){for(;n<7&&n!=1||n==1&&t.charAt(1)>3;)g=g.times(e),t=J(g.d),n=t.charAt(0),f++;o=g.e,n>1?(g=new T("0."+t),o++):g=new T(n+"."+t.slice(1))}else return u=bn(T,c+2,b).times(o+""),g=Ke(new T(n+"."+t.slice(1)),c-h).plus(u),T.precision=b,r==null?y(g,b,S,w=!0):g;for(p=g,l=s=g=L(g.minus(1),g.plus(1),c,1),d=y(g.times(g),c,1),i=3;;){if(s=y(s.times(d),c,1),u=l.plus(L(s,new T(i),c,1)),J(u.d).slice(0,c)===J(l.d).slice(0,c))if(l=l.times(2),o!==0&&(l=l.plus(bn(T,c+2,b).times(o+""))),l=L(l,new T(f),c,1),r==null)if(ut(l.d,c-h,S,a))T.precision=c+=h,u=s=g=L(p.minus(1),p.plus(1),c,1),d=y(g.times(g),c,1),i=a=1;else return y(l,T.precision=b,S,w=!0);else return T.precision=b,l;l=u,i+=2}}function Ws(e){return String(e.s*e.s/0)}function gn(e,r){var t,n,i;for((t=r.indexOf("."))>-1&&(r=r.replace(".","")),(n=r.search(/e/i))>0?(t<0&&(t=n),t+=+r.slice(n+1),r=r.substring(0,n)):t<0&&(t=r.length),n=0;r.charCodeAt(n)===48;n++);for(i=r.length;r.charCodeAt(i-1)===48;--i);if(r=r.slice(n,i),r){if(i-=n,e.e=t=t-n-1,e.d=[],n=(t+1)%E,t<0&&(n+=E),ne.constructor.maxE?(e.d=null,e.e=NaN):e.e-1){if(r=r.replace(/(\d)_(?=\d)/g,"$1"),Bs.test(r))return gn(e,r)}else if(r==="Infinity"||r==="NaN")return+r||(e.s=NaN),e.e=NaN,e.d=null,e;if(Ep.test(r))t=16,r=r.toLowerCase();else if(bp.test(r))t=2;else if(wp.test(r))t=8;else throw Error(He+r);for(o=r.search(/p/i),o>0?(l=+r.slice(o+1),r=r.substring(2,o)):r=r.slice(2),o=r.indexOf("."),s=o>=0,n=e.constructor,s&&(r=r.replace(".",""),a=r.length,o=a-o,i=Gs(n,new n(t),o,o*2)),u=fn(r,t,fe),c=u.length-1,o=c;u[o]===0;--o)u.pop();return o<0?new n(e.s*0):(e.e=wn(u,c),e.d=u,w=!1,s&&(e=L(e,i,a*4)),l&&(e=e.times(Math.abs(l)<54?U(2,l):Le.pow(2,l))),w=!0,e)}function Sp(e,r){var t,n=r.d.length;if(n<3)return r.isZero()?r:Tr(e,2,r,r);t=1.4*Math.sqrt(n),t=t>16?16:t|0,r=r.times(1/xn(5,t)),r=Tr(e,2,r,r);for(var i,o=new e(5),s=new e(16),a=new e(20);t--;)i=r.times(r),r=r.times(o.plus(i.times(s.times(i).minus(a))));return r}function Tr(e,r,t,n,i){var o,s,a,l,u=1,c=e.precision,p=Math.ceil(c/E);for(w=!1,l=t.times(t),a=new e(n);;){if(s=L(a.times(l),new e(r++*r++),c,1),a=i?n.plus(s):n.minus(s),n=L(s.times(l),new e(r++*r++),c,1),s=a.plus(n),s.d[p]!==void 0){for(o=p;s.d[o]===a.d[o]&&o--;);if(o==-1)break}o=a,a=n,n=s,s=o,u++}return w=!0,s.d.length=p+1,s}function xn(e,r){for(var t=e;--r;)t*=e;return t}function Js(e,r){var t,n=r.s<0,i=xe(e,e.precision,1),o=i.times(.5);if(r=r.abs(),r.lte(o))return Ne=n?4:1,r;if(t=r.divToInt(i),t.isZero())Ne=n?3:2;else{if(r=r.minus(t.times(i)),r.lte(o))return Ne=Ls(t)?n?2:3:n?4:1,r;Ne=Ls(t)?n?1:4:n?3:2}return r.minus(i).abs()}function Ji(e,r,t,n){var i,o,s,a,l,u,c,p,d,f=e.constructor,h=t!==void 0;if(h?(ne(t,1,Ye),n===void 0?n=f.rounding:ne(n,0,8)):(t=f.precision,n=f.rounding),!e.isFinite())c=Ws(e);else{for(c=ve(e),s=c.indexOf("."),h?(i=2,r==16?t=t*4-3:r==8&&(t=t*3-2)):i=r,s>=0&&(c=c.replace(".",""),d=new f(1),d.e=c.length-s,d.d=fn(ve(d),10,i),d.e=d.d.length),p=fn(c,10,i),o=l=p.length;p[--l]==0;)p.pop();if(!p[0])c=h?"0p+0":"0";else{if(s<0?o--:(e=new f(e),e.d=p,e.e=o,e=L(e,d,t,n,0,i),p=e.d,o=e.e,u=$s),s=p[t],a=i/2,u=u||p[t+1]!==void 0,u=n<4?(s!==void 0||u)&&(n===0||n===(e.s<0?3:2)):s>a||s===a&&(n===4||u||n===6&&p[t-1]&1||n===(e.s<0?8:7)),p.length=t,u)for(;++p[--t]>i-1;)p[t]=0,t||(++o,p.unshift(1));for(l=p.length;!p[l-1];--l);for(s=0,c="";s1)if(r==16||r==8){for(s=r==16?4:3,--l;l%s;l++)c+="0";for(p=fn(c,i,r),l=p.length;!p[l-1];--l);for(s=1,c="1.";sl)for(o-=l;o--;)c+="0";else or)return e.length=r,!0}function Rp(e){return new this(e).abs()}function Ap(e){return new this(e).acos()}function Cp(e){return new this(e).acosh()}function Ip(e,r){return new this(e).plus(r)}function Dp(e){return new this(e).asin()}function Op(e){return new this(e).asinh()}function kp(e){return new this(e).atan()}function _p(e){return new this(e).atanh()}function Np(e,r){e=new this(e),r=new this(r);var t,n=this.precision,i=this.rounding,o=n+4;return!e.s||!r.s?t=new this(NaN):!e.d&&!r.d?(t=xe(this,o,1).times(r.s>0?.25:.75),t.s=e.s):!r.d||e.isZero()?(t=r.s<0?xe(this,n,i):new this(0),t.s=e.s):!e.d||r.isZero()?(t=xe(this,o,1).times(.5),t.s=e.s):r.s<0?(this.precision=o,this.rounding=1,t=this.atan(L(e,r,o,1)),r=xe(this,o,1),this.precision=n,this.rounding=i,t=e.s<0?t.minus(r):t.plus(r)):t=this.atan(L(e,r,o,1)),t}function Lp(e){return new this(e).cbrt()}function Fp(e){return y(e=new this(e),e.e+1,2)}function Mp(e,r,t){return new this(e).clamp(r,t)}function $p(e){if(!e||typeof e!="object")throw Error(En+"Object expected");var r,t,n,i=e.defaults===!0,o=["precision",1,Ye,"rounding",0,8,"toExpNeg",-Pr,0,"toExpPos",0,Pr,"maxE",0,Pr,"minE",-Pr,0,"modulo",0,9];for(r=0;r=o[r+1]&&n<=o[r+2])this[t]=n;else throw Error(He+t+": "+n);if(t="crypto",i&&(this[t]=Gi[t]),(n=e[t])!==void 0)if(n===!0||n===!1||n===0||n===1)if(n)if(typeof crypto<"u"&&crypto&&(crypto.getRandomValues||crypto.randomBytes))this[t]=!0;else throw Error(Vs);else this[t]=!1;else throw Error(He+t+": "+n);return this}function qp(e){return new this(e).cos()}function Vp(e){return new this(e).cosh()}function Ks(e){var r,t,n;function i(o){var s,a,l,u=this;if(!(u instanceof i))return new i(o);if(u.constructor=i,Ms(o)){u.s=o.s,w?!o.d||o.e>i.maxE?(u.e=NaN,u.d=null):o.e=10;a/=10)s++;w?s>i.maxE?(u.e=NaN,u.d=null):s=429e7?r[o]=crypto.getRandomValues(new Uint32Array(1))[0]:a[o++]=i%1e7;else if(crypto.randomBytes){for(r=crypto.randomBytes(n*=4);o=214e7?crypto.randomBytes(4).copy(r,o):(a.push(i%1e7),o+=4);o=n/4}else throw Error(Vs);else for(;o=10;i/=10)n++;nRr,datamodelEnumToSchemaEnum:()=>pd});function pd(e){return{name:e.name,values:e.values.map(r=>r.name)}}var Rr=(b=>(b.findUnique="findUnique",b.findUniqueOrThrow="findUniqueOrThrow",b.findFirst="findFirst",b.findFirstOrThrow="findFirstOrThrow",b.findMany="findMany",b.create="create",b.createMany="createMany",b.createManyAndReturn="createManyAndReturn",b.update="update",b.updateMany="updateMany",b.updateManyAndReturn="updateManyAndReturn",b.upsert="upsert",b.delete="delete",b.deleteMany="deleteMany",b.groupBy="groupBy",b.count="count",b.aggregate="aggregate",b.findRaw="findRaw",b.aggregateRaw="aggregateRaw",b))(Rr||{});var Xs=O(Di());var Zs=O(require("node:fs"));var Hs={keyword:De,entity:De,value:e=>W(nr(e)),punctuation:nr,directive:De,function:De,variable:e=>W(nr(e)),string:e=>W(qe(e)),boolean:Ie,number:De,comment:Hr};var dd=e=>e,vn={},md=0,v={manual:vn.Prism&&vn.Prism.manual,disableWorkerMessageHandler:vn.Prism&&vn.Prism.disableWorkerMessageHandler,util:{encode:function(e){if(e instanceof ge){let r=e;return new ge(r.type,v.util.encode(r.content),r.alias)}else return Array.isArray(e)?e.map(v.util.encode):e.replace(/&/g,"&").replace(/e.length)return;if(Ae instanceof ge)continue;if(me&&j!=r.length-1){S.lastIndex=te;var p=S.exec(e);if(!p)break;var c=p.index+(D?p[1].length:0),d=p.index+p[0].length,a=j,l=te;for(let k=r.length;a=l&&(++j,te=l);if(r[j]instanceof ge)continue;u=a-j,Ae=e.slice(te,l),p.index-=te}else{S.lastIndex=0;var p=S.exec(Ae),u=1}if(!p){if(o)break;continue}D&&(se=p[1]?p[1].length:0);var c=p.index+se,p=p[0].slice(se),d=c+p.length,f=Ae.slice(0,c),h=Ae.slice(d);let K=[j,u];f&&(++j,te+=f.length,K.push(f));let fr=new ge(g,b?v.tokenize(p,b):p,Kr,p,me);if(K.push(fr),h&&K.push(h),Array.prototype.splice.apply(r,K),u!=1&&v.matchGrammar(e,r,t,j,te,!0,g),o)break}}}},tokenize:function(e,r){let t=[e],n=r.rest;if(n){for(let i in n)r[i]=n[i];delete r.rest}return v.matchGrammar(e,t,r,0,0,!1),t},hooks:{all:{},add:function(e,r){let t=v.hooks.all;t[e]=t[e]||[],t[e].push(r)},run:function(e,r){let t=v.hooks.all[e];if(!(!t||!t.length))for(var n=0,i;i=t[n++];)i(r)}},Token:ge};v.languages.clike={comment:[{pattern:/(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,lookbehind:!0},{pattern:/(^|[^\\:])\/\/.*/,lookbehind:!0,greedy:!0}],string:{pattern:/(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,greedy:!0},"class-name":{pattern:/((?:\b(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[\w.\\]+/i,lookbehind:!0,inside:{punctuation:/[.\\]/}},keyword:/\b(?:if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/,boolean:/\b(?:true|false)\b/,function:/\w+(?=\()/,number:/\b0x[\da-f]+\b|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?/i,operator:/--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&?|\|\|?|\?|\*|\/|~|\^|%/,punctuation:/[{}[\];(),.:]/};v.languages.javascript=v.languages.extend("clike",{"class-name":[v.languages.clike["class-name"],{pattern:/(^|[^$\w\xA0-\uFFFF])[_$A-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\.(?:prototype|constructor))/,lookbehind:!0}],keyword:[{pattern:/((?:^|})\s*)(?:catch|finally)\b/,lookbehind:!0},{pattern:/(^|[^.])\b(?:as|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,lookbehind:!0}],number:/\b(?:(?:0[xX](?:[\dA-Fa-f](?:_[\dA-Fa-f])?)+|0[bB](?:[01](?:_[01])?)+|0[oO](?:[0-7](?:_[0-7])?)+)n?|(?:\d(?:_\d)?)+n|NaN|Infinity)\b|(?:\b(?:\d(?:_\d)?)+\.?(?:\d(?:_\d)?)*|\B\.(?:\d(?:_\d)?)+)(?:[Ee][+-]?(?:\d(?:_\d)?)+)?/,function:/[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,operator:/-[-=]?|\+[+=]?|!=?=?|<>?>?=?|=(?:==?|>)?|&[&=]?|\|[|=]?|\*\*?=?|\/=?|~|\^=?|%=?|\?|\.{3}/});v.languages.javascript["class-name"][0].pattern=/(\b(?:class|interface|extends|implements|instanceof|new)\s+)[\w.\\]+/;v.languages.insertBefore("javascript","keyword",{regex:{pattern:/((?:^|[^$\w\xA0-\uFFFF."'\])\s])\s*)\/(\[(?:[^\]\\\r\n]|\\.)*]|\\.|[^/\\\[\r\n])+\/[gimyus]{0,6}(?=\s*($|[\r\n,.;})\]]))/,lookbehind:!0,greedy:!0},"function-variable":{pattern:/[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*)\s*=>))/,alias:"function"},parameter:[{pattern:/(function(?:\s+[_$A-Za-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*)?\s*\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\))/,lookbehind:!0,inside:v.languages.javascript},{pattern:/[_$a-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*=>)/i,inside:v.languages.javascript},{pattern:/(\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\)\s*=>)/,lookbehind:!0,inside:v.languages.javascript},{pattern:/((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:[_$A-Za-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\s*)\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\)\s*\{)/,lookbehind:!0,inside:v.languages.javascript}],constant:/\b[A-Z](?:[A-Z_]|\dx?)*\b/});v.languages.markup&&v.languages.markup.tag.addInlined("script","javascript");v.languages.js=v.languages.javascript;v.languages.typescript=v.languages.extend("javascript",{keyword:/\b(?:abstract|as|async|await|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|is|keyof|let|module|namespace|new|null|of|package|private|protected|public|readonly|return|require|set|static|super|switch|this|throw|try|type|typeof|var|void|while|with|yield)\b/,builtin:/\b(?:string|Function|any|number|boolean|Array|symbol|console|Promise|unknown|never)\b/});v.languages.ts=v.languages.typescript;function ge(e,r,t,n,i){this.type=e,this.content=r,this.alias=t,this.length=(n||"").length|0,this.greedy=!!i}ge.stringify=function(e,r){return typeof e=="string"?e:Array.isArray(e)?e.map(function(t){return ge.stringify(t,r)}).join(""):fd(e.type)(e.content)};function fd(e){return Hs[e]||dd}function Ys(e){return gd(e,v.languages.javascript)}function gd(e,r){return v.tokenize(e,r).map(n=>ge.stringify(n)).join("")}function zs(e){return Ci(e)}var Pn=class e{firstLineNumber;lines;static read(r){let t;try{t=Zs.default.readFileSync(r,"utf-8")}catch{return null}return e.fromContent(t)}static fromContent(r){let t=r.split(/\r?\n/);return new e(1,t)}constructor(r,t){this.firstLineNumber=r,this.lines=t}get lastLineNumber(){return this.firstLineNumber+this.lines.length-1}mapLineAt(r,t){if(rthis.lines.length+this.firstLineNumber)return this;let n=r-this.firstLineNumber,i=[...this.lines];return i[n]=t(i[n]),new e(this.firstLineNumber,i)}mapLines(r){return new e(this.firstLineNumber,this.lines.map((t,n)=>r(t,this.firstLineNumber+n)))}lineAt(r){return this.lines[r-this.firstLineNumber]}prependSymbolAt(r,t){return this.mapLines((n,i)=>i===r?`${t} ${n}`:` ${n}`)}slice(r,t){let n=this.lines.slice(r-1,t).join(` -`);return new e(r,zs(n).split(` -`))}highlight(){let r=Ys(this.toString());return new e(this.firstLineNumber,r.split(` -`))}toString(){return this.lines.join(` -`)}};var hd={red:ce,gray:Hr,dim:Ce,bold:W,underline:Y,highlightSource:e=>e.highlight()},yd={red:e=>e,gray:e=>e,dim:e=>e,bold:e=>e,underline:e=>e,highlightSource:e=>e};function bd({message:e,originalMethod:r,isPanic:t,callArguments:n}){return{functionName:`prisma.${r}()`,message:e,isPanic:t??!1,callArguments:n}}function Ed({callsite:e,message:r,originalMethod:t,isPanic:n,callArguments:i},o){let s=bd({message:r,originalMethod:t,isPanic:n,callArguments:i});if(!e||typeof window<"u"||process.env.NODE_ENV==="production")return s;let a=e.getLocation();if(!a||!a.lineNumber||!a.columnNumber)return s;let l=Math.max(1,a.lineNumber-3),u=Pn.read(a.fileName)?.slice(l,a.lineNumber),c=u?.lineAt(a.lineNumber);if(u&&c){let p=xd(c),d=wd(c);if(!d)return s;s.functionName=`${d.code})`,s.location=a,n||(u=u.mapLineAt(a.lineNumber,h=>h.slice(0,d.openingBraceIndex))),u=o.highlightSource(u);let f=String(u.lastLineNumber).length;if(s.contextLines=u.mapLines((h,g)=>o.gray(String(g).padStart(f))+" "+h).mapLines(h=>o.dim(h)).prependSymbolAt(a.lineNumber,o.bold(o.red("\u2192"))),i){let h=p+f+1;h+=2,s.callArguments=(0,Xs.default)(i,h).slice(h)}}return s}function wd(e){let r=Object.keys(Rr).join("|"),n=new RegExp(String.raw`\.(${r})\(`).exec(e);if(n){let i=n.index+n[0].length,o=e.lastIndexOf(" ",n.index)+1;return{code:e.slice(o,i),openingBraceIndex:i}}return null}function xd(e){let r=0;for(let t=0;t"Unknown error")}function ia(e){return e.errors.flatMap(r=>r.kind==="Union"?ia(r):[r])}function Td(e){let r=new Map,t=[];for(let n of e){if(n.kind!=="InvalidArgumentType"){t.push(n);continue}let i=`${n.selectionPath.join(".")}:${n.argumentPath.join(".")}`,o=r.get(i);o?r.set(i,{...n,argument:{...n.argument,typeNames:Sd(o.argument.typeNames,n.argument.typeNames)}}):r.set(i,n)}return t.push(...r.values()),t}function Sd(e,r){return[...new Set(e.concat(r))]}function Rd(e){return ji(e,(r,t)=>{let n=ra(r),i=ra(t);return n!==i?n-i:ta(r)-ta(t)})}function ra(e){let r=0;return Array.isArray(e.selectionPath)&&(r+=e.selectionPath.length),Array.isArray(e.argumentPath)&&(r+=e.argumentPath.length),r}function ta(e){switch(e.kind){case"InvalidArgumentValue":case"ValueTooLarge":return 20;case"InvalidArgumentType":return 10;case"RequiredArgumentMissing":return-10;default:return 0}}var le=class{constructor(r,t){this.name=r;this.value=t}isRequired=!1;makeRequired(){return this.isRequired=!0,this}write(r){let{colors:{green:t}}=r.context;r.addMarginSymbol(t(this.isRequired?"+":"?")),r.write(t(this.name)),this.isRequired||r.write(t("?")),r.write(t(": ")),typeof this.value=="string"?r.write(t(this.value)):r.write(this.value)}};sa();var Ar=class{constructor(r=0,t){this.context=t;this.currentIndent=r}lines=[];currentLine="";currentIndent=0;marginSymbol;afterNextNewLineCallback;write(r){return typeof r=="string"?this.currentLine+=r:r.write(this),this}writeJoined(r,t,n=(i,o)=>o.write(i)){let i=t.length-1;for(let o=0;o0&&this.currentIndent--,this}addMarginSymbol(r){return this.marginSymbol=r,this}toString(){return this.lines.concat(this.indentedCurrentLine()).join(` -`)}getCurrentLineLength(){return this.currentLine.length}indentedCurrentLine(){let r=this.currentLine.padStart(this.currentLine.length+2*this.currentIndent);return this.marginSymbol?this.marginSymbol+r.slice(1):r}};oa();var Rn=class{constructor(r){this.value=r}write(r){r.write(this.value)}markAsError(){this.value.markAsError()}};var An=e=>e,Cn={bold:An,red:An,green:An,dim:An,enabled:!1},aa={bold:W,red:ce,green:qe,dim:Ce,enabled:!0},Cr={write(e){e.writeLine(",")}};var Pe=class{constructor(r){this.contents=r}isUnderlined=!1;color=r=>r;underline(){return this.isUnderlined=!0,this}setColor(r){return this.color=r,this}write(r){let t=r.getCurrentLineLength();r.write(this.color(this.contents)),this.isUnderlined&&r.afterNextNewline(()=>{r.write(" ".repeat(t)).writeLine(this.color("~".repeat(this.contents.length)))})}};var ze=class{hasError=!1;markAsError(){return this.hasError=!0,this}};var Ir=class extends ze{items=[];addItem(r){return this.items.push(new Rn(r)),this}getField(r){return this.items[r]}getPrintWidth(){return this.items.length===0?2:Math.max(...this.items.map(t=>t.value.getPrintWidth()))+2}write(r){if(this.items.length===0){this.writeEmpty(r);return}this.writeWithItems(r)}writeEmpty(r){let t=new Pe("[]");this.hasError&&t.setColor(r.context.colors.red).underline(),r.write(t)}writeWithItems(r){let{colors:t}=r.context;r.writeLine("[").withIndent(()=>r.writeJoined(Cr,this.items).newLine()).write("]"),this.hasError&&r.afterNextNewline(()=>{r.writeLine(t.red("~".repeat(this.getPrintWidth())))})}asObject(){}};var Dr=class e extends ze{fields={};suggestions=[];addField(r){this.fields[r.name]=r}addSuggestion(r){this.suggestions.push(r)}getField(r){return this.fields[r]}getDeepField(r){let[t,...n]=r,i=this.getField(t);if(!i)return;let o=i;for(let s of n){let a;if(o.value instanceof e?a=o.value.getField(s):o.value instanceof Ir&&(a=o.value.getField(Number(s))),!a)return;o=a}return o}getDeepFieldValue(r){return r.length===0?this:this.getDeepField(r)?.value}hasField(r){return!!this.getField(r)}removeAllFields(){this.fields={}}removeField(r){delete this.fields[r]}getFields(){return this.fields}isEmpty(){return Object.keys(this.fields).length===0}getFieldValue(r){return this.getField(r)?.value}getDeepSubSelectionValue(r){let t=this;for(let n of r){if(!(t instanceof e))return;let i=t.getSubSelectionValue(n);if(!i)return;t=i}return t}getDeepSelectionParent(r){let t=this.getSelectionParent();if(!t)return;let n=t;for(let i of r){let o=n.value.getFieldValue(i);if(!o||!(o instanceof e))return;let s=o.getSelectionParent();if(!s)return;n=s}return n}getSelectionParent(){let r=this.getField("select")?.value.asObject();if(r)return{kind:"select",value:r};let t=this.getField("include")?.value.asObject();if(t)return{kind:"include",value:t}}getSubSelectionValue(r){return this.getSelectionParent()?.value.fields[r].value}getPrintWidth(){let r=Object.values(this.fields);return r.length==0?2:Math.max(...r.map(n=>n.getPrintWidth()))+2}write(r){let t=Object.values(this.fields);if(t.length===0&&this.suggestions.length===0){this.writeEmpty(r);return}this.writeWithContents(r,t)}asObject(){return this}writeEmpty(r){let t=new Pe("{}");this.hasError&&t.setColor(r.context.colors.red).underline(),r.write(t)}writeWithContents(r,t){r.writeLine("{").withIndent(()=>{r.writeJoined(Cr,[...t,...this.suggestions]).newLine()}),r.write("}"),this.hasError&&r.afterNextNewline(()=>{r.writeLine(r.context.colors.red("~".repeat(this.getPrintWidth())))})}};var Q=class extends ze{constructor(t){super();this.text=t}getPrintWidth(){return this.text.length}write(t){let n=new Pe(this.text);this.hasError&&n.underline().setColor(t.context.colors.red),t.write(n)}asObject(){}};var pt=class{fields=[];addField(r,t){return this.fields.push({write(n){let{green:i,dim:o}=n.context.colors;n.write(i(o(`${r}: ${t}`))).addMarginSymbol(i(o("+")))}}),this}write(r){let{colors:{green:t}}=r.context;r.writeLine(t("{")).withIndent(()=>{r.writeJoined(Cr,this.fields).newLine()}).write(t("}")).addMarginSymbol(t("+"))}};function Sn(e,r,t){switch(e.kind){case"MutuallyExclusiveFields":Ad(e,r);break;case"IncludeOnScalar":Cd(e,r);break;case"EmptySelection":Id(e,r,t);break;case"UnknownSelectionField":_d(e,r);break;case"InvalidSelectionValue":Nd(e,r);break;case"UnknownArgument":Ld(e,r);break;case"UnknownInputField":Fd(e,r);break;case"RequiredArgumentMissing":Md(e,r);break;case"InvalidArgumentType":$d(e,r);break;case"InvalidArgumentValue":qd(e,r);break;case"ValueTooLarge":Vd(e,r);break;case"SomeFieldsMissing":jd(e,r);break;case"TooManyFieldsGiven":Bd(e,r);break;case"Union":na(e,r,t);break;default:throw new Error("not implemented: "+e.kind)}}function Ad(e,r){let t=r.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();t&&(t.getField(e.firstField)?.markAsError(),t.getField(e.secondField)?.markAsError()),r.addErrorMessage(n=>`Please ${n.bold("either")} use ${n.green(`\`${e.firstField}\``)} or ${n.green(`\`${e.secondField}\``)}, but ${n.red("not both")} at the same time.`)}function Cd(e,r){let[t,n]=Or(e.selectionPath),i=e.outputType,o=r.arguments.getDeepSelectionParent(t)?.value;if(o&&(o.getField(n)?.markAsError(),i))for(let s of i.fields)s.isRelation&&o.addSuggestion(new le(s.name,"true"));r.addErrorMessage(s=>{let a=`Invalid scalar field ${s.red(`\`${n}\``)} for ${s.bold("include")} statement`;return i?a+=` on model ${s.bold(i.name)}. ${dt(s)}`:a+=".",a+=` -Note that ${s.bold("include")} statements only accept relation fields.`,a})}function Id(e,r,t){let n=r.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(n){let i=n.getField("omit")?.value.asObject();if(i){Dd(e,r,i);return}if(n.hasField("select")){Od(e,r);return}}if(t?.[We(e.outputType.name)]){kd(e,r);return}r.addErrorMessage(()=>`Unknown field at "${e.selectionPath.join(".")} selection"`)}function Dd(e,r,t){t.removeAllFields();for(let n of e.outputType.fields)t.addSuggestion(new le(n.name,"false"));r.addErrorMessage(n=>`The ${n.red("omit")} statement includes every field of the model ${n.bold(e.outputType.name)}. At least one field must be included in the result`)}function Od(e,r){let t=e.outputType,n=r.arguments.getDeepSelectionParent(e.selectionPath)?.value,i=n?.isEmpty()??!1;n&&(n.removeAllFields(),pa(n,t)),r.addErrorMessage(o=>i?`The ${o.red("`select`")} statement for type ${o.bold(t.name)} must not be empty. ${dt(o)}`:`The ${o.red("`select`")} statement for type ${o.bold(t.name)} needs ${o.bold("at least one truthy value")}.`)}function kd(e,r){let t=new pt;for(let i of e.outputType.fields)i.isRelation||t.addField(i.name,"false");let n=new le("omit",t).makeRequired();if(e.selectionPath.length===0)r.arguments.addSuggestion(n);else{let[i,o]=Or(e.selectionPath),a=r.arguments.getDeepSelectionParent(i)?.value.asObject()?.getField(o);if(a){let l=a?.value.asObject()??new Dr;l.addSuggestion(n),a.value=l}}r.addErrorMessage(i=>`The global ${i.red("omit")} configuration excludes every field of the model ${i.bold(e.outputType.name)}. At least one field must be included in the result`)}function _d(e,r){let t=da(e.selectionPath,r);if(t.parentKind!=="unknown"){t.field.markAsError();let n=t.parent;switch(t.parentKind){case"select":pa(n,e.outputType);break;case"include":Ud(n,e.outputType);break;case"omit":Gd(n,e.outputType);break}}r.addErrorMessage(n=>{let i=[`Unknown field ${n.red(`\`${t.fieldName}\``)}`];return t.parentKind!=="unknown"&&i.push(`for ${n.bold(t.parentKind)} statement`),i.push(`on model ${n.bold(`\`${e.outputType.name}\``)}.`),i.push(dt(n)),i.join(" ")})}function Nd(e,r){let t=da(e.selectionPath,r);t.parentKind!=="unknown"&&t.field.value.markAsError(),r.addErrorMessage(n=>`Invalid value for selection field \`${n.red(t.fieldName)}\`: ${e.underlyingError}`)}function Ld(e,r){let t=e.argumentPath[0],n=r.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();n&&(n.getField(t)?.markAsError(),Qd(n,e.arguments)),r.addErrorMessage(i=>ua(i,t,e.arguments.map(o=>o.name)))}function Fd(e,r){let[t,n]=Or(e.argumentPath),i=r.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(i){i.getDeepField(e.argumentPath)?.markAsError();let o=i.getDeepFieldValue(t)?.asObject();o&&ma(o,e.inputType)}r.addErrorMessage(o=>ua(o,n,e.inputType.fields.map(s=>s.name)))}function ua(e,r,t){let n=[`Unknown argument \`${e.red(r)}\`.`],i=Jd(r,t);return i&&n.push(`Did you mean \`${e.green(i)}\`?`),t.length>0&&n.push(dt(e)),n.join(" ")}function Md(e,r){let t;r.addErrorMessage(l=>t?.value instanceof Q&&t.value.text==="null"?`Argument \`${l.green(o)}\` must not be ${l.red("null")}.`:`Argument \`${l.green(o)}\` is missing.`);let n=r.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(!n)return;let[i,o]=Or(e.argumentPath),s=new pt,a=n.getDeepFieldValue(i)?.asObject();if(a){if(t=a.getField(o),t&&a.removeField(o),e.inputTypes.length===1&&e.inputTypes[0].kind==="object"){for(let l of e.inputTypes[0].fields)s.addField(l.name,l.typeNames.join(" | "));a.addSuggestion(new le(o,s).makeRequired())}else{let l=e.inputTypes.map(ca).join(" | ");a.addSuggestion(new le(o,l).makeRequired())}if(e.dependentArgumentPath){n.getDeepField(e.dependentArgumentPath)?.markAsError();let[,l]=Or(e.dependentArgumentPath);r.addErrorMessage(u=>`Argument \`${u.green(o)}\` is required because argument \`${u.green(l)}\` was provided.`)}}}function ca(e){return e.kind==="list"?`${ca(e.elementType)}[]`:e.name}function $d(e,r){let t=e.argument.name,n=r.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();n&&n.getDeepFieldValue(e.argumentPath)?.markAsError(),r.addErrorMessage(i=>{let o=In("or",e.argument.typeNames.map(s=>i.green(s)));return`Argument \`${i.bold(t)}\`: Invalid value provided. Expected ${o}, provided ${i.red(e.inferredType)}.`})}function qd(e,r){let t=e.argument.name,n=r.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();n&&n.getDeepFieldValue(e.argumentPath)?.markAsError(),r.addErrorMessage(i=>{let o=[`Invalid value for argument \`${i.bold(t)}\``];if(e.underlyingError&&o.push(`: ${e.underlyingError}`),o.push("."),e.argument.typeNames.length>0){let s=In("or",e.argument.typeNames.map(a=>i.green(a)));o.push(` Expected ${s}.`)}return o.join("")})}function Vd(e,r){let t=e.argument.name,n=r.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject(),i;if(n){let s=n.getDeepField(e.argumentPath)?.value;s?.markAsError(),s instanceof Q&&(i=s.text)}r.addErrorMessage(o=>{let s=["Unable to fit value"];return i&&s.push(o.red(i)),s.push(`into a 64-bit signed integer for field \`${o.bold(t)}\``),s.join(" ")})}function jd(e,r){let t=e.argumentPath[e.argumentPath.length-1],n=r.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(n){let i=n.getDeepFieldValue(e.argumentPath)?.asObject();i&&ma(i,e.inputType)}r.addErrorMessage(i=>{let o=[`Argument \`${i.bold(t)}\` of type ${i.bold(e.inputType.name)} needs`];return e.constraints.minFieldCount===1?e.constraints.requiredFields?o.push(`${i.green("at least one of")} ${In("or",e.constraints.requiredFields.map(s=>`\`${i.bold(s)}\``))} arguments.`):o.push(`${i.green("at least one")} argument.`):o.push(`${i.green(`at least ${e.constraints.minFieldCount}`)} arguments.`),o.push(dt(i)),o.join(" ")})}function Bd(e,r){let t=e.argumentPath[e.argumentPath.length-1],n=r.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject(),i=[];if(n){let o=n.getDeepFieldValue(e.argumentPath)?.asObject();o&&(o.markAsError(),i=Object.keys(o.getFields()))}r.addErrorMessage(o=>{let s=[`Argument \`${o.bold(t)}\` of type ${o.bold(e.inputType.name)} needs`];return e.constraints.minFieldCount===1&&e.constraints.maxFieldCount==1?s.push(`${o.green("exactly one")} argument,`):e.constraints.maxFieldCount==1?s.push(`${o.green("at most one")} argument,`):s.push(`${o.green(`at most ${e.constraints.maxFieldCount}`)} arguments,`),s.push(`but you provided ${In("and",i.map(a=>o.red(a)))}. Please choose`),e.constraints.maxFieldCount===1?s.push("one."):s.push(`${e.constraints.maxFieldCount}.`),s.join(" ")})}function pa(e,r){for(let t of r.fields)e.hasField(t.name)||e.addSuggestion(new le(t.name,"true"))}function Ud(e,r){for(let t of r.fields)t.isRelation&&!e.hasField(t.name)&&e.addSuggestion(new le(t.name,"true"))}function Gd(e,r){for(let t of r.fields)!e.hasField(t.name)&&!t.isRelation&&e.addSuggestion(new le(t.name,"true"))}function Qd(e,r){for(let t of r)e.hasField(t.name)||e.addSuggestion(new le(t.name,t.typeNames.join(" | ")))}function da(e,r){let[t,n]=Or(e),i=r.arguments.getDeepSubSelectionValue(t)?.asObject();if(!i)return{parentKind:"unknown",fieldName:n};let o=i.getFieldValue("select")?.asObject(),s=i.getFieldValue("include")?.asObject(),a=i.getFieldValue("omit")?.asObject(),l=o?.getField(n);return o&&l?{parentKind:"select",parent:o,field:l,fieldName:n}:(l=s?.getField(n),s&&l?{parentKind:"include",field:l,parent:s,fieldName:n}:(l=a?.getField(n),a&&l?{parentKind:"omit",field:l,parent:a,fieldName:n}:{parentKind:"unknown",fieldName:n}))}function ma(e,r){if(r.kind==="object")for(let t of r.fields)e.hasField(t.name)||e.addSuggestion(new le(t.name,t.typeNames.join(" | ")))}function Or(e){let r=[...e],t=r.pop();if(!t)throw new Error("unexpected empty path");return[r,t]}function dt({green:e,enabled:r}){return"Available options are "+(r?`listed in ${e("green")}`:"marked with ?")+"."}function In(e,r){if(r.length===1)return r[0];let t=[...r],n=t.pop();return`${t.join(", ")} ${e} ${n}`}var Wd=3;function Jd(e,r){let t=1/0,n;for(let i of r){let o=(0,la.default)(e,i);o>Wd||o`}};function kr(e){return e instanceof mt}var Dn=Symbol(),Yi=new WeakMap,Me=class{constructor(r){r===Dn?Yi.set(this,`Prisma.${this._getName()}`):Yi.set(this,`new Prisma.${this._getNamespace()}.${this._getName()}()`)}_getName(){return this.constructor.name}toString(){return Yi.get(this)}},ft=class extends Me{_getNamespace(){return"NullTypes"}},gt=class extends ft{#e};zi(gt,"DbNull");var ht=class extends ft{#e};zi(ht,"JsonNull");var yt=class extends ft{#e};zi(yt,"AnyNull");var On={classes:{DbNull:gt,JsonNull:ht,AnyNull:yt},instances:{DbNull:new gt(Dn),JsonNull:new ht(Dn),AnyNull:new yt(Dn)}};function zi(e,r){Object.defineProperty(e,"name",{value:r,configurable:!0})}var fa=": ",kn=class{constructor(r,t){this.name=r;this.value=t}hasError=!1;markAsError(){this.hasError=!0}getPrintWidth(){return this.name.length+this.value.getPrintWidth()+fa.length}write(r){let t=new Pe(this.name);this.hasError&&t.underline().setColor(r.context.colors.red),r.write(t).write(fa).write(this.value)}};var Zi=class{arguments;errorMessages=[];constructor(r){this.arguments=r}write(r){r.write(this.arguments)}addErrorMessage(r){this.errorMessages.push(r)}renderAllMessages(r){return this.errorMessages.map(t=>t(r)).join(` -`)}};function _r(e){return new Zi(ga(e))}function ga(e){let r=new Dr;for(let[t,n]of Object.entries(e)){let i=new kn(t,ha(n));r.addField(i)}return r}function ha(e){if(typeof e=="string")return new Q(JSON.stringify(e));if(typeof e=="number"||typeof e=="boolean")return new Q(String(e));if(typeof e=="bigint")return new Q(`${e}n`);if(e===null)return new Q("null");if(e===void 0)return new Q("undefined");if(Sr(e))return new Q(`new Prisma.Decimal("${e.toFixed()}")`);if(e instanceof Uint8Array)return Buffer.isBuffer(e)?new Q(`Buffer.alloc(${e.byteLength})`):new Q(`new Uint8Array(${e.byteLength})`);if(e instanceof Date){let r=mn(e)?e.toISOString():"Invalid Date";return new Q(`new Date("${r}")`)}return e instanceof Me?new Q(`Prisma.${e._getName()}`):kr(e)?new Q(`prisma.${We(e.modelName)}.$fields.${e.name}`):Array.isArray(e)?Kd(e):typeof e=="object"?ga(e):new Q(Object.prototype.toString.call(e))}function Kd(e){let r=new Ir;for(let t of e)r.addItem(ha(t));return r}function _n(e,r){let t=r==="pretty"?aa:Cn,n=e.renderAllMessages(t),i=new Ar(0,{colors:t}).write(e).toString();return{message:n,args:i}}function Nn({args:e,errors:r,errorFormat:t,callsite:n,originalMethod:i,clientVersion:o,globalOmit:s}){let a=_r(e);for(let p of r)Sn(p,a,s);let{message:l,args:u}=_n(a,t),c=Tn({message:l,callsite:n,originalMethod:i,showColors:t==="pretty",callArguments:u});throw new Z(c,{clientVersion:o})}function Te(e){return e.replace(/^./,r=>r.toLowerCase())}function ba(e,r,t){let n=Te(t);return!r.result||!(r.result.$allModels||r.result[n])?e:Hd({...e,...ya(r.name,e,r.result.$allModels),...ya(r.name,e,r.result[n])})}function Hd(e){let r=new we,t=(n,i)=>r.getOrCreate(n,()=>i.has(n)?[n]:(i.add(n),e[n]?e[n].needs.flatMap(o=>t(o,i)):[n]));return pn(e,n=>({...n,needs:t(n.name,new Set)}))}function ya(e,r,t){return t?pn(t,({needs:n,compute:i},o)=>({name:o,needs:n?Object.keys(n).filter(s=>n[s]):[],compute:Yd(r,o,i)})):{}}function Yd(e,r,t){let n=e?.[r]?.compute;return n?i=>t({...i,[r]:n(i)}):t}function Ea(e,r){if(!r)return e;let t={...e};for(let n of Object.values(r))if(e[n.name])for(let i of n.needs)t[i]=!0;return t}function wa(e,r){if(!r)return e;let t={...e};for(let n of Object.values(r))if(!e[n.name])for(let i of n.needs)delete t[i];return t}var Ln=class{constructor(r,t){this.extension=r;this.previous=t}computedFieldsCache=new we;modelExtensionsCache=new we;queryCallbacksCache=new we;clientExtensions=lt(()=>this.extension.client?{...this.previous?.getAllClientExtensions(),...this.extension.client}:this.previous?.getAllClientExtensions());batchCallbacks=lt(()=>{let r=this.previous?.getAllBatchQueryCallbacks()??[],t=this.extension.query?.$__internalBatch;return t?r.concat(t):r});getAllComputedFields(r){return this.computedFieldsCache.getOrCreate(r,()=>ba(this.previous?.getAllComputedFields(r),this.extension,r))}getAllClientExtensions(){return this.clientExtensions.get()}getAllModelExtensions(r){return this.modelExtensionsCache.getOrCreate(r,()=>{let t=Te(r);return!this.extension.model||!(this.extension.model[t]||this.extension.model.$allModels)?this.previous?.getAllModelExtensions(r):{...this.previous?.getAllModelExtensions(r),...this.extension.model.$allModels,...this.extension.model[t]}})}getAllQueryCallbacks(r,t){return this.queryCallbacksCache.getOrCreate(`${r}:${t}`,()=>{let n=this.previous?.getAllQueryCallbacks(r,t)??[],i=[],o=this.extension.query;return!o||!(o[r]||o.$allModels||o[t]||o.$allOperations)?n:(o[r]!==void 0&&(o[r][t]!==void 0&&i.push(o[r][t]),o[r].$allOperations!==void 0&&i.push(o[r].$allOperations)),r!=="$none"&&o.$allModels!==void 0&&(o.$allModels[t]!==void 0&&i.push(o.$allModels[t]),o.$allModels.$allOperations!==void 0&&i.push(o.$allModels.$allOperations)),o[t]!==void 0&&i.push(o[t]),o.$allOperations!==void 0&&i.push(o.$allOperations),n.concat(i))})}getAllBatchQueryCallbacks(){return this.batchCallbacks.get()}},Nr=class e{constructor(r){this.head=r}static empty(){return new e}static single(r){return new e(new Ln(r))}isEmpty(){return this.head===void 0}append(r){return new e(new Ln(r,this.head))}getAllComputedFields(r){return this.head?.getAllComputedFields(r)}getAllClientExtensions(){return this.head?.getAllClientExtensions()}getAllModelExtensions(r){return this.head?.getAllModelExtensions(r)}getAllQueryCallbacks(r,t){return this.head?.getAllQueryCallbacks(r,t)??[]}getAllBatchQueryCallbacks(){return this.head?.getAllBatchQueryCallbacks()??[]}};var Fn=class{constructor(r){this.name=r}};function xa(e){return e instanceof Fn}function va(e){return new Fn(e)}var Pa=Symbol(),bt=class{constructor(r){if(r!==Pa)throw new Error("Skip instance can not be constructed directly")}ifUndefined(r){return r===void 0?Mn:r}},Mn=new bt(Pa);function Se(e){return e instanceof bt}var zd={findUnique:"findUnique",findUniqueOrThrow:"findUniqueOrThrow",findFirst:"findFirst",findFirstOrThrow:"findFirstOrThrow",findMany:"findMany",count:"aggregate",create:"createOne",createMany:"createMany",createManyAndReturn:"createManyAndReturn",update:"updateOne",updateMany:"updateMany",updateManyAndReturn:"updateManyAndReturn",upsert:"upsertOne",delete:"deleteOne",deleteMany:"deleteMany",executeRaw:"executeRaw",queryRaw:"queryRaw",aggregate:"aggregate",groupBy:"groupBy",runCommandRaw:"runCommandRaw",findRaw:"findRaw",aggregateRaw:"aggregateRaw"},Ta="explicitly `undefined` values are not allowed";function $n({modelName:e,action:r,args:t,runtimeDataModel:n,extensions:i=Nr.empty(),callsite:o,clientMethod:s,errorFormat:a,clientVersion:l,previewFeatures:u,globalOmit:c}){let p=new Xi({runtimeDataModel:n,modelName:e,action:r,rootArgs:t,callsite:o,extensions:i,selectionPath:[],argumentPath:[],originalMethod:s,errorFormat:a,clientVersion:l,previewFeatures:u,globalOmit:c});return{modelName:e,action:zd[r],query:Et(t,p)}}function Et({select:e,include:r,...t}={},n){let i=t.omit;return delete t.omit,{arguments:Ra(t,n),selection:Zd(e,r,i,n)}}function Zd(e,r,t,n){return e?(r?n.throwValidationError({kind:"MutuallyExclusiveFields",firstField:"include",secondField:"select",selectionPath:n.getSelectionPath()}):t&&n.throwValidationError({kind:"MutuallyExclusiveFields",firstField:"omit",secondField:"select",selectionPath:n.getSelectionPath()}),tm(e,n)):Xd(n,r,t)}function Xd(e,r,t){let n={};return e.modelOrType&&!e.isRawAction()&&(n.$composites=!0,n.$scalars=!0),r&&em(n,r,e),rm(n,t,e),n}function em(e,r,t){for(let[n,i]of Object.entries(r)){if(Se(i))continue;let o=t.nestSelection(n);if(eo(i,o),i===!1||i===void 0){e[n]=!1;continue}let s=t.findField(n);if(s&&s.kind!=="object"&&t.throwValidationError({kind:"IncludeOnScalar",selectionPath:t.getSelectionPath().concat(n),outputType:t.getOutputTypeDescription()}),s){e[n]=Et(i===!0?{}:i,o);continue}if(i===!0){e[n]=!0;continue}e[n]=Et(i,o)}}function rm(e,r,t){let n=t.getComputedFields(),i={...t.getGlobalOmit(),...r},o=wa(i,n);for(let[s,a]of Object.entries(o)){if(Se(a))continue;eo(a,t.nestSelection(s));let l=t.findField(s);n?.[s]&&!l||(e[s]=!a)}}function tm(e,r){let t={},n=r.getComputedFields(),i=Ea(e,n);for(let[o,s]of Object.entries(i)){if(Se(s))continue;let a=r.nestSelection(o);eo(s,a);let l=r.findField(o);if(!(n?.[o]&&!l)){if(s===!1||s===void 0||Se(s)){t[o]=!1;continue}if(s===!0){l?.kind==="object"?t[o]=Et({},a):t[o]=!0;continue}t[o]=Et(s,a)}}return t}function Sa(e,r){if(e===null)return null;if(typeof e=="string"||typeof e=="number"||typeof e=="boolean")return e;if(typeof e=="bigint")return{$type:"BigInt",value:String(e)};if(vr(e)){if(mn(e))return{$type:"DateTime",value:e.toISOString()};r.throwValidationError({kind:"InvalidArgumentValue",selectionPath:r.getSelectionPath(),argumentPath:r.getArgumentPath(),argument:{name:r.getArgumentName(),typeNames:["Date"]},underlyingError:"Provided Date object is invalid"})}if(xa(e))return{$type:"Param",value:e.name};if(kr(e))return{$type:"FieldRef",value:{_ref:e.name,_container:e.modelName}};if(Array.isArray(e))return nm(e,r);if(ArrayBuffer.isView(e)){let{buffer:t,byteOffset:n,byteLength:i}=e;return{$type:"Bytes",value:Buffer.from(t,n,i).toString("base64")}}if(im(e))return e.values;if(Sr(e))return{$type:"Decimal",value:e.toFixed()};if(e instanceof Me){if(e!==On.instances[e._getName()])throw new Error("Invalid ObjectEnumValue");return{$type:"Enum",value:e._getName()}}if(om(e))return e.toJSON();if(typeof e=="object")return Ra(e,r);r.throwValidationError({kind:"InvalidArgumentValue",selectionPath:r.getSelectionPath(),argumentPath:r.getArgumentPath(),argument:{name:r.getArgumentName(),typeNames:[]},underlyingError:`We could not serialize ${Object.prototype.toString.call(e)} value. Serialize the object to JSON or implement a ".toJSON()" method on it`})}function Ra(e,r){if(e.$type)return{$type:"Raw",value:e};let t={};for(let n in e){let i=e[n],o=r.nestArgument(n);Se(i)||(i!==void 0?t[n]=Sa(i,o):r.isPreviewFeatureOn("strictUndefinedChecks")&&r.throwValidationError({kind:"InvalidArgumentValue",argumentPath:o.getArgumentPath(),selectionPath:r.getSelectionPath(),argument:{name:r.getArgumentName(),typeNames:[]},underlyingError:Ta}))}return t}function nm(e,r){let t=[];for(let n=0;n({name:r.name,typeName:"boolean",isRelation:r.kind==="object"}))}}isRawAction(){return["executeRaw","queryRaw","runCommandRaw","findRaw","aggregateRaw"].includes(this.params.action)}isPreviewFeatureOn(r){return this.params.previewFeatures.includes(r)}getComputedFields(){if(this.params.modelName)return this.params.extensions.getAllComputedFields(this.params.modelName)}findField(r){return this.modelOrType?.fields.find(t=>t.name===r)}nestSelection(r){let t=this.findField(r),n=t?.kind==="object"?t.type:void 0;return new e({...this.params,modelName:n,selectionPath:this.params.selectionPath.concat(r)})}getGlobalOmit(){return this.params.modelName&&this.shouldApplyGlobalOmit()?this.params.globalOmit?.[We(this.params.modelName)]??{}:{}}shouldApplyGlobalOmit(){switch(this.params.action){case"findFirst":case"findFirstOrThrow":case"findUniqueOrThrow":case"findMany":case"upsert":case"findUnique":case"createManyAndReturn":case"create":case"update":case"updateManyAndReturn":case"delete":return!0;case"executeRaw":case"aggregateRaw":case"runCommandRaw":case"findRaw":case"createMany":case"deleteMany":case"groupBy":case"updateMany":case"count":case"aggregate":case"queryRaw":return!1;default:ar(this.params.action,"Unknown action")}}nestArgument(r){return new e({...this.params,argumentPath:this.params.argumentPath.concat(r)})}};function Aa(e){if(!e._hasPreviewFlag("metrics"))throw new Z("`metrics` preview feature must be enabled in order to access metrics API",{clientVersion:e._clientVersion})}var Lr=class{_client;constructor(r){this._client=r}prometheus(r){return Aa(this._client),this._client._engine.metrics({format:"prometheus",...r})}json(r){return Aa(this._client),this._client._engine.metrics({format:"json",...r})}};function Ca(e,r){let t=lt(()=>sm(r));Object.defineProperty(e,"dmmf",{get:()=>t.get()})}function sm(e){return{datamodel:{models:ro(e.models),enums:ro(e.enums),types:ro(e.types)}}}function ro(e){return Object.entries(e).map(([r,t])=>({name:r,...t}))}var to=new WeakMap,qn="$$PrismaTypedSql",wt=class{constructor(r,t){to.set(this,{sql:r,values:t}),Object.defineProperty(this,qn,{value:qn})}get sql(){return to.get(this).sql}get values(){return to.get(this).values}};function Ia(e){return(...r)=>new wt(e,r)}function Vn(e){return e!=null&&e[qn]===qn}var cu=O(Ti());var pu=require("node:async_hooks"),du=require("node:events"),mu=O(require("node:fs")),ri=O(require("node:path"));var ie=class e{constructor(r,t){if(r.length-1!==t.length)throw r.length===0?new TypeError("Expected at least 1 string"):new TypeError(`Expected ${r.length} strings to have ${r.length-1} values`);let n=t.reduce((s,a)=>s+(a instanceof e?a.values.length:1),0);this.values=new Array(n),this.strings=new Array(n+1),this.strings[0]=r[0];let i=0,o=0;for(;ie.getPropertyValue(t))},getPropertyDescriptor(t){return e.getPropertyDescriptor?.(t)}}}var jn={enumerable:!0,configurable:!0,writable:!0};function Bn(e){let r=new Set(e);return{getPrototypeOf:()=>Object.prototype,getOwnPropertyDescriptor:()=>jn,has:(t,n)=>r.has(n),set:(t,n,i)=>r.add(n)&&Reflect.set(t,n,i),ownKeys:()=>[...r]}}var ka=Symbol.for("nodejs.util.inspect.custom");function he(e,r){let t=am(r),n=new Set,i=new Proxy(e,{get(o,s){if(n.has(s))return o[s];let a=t.get(s);return a?a.getPropertyValue(s):o[s]},has(o,s){if(n.has(s))return!0;let a=t.get(s);return a?a.has?.(s)??!0:Reflect.has(o,s)},ownKeys(o){let s=_a(Reflect.ownKeys(o),t),a=_a(Array.from(t.keys()),t);return[...new Set([...s,...a,...n])]},set(o,s,a){return t.get(s)?.getPropertyDescriptor?.(s)?.writable===!1?!1:(n.add(s),Reflect.set(o,s,a))},getOwnPropertyDescriptor(o,s){let a=Reflect.getOwnPropertyDescriptor(o,s);if(a&&!a.configurable)return a;let l=t.get(s);return l?l.getPropertyDescriptor?{...jn,...l?.getPropertyDescriptor(s)}:jn:a},defineProperty(o,s,a){return n.add(s),Reflect.defineProperty(o,s,a)},getPrototypeOf:()=>Object.prototype});return i[ka]=function(){let o={...this};return delete o[ka],o},i}function am(e){let r=new Map;for(let t of e){let n=t.getKeys();for(let i of n)r.set(i,t)}return r}function _a(e,r){return e.filter(t=>r.get(t)?.has?.(t)??!0)}function Fr(e){return{getKeys(){return e},has(){return!1},getPropertyValue(){}}}function Mr(e,r){return{batch:e,transaction:r?.kind==="batch"?{isolationLevel:r.options.isolationLevel}:void 0}}function Na(e){if(e===void 0)return"";let r=_r(e);return new Ar(0,{colors:Cn}).write(r).toString()}var lm="P2037";function $r({error:e,user_facing_error:r},t,n){return r.error_code?new z(um(r,n),{code:r.error_code,clientVersion:t,meta:r.meta,batchRequestIdx:r.batch_request_idx}):new V(e,{clientVersion:t,batchRequestIdx:r.batch_request_idx})}function um(e,r){let t=e.message;return(r==="postgresql"||r==="postgres"||r==="mysql")&&e.error_code===lm&&(t+=` -Prisma Accelerate has built-in connection pooling to prevent such errors: https://pris.ly/client/error-accelerate`),t}var vt="";function La(e){var r=e.split(` -`);return r.reduce(function(t,n){var i=dm(n)||fm(n)||ym(n)||xm(n)||Em(n);return i&&t.push(i),t},[])}var cm=/^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack|rsc||\/|[a-z]:\\|\\\\).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i,pm=/\((\S*)(?::(\d+))(?::(\d+))\)/;function dm(e){var r=cm.exec(e);if(!r)return null;var t=r[2]&&r[2].indexOf("native")===0,n=r[2]&&r[2].indexOf("eval")===0,i=pm.exec(r[2]);return n&&i!=null&&(r[2]=i[1],r[3]=i[2],r[4]=i[3]),{file:t?null:r[2],methodName:r[1]||vt,arguments:t?[r[2]]:[],lineNumber:r[3]?+r[3]:null,column:r[4]?+r[4]:null}}var mm=/^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|rsc|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i;function fm(e){var r=mm.exec(e);return r?{file:r[2],methodName:r[1]||vt,arguments:[],lineNumber:+r[3],column:r[4]?+r[4]:null}:null}var gm=/^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|rsc|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i,hm=/(\S+) line (\d+)(?: > eval line \d+)* > eval/i;function ym(e){var r=gm.exec(e);if(!r)return null;var t=r[3]&&r[3].indexOf(" > eval")>-1,n=hm.exec(r[3]);return t&&n!=null&&(r[3]=n[1],r[4]=n[2],r[5]=null),{file:r[3],methodName:r[1]||vt,arguments:r[2]?r[2].split(","):[],lineNumber:r[4]?+r[4]:null,column:r[5]?+r[5]:null}}var bm=/^\s*(?:([^@]*)(?:\((.*?)\))?@)?(\S.*?):(\d+)(?::(\d+))?\s*$/i;function Em(e){var r=bm.exec(e);return r?{file:r[3],methodName:r[1]||vt,arguments:[],lineNumber:+r[4],column:r[5]?+r[5]:null}:null}var wm=/^\s*at (?:((?:\[object object\])?[^\\/]+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$/i;function xm(e){var r=wm.exec(e);return r?{file:r[2],methodName:r[1]||vt,arguments:[],lineNumber:+r[3],column:r[4]?+r[4]:null}:null}var oo=class{getLocation(){return null}},so=class{_error;constructor(){this._error=new Error}getLocation(){let r=this._error.stack;if(!r)return null;let n=La(r).find(i=>{if(!i.file)return!1;let o=Li(i.file);return o!==""&&!o.includes("@prisma")&&!o.includes("/packages/client/src/runtime/")&&!o.endsWith("/runtime/binary.js")&&!o.endsWith("/runtime/library.js")&&!o.endsWith("/runtime/edge.js")&&!o.endsWith("/runtime/edge-esm.js")&&!o.startsWith("internal/")&&!i.methodName.includes("new ")&&!i.methodName.includes("getCallSite")&&!i.methodName.includes("Proxy.")&&i.methodName.split(".").length<4});return!n||!n.file?null:{fileName:n.file,lineNumber:n.lineNumber,columnNumber:n.column}}};function Ze(e){return e==="minimal"?typeof $EnabledCallSite=="function"&&e!=="minimal"?new $EnabledCallSite:new oo:new so}var Fa={_avg:!0,_count:!0,_sum:!0,_min:!0,_max:!0};function qr(e={}){let r=Pm(e);return Object.entries(r).reduce((n,[i,o])=>(Fa[i]!==void 0?n.select[i]={select:o}:n[i]=o,n),{select:{}})}function Pm(e={}){return typeof e._count=="boolean"?{...e,_count:{_all:e._count}}:e}function Un(e={}){return r=>(typeof e._count=="boolean"&&(r._count=r._count._all),r)}function Ma(e,r){let t=Un(e);return r({action:"aggregate",unpacker:t,argsMapper:qr})(e)}function Tm(e={}){let{select:r,...t}=e;return typeof r=="object"?qr({...t,_count:r}):qr({...t,_count:{_all:!0}})}function Sm(e={}){return typeof e.select=="object"?r=>Un(e)(r)._count:r=>Un(e)(r)._count._all}function $a(e,r){return r({action:"count",unpacker:Sm(e),argsMapper:Tm})(e)}function Rm(e={}){let r=qr(e);if(Array.isArray(r.by))for(let t of r.by)typeof t=="string"&&(r.select[t]=!0);else typeof r.by=="string"&&(r.select[r.by]=!0);return r}function Am(e={}){return r=>(typeof e?._count=="boolean"&&r.forEach(t=>{t._count=t._count._all}),r)}function qa(e,r){return r({action:"groupBy",unpacker:Am(e),argsMapper:Rm})(e)}function Va(e,r,t){if(r==="aggregate")return n=>Ma(n,t);if(r==="count")return n=>$a(n,t);if(r==="groupBy")return n=>qa(n,t)}function ja(e,r){let t=r.fields.filter(i=>!i.relationName),n=_s(t,"name");return new Proxy({},{get(i,o){if(o in i||typeof o=="symbol")return i[o];let s=n[o];if(s)return new mt(e,o,s.type,s.isList,s.kind==="enum")},...Bn(Object.keys(n))})}var Ba=e=>Array.isArray(e)?e:e.split("."),ao=(e,r)=>Ba(r).reduce((t,n)=>t&&t[n],e),Ua=(e,r,t)=>Ba(r).reduceRight((n,i,o,s)=>Object.assign({},ao(e,s.slice(0,o)),{[i]:n}),t);function Cm(e,r){return e===void 0||r===void 0?[]:[...r,"select",e]}function Im(e,r,t){return r===void 0?e??{}:Ua(r,t,e||!0)}function lo(e,r,t,n,i,o){let a=e._runtimeDataModel.models[r].fields.reduce((l,u)=>({...l,[u.name]:u}),{});return l=>{let u=Ze(e._errorFormat),c=Cm(n,i),p=Im(l,o,c),d=t({dataPath:c,callsite:u})(p),f=Dm(e,r);return new Proxy(d,{get(h,g){if(!f.includes(g))return h[g];let T=[a[g].type,t,g],S=[c,p];return lo(e,...T,...S)},...Bn([...f,...Object.getOwnPropertyNames(d)])})}}function Dm(e,r){return e._runtimeDataModel.models[r].fields.filter(t=>t.kind==="object").map(t=>t.name)}var Om=["findUnique","findUniqueOrThrow","findFirst","findFirstOrThrow","create","update","upsert","delete"],km=["aggregate","count","groupBy"];function uo(e,r){let t=e._extensions.getAllModelExtensions(r)??{},n=[_m(e,r),Lm(e,r),xt(t),re("name",()=>r),re("$name",()=>r),re("$parent",()=>e._appliedParent)];return he({},n)}function _m(e,r){let t=Te(r),n=Object.keys(Rr).concat("count");return{getKeys(){return n},getPropertyValue(i){let o=i,s=a=>l=>{let u=Ze(e._errorFormat);return e._createPrismaPromise(c=>{let p={args:l,dataPath:[],action:o,model:r,clientMethod:`${t}.${i}`,jsModelName:t,transaction:c,callsite:u};return e._request({...p,...a})},{action:o,args:l,model:r})};return Om.includes(o)?lo(e,r,s):Nm(i)?Va(e,i,s):s({})}}}function Nm(e){return km.includes(e)}function Lm(e,r){return lr(re("fields",()=>{let t=e._runtimeDataModel.models[r];return ja(r,t)}))}function Ga(e){return e.replace(/^./,r=>r.toUpperCase())}var co=Symbol();function Pt(e){let r=[Fm(e),Mm(e),re(co,()=>e),re("$parent",()=>e._appliedParent)],t=e._extensions.getAllClientExtensions();return t&&r.push(xt(t)),he(e,r)}function Fm(e){let r=Object.getPrototypeOf(e._originalClient),t=[...new Set(Object.getOwnPropertyNames(r))];return{getKeys(){return t},getPropertyValue(n){return e[n]}}}function Mm(e){let r=Object.keys(e._runtimeDataModel.models),t=r.map(Te),n=[...new Set(r.concat(t))];return lr({getKeys(){return n},getPropertyValue(i){let o=Ga(i);if(e._runtimeDataModel.models[o]!==void 0)return uo(e,o);if(e._runtimeDataModel.models[i]!==void 0)return uo(e,i)},getPropertyDescriptor(i){if(!t.includes(i))return{enumerable:!1}}})}function Qa(e){return e[co]?e[co]:e}function Wa(e){if(typeof e=="function")return e(this);if(e.client?.__AccelerateEngine){let t=e.client.__AccelerateEngine;this._originalClient._engine=new t(this._originalClient._accelerateEngineConfig)}let r=Object.create(this._originalClient,{_extensions:{value:this._extensions.append(e)},_appliedParent:{value:this,configurable:!0},$on:{value:void 0}});return Pt(r)}function Ja({result:e,modelName:r,select:t,omit:n,extensions:i}){let o=i.getAllComputedFields(r);if(!o)return e;let s=[],a=[];for(let l of Object.values(o)){if(n){if(n[l.name])continue;let u=l.needs.filter(c=>n[c]);u.length>0&&a.push(Fr(u))}else if(t){if(!t[l.name])continue;let u=l.needs.filter(c=>!t[c]);u.length>0&&a.push(Fr(u))}$m(e,l.needs)&&s.push(qm(l,he(e,s)))}return s.length>0||a.length>0?he(e,[...s,...a]):e}function $m(e,r){return r.every(t=>Vi(e,t))}function qm(e,r){return lr(re(e.name,()=>e.compute(r)))}function Gn({visitor:e,result:r,args:t,runtimeDataModel:n,modelName:i}){if(Array.isArray(r)){for(let s=0;sc.name===o);if(!l||l.kind!=="object"||!l.relationName)continue;let u=typeof s=="object"?s:{};r[o]=Gn({visitor:i,result:r[o],args:u,modelName:l.type,runtimeDataModel:n})}}function Ha({result:e,modelName:r,args:t,extensions:n,runtimeDataModel:i,globalOmit:o}){return n.isEmpty()||e==null||typeof e!="object"||!i.models[r]?e:Gn({result:e,args:t??{},modelName:r,runtimeDataModel:i,visitor:(a,l,u)=>{let c=Te(l);return Ja({result:a,modelName:c,select:u.select,omit:u.select?void 0:{...o?.[c],...u.omit},extensions:n})}})}var Vm=["$connect","$disconnect","$on","$transaction","$extends"],Ya=Vm;function za(e){if(e instanceof ie)return jm(e);if(Vn(e))return Bm(e);if(Array.isArray(e)){let t=[e[0]];for(let n=1;n{let o=r.customDataProxyFetch;return"transaction"in r&&i!==void 0&&(r.transaction?.kind==="batch"&&r.transaction.lock.then(),r.transaction=i),n===t.length?e._executeRequest(r):t[n]({model:r.model,operation:r.model?r.action:r.clientMethod,args:za(r.args??{}),__internalParams:r,query:(s,a=r)=>{let l=a.customDataProxyFetch;return a.customDataProxyFetch=nl(o,l),a.args=s,Xa(e,a,t,n+1)}})})}function el(e,r){let{jsModelName:t,action:n,clientMethod:i}=r,o=t?n:i;if(e._extensions.isEmpty())return e._executeRequest(r);let s=e._extensions.getAllQueryCallbacks(t??"$none",o);return Xa(e,r,s)}function rl(e){return r=>{let t={requests:r},n=r[0].extensions.getAllBatchQueryCallbacks();return n.length?tl(t,n,0,e):e(t)}}function tl(e,r,t,n){if(t===r.length)return n(e);let i=e.customDataProxyFetch,o=e.requests[0].transaction;return r[t]({args:{queries:e.requests.map(s=>({model:s.modelName,operation:s.action,args:s.args})),transaction:o?{isolationLevel:o.kind==="batch"?o.isolationLevel:void 0}:void 0},__internalParams:e,query(s,a=e){let l=a.customDataProxyFetch;return a.customDataProxyFetch=nl(i,l),tl(a,r,t+1,n)}})}var Za=e=>e;function nl(e=Za,r=Za){return t=>e(r(t))}var il=N("prisma:client"),ol={Vercel:"vercel","Netlify CI":"netlify"};function sl({postinstall:e,ciName:r,clientVersion:t,generator:n}){if(il("checkPlatformCaching:postinstall",e),il("checkPlatformCaching:ciName",r),e===!0&&!(n?.output&&typeof(n.output.fromEnvVar??n.output.value)=="string")&&r&&r in ol){let i=`Prisma has detected that this project was built on ${r}, which caches dependencies. This leads to an outdated Prisma Client because Prisma's auto-generation isn't triggered. To fix this, make sure to run the \`prisma generate\` command during the build process. - -Learn how: https://pris.ly/d/${ol[r]}-build`;throw console.error(i),new P(i,t)}}function al(e,r){return e?e.datasources?e.datasources:e.datasourceUrl?{[r[0]]:{url:e.datasourceUrl}}:{}:{}}var dl=O(require("node:fs")),St=O(require("node:path"));function Qn(e){let{runtimeBinaryTarget:r}=e;return`Add "${r}" to \`binaryTargets\` in the "schema.prisma" file and run \`prisma generate\` after saving it: - -${Um(e)}`}function Um(e){let{generator:r,generatorBinaryTargets:t,runtimeBinaryTarget:n}=e,i={fromEnvVar:null,value:n},o=[...t,i];return ki({...r,binaryTargets:o})}function Xe(e){let{runtimeBinaryTarget:r}=e;return`Prisma Client could not locate the Query Engine for runtime "${r}".`}function er(e){let{searchedLocations:r}=e;return`The following locations have been searched: -${[...new Set(r)].map(i=>` ${i}`).join(` -`)}`}function ll(e){let{runtimeBinaryTarget:r}=e;return`${Xe(e)} - -This happened because \`binaryTargets\` have been pinned, but the actual deployment also required "${r}". -${Qn(e)} - -${er(e)}`}function Wn(e){return`We would appreciate if you could take the time to share some information with us. -Please help us by answering a few questions: https://pris.ly/${e}`}function Jn(e){let{errorStack:r}=e;return r?.match(/\/\.next|\/next@|\/next\//)?` - -We detected that you are using Next.js, learn how to fix this: https://pris.ly/d/engine-not-found-nextjs.`:""}function ul(e){let{queryEngineName:r}=e;return`${Xe(e)}${Jn(e)} - -This is likely caused by a bundler that has not copied "${r}" next to the resulting bundle. -Ensure that "${r}" has been copied next to the bundle or in "${e.expectedLocation}". - -${Wn("engine-not-found-bundler-investigation")} - -${er(e)}`}function cl(e){let{runtimeBinaryTarget:r,generatorBinaryTargets:t}=e,n=t.find(i=>i.native);return`${Xe(e)} - -This happened because Prisma Client was generated for "${n?.value??"unknown"}", but the actual deployment required "${r}". -${Qn(e)} - -${er(e)}`}function pl(e){let{queryEngineName:r}=e;return`${Xe(e)}${Jn(e)} - -This is likely caused by tooling that has not copied "${r}" to the deployment folder. -Ensure that you ran \`prisma generate\` and that "${r}" has been copied to "${e.expectedLocation}". - -${Wn("engine-not-found-tooling-investigation")} - -${er(e)}`}var Gm=N("prisma:client:engines:resolveEnginePath"),Qm=()=>new RegExp("runtime[\\\\/]library\\.m?js$");async function ml(e,r){let t={binary:process.env.PRISMA_QUERY_ENGINE_BINARY,library:process.env.PRISMA_QUERY_ENGINE_LIBRARY}[e]??r.prismaPath;if(t!==void 0)return t;let{enginePath:n,searchedLocations:i}=await Wm(e,r);if(Gm("enginePath",n),n!==void 0&&e==="binary"&&Ri(n),n!==void 0)return r.prismaPath=n;let o=await ir(),s=r.generator?.binaryTargets??[],a=s.some(d=>d.native),l=!s.some(d=>d.value===o),u=__filename.match(Qm())===null,c={searchedLocations:i,generatorBinaryTargets:s,generator:r.generator,runtimeBinaryTarget:o,queryEngineName:fl(e,o),expectedLocation:St.default.relative(process.cwd(),r.dirname),errorStack:new Error().stack},p;throw a&&l?p=cl(c):l?p=ll(c):u?p=ul(c):p=pl(c),new P(p,r.clientVersion)}async function Wm(e,r){let t=await ir(),n=[],i=[r.dirname,St.default.resolve(__dirname,".."),r.generator?.output?.value??__dirname,St.default.resolve(__dirname,"../../../.prisma/client"),"/tmp/prisma-engines",r.cwd];__filename.includes("resolveEnginePath")&&i.push(ms());for(let o of i){let s=fl(e,t),a=St.default.join(o,s);if(n.push(o),dl.default.existsSync(a))return{enginePath:a,searchedLocations:n}}return{enginePath:void 0,searchedLocations:n}}function fl(e,r){return e==="library"?Gt(r,"fs"):`query-engine-${r}${r==="windows"?".exe":""}`}function gl(e){return e?e.replace(/".*"/g,'"X"').replace(/[\s:\[]([+-]?([0-9]*[.])?[0-9]+)/g,r=>`${r[0]}5`):""}function hl(e){return e.split(` -`).map(r=>r.replace(/^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z)\s*/,"").replace(/\+\d+\s*ms$/,"")).join(` -`)}var yl=O(Os());function bl({title:e,user:r="prisma",repo:t="prisma",template:n="bug_report.yml",body:i}){return(0,yl.default)({user:r,repo:t,template:n,title:e,body:i})}function El({version:e,binaryTarget:r,title:t,description:n,engineVersion:i,database:o,query:s}){let a=Bo(6e3-(s?.length??0)),l=hl(wr(a)),u=n?`# Description -\`\`\` -${n} -\`\`\``:"",c=wr(`Hi Prisma Team! My Prisma Client just crashed. This is the report: -## Versions - -| Name | Version | -|-----------------|--------------------| -| Node | ${process.version?.padEnd(19)}| -| OS | ${r?.padEnd(19)}| -| Prisma Client | ${e?.padEnd(19)}| -| Query Engine | ${i?.padEnd(19)}| -| Database | ${o?.padEnd(19)}| - -${u} - -## Logs -\`\`\` -${l} -\`\`\` - -## Client Snippet -\`\`\`ts -// PLEASE FILL YOUR CODE SNIPPET HERE -\`\`\` - -## Schema -\`\`\`prisma -// PLEASE ADD YOUR SCHEMA HERE IF POSSIBLE -\`\`\` - -## Prisma Engine Query -\`\`\` -${s?gl(s):""} -\`\`\` -`),p=bl({title:t,body:c});return`${t} - -This is a non-recoverable error which probably happens when the Prisma Query Engine has a panic. - -${Y(p)} - -If you want the Prisma team to look into it, please open the link above \u{1F64F} -To increase the chance of success, please post your schema and a snippet of -how you used Prisma Client in the issue. -`}function wl(e,r){throw new Error(r)}function Jm(e){return e!==null&&typeof e=="object"&&typeof e.$type=="string"}function Km(e,r){let t={};for(let n of Object.keys(e))t[n]=r(e[n],n);return t}function Vr(e){return e===null?e:Array.isArray(e)?e.map(Vr):typeof e=="object"?Jm(e)?Hm(e):e.constructor!==null&&e.constructor.name!=="Object"?e:Km(e,Vr):e}function Hm({$type:e,value:r}){switch(e){case"BigInt":return BigInt(r);case"Bytes":{let{buffer:t,byteOffset:n,byteLength:i}=Buffer.from(r,"base64");return new Uint8Array(t,n,i)}case"DateTime":return new Date(r);case"Decimal":return new Le(r);case"Json":return JSON.parse(r);default:wl(r,"Unknown tagged value")}}var xl="6.19.1";var zm=()=>globalThis.process?.release?.name==="node",Zm=()=>!!globalThis.Bun||!!globalThis.process?.versions?.bun,Xm=()=>!!globalThis.Deno,ef=()=>typeof globalThis.Netlify=="object",rf=()=>typeof globalThis.EdgeRuntime=="object",tf=()=>globalThis.navigator?.userAgent==="Cloudflare-Workers";function nf(){return[[ef,"netlify"],[rf,"edge-light"],[tf,"workerd"],[Xm,"deno"],[Zm,"bun"],[zm,"node"]].flatMap(t=>t[0]()?[t[1]]:[]).at(0)??""}var of={node:"Node.js",workerd:"Cloudflare Workers",deno:"Deno and Deno Deploy",netlify:"Netlify Edge Functions","edge-light":"Edge Runtime (Vercel Edge Functions, Vercel Edge Middleware, Next.js (Pages Router) Edge API Routes, Next.js (App Router) Edge Route Handlers or Next.js Middleware)"};function Kn(){let e=nf();return{id:e,prettyName:of[e]||e,isEdge:["workerd","deno","netlify","edge-light"].includes(e)}}function jr({inlineDatasources:e,overrideDatasources:r,env:t,clientVersion:n}){let i,o=Object.keys(e)[0],s=e[o]?.url,a=r[o]?.url;if(o===void 0?i=void 0:a?i=a:s?.value?i=s.value:s?.fromEnvVar&&(i=t[s.fromEnvVar]),s?.fromEnvVar!==void 0&&i===void 0)throw new P(`error: Environment variable not found: ${s.fromEnvVar}.`,n);if(i===void 0)throw new P("error: Missing URL environment variable, value, or override.",n);return i}var Hn=class extends Error{clientVersion;cause;constructor(r,t){super(r),this.clientVersion=t.clientVersion,this.cause=t.cause}get[Symbol.toStringTag](){return this.name}};var oe=class extends Hn{isRetryable;constructor(r,t){super(r,t),this.isRetryable=t.isRetryable??!0}};function R(e,r){return{...e,isRetryable:r}}var ur=class extends oe{name="InvalidDatasourceError";code="P6001";constructor(r,t){super(r,R(t,!1))}};x(ur,"InvalidDatasourceError");function vl(e){let r={clientVersion:e.clientVersion},t=Object.keys(e.inlineDatasources)[0],n=jr({inlineDatasources:e.inlineDatasources,overrideDatasources:e.overrideDatasources,clientVersion:e.clientVersion,env:{...e.env,...typeof process<"u"?process.env:{}}}),i;try{i=new URL(n)}catch{throw new ur(`Error validating datasource \`${t}\`: the URL must start with the protocol \`prisma://\``,r)}let{protocol:o,searchParams:s}=i;if(o!=="prisma:"&&o!==sn)throw new ur(`Error validating datasource \`${t}\`: the URL must start with the protocol \`prisma://\` or \`prisma+postgres://\``,r);let a=s.get("api_key");if(a===null||a.length<1)throw new ur(`Error validating datasource \`${t}\`: the URL must contain a valid API key`,r);let l=Ii(i)?"http:":"https:";process.env.TEST_CLIENT_ENGINE_REMOTE_EXECUTOR&&i.searchParams.has("use_http")&&(l="http:");let u=new URL(i.href.replace(o,l));return{apiKey:a,url:u}}var Pl=O(on()),Yn=class{apiKey;tracingHelper;logLevel;logQueries;engineHash;constructor({apiKey:r,tracingHelper:t,logLevel:n,logQueries:i,engineHash:o}){this.apiKey=r,this.tracingHelper=t,this.logLevel=n,this.logQueries=i,this.engineHash=o}build({traceparent:r,transactionId:t}={}){let n={Accept:"application/json",Authorization:`Bearer ${this.apiKey}`,"Content-Type":"application/json","Prisma-Engine-Hash":this.engineHash,"Prisma-Engine-Version":Pl.enginesVersion};this.tracingHelper.isEnabled()&&(n.traceparent=r??this.tracingHelper.getTraceParent()),t&&(n["X-Transaction-Id"]=t);let i=this.#e();return i.length>0&&(n["X-Capture-Telemetry"]=i.join(", ")),n}#e(){let r=[];return this.tracingHelper.isEnabled()&&r.push("tracing"),this.logLevel&&r.push(this.logLevel),this.logQueries&&r.push("query"),r}};function sf(e){return e[0]*1e3+e[1]/1e6}function po(e){return new Date(sf(e))}var Br=class extends oe{name="ForcedRetryError";code="P5001";constructor(r){super("This request must be retried",R(r,!0))}};x(Br,"ForcedRetryError");var cr=class extends oe{name="NotImplementedYetError";code="P5004";constructor(r,t){super(r,R(t,!1))}};x(cr,"NotImplementedYetError");var $=class extends oe{response;constructor(r,t){super(r,t),this.response=t.response;let n=this.response.headers.get("prisma-request-id");if(n){let i=`(The request id was: ${n})`;this.message=this.message+" "+i}}};var pr=class extends ${name="SchemaMissingError";code="P5005";constructor(r){super("Schema needs to be uploaded",R(r,!0))}};x(pr,"SchemaMissingError");var mo="This request could not be understood by the server",Rt=class extends ${name="BadRequestError";code="P5000";constructor(r,t,n){super(t||mo,R(r,!1)),n&&(this.code=n)}};x(Rt,"BadRequestError");var At=class extends ${name="HealthcheckTimeoutError";code="P5013";logs;constructor(r,t){super("Engine not started: healthcheck timeout",R(r,!0)),this.logs=t}};x(At,"HealthcheckTimeoutError");var Ct=class extends ${name="EngineStartupError";code="P5014";logs;constructor(r,t,n){super(t,R(r,!0)),this.logs=n}};x(Ct,"EngineStartupError");var It=class extends ${name="EngineVersionNotSupportedError";code="P5012";constructor(r){super("Engine version is not supported",R(r,!1))}};x(It,"EngineVersionNotSupportedError");var fo="Request timed out",Dt=class extends ${name="GatewayTimeoutError";code="P5009";constructor(r,t=fo){super(t,R(r,!1))}};x(Dt,"GatewayTimeoutError");var af="Interactive transaction error",Ot=class extends ${name="InteractiveTransactionError";code="P5015";constructor(r,t=af){super(t,R(r,!1))}};x(Ot,"InteractiveTransactionError");var lf="Request parameters are invalid",kt=class extends ${name="InvalidRequestError";code="P5011";constructor(r,t=lf){super(t,R(r,!1))}};x(kt,"InvalidRequestError");var go="Requested resource does not exist",_t=class extends ${name="NotFoundError";code="P5003";constructor(r,t=go){super(t,R(r,!1))}};x(_t,"NotFoundError");var ho="Unknown server error",Ur=class extends ${name="ServerError";code="P5006";logs;constructor(r,t,n){super(t||ho,R(r,!0)),this.logs=n}};x(Ur,"ServerError");var yo="Unauthorized, check your connection string",Nt=class extends ${name="UnauthorizedError";code="P5007";constructor(r,t=yo){super(t,R(r,!1))}};x(Nt,"UnauthorizedError");var bo="Usage exceeded, retry again later",Lt=class extends ${name="UsageExceededError";code="P5008";constructor(r,t=bo){super(t,R(r,!0))}};x(Lt,"UsageExceededError");async function uf(e){let r;try{r=await e.text()}catch{return{type:"EmptyError"}}try{let t=JSON.parse(r);if(typeof t=="string")switch(t){case"InternalDataProxyError":return{type:"DataProxyError",body:t};default:return{type:"UnknownTextError",body:t}}if(typeof t=="object"&&t!==null){if("is_panic"in t&&"message"in t&&"error_code"in t)return{type:"QueryEngineError",body:t};if("EngineNotStarted"in t||"InteractiveTransactionMisrouted"in t||"InvalidRequestError"in t){let n=Object.values(t)[0].reason;return typeof n=="string"&&!["SchemaMissing","EngineVersionNotSupported"].includes(n)?{type:"UnknownJsonError",body:t}:{type:"DataProxyError",body:t}}}return{type:"UnknownJsonError",body:t}}catch{return r===""?{type:"EmptyError"}:{type:"UnknownTextError",body:r}}}async function Ft(e,r){if(e.ok)return;let t={clientVersion:r,response:e},n=await uf(e);if(n.type==="QueryEngineError")throw new z(n.body.message,{code:n.body.error_code,clientVersion:r});if(n.type==="DataProxyError"){if(n.body==="InternalDataProxyError")throw new Ur(t,"Internal Data Proxy error");if("EngineNotStarted"in n.body){if(n.body.EngineNotStarted.reason==="SchemaMissing")return new pr(t);if(n.body.EngineNotStarted.reason==="EngineVersionNotSupported")throw new It(t);if("EngineStartupError"in n.body.EngineNotStarted.reason){let{msg:i,logs:o}=n.body.EngineNotStarted.reason.EngineStartupError;throw new Ct(t,i,o)}if("KnownEngineStartupError"in n.body.EngineNotStarted.reason){let{msg:i,error_code:o}=n.body.EngineNotStarted.reason.KnownEngineStartupError;throw new P(i,r,o)}if("HealthcheckTimeout"in n.body.EngineNotStarted.reason){let{logs:i}=n.body.EngineNotStarted.reason.HealthcheckTimeout;throw new At(t,i)}}if("InteractiveTransactionMisrouted"in n.body){let i={IDParseError:"Could not parse interactive transaction ID",NoQueryEngineFoundError:"Could not find Query Engine for the specified host and transaction ID",TransactionStartError:"Could not start interactive transaction"};throw new Ot(t,i[n.body.InteractiveTransactionMisrouted.reason])}if("InvalidRequestError"in n.body)throw new kt(t,n.body.InvalidRequestError.reason)}if(e.status===401||e.status===403)throw new Nt(t,Gr(yo,n));if(e.status===404)return new _t(t,Gr(go,n));if(e.status===429)throw new Lt(t,Gr(bo,n));if(e.status===504)throw new Dt(t,Gr(fo,n));if(e.status>=500)throw new Ur(t,Gr(ho,n));if(e.status>=400)throw new Rt(t,Gr(mo,n))}function Gr(e,r){return r.type==="EmptyError"?e:`${e}: ${JSON.stringify(r)}`}function Tl(e){let r=Math.pow(2,e)*50,t=Math.ceil(Math.random()*r)-Math.ceil(r/2),n=r+t;return new Promise(i=>setTimeout(()=>i(n),n))}var $e="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";function Sl(e){let r=new TextEncoder().encode(e),t="",n=r.byteLength,i=n%3,o=n-i,s,a,l,u,c;for(let p=0;p>18,a=(c&258048)>>12,l=(c&4032)>>6,u=c&63,t+=$e[s]+$e[a]+$e[l]+$e[u];return i==1?(c=r[o],s=(c&252)>>2,a=(c&3)<<4,t+=$e[s]+$e[a]+"=="):i==2&&(c=r[o]<<8|r[o+1],s=(c&64512)>>10,a=(c&1008)>>4,l=(c&15)<<2,t+=$e[s]+$e[a]+$e[l]+"="),t}function Rl(e){if(!!e.generator?.previewFeatures.some(t=>t.toLowerCase().includes("metrics")))throw new P("The `metrics` preview feature is not yet available with Accelerate.\nPlease remove `metrics` from the `previewFeatures` in your schema.\n\nMore information about Accelerate: https://pris.ly/d/accelerate",e.clientVersion)}var Al={"@prisma/debug":"workspace:*","@prisma/engines-version":"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7","@prisma/fetch-engine":"workspace:*","@prisma/get-platform":"workspace:*"};var Mt=class extends oe{name="RequestError";code="P5010";constructor(r,t){super(`Cannot fetch data from service: -${r}`,R(t,!0))}};x(Mt,"RequestError");async function dr(e,r,t=n=>n){let{clientVersion:n,...i}=r,o=t(fetch);try{return await o(e,i)}catch(s){let a=s.message??"Unknown error";throw new Mt(a,{clientVersion:n,cause:s})}}var pf=/^[1-9][0-9]*\.[0-9]+\.[0-9]+$/,Cl=N("prisma:client:dataproxyEngine");async function df(e,r){let t=Al["@prisma/engines-version"],n=r.clientVersion??"unknown";if(process.env.PRISMA_CLIENT_DATA_PROXY_CLIENT_VERSION||globalThis.PRISMA_CLIENT_DATA_PROXY_CLIENT_VERSION)return process.env.PRISMA_CLIENT_DATA_PROXY_CLIENT_VERSION||globalThis.PRISMA_CLIENT_DATA_PROXY_CLIENT_VERSION;if(e.includes("accelerate")&&n!=="0.0.0"&&n!=="in-memory")return n;let[i,o]=n?.split("-")??[];if(o===void 0&&pf.test(i))return i;if(o!==void 0||n==="0.0.0"||n==="in-memory"){let[s]=t.split("-")??[],[a,l,u]=s.split("."),c=mf(`<=${a}.${l}.${u}`),p=await dr(c,{clientVersion:n});if(!p.ok)throw new Error(`Failed to fetch stable Prisma version, unpkg.com status ${p.status} ${p.statusText}, response body: ${await p.text()||""}`);let d=await p.text();Cl("length of body fetched from unpkg.com",d.length);let f;try{f=JSON.parse(d)}catch(h){throw console.error("JSON.parse error: body fetched from unpkg.com: ",d),h}return f.version}throw new cr("Only `major.minor.patch` versions are supported by Accelerate.",{clientVersion:n})}async function Il(e,r){let t=await df(e,r);return Cl("version",t),t}function mf(e){return encodeURI(`https://unpkg.com/prisma@${e}/package.json`)}var Dl=3,$t=N("prisma:client:dataproxyEngine"),qt=class{name="DataProxyEngine";inlineSchema;inlineSchemaHash;inlineDatasources;config;logEmitter;env;clientVersion;engineHash;tracingHelper;remoteClientVersion;host;headerBuilder;startPromise;protocol;constructor(r){Rl(r),this.config=r,this.env=r.env,this.inlineSchema=Sl(r.inlineSchema),this.inlineDatasources=r.inlineDatasources,this.inlineSchemaHash=r.inlineSchemaHash,this.clientVersion=r.clientVersion,this.engineHash=r.engineVersion,this.logEmitter=r.logEmitter,this.tracingHelper=r.tracingHelper}apiKey(){return this.headerBuilder.apiKey}version(){return this.engineHash}async start(){this.startPromise!==void 0&&await this.startPromise,this.startPromise=(async()=>{let{apiKey:r,url:t}=this.getURLAndAPIKey();this.host=t.host,this.protocol=t.protocol,this.headerBuilder=new Yn({apiKey:r,tracingHelper:this.tracingHelper,logLevel:this.config.logLevel??"error",logQueries:this.config.logQueries,engineHash:this.engineHash}),this.remoteClientVersion=await Il(this.host,this.config),$t("host",this.host),$t("protocol",this.protocol)})(),await this.startPromise}async stop(){}propagateResponseExtensions(r){r?.logs?.length&&r.logs.forEach(t=>{switch(t.level){case"debug":case"trace":$t(t);break;case"error":case"warn":case"info":{this.logEmitter.emit(t.level,{timestamp:po(t.timestamp),message:t.attributes.message??"",target:t.target??"BinaryEngine"});break}case"query":{this.logEmitter.emit("query",{query:t.attributes.query??"",timestamp:po(t.timestamp),duration:t.attributes.duration_ms??0,params:t.attributes.params??"",target:t.target??"BinaryEngine"});break}default:t.level}}),r?.traces?.length&&this.tracingHelper.dispatchEngineSpans(r.traces)}onBeforeExit(){throw new Error('"beforeExit" hook is not applicable to the remote query engine')}async url(r){return await this.start(),`${this.protocol}//${this.host}/${this.remoteClientVersion}/${this.inlineSchemaHash}/${r}`}async uploadSchema(){let r={name:"schemaUpload",internal:!0};return this.tracingHelper.runInChildSpan(r,async()=>{let t=await dr(await this.url("schema"),{method:"PUT",headers:this.headerBuilder.build(),body:this.inlineSchema,clientVersion:this.clientVersion});t.ok||$t("schema response status",t.status);let n=await Ft(t,this.clientVersion);if(n)throw this.logEmitter.emit("warn",{message:`Error while uploading schema: ${n.message}`,timestamp:new Date,target:""}),n;this.logEmitter.emit("info",{message:`Schema (re)uploaded (hash: ${this.inlineSchemaHash})`,timestamp:new Date,target:""})})}request(r,{traceparent:t,interactiveTransaction:n,customDataProxyFetch:i}){return this.requestInternal({body:r,traceparent:t,interactiveTransaction:n,customDataProxyFetch:i})}async requestBatch(r,{traceparent:t,transaction:n,customDataProxyFetch:i}){let o=n?.kind==="itx"?n.options:void 0,s=Mr(r,n);return(await this.requestInternal({body:s,customDataProxyFetch:i,interactiveTransaction:o,traceparent:t})).map(l=>(l.extensions&&this.propagateResponseExtensions(l.extensions),"errors"in l?this.convertProtocolErrorsToClientError(l.errors):l))}requestInternal({body:r,traceparent:t,customDataProxyFetch:n,interactiveTransaction:i}){return this.withRetry({actionGerund:"querying",callback:async({logHttpCall:o})=>{let s=i?`${i.payload.endpoint}/graphql`:await this.url("graphql");o(s);let a=await dr(s,{method:"POST",headers:this.headerBuilder.build({traceparent:t,transactionId:i?.id}),body:JSON.stringify(r),clientVersion:this.clientVersion},n);a.ok||$t("graphql response status",a.status),await this.handleError(await Ft(a,this.clientVersion));let l=await a.json();if(l.extensions&&this.propagateResponseExtensions(l.extensions),"errors"in l)throw this.convertProtocolErrorsToClientError(l.errors);return"batchResult"in l?l.batchResult:l}})}async transaction(r,t,n){let i={start:"starting",commit:"committing",rollback:"rolling back"};return this.withRetry({actionGerund:`${i[r]} transaction`,callback:async({logHttpCall:o})=>{if(r==="start"){let s=JSON.stringify({max_wait:n.maxWait,timeout:n.timeout,isolation_level:n.isolationLevel}),a=await this.url("transaction/start");o(a);let l=await dr(a,{method:"POST",headers:this.headerBuilder.build({traceparent:t.traceparent}),body:s,clientVersion:this.clientVersion});await this.handleError(await Ft(l,this.clientVersion));let u=await l.json(),{extensions:c}=u;c&&this.propagateResponseExtensions(c);let p=u.id,d=u["data-proxy"].endpoint;return{id:p,payload:{endpoint:d}}}else{let s=`${n.payload.endpoint}/${r}`;o(s);let a=await dr(s,{method:"POST",headers:this.headerBuilder.build({traceparent:t.traceparent}),clientVersion:this.clientVersion});await this.handleError(await Ft(a,this.clientVersion));let l=await a.json(),{extensions:u}=l;u&&this.propagateResponseExtensions(u);return}}})}getURLAndAPIKey(){return vl({clientVersion:this.clientVersion,env:this.env,inlineDatasources:this.inlineDatasources,overrideDatasources:this.config.overrideDatasources})}metrics(){throw new cr("Metrics are not yet supported for Accelerate",{clientVersion:this.clientVersion})}async withRetry(r){for(let t=0;;t++){let n=i=>{this.logEmitter.emit("info",{message:`Calling ${i} (n=${t})`,timestamp:new Date,target:""})};try{return await r.callback({logHttpCall:n})}catch(i){if(!(i instanceof oe)||!i.isRetryable)throw i;if(t>=Dl)throw i instanceof Br?i.cause:i;this.logEmitter.emit("warn",{message:`Attempt ${t+1}/${Dl} failed for ${r.actionGerund}: ${i.message??"(unknown)"}`,timestamp:new Date,target:""});let o=await Tl(t);this.logEmitter.emit("warn",{message:`Retrying after ${o}ms`,timestamp:new Date,target:""})}}}async handleError(r){if(r instanceof pr)throw await this.uploadSchema(),new Br({clientVersion:this.clientVersion,cause:r});if(r)throw r}convertProtocolErrorsToClientError(r){return r.length===1?$r(r[0],this.config.clientVersion,this.config.activeProvider):new V(JSON.stringify(r),{clientVersion:this.config.clientVersion})}applyPendingMigrations(){throw new Error("Method not implemented.")}};function Ol(e){if(e?.kind==="itx")return e.options.id}var wo=O(require("node:os")),kl=O(require("node:path"));var Eo=Symbol("PrismaLibraryEngineCache");function ff(){let e=globalThis;return e[Eo]===void 0&&(e[Eo]={}),e[Eo]}function gf(e){let r=ff();if(r[e]!==void 0)return r[e];let t=kl.default.toNamespacedPath(e),n={exports:{}},i=0;return process.platform!=="win32"&&(i=wo.default.constants.dlopen.RTLD_LAZY|wo.default.constants.dlopen.RTLD_DEEPBIND),process.dlopen(n,t,i),r[e]=n.exports,n.exports}var _l={async loadLibrary(e){let r=await fi(),t=await ml("library",e);try{return e.tracingHelper.runInChildSpan({name:"loadLibrary",internal:!0},()=>gf(t))}catch(n){let i=Ai({e:n,platformInfo:r,id:t});throw new P(i,e.clientVersion)}}};var xo,Nl={async loadLibrary(e){let{clientVersion:r,adapter:t,engineWasm:n}=e;if(t===void 0)throw new P(`The \`adapter\` option for \`PrismaClient\` is required in this context (${Kn().prettyName})`,r);if(n===void 0)throw new P("WASM engine was unexpectedly `undefined`",r);xo===void 0&&(xo=(async()=>{let o=await n.getRuntime(),s=await n.getQueryEngineWasmModule();if(s==null)throw new P("The loaded wasm module was unexpectedly `undefined` or `null` once loaded",r);let a={"./query_engine_bg.js":o},l=new WebAssembly.Instance(s,a),u=l.exports.__wbindgen_start;return o.__wbg_set_wasm(l.exports),u(),o.QueryEngine})());let i=await xo;return{debugPanic(){return Promise.reject("{}")},dmmf(){return Promise.resolve("{}")},version(){return{commit:"unknown",version:"unknown"}},QueryEngine:i}}};var hf="P2036",Re=N("prisma:client:libraryEngine");function yf(e){return e.item_type==="query"&&"query"in e}function bf(e){return"level"in e?e.level==="error"&&e.message==="PANIC":!1}var Ll=[...li,"native"],Ef=0xffffffffffffffffn,vo=1n;function wf(){let e=vo++;return vo>Ef&&(vo=1n),e}var Qr=class{name="LibraryEngine";engine;libraryInstantiationPromise;libraryStartingPromise;libraryStoppingPromise;libraryStarted;executingQueryPromise;config;QueryEngineConstructor;libraryLoader;library;logEmitter;libQueryEnginePath;binaryTarget;datasourceOverrides;datamodel;logQueries;logLevel;lastQuery;loggerRustPanic;tracingHelper;adapterPromise;versionInfo;constructor(r,t){this.libraryLoader=t??_l,r.engineWasm!==void 0&&(this.libraryLoader=t??Nl),this.config=r,this.libraryStarted=!1,this.logQueries=r.logQueries??!1,this.logLevel=r.logLevel??"error",this.logEmitter=r.logEmitter,this.datamodel=r.inlineSchema,this.tracingHelper=r.tracingHelper,r.enableDebugLogs&&(this.logLevel="debug");let n=Object.keys(r.overrideDatasources)[0],i=r.overrideDatasources[n]?.url;n!==void 0&&i!==void 0&&(this.datasourceOverrides={[n]:i}),this.libraryInstantiationPromise=this.instantiateLibrary()}wrapEngine(r){return{applyPendingMigrations:r.applyPendingMigrations?.bind(r),commitTransaction:this.withRequestId(r.commitTransaction.bind(r)),connect:this.withRequestId(r.connect.bind(r)),disconnect:this.withRequestId(r.disconnect.bind(r)),metrics:r.metrics?.bind(r),query:this.withRequestId(r.query.bind(r)),rollbackTransaction:this.withRequestId(r.rollbackTransaction.bind(r)),sdlSchema:r.sdlSchema?.bind(r),startTransaction:this.withRequestId(r.startTransaction.bind(r)),trace:r.trace.bind(r),free:r.free?.bind(r)}}withRequestId(r){return async(...t)=>{let n=wf().toString();try{return await r(...t,n)}finally{if(this.tracingHelper.isEnabled()){let i=await this.engine?.trace(n);if(i){let o=JSON.parse(i);this.tracingHelper.dispatchEngineSpans(o.spans)}}}}}async applyPendingMigrations(){throw new Error("Cannot call this method from this type of engine instance")}async transaction(r,t,n){await this.start();let i=await this.adapterPromise,o=JSON.stringify(t),s;if(r==="start"){let l=JSON.stringify({max_wait:n.maxWait,timeout:n.timeout,isolation_level:n.isolationLevel});s=await this.engine?.startTransaction(l,o)}else r==="commit"?s=await this.engine?.commitTransaction(n.id,o):r==="rollback"&&(s=await this.engine?.rollbackTransaction(n.id,o));let a=this.parseEngineResponse(s);if(xf(a)){let l=this.getExternalAdapterError(a,i?.errorRegistry);throw l?l.error:new z(a.message,{code:a.error_code,clientVersion:this.config.clientVersion,meta:a.meta})}else if(typeof a.message=="string")throw new V(a.message,{clientVersion:this.config.clientVersion});return a}async instantiateLibrary(){if(Re("internalSetup"),this.libraryInstantiationPromise)return this.libraryInstantiationPromise;ai(),this.binaryTarget=await this.getCurrentBinaryTarget(),await this.tracingHelper.runInChildSpan("load_engine",()=>this.loadEngine()),this.version()}async getCurrentBinaryTarget(){{if(this.binaryTarget)return this.binaryTarget;let r=await this.tracingHelper.runInChildSpan("detect_platform",()=>ir());if(!Ll.includes(r))throw new P(`Unknown ${ce("PRISMA_QUERY_ENGINE_LIBRARY")} ${ce(W(r))}. Possible binaryTargets: ${qe(Ll.join(", "))} or a path to the query engine library. -You may have to run ${qe("prisma generate")} for your changes to take effect.`,this.config.clientVersion);return r}}parseEngineResponse(r){if(!r)throw new V("Response from the Engine was empty",{clientVersion:this.config.clientVersion});try{return JSON.parse(r)}catch{throw new V("Unable to JSON.parse response from engine",{clientVersion:this.config.clientVersion})}}async loadEngine(){if(!this.engine){this.QueryEngineConstructor||(this.library=await this.libraryLoader.loadLibrary(this.config),this.QueryEngineConstructor=this.library.QueryEngine);try{let r=new WeakRef(this);this.adapterPromise||(this.adapterPromise=this.config.adapter?.connect()?.then(tn));let t=await this.adapterPromise;t&&Re("Using driver adapter: %O",t),this.engine=this.wrapEngine(new this.QueryEngineConstructor({datamodel:this.datamodel,env:process.env,logQueries:this.config.logQueries??!1,ignoreEnvVarErrors:!0,datasourceOverrides:this.datasourceOverrides??{},logLevel:this.logLevel,configDir:this.config.cwd,engineProtocol:"json",enableTracing:this.tracingHelper.isEnabled()},n=>{r.deref()?.logger(n)},t))}catch(r){let t=r,n=this.parseInitError(t.message);throw typeof n=="string"?t:new P(n.message,this.config.clientVersion,n.error_code)}}}logger(r){let t=this.parseEngineResponse(r);t&&(t.level=t?.level.toLowerCase()??"unknown",yf(t)?this.logEmitter.emit("query",{timestamp:new Date,query:t.query,params:t.params,duration:Number(t.duration_ms),target:t.module_path}):bf(t)?this.loggerRustPanic=new ae(Po(this,`${t.message}: ${t.reason} in ${t.file}:${t.line}:${t.column}`),this.config.clientVersion):this.logEmitter.emit(t.level,{timestamp:new Date,message:t.message,target:t.module_path}))}parseInitError(r){try{return JSON.parse(r)}catch{}return r}parseRequestError(r){try{return JSON.parse(r)}catch{}return r}onBeforeExit(){throw new Error('"beforeExit" hook is not applicable to the library engine since Prisma 5.0.0, it is only relevant and implemented for the binary engine. Please add your event listener to the `process` object directly instead.')}async start(){if(this.libraryInstantiationPromise||(this.libraryInstantiationPromise=this.instantiateLibrary()),await this.libraryInstantiationPromise,await this.libraryStoppingPromise,this.libraryStartingPromise)return Re(`library already starting, this.libraryStarted: ${this.libraryStarted}`),this.libraryStartingPromise;if(this.libraryStarted)return;let r=async()=>{Re("library starting");try{let t={traceparent:this.tracingHelper.getTraceParent()};await this.engine?.connect(JSON.stringify(t)),this.libraryStarted=!0,this.adapterPromise||(this.adapterPromise=this.config.adapter?.connect()?.then(tn)),await this.adapterPromise,Re("library started")}catch(t){let n=this.parseInitError(t.message);throw typeof n=="string"?t:new P(n.message,this.config.clientVersion,n.error_code)}finally{this.libraryStartingPromise=void 0}};return this.libraryStartingPromise=this.tracingHelper.runInChildSpan("connect",r),this.libraryStartingPromise}async stop(){if(await this.libraryInstantiationPromise,await this.libraryStartingPromise,await this.executingQueryPromise,this.libraryStoppingPromise)return Re("library is already stopping"),this.libraryStoppingPromise;if(!this.libraryStarted){await(await this.adapterPromise)?.dispose(),this.adapterPromise=void 0;return}let r=async()=>{await new Promise(n=>setImmediate(n)),Re("library stopping");let t={traceparent:this.tracingHelper.getTraceParent()};await this.engine?.disconnect(JSON.stringify(t)),this.engine?.free&&this.engine.free(),this.engine=void 0,this.libraryStarted=!1,this.libraryStoppingPromise=void 0,this.libraryInstantiationPromise=void 0,await(await this.adapterPromise)?.dispose(),this.adapterPromise=void 0,Re("library stopped")};return this.libraryStoppingPromise=this.tracingHelper.runInChildSpan("disconnect",r),this.libraryStoppingPromise}version(){return this.versionInfo=this.library?.version(),this.versionInfo?.version??"unknown"}debugPanic(r){return this.library?.debugPanic(r)}async request(r,{traceparent:t,interactiveTransaction:n}){Re(`sending request, this.libraryStarted: ${this.libraryStarted}`);let i=JSON.stringify({traceparent:t}),o=JSON.stringify(r);try{await this.start();let s=await this.adapterPromise;this.executingQueryPromise=this.engine?.query(o,i,n?.id),this.lastQuery=o;let a=this.parseEngineResponse(await this.executingQueryPromise);if(a.errors)throw a.errors.length===1?this.buildQueryError(a.errors[0],s?.errorRegistry):new V(JSON.stringify(a.errors),{clientVersion:this.config.clientVersion});if(this.loggerRustPanic)throw this.loggerRustPanic;return{data:a}}catch(s){if(s instanceof P)throw s;if(s.code==="GenericFailure"&&s.message?.startsWith("PANIC:"))throw new ae(Po(this,s.message),this.config.clientVersion);let a=this.parseRequestError(s.message);throw typeof a=="string"?s:new V(`${a.message} -${a.backtrace}`,{clientVersion:this.config.clientVersion})}}async requestBatch(r,{transaction:t,traceparent:n}){Re("requestBatch");let i=Mr(r,t);await this.start();let o=await this.adapterPromise;this.lastQuery=JSON.stringify(i),this.executingQueryPromise=this.engine?.query(this.lastQuery,JSON.stringify({traceparent:n}),Ol(t));let s=await this.executingQueryPromise,a=this.parseEngineResponse(s);if(a.errors)throw a.errors.length===1?this.buildQueryError(a.errors[0],o?.errorRegistry):new V(JSON.stringify(a.errors),{clientVersion:this.config.clientVersion});let{batchResult:l,errors:u}=a;if(Array.isArray(l))return l.map(c=>c.errors&&c.errors.length>0?this.loggerRustPanic??this.buildQueryError(c.errors[0],o?.errorRegistry):{data:c});throw u&&u.length===1?new Error(u[0].error):new Error(JSON.stringify(a))}buildQueryError(r,t){if(r.user_facing_error.is_panic)return new ae(Po(this,r.user_facing_error.message),this.config.clientVersion);let n=this.getExternalAdapterError(r.user_facing_error,t);return n?n.error:$r(r,this.config.clientVersion,this.config.activeProvider)}getExternalAdapterError(r,t){if(r.error_code===hf&&t){let n=r.meta?.id;ln(typeof n=="number","Malformed external JS error received from the engine");let i=t.consumeError(n);return ln(i,"External error with reported id was not registered"),i}}async metrics(r){await this.start();let t=await this.engine.metrics(JSON.stringify(r));return r.format==="prometheus"?t:this.parseEngineResponse(t)}};function xf(e){return typeof e=="object"&&e!==null&&e.error_code!==void 0}function Po(e,r){return El({binaryTarget:e.binaryTarget,title:r,version:e.config.clientVersion,engineVersion:e.versionInfo?.commit,database:e.config.activeProvider,query:e.lastQuery})}function Fl({url:e,adapter:r,copyEngine:t,targetBuildType:n}){let i=[],o=[],s=g=>{i.push({_tag:"warning",value:g})},a=g=>{let I=g.join(` -`);o.push({_tag:"error",value:I})},l=!!e?.startsWith("prisma://"),u=an(e),c=!!r,p=l||u;!c&&t&&p&&n!=="client"&&n!=="wasm-compiler-edge"&&s(["recommend--no-engine","In production, we recommend using `prisma generate --no-engine` (See: `prisma generate --help`)"]);let d=p||!t;c&&(d||n==="edge")&&(n==="edge"?a(["Prisma Client was configured to use the `adapter` option but it was imported via its `/edge` endpoint.","Please either remove the `/edge` endpoint or remove the `adapter` from the Prisma Client constructor."]):p?a(["You've provided both a driver adapter and an Accelerate database URL. Driver adapters currently cannot connect to Accelerate.","Please provide either a driver adapter with a direct database URL or an Accelerate URL and no driver adapter."]):t||a(["Prisma Client was configured to use the `adapter` option but `prisma generate` was run with `--no-engine`.","Please run `prisma generate` without `--no-engine` to be able to use Prisma Client with the adapter."]));let f={accelerate:d,ppg:u,driverAdapters:c};function h(g){return g.length>0}return h(o)?{ok:!1,diagnostics:{warnings:i,errors:o},isUsing:f}:{ok:!0,diagnostics:{warnings:i},isUsing:f}}function Ml({copyEngine:e=!0},r){let t;try{t=jr({inlineDatasources:r.inlineDatasources,overrideDatasources:r.overrideDatasources,env:{...r.env,...process.env},clientVersion:r.clientVersion})}catch{}let{ok:n,isUsing:i,diagnostics:o}=Fl({url:t,adapter:r.adapter,copyEngine:e,targetBuildType:"library"});for(let p of o.warnings)at(...p.value);if(!n){let p=o.errors[0];throw new Z(p.value,{clientVersion:r.clientVersion})}let s=Er(r.generator),a=s==="library",l=s==="binary",u=s==="client",c=(i.accelerate||i.ppg)&&!i.driverAdapters;return i.accelerate?new qt(r):(i.driverAdapters,a?new Qr(r):(i.accelerate,new Qr(r)))}function $l({generator:e}){return e?.previewFeatures??[]}var ql=e=>({command:e});var Vl=e=>e.strings.reduce((r,t,n)=>`${r}@P${n}${t}`);function Wr(e){try{return jl(e,"fast")}catch{return jl(e,"slow")}}function jl(e,r){return JSON.stringify(e.map(t=>Ul(t,r)))}function Ul(e,r){if(Array.isArray(e))return e.map(t=>Ul(t,r));if(typeof e=="bigint")return{prisma__type:"bigint",prisma__value:e.toString()};if(vr(e))return{prisma__type:"date",prisma__value:e.toJSON()};if(Fe.isDecimal(e))return{prisma__type:"decimal",prisma__value:e.toJSON()};if(Buffer.isBuffer(e))return{prisma__type:"bytes",prisma__value:e.toString("base64")};if(vf(e))return{prisma__type:"bytes",prisma__value:Buffer.from(e).toString("base64")};if(ArrayBuffer.isView(e)){let{buffer:t,byteOffset:n,byteLength:i}=e;return{prisma__type:"bytes",prisma__value:Buffer.from(t,n,i).toString("base64")}}return typeof e=="object"&&r==="slow"?Gl(e):e}function vf(e){return e instanceof ArrayBuffer||e instanceof SharedArrayBuffer?!0:typeof e=="object"&&e!==null?e[Symbol.toStringTag]==="ArrayBuffer"||e[Symbol.toStringTag]==="SharedArrayBuffer":!1}function Gl(e){if(typeof e!="object"||e===null)return e;if(typeof e.toJSON=="function")return e.toJSON();if(Array.isArray(e))return e.map(Bl);let r={};for(let t of Object.keys(e))r[t]=Bl(e[t]);return r}function Bl(e){return typeof e=="bigint"?e.toString():Gl(e)}var Pf=/^(\s*alter\s)/i,Ql=N("prisma:client");function To(e,r,t,n){if(!(e!=="postgresql"&&e!=="cockroachdb")&&t.length>0&&Pf.exec(r))throw new Error(`Running ALTER using ${n} is not supported -Using the example below you can still execute your query with Prisma, but please note that it is vulnerable to SQL injection attacks and requires you to take care of input sanitization. - -Example: - await prisma.$executeRawUnsafe(\`ALTER USER prisma WITH PASSWORD '\${password}'\`) - -More Information: https://pris.ly/d/execute-raw -`)}var So=({clientMethod:e,activeProvider:r})=>t=>{let n="",i;if(Vn(t))n=t.sql,i={values:Wr(t.values),__prismaRawParameters__:!0};else if(Array.isArray(t)){let[o,...s]=t;n=o,i={values:Wr(s||[]),__prismaRawParameters__:!0}}else switch(r){case"sqlite":case"mysql":{n=t.sql,i={values:Wr(t.values),__prismaRawParameters__:!0};break}case"cockroachdb":case"postgresql":case"postgres":{n=t.text,i={values:Wr(t.values),__prismaRawParameters__:!0};break}case"sqlserver":{n=Vl(t),i={values:Wr(t.values),__prismaRawParameters__:!0};break}default:throw new Error(`The ${r} provider does not support ${e}`)}return i?.values?Ql(`prisma.${e}(${n}, ${i.values})`):Ql(`prisma.${e}(${n})`),{query:n,parameters:i}},Wl={requestArgsToMiddlewareArgs(e){return[e.strings,...e.values]},middlewareArgsToRequestArgs(e){let[r,...t]=e;return new ie(r,t)}},Jl={requestArgsToMiddlewareArgs(e){return[e]},middlewareArgsToRequestArgs(e){return e[0]}};function Ro(e){return function(t,n){let i,o=(s=e)=>{try{return s===void 0||s?.kind==="itx"?i??=Kl(t(s)):Kl(t(s))}catch(a){return Promise.reject(a)}};return{get spec(){return n},then(s,a){return o().then(s,a)},catch(s){return o().catch(s)},finally(s){return o().finally(s)},requestTransaction(s){let a=o(s);return a.requestTransaction?a.requestTransaction(s):a},[Symbol.toStringTag]:"PrismaPromise"}}}function Kl(e){return typeof e.then=="function"?e:Promise.resolve(e)}var Tf=xi.split(".")[0],Sf={isEnabled(){return!1},getTraceParent(){return"00-10-10-00"},dispatchEngineSpans(){},getActiveContext(){},runInChildSpan(e,r){return r()}},Ao=class{isEnabled(){return this.getGlobalTracingHelper().isEnabled()}getTraceParent(r){return this.getGlobalTracingHelper().getTraceParent(r)}dispatchEngineSpans(r){return this.getGlobalTracingHelper().dispatchEngineSpans(r)}getActiveContext(){return this.getGlobalTracingHelper().getActiveContext()}runInChildSpan(r,t){return this.getGlobalTracingHelper().runInChildSpan(r,t)}getGlobalTracingHelper(){let r=globalThis[`V${Tf}_PRISMA_INSTRUMENTATION`],t=globalThis.PRISMA_INSTRUMENTATION;return r?.helper??t?.helper??Sf}};function Hl(){return new Ao}function Yl(e,r=()=>{}){let t,n=new Promise(i=>t=i);return{then(i){return--e===0&&t(r()),i?.(n)}}}function zl(e){return typeof e=="string"?e:e.reduce((r,t)=>{let n=typeof t=="string"?t:t.level;return n==="query"?r:r&&(t==="info"||r==="info")?"info":n},void 0)}function zn(e){return typeof e.batchRequestIdx=="number"}function Zl(e){if(e.action!=="findUnique"&&e.action!=="findUniqueOrThrow")return;let r=[];return e.modelName&&r.push(e.modelName),e.query.arguments&&r.push(Co(e.query.arguments)),r.push(Co(e.query.selection)),r.join("")}function Co(e){return`(${Object.keys(e).sort().map(t=>{let n=e[t];return typeof n=="object"&&n!==null?`(${t} ${Co(n)})`:t}).join(" ")})`}var Rf={aggregate:!1,aggregateRaw:!1,createMany:!0,createManyAndReturn:!0,createOne:!0,deleteMany:!0,deleteOne:!0,executeRaw:!0,findFirst:!1,findFirstOrThrow:!1,findMany:!1,findRaw:!1,findUnique:!1,findUniqueOrThrow:!1,groupBy:!1,queryRaw:!1,runCommandRaw:!0,updateMany:!0,updateManyAndReturn:!0,updateOne:!0,upsertOne:!0};function Io(e){return Rf[e]}var Zn=class{constructor(r){this.options=r;this.batches={}}batches;tickActive=!1;request(r){let t=this.options.batchBy(r);return t?(this.batches[t]||(this.batches[t]=[],this.tickActive||(this.tickActive=!0,process.nextTick(()=>{this.dispatchBatches(),this.tickActive=!1}))),new Promise((n,i)=>{this.batches[t].push({request:r,resolve:n,reject:i})})):this.options.singleLoader(r)}dispatchBatches(){for(let r in this.batches){let t=this.batches[r];delete this.batches[r],t.length===1?this.options.singleLoader(t[0].request).then(n=>{n instanceof Error?t[0].reject(n):t[0].resolve(n)}).catch(n=>{t[0].reject(n)}):(t.sort((n,i)=>this.options.batchOrder(n.request,i.request)),this.options.batchLoader(t.map(n=>n.request)).then(n=>{if(n instanceof Error)for(let i=0;i{for(let i=0;imr("bigint",t));case"bytes-array":return r.map(t=>mr("bytes",t));case"decimal-array":return r.map(t=>mr("decimal",t));case"datetime-array":return r.map(t=>mr("datetime",t));case"date-array":return r.map(t=>mr("date",t));case"time-array":return r.map(t=>mr("time",t));default:return r}}function Xn(e){let r=[],t=Af(e);for(let n=0;n{let{transaction:o,otelParentCtx:s}=n[0],a=n.map(p=>p.protocolQuery),l=this.client._tracingHelper.getTraceParent(s),u=n.some(p=>Io(p.protocolQuery.action));return(await this.client._engine.requestBatch(a,{traceparent:l,transaction:If(o),containsWrite:u,customDataProxyFetch:i})).map((p,d)=>{if(p instanceof Error)return p;try{return this.mapQueryEngineResult(n[d],p)}catch(f){return f}})}),singleLoader:async n=>{let i=n.transaction?.kind==="itx"?Xl(n.transaction):void 0,o=await this.client._engine.request(n.protocolQuery,{traceparent:this.client._tracingHelper.getTraceParent(),interactiveTransaction:i,isWrite:Io(n.protocolQuery.action),customDataProxyFetch:n.customDataProxyFetch});return this.mapQueryEngineResult(n,o)},batchBy:n=>n.transaction?.id?`transaction-${n.transaction.id}`:Zl(n.protocolQuery),batchOrder(n,i){return n.transaction?.kind==="batch"&&i.transaction?.kind==="batch"?n.transaction.index-i.transaction.index:0}})}async request(r){try{return await this.dataloader.request(r)}catch(t){let{clientMethod:n,callsite:i,transaction:o,args:s,modelName:a}=r;this.handleAndLogRequestError({error:t,clientMethod:n,callsite:i,transaction:o,args:s,modelName:a,globalOmit:r.globalOmit})}}mapQueryEngineResult({dataPath:r,unpacker:t},n){let i=n?.data,o=this.unpack(i,r,t);return process.env.PRISMA_CLIENT_GET_TIME?{data:o}:o}handleAndLogRequestError(r){try{this.handleRequestError(r)}catch(t){throw this.logEmitter&&this.logEmitter.emit("error",{message:t.message,target:r.clientMethod,timestamp:new Date}),t}}handleRequestError({error:r,clientMethod:t,callsite:n,transaction:i,args:o,modelName:s,globalOmit:a}){if(Cf(r),Df(r,i))throw r;if(r instanceof z&&Of(r)){let u=eu(r.meta);Nn({args:o,errors:[u],callsite:n,errorFormat:this.client._errorFormat,originalMethod:t,clientVersion:this.client._clientVersion,globalOmit:a})}let l=r.message;if(n&&(l=Tn({callsite:n,originalMethod:t,isPanic:r.isPanic,showColors:this.client._errorFormat==="pretty",message:l})),l=this.sanitizeMessage(l),r.code){let u=s?{modelName:s,...r.meta}:r.meta;throw new z(l,{code:r.code,clientVersion:this.client._clientVersion,meta:u,batchRequestIdx:r.batchRequestIdx})}else{if(r.isPanic)throw new ae(l,this.client._clientVersion);if(r instanceof V)throw new V(l,{clientVersion:this.client._clientVersion,batchRequestIdx:r.batchRequestIdx});if(r instanceof P)throw new P(l,this.client._clientVersion);if(r instanceof ae)throw new ae(l,this.client._clientVersion)}throw r.clientVersion=this.client._clientVersion,r}sanitizeMessage(r){return this.client._errorFormat&&this.client._errorFormat!=="pretty"?wr(r):r}unpack(r,t,n){if(!r||(r.data&&(r=r.data),!r))return r;let i=Object.keys(r)[0],o=Object.values(r)[0],s=t.filter(u=>u!=="select"&&u!=="include"),a=ao(o,s),l=i==="queryRaw"?Xn(a):Vr(a);return n?n(l):l}get[Symbol.toStringTag](){return"RequestHandler"}};function If(e){if(e){if(e.kind==="batch")return{kind:"batch",options:{isolationLevel:e.isolationLevel}};if(e.kind==="itx")return{kind:"itx",options:Xl(e)};ar(e,"Unknown transaction kind")}}function Xl(e){return{id:e.id,payload:e.payload}}function Df(e,r){return zn(e)&&r?.kind==="batch"&&e.batchRequestIdx!==r.index}function Of(e){return e.code==="P2009"||e.code==="P2012"}function eu(e){if(e.kind==="Union")return{kind:"Union",errors:e.errors.map(eu)};if(Array.isArray(e.selectionPath)){let[,...r]=e.selectionPath;return{...e,selectionPath:r}}return e}var ru=xl;var su=O(Ki());var _=class extends Error{constructor(r){super(r+` -Read more at https://pris.ly/d/client-constructor`),this.name="PrismaClientConstructorValidationError"}get[Symbol.toStringTag](){return"PrismaClientConstructorValidationError"}};x(_,"PrismaClientConstructorValidationError");var tu=["datasources","datasourceUrl","errorFormat","adapter","log","transactionOptions","omit","__internal"],nu=["pretty","colorless","minimal"],iu=["info","query","warn","error"],kf={datasources:(e,{datasourceNames:r})=>{if(e){if(typeof e!="object"||Array.isArray(e))throw new _(`Invalid value ${JSON.stringify(e)} for "datasources" provided to PrismaClient constructor`);for(let[t,n]of Object.entries(e)){if(!r.includes(t)){let i=Jr(t,r)||` Available datasources: ${r.join(", ")}`;throw new _(`Unknown datasource ${t} provided to PrismaClient constructor.${i}`)}if(typeof n!="object"||Array.isArray(n))throw new _(`Invalid value ${JSON.stringify(e)} for datasource "${t}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`);if(n&&typeof n=="object")for(let[i,o]of Object.entries(n)){if(i!=="url")throw new _(`Invalid value ${JSON.stringify(e)} for datasource "${t}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`);if(typeof o!="string")throw new _(`Invalid value ${JSON.stringify(o)} for datasource "${t}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`)}}}},adapter:(e,r)=>{if(!e&&Er(r.generator)==="client")throw new _('Using engine type "client" requires a driver adapter to be provided to PrismaClient constructor.');if(e!==null){if(e===void 0)throw new _('"adapter" property must not be undefined, use null to conditionally disable driver adapters.');if(Er(r.generator)==="binary")throw new _('Cannot use a driver adapter with the "binary" Query Engine. Please use the "library" Query Engine.')}},datasourceUrl:e=>{if(typeof e<"u"&&typeof e!="string")throw new _(`Invalid value ${JSON.stringify(e)} for "datasourceUrl" provided to PrismaClient constructor. -Expected string or undefined.`)},errorFormat:e=>{if(e){if(typeof e!="string")throw new _(`Invalid value ${JSON.stringify(e)} for "errorFormat" provided to PrismaClient constructor.`);if(!nu.includes(e)){let r=Jr(e,nu);throw new _(`Invalid errorFormat ${e} provided to PrismaClient constructor.${r}`)}}},log:e=>{if(!e)return;if(!Array.isArray(e))throw new _(`Invalid value ${JSON.stringify(e)} for "log" provided to PrismaClient constructor.`);function r(t){if(typeof t=="string"&&!iu.includes(t)){let n=Jr(t,iu);throw new _(`Invalid log level "${t}" provided to PrismaClient constructor.${n}`)}}for(let t of e){r(t);let n={level:r,emit:i=>{let o=["stdout","event"];if(!o.includes(i)){let s=Jr(i,o);throw new _(`Invalid value ${JSON.stringify(i)} for "emit" in logLevel provided to PrismaClient constructor.${s}`)}}};if(t&&typeof t=="object")for(let[i,o]of Object.entries(t))if(n[i])n[i](o);else throw new _(`Invalid property ${i} for "log" provided to PrismaClient constructor`)}},transactionOptions:e=>{if(!e)return;let r=e.maxWait;if(r!=null&&r<=0)throw new _(`Invalid value ${r} for maxWait in "transactionOptions" provided to PrismaClient constructor. maxWait needs to be greater than 0`);let t=e.timeout;if(t!=null&&t<=0)throw new _(`Invalid value ${t} for timeout in "transactionOptions" provided to PrismaClient constructor. timeout needs to be greater than 0`)},omit:(e,r)=>{if(typeof e!="object")throw new _('"omit" option is expected to be an object.');if(e===null)throw new _('"omit" option can not be `null`');let t=[];for(let[n,i]of Object.entries(e)){let o=Nf(n,r.runtimeDataModel);if(!o){t.push({kind:"UnknownModel",modelKey:n});continue}for(let[s,a]of Object.entries(i)){let l=o.fields.find(u=>u.name===s);if(!l){t.push({kind:"UnknownField",modelKey:n,fieldName:s});continue}if(l.relationName){t.push({kind:"RelationInOmit",modelKey:n,fieldName:s});continue}typeof a!="boolean"&&t.push({kind:"InvalidFieldValue",modelKey:n,fieldName:s})}}if(t.length>0)throw new _(Lf(e,t))},__internal:e=>{if(!e)return;let r=["debug","engine","configOverride"];if(typeof e!="object")throw new _(`Invalid value ${JSON.stringify(e)} for "__internal" to PrismaClient constructor`);for(let[t]of Object.entries(e))if(!r.includes(t)){let n=Jr(t,r);throw new _(`Invalid property ${JSON.stringify(t)} for "__internal" provided to PrismaClient constructor.${n}`)}}};function au(e,r){for(let[t,n]of Object.entries(e)){if(!tu.includes(t)){let i=Jr(t,tu);throw new _(`Unknown property ${t} provided to PrismaClient constructor.${i}`)}kf[t](n,r)}if(e.datasourceUrl&&e.datasources)throw new _('Can not use "datasourceUrl" and "datasources" options at the same time. Pick one of them')}function Jr(e,r){if(r.length===0||typeof e!="string")return"";let t=_f(e,r);return t?` Did you mean "${t}"?`:""}function _f(e,r){if(r.length===0)return null;let t=r.map(i=>({value:i,distance:(0,su.default)(e,i)}));t.sort((i,o)=>i.distanceWe(n)===r);if(t)return e[t]}function Lf(e,r){let t=_r(e);for(let o of r)switch(o.kind){case"UnknownModel":t.arguments.getField(o.modelKey)?.markAsError(),t.addErrorMessage(()=>`Unknown model name: ${o.modelKey}.`);break;case"UnknownField":t.arguments.getDeepField([o.modelKey,o.fieldName])?.markAsError(),t.addErrorMessage(()=>`Model "${o.modelKey}" does not have a field named "${o.fieldName}".`);break;case"RelationInOmit":t.arguments.getDeepField([o.modelKey,o.fieldName])?.markAsError(),t.addErrorMessage(()=>'Relations are already excluded by default and can not be specified in "omit".');break;case"InvalidFieldValue":t.arguments.getDeepFieldValue([o.modelKey,o.fieldName])?.markAsError(),t.addErrorMessage(()=>"Omit field option value must be a boolean.");break}let{message:n,args:i}=_n(t,"colorless");return`Error validating "omit" option: - -${i} - -${n}`}function lu(e){return e.length===0?Promise.resolve([]):new Promise((r,t)=>{let n=new Array(e.length),i=null,o=!1,s=0,a=()=>{o||(s++,s===e.length&&(o=!0,i?t(i):r(n)))},l=u=>{o||(o=!0,t(u))};for(let u=0;u{n[u]=c,a()},c=>{if(!zn(c)){l(c);return}c.batchRequestIdx===u?l(c):(i||(i=c),a())})})}var rr=N("prisma:client");typeof globalThis=="object"&&(globalThis.NODE_CLIENT=!0);var Ff={requestArgsToMiddlewareArgs:e=>e,middlewareArgsToRequestArgs:e=>e},Mf=Symbol.for("prisma.client.transaction.id"),$f={id:0,nextId(){return++this.id}};function fu(e){class r{_originalClient=this;_runtimeDataModel;_requestHandler;_connectionPromise;_disconnectionPromise;_engineConfig;_accelerateEngineConfig;_clientVersion;_errorFormat;_tracingHelper;_previewFeatures;_activeProvider;_globalOmit;_extensions;_engine;_appliedParent;_createPrismaPromise=Ro();constructor(n){e=n?.__internal?.configOverride?.(e)??e,sl(e),n&&au(n,e);let i=new du.EventEmitter().on("error",()=>{});this._extensions=Nr.empty(),this._previewFeatures=$l(e),this._clientVersion=e.clientVersion??ru,this._activeProvider=e.activeProvider,this._globalOmit=n?.omit,this._tracingHelper=Hl();let o=e.relativeEnvPaths&&{rootEnvPath:e.relativeEnvPaths.rootEnvPath&&ri.default.resolve(e.dirname,e.relativeEnvPaths.rootEnvPath),schemaEnvPath:e.relativeEnvPaths.schemaEnvPath&&ri.default.resolve(e.dirname,e.relativeEnvPaths.schemaEnvPath)},s;if(n?.adapter){s=n.adapter;let l=e.activeProvider==="postgresql"||e.activeProvider==="cockroachdb"?"postgres":e.activeProvider;if(s.provider!==l)throw new P(`The Driver Adapter \`${s.adapterName}\`, based on \`${s.provider}\`, is not compatible with the provider \`${l}\` specified in the Prisma schema.`,this._clientVersion);if(n.datasources||n.datasourceUrl!==void 0)throw new P("Custom datasource configuration is not compatible with Prisma Driver Adapters. Please define the database connection string directly in the Driver Adapter configuration.",this._clientVersion)}let a=!s&&o&&st(o,{conflictCheck:"none"})||e.injectableEdgeEnv?.();try{let l=n??{},u=l.__internal??{},c=u.debug===!0;c&&N.enable("prisma:client");let p=ri.default.resolve(e.dirname,e.relativePath);mu.default.existsSync(p)||(p=e.dirname),rr("dirname",e.dirname),rr("relativePath",e.relativePath),rr("cwd",p);let d=u.engine||{};if(l.errorFormat?this._errorFormat=l.errorFormat:process.env.NODE_ENV==="production"?this._errorFormat="minimal":process.env.NO_COLOR?this._errorFormat="colorless":this._errorFormat="colorless",this._runtimeDataModel=e.runtimeDataModel,this._engineConfig={cwd:p,dirname:e.dirname,enableDebugLogs:c,allowTriggerPanic:d.allowTriggerPanic,prismaPath:d.binaryPath??void 0,engineEndpoint:d.endpoint,generator:e.generator,showColors:this._errorFormat==="pretty",logLevel:l.log&&zl(l.log),logQueries:l.log&&!!(typeof l.log=="string"?l.log==="query":l.log.find(f=>typeof f=="string"?f==="query":f.level==="query")),env:a?.parsed??{},flags:[],engineWasm:e.engineWasm,compilerWasm:e.compilerWasm,clientVersion:e.clientVersion,engineVersion:e.engineVersion,previewFeatures:this._previewFeatures,activeProvider:e.activeProvider,inlineSchema:e.inlineSchema,overrideDatasources:al(l,e.datasourceNames),inlineDatasources:e.inlineDatasources,inlineSchemaHash:e.inlineSchemaHash,tracingHelper:this._tracingHelper,transactionOptions:{maxWait:l.transactionOptions?.maxWait??2e3,timeout:l.transactionOptions?.timeout??5e3,isolationLevel:l.transactionOptions?.isolationLevel},logEmitter:i,isBundled:e.isBundled,adapter:s},this._accelerateEngineConfig={...this._engineConfig,accelerateUtils:{resolveDatasourceUrl:jr,getBatchRequestPayload:Mr,prismaGraphQLToJSError:$r,PrismaClientUnknownRequestError:V,PrismaClientInitializationError:P,PrismaClientKnownRequestError:z,debug:N("prisma:client:accelerateEngine"),engineVersion:cu.version,clientVersion:e.clientVersion}},rr("clientVersion",e.clientVersion),this._engine=Ml(e,this._engineConfig),this._requestHandler=new ei(this,i),l.log)for(let f of l.log){let h=typeof f=="string"?f:f.emit==="stdout"?f.level:null;h&&this.$on(h,g=>{nt.log(`${nt.tags[h]??""}`,g.message||g.query)})}}catch(l){throw l.clientVersion=this._clientVersion,l}return this._appliedParent=Pt(this)}get[Symbol.toStringTag](){return"PrismaClient"}$on(n,i){return n==="beforeExit"?this._engine.onBeforeExit(i):n&&this._engineConfig.logEmitter.on(n,i),this}$connect(){try{return this._engine.start()}catch(n){throw n.clientVersion=this._clientVersion,n}}async $disconnect(){try{await this._engine.stop()}catch(n){throw n.clientVersion=this._clientVersion,n}finally{Uo()}}$executeRawInternal(n,i,o,s){let a=this._activeProvider;return this._request({action:"executeRaw",args:o,transaction:n,clientMethod:i,argsMapper:So({clientMethod:i,activeProvider:a}),callsite:Ze(this._errorFormat),dataPath:[],middlewareArgsMapper:s})}$executeRaw(n,...i){return this._createPrismaPromise(o=>{if(n.raw!==void 0||n.sql!==void 0){let[s,a]=uu(n,i);return To(this._activeProvider,s.text,s.values,Array.isArray(n)?"prisma.$executeRaw``":"prisma.$executeRaw(sql``)"),this.$executeRawInternal(o,"$executeRaw",s,a)}throw new Z("`$executeRaw` is a tag function, please use it like the following:\n```\nconst result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`\n```\n\nOr read our docs at https://www.prisma.io/docs/concepts/components/prisma-client/raw-database-access#executeraw\n",{clientVersion:this._clientVersion})})}$executeRawUnsafe(n,...i){return this._createPrismaPromise(o=>(To(this._activeProvider,n,i,"prisma.$executeRawUnsafe(, [...values])"),this.$executeRawInternal(o,"$executeRawUnsafe",[n,...i])))}$runCommandRaw(n){if(e.activeProvider!=="mongodb")throw new Z(`The ${e.activeProvider} provider does not support $runCommandRaw. Use the mongodb provider.`,{clientVersion:this._clientVersion});return this._createPrismaPromise(i=>this._request({args:n,clientMethod:"$runCommandRaw",dataPath:[],action:"runCommandRaw",argsMapper:ql,callsite:Ze(this._errorFormat),transaction:i}))}async $queryRawInternal(n,i,o,s){let a=this._activeProvider;return this._request({action:"queryRaw",args:o,transaction:n,clientMethod:i,argsMapper:So({clientMethod:i,activeProvider:a}),callsite:Ze(this._errorFormat),dataPath:[],middlewareArgsMapper:s})}$queryRaw(n,...i){return this._createPrismaPromise(o=>{if(n.raw!==void 0||n.sql!==void 0)return this.$queryRawInternal(o,"$queryRaw",...uu(n,i));throw new Z("`$queryRaw` is a tag function, please use it like the following:\n```\nconst result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`\n```\n\nOr read our docs at https://www.prisma.io/docs/concepts/components/prisma-client/raw-database-access#queryraw\n",{clientVersion:this._clientVersion})})}$queryRawTyped(n){return this._createPrismaPromise(i=>{if(!this._hasPreviewFlag("typedSql"))throw new Z("`typedSql` preview feature must be enabled in order to access $queryRawTyped API",{clientVersion:this._clientVersion});return this.$queryRawInternal(i,"$queryRawTyped",n)})}$queryRawUnsafe(n,...i){return this._createPrismaPromise(o=>this.$queryRawInternal(o,"$queryRawUnsafe",[n,...i]))}_transactionWithArray({promises:n,options:i}){let o=$f.nextId(),s=Yl(n.length),a=n.map((l,u)=>{if(l?.[Symbol.toStringTag]!=="PrismaPromise")throw new Error("All elements of the array need to be Prisma Client promises. Hint: Please make sure you are not awaiting the Prisma client calls you intended to pass in the $transaction function.");let c=i?.isolationLevel??this._engineConfig.transactionOptions.isolationLevel,p={kind:"batch",id:o,index:u,isolationLevel:c,lock:s};return l.requestTransaction?.(p)??l});return lu(a)}async _transactionWithCallback({callback:n,options:i}){let o={traceparent:this._tracingHelper.getTraceParent()},s={maxWait:i?.maxWait??this._engineConfig.transactionOptions.maxWait,timeout:i?.timeout??this._engineConfig.transactionOptions.timeout,isolationLevel:i?.isolationLevel??this._engineConfig.transactionOptions.isolationLevel},a=await this._engine.transaction("start",o,s),l;try{let u={kind:"itx",...a};l=await n(this._createItxClient(u)),await this._engine.transaction("commit",o,a)}catch(u){throw await this._engine.transaction("rollback",o,a).catch(()=>{}),u}return l}_createItxClient(n){return he(Pt(he(Qa(this),[re("_appliedParent",()=>this._appliedParent._createItxClient(n)),re("_createPrismaPromise",()=>Ro(n)),re(Mf,()=>n.id)])),[Fr(Ya)])}$transaction(n,i){let o;typeof n=="function"?this._engineConfig.adapter?.adapterName==="@prisma/adapter-d1"?o=()=>{throw new Error("Cloudflare D1 does not support interactive transactions. We recommend you to refactor your queries with that limitation in mind, and use batch transactions with `prisma.$transactions([])` where applicable.")}:o=()=>this._transactionWithCallback({callback:n,options:i}):o=()=>this._transactionWithArray({promises:n,options:i});let s={name:"transaction",attributes:{method:"$transaction"}};return this._tracingHelper.runInChildSpan(s,o)}_request(n){n.otelParentCtx=this._tracingHelper.getActiveContext();let i=n.middlewareArgsMapper??Ff,o={args:i.requestArgsToMiddlewareArgs(n.args),dataPath:n.dataPath,runInTransaction:!!n.transaction,action:n.action,model:n.model},s={operation:{name:"operation",attributes:{method:o.action,model:o.model,name:o.model?`${o.model}.${o.action}`:o.action}}},a=async l=>{let{runInTransaction:u,args:c,...p}=l,d={...n,...p};c&&(d.args=i.middlewareArgsToRequestArgs(c)),n.transaction!==void 0&&u===!1&&delete d.transaction;let f=await el(this,d);return d.model?Ha({result:f,modelName:d.model,args:d.args,extensions:this._extensions,runtimeDataModel:this._runtimeDataModel,globalOmit:this._globalOmit}):f};return this._tracingHelper.runInChildSpan(s.operation,()=>new pu.AsyncResource("prisma-client-request").runInAsyncScope(()=>a(o)))}async _executeRequest({args:n,clientMethod:i,dataPath:o,callsite:s,action:a,model:l,argsMapper:u,transaction:c,unpacker:p,otelParentCtx:d,customDataProxyFetch:f}){try{n=u?u(n):n;let h={name:"serialize"},g=this._tracingHelper.runInChildSpan(h,()=>$n({modelName:l,runtimeDataModel:this._runtimeDataModel,action:a,args:n,clientMethod:i,callsite:s,extensions:this._extensions,errorFormat:this._errorFormat,clientVersion:this._clientVersion,previewFeatures:this._previewFeatures,globalOmit:this._globalOmit}));return N.enabled("prisma:client")&&(rr("Prisma Client call:"),rr(`prisma.${i}(${Na(n)})`),rr("Generated request:"),rr(JSON.stringify(g,null,2)+` -`)),c?.kind==="batch"&&await c.lock,this._requestHandler.request({protocolQuery:g,modelName:l,action:a,clientMethod:i,dataPath:o,callsite:s,args:n,extensions:this._extensions,transaction:c,unpacker:p,otelParentCtx:d,otelChildCtx:this._tracingHelper.getActiveContext(),globalOmit:this._globalOmit,customDataProxyFetch:f})}catch(h){throw h.clientVersion=this._clientVersion,h}}$metrics=new Lr(this);_hasPreviewFlag(n){return!!this._engineConfig.previewFeatures?.includes(n)}$applyPendingMigrations(){return this._engine.applyPendingMigrations()}$extends=Wa}return r}function uu(e,r){return qf(e)?[new ie(e,r),Wl]:[e,Jl]}function qf(e){return Array.isArray(e)&&Array.isArray(e.raw)}var Vf=new Set(["toJSON","$$typeof","asymmetricMatch",Symbol.iterator,Symbol.toStringTag,Symbol.isConcatSpreadable,Symbol.toPrimitive]);function gu(e){return new Proxy(e,{get(r,t){if(t in r)return r[t];if(!Vf.has(t))throw new TypeError(`Invalid enum value: ${String(t)}`)}})}function hu(e){st(e,{conflictCheck:"warn"})}0&&(module.exports={DMMF,Debug,Decimal,Extensions,MetricsClient,PrismaClientInitializationError,PrismaClientKnownRequestError,PrismaClientRustPanicError,PrismaClientUnknownRequestError,PrismaClientValidationError,Public,Sql,createParam,defineDmmfProperty,deserializeJsonResponse,deserializeRawResult,dmmfToRuntimeDataModel,empty,getPrismaClient,getRuntime,join,makeStrictEnum,makeTypedQueryFactory,objectEnumValues,raw,serializeJsonQuery,skip,sqltag,warnEnvConflicts,warnOnce}); -/*! Bundled license information: - -decimal.js/decimal.mjs: - (*! - * decimal.js v10.5.0 - * An arbitrary-precision Decimal type for JavaScript. - * https://github.com/MikeMcl/decimal.js - * Copyright (c) 2025 Michael Mclaughlin - * MIT Licence - *) -*/ -//# sourceMappingURL=library.js.map diff --git a/frontend/generated/prisma/runtime/react-native.js b/frontend/generated/prisma/runtime/react-native.js deleted file mode 100644 index 03e959b..0000000 --- a/frontend/generated/prisma/runtime/react-native.js +++ /dev/null @@ -1,84 +0,0 @@ - -/* !!! This is code generated by Prisma. Do not edit directly. !!! -/* eslint-disable */ -// biome-ignore-all lint: generated file -"use strict";var ha=Object.create;var rr=Object.defineProperty;var ya=Object.getOwnPropertyDescriptor;var wa=Object.getOwnPropertyNames;var ba=Object.getPrototypeOf,Ea=Object.prototype.hasOwnProperty;var he=(e,t)=>()=>(e&&(t=e(e=0)),t);var Ve=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),Xe=(e,t)=>{for(var r in t)rr(e,r,{get:t[r],enumerable:!0})},ni=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of wa(t))!Ea.call(e,i)&&i!==r&&rr(e,i,{get:()=>t[i],enumerable:!(n=ya(t,i))||n.enumerable});return e};var Qe=(e,t,r)=>(r=e!=null?ha(ba(e)):{},ni(t||!e||!e.__esModule?rr(r,"default",{value:e,enumerable:!0}):r,e)),xa=e=>ni(rr({},"__esModule",{value:!0}),e);var y,x,c=he(()=>{"use strict";y={nextTick:(e,...t)=>{setTimeout(()=>{e(...t)},0)},env:{},version:"",cwd:()=>"/",stderr:{},argv:["/bin/node"],pid:1e4},{cwd:x}=y});var P,p=he(()=>{"use strict";P=globalThis.performance??(()=>{let e=Date.now();return{now:()=>Date.now()-e}})()});var E,d=he(()=>{"use strict";E=()=>{};E.prototype=E});var b,f=he(()=>{"use strict";b=class{value;constructor(t){this.value=t}deref(){return this.value}}});var Pi=Ve(nt=>{"use strict";m();c();p();d();f();var li=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),Pa=li(e=>{"use strict";e.byteLength=l,e.toByteArray=g,e.fromByteArray=O;var t=[],r=[],n=typeof Uint8Array<"u"?Uint8Array:Array,i="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";for(o=0,s=i.length;o0)throw new Error("Invalid string. Length must be a multiple of 4");var F=C.indexOf("=");F===-1&&(F=S);var _=F===S?0:4-F%4;return[F,_]}function l(C){var S=a(C),F=S[0],_=S[1];return(F+_)*3/4-_}function u(C,S,F){return(S+F)*3/4-F}function g(C){var S,F=a(C),_=F[0],L=F[1],k=new n(u(C,_,L)),q=0,Y=L>0?_-4:_,$;for($=0;$>16&255,k[q++]=S>>8&255,k[q++]=S&255;return L===2&&(S=r[C.charCodeAt($)]<<2|r[C.charCodeAt($+1)]>>4,k[q++]=S&255),L===1&&(S=r[C.charCodeAt($)]<<10|r[C.charCodeAt($+1)]<<4|r[C.charCodeAt($+2)]>>2,k[q++]=S>>8&255,k[q++]=S&255),k}function h(C){return t[C>>18&63]+t[C>>12&63]+t[C>>6&63]+t[C&63]}function T(C,S,F){for(var _,L=[],k=S;kY?Y:q+k));return _===1?(S=C[F-1],L.push(t[S>>2]+t[S<<4&63]+"==")):_===2&&(S=(C[F-2]<<8)+C[F-1],L.push(t[S>>10]+t[S>>4&63]+t[S<<2&63]+"=")),L.join("")}}),va=li(e=>{e.read=function(t,r,n,i,o){var s,a,l=o*8-i-1,u=(1<>1,h=-7,T=n?o-1:0,O=n?-1:1,C=t[r+T];for(T+=O,s=C&(1<<-h)-1,C>>=-h,h+=l;h>0;s=s*256+t[r+T],T+=O,h-=8);for(a=s&(1<<-h)-1,s>>=-h,h+=i;h>0;a=a*256+t[r+T],T+=O,h-=8);if(s===0)s=1-g;else{if(s===u)return a?NaN:(C?-1:1)*(1/0);a=a+Math.pow(2,i),s=s-g}return(C?-1:1)*a*Math.pow(2,s-i)},e.write=function(t,r,n,i,o,s){var a,l,u,g=s*8-o-1,h=(1<>1,O=o===23?Math.pow(2,-24)-Math.pow(2,-77):0,C=i?0:s-1,S=i?1:-1,F=r<0||r===0&&1/r<0?1:0;for(r=Math.abs(r),isNaN(r)||r===1/0?(l=isNaN(r)?1:0,a=h):(a=Math.floor(Math.log(r)/Math.LN2),r*(u=Math.pow(2,-a))<1&&(a--,u*=2),a+T>=1?r+=O/u:r+=O*Math.pow(2,1-T),r*u>=2&&(a++,u/=2),a+T>=h?(l=0,a=h):a+T>=1?(l=(r*u-1)*Math.pow(2,o),a=a+T):(l=r*Math.pow(2,T-1)*Math.pow(2,o),a=0));o>=8;t[n+C]=l&255,C+=S,l/=256,o-=8);for(a=a<0;t[n+C]=a&255,C+=S,a/=256,g-=8);t[n+C-S]|=F*128}}),Xr=Pa(),tt=va(),ii=typeof Symbol=="function"&&typeof Symbol.for=="function"?Symbol.for("nodejs.util.inspect.custom"):null;nt.Buffer=A;nt.SlowBuffer=Oa;nt.INSPECT_MAX_BYTES=50;var nr=2147483647;nt.kMaxLength=nr;A.TYPED_ARRAY_SUPPORT=Ta();!A.TYPED_ARRAY_SUPPORT&&typeof console<"u"&&typeof console.error=="function"&&console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");function Ta(){try{let e=new Uint8Array(1),t={foo:function(){return 42}};return Object.setPrototypeOf(t,Uint8Array.prototype),Object.setPrototypeOf(e,t),e.foo()===42}catch{return!1}}Object.defineProperty(A.prototype,"parent",{enumerable:!0,get:function(){if(A.isBuffer(this))return this.buffer}});Object.defineProperty(A.prototype,"offset",{enumerable:!0,get:function(){if(A.isBuffer(this))return this.byteOffset}});function Ce(e){if(e>nr)throw new RangeError('The value "'+e+'" is invalid for option "size"');let t=new Uint8Array(e);return Object.setPrototypeOf(t,A.prototype),t}function A(e,t,r){if(typeof e=="number"){if(typeof t=="string")throw new TypeError('The "string" argument must be of type string. Received type number');return rn(e)}return ui(e,t,r)}A.poolSize=8192;function ui(e,t,r){if(typeof e=="string")return Ca(e,t);if(ArrayBuffer.isView(e))return Sa(e);if(e==null)throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type "+typeof e);if(ye(e,ArrayBuffer)||e&&ye(e.buffer,ArrayBuffer)||typeof SharedArrayBuffer<"u"&&(ye(e,SharedArrayBuffer)||e&&ye(e.buffer,SharedArrayBuffer)))return pi(e,t,r);if(typeof e=="number")throw new TypeError('The "value" argument must not be of type number. Received type number');let n=e.valueOf&&e.valueOf();if(n!=null&&n!==e)return A.from(n,t,r);let i=Ra(e);if(i)return i;if(typeof Symbol<"u"&&Symbol.toPrimitive!=null&&typeof e[Symbol.toPrimitive]=="function")return A.from(e[Symbol.toPrimitive]("string"),t,r);throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type "+typeof e)}A.from=function(e,t,r){return ui(e,t,r)};Object.setPrototypeOf(A.prototype,Uint8Array.prototype);Object.setPrototypeOf(A,Uint8Array);function ci(e){if(typeof e!="number")throw new TypeError('"size" argument must be of type number');if(e<0)throw new RangeError('The value "'+e+'" is invalid for option "size"')}function Aa(e,t,r){return ci(e),e<=0?Ce(e):t!==void 0?typeof r=="string"?Ce(e).fill(t,r):Ce(e).fill(t):Ce(e)}A.alloc=function(e,t,r){return Aa(e,t,r)};function rn(e){return ci(e),Ce(e<0?0:nn(e)|0)}A.allocUnsafe=function(e){return rn(e)};A.allocUnsafeSlow=function(e){return rn(e)};function Ca(e,t){if((typeof t!="string"||t==="")&&(t="utf8"),!A.isEncoding(t))throw new TypeError("Unknown encoding: "+t);let r=di(e,t)|0,n=Ce(r),i=n.write(e,t);return i!==r&&(n=n.slice(0,i)),n}function en(e){let t=e.length<0?0:nn(e.length)|0,r=Ce(t);for(let n=0;n=nr)throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+nr.toString(16)+" bytes");return e|0}function Oa(e){return+e!=e&&(e=0),A.alloc(+e)}A.isBuffer=function(e){return e!=null&&e._isBuffer===!0&&e!==A.prototype};A.compare=function(e,t){if(ye(e,Uint8Array)&&(e=A.from(e,e.offset,e.byteLength)),ye(t,Uint8Array)&&(t=A.from(t,t.offset,t.byteLength)),!A.isBuffer(e)||!A.isBuffer(t))throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');if(e===t)return 0;let r=e.length,n=t.length;for(let i=0,o=Math.min(r,n);in.length?(A.isBuffer(o)||(o=A.from(o)),o.copy(n,i)):Uint8Array.prototype.set.call(n,o,i);else if(A.isBuffer(o))o.copy(n,i);else throw new TypeError('"list" argument must be an Array of Buffers');i+=o.length}return n};function di(e,t){if(A.isBuffer(e))return e.length;if(ArrayBuffer.isView(e)||ye(e,ArrayBuffer))return e.byteLength;if(typeof e!="string")throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type '+typeof e);let r=e.length,n=arguments.length>2&&arguments[2]===!0;if(!n&&r===0)return 0;let i=!1;for(;;)switch(t){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":return tn(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return r*2;case"hex":return r>>>1;case"base64":return xi(e).length;default:if(i)return n?-1:tn(e).length;t=(""+t).toLowerCase(),i=!0}}A.byteLength=di;function ka(e,t,r){let n=!1;if((t===void 0||t<0)&&(t=0),t>this.length||((r===void 0||r>this.length)&&(r=this.length),r<=0)||(r>>>=0,t>>>=0,r<=t))return"";for(e||(e="utf8");;)switch(e){case"hex":return ja(this,t,r);case"utf8":case"utf-8":return mi(this,t,r);case"ascii":return qa(this,t,r);case"latin1":case"binary":return Ba(this,t,r);case"base64":return La(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return Ua(this,t,r);default:if(n)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),n=!0}}A.prototype._isBuffer=!0;function Je(e,t,r){let n=e[t];e[t]=e[r],e[r]=n}A.prototype.swap16=function(){let e=this.length;if(e%2!==0)throw new RangeError("Buffer size must be a multiple of 16-bits");for(let t=0;tt&&(e+=" ... "),""};ii&&(A.prototype[ii]=A.prototype.inspect);A.prototype.compare=function(e,t,r,n,i){if(ye(e,Uint8Array)&&(e=A.from(e,e.offset,e.byteLength)),!A.isBuffer(e))throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type '+typeof e);if(t===void 0&&(t=0),r===void 0&&(r=e?e.length:0),n===void 0&&(n=0),i===void 0&&(i=this.length),t<0||r>e.length||n<0||i>this.length)throw new RangeError("out of range index");if(n>=i&&t>=r)return 0;if(n>=i)return-1;if(t>=r)return 1;if(t>>>=0,r>>>=0,n>>>=0,i>>>=0,this===e)return 0;let o=i-n,s=r-t,a=Math.min(o,s),l=this.slice(n,i),u=e.slice(t,r);for(let g=0;g2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),r=+r,sn(r)&&(r=i?0:e.length-1),r<0&&(r=e.length+r),r>=e.length){if(i)return-1;r=e.length-1}else if(r<0)if(i)r=0;else return-1;if(typeof t=="string"&&(t=A.from(t,n)),A.isBuffer(t))return t.length===0?-1:oi(e,t,r,n,i);if(typeof t=="number")return t=t&255,typeof Uint8Array.prototype.indexOf=="function"?i?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):oi(e,[t],r,n,i);throw new TypeError("val must be string, number or Buffer")}function oi(e,t,r,n,i){let o=1,s=e.length,a=t.length;if(n!==void 0&&(n=String(n).toLowerCase(),n==="ucs2"||n==="ucs-2"||n==="utf16le"||n==="utf-16le")){if(e.length<2||t.length<2)return-1;o=2,s/=2,a/=2,r/=2}function l(g,h){return o===1?g[h]:g.readUInt16BE(h*o)}let u;if(i){let g=-1;for(u=r;us&&(r=s-a),u=r;u>=0;u--){let g=!0;for(let h=0;hi&&(n=i)):n=i;let o=t.length;n>o/2&&(n=o/2);let s;for(s=0;s>>0,isFinite(r)?(r=r>>>0,n===void 0&&(n="utf8")):(n=r,r=void 0);else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");let i=this.length-t;if((r===void 0||r>i)&&(r=i),e.length>0&&(r<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");let o=!1;for(;;)switch(n){case"hex":return Ia(this,e,t,r);case"utf8":case"utf-8":return Fa(this,e,t,r);case"ascii":case"latin1":case"binary":return Ma(this,e,t,r);case"base64":return _a(this,e,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return Da(this,e,t,r);default:if(o)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),o=!0}};A.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};function La(e,t,r){return t===0&&r===e.length?Xr.fromByteArray(e):Xr.fromByteArray(e.slice(t,r))}function mi(e,t,r){r=Math.min(e.length,r);let n=[],i=t;for(;i239?4:o>223?3:o>191?2:1;if(i+a<=r){let l,u,g,h;switch(a){case 1:o<128&&(s=o);break;case 2:l=e[i+1],(l&192)===128&&(h=(o&31)<<6|l&63,h>127&&(s=h));break;case 3:l=e[i+1],u=e[i+2],(l&192)===128&&(u&192)===128&&(h=(o&15)<<12|(l&63)<<6|u&63,h>2047&&(h<55296||h>57343)&&(s=h));break;case 4:l=e[i+1],u=e[i+2],g=e[i+3],(l&192)===128&&(u&192)===128&&(g&192)===128&&(h=(o&15)<<18|(l&63)<<12|(u&63)<<6|g&63,h>65535&&h<1114112&&(s=h))}}s===null?(s=65533,a=1):s>65535&&(s-=65536,n.push(s>>>10&1023|55296),s=56320|s&1023),n.push(s),i+=a}return Na(n)}var si=4096;function Na(e){let t=e.length;if(t<=si)return String.fromCharCode.apply(String,e);let r="",n=0;for(;nn)&&(r=n);let i="";for(let o=t;or&&(e=r),t<0?(t+=r,t<0&&(t=0)):t>r&&(t=r),tr)throw new RangeError("Trying to access beyond buffer length")}A.prototype.readUintLE=A.prototype.readUIntLE=function(e,t,r){e=e>>>0,t=t>>>0,r||K(e,t,this.length);let n=this[e],i=1,o=0;for(;++o>>0,t=t>>>0,r||K(e,t,this.length);let n=this[e+--t],i=1;for(;t>0&&(i*=256);)n+=this[e+--t]*i;return n};A.prototype.readUint8=A.prototype.readUInt8=function(e,t){return e=e>>>0,t||K(e,1,this.length),this[e]};A.prototype.readUint16LE=A.prototype.readUInt16LE=function(e,t){return e=e>>>0,t||K(e,2,this.length),this[e]|this[e+1]<<8};A.prototype.readUint16BE=A.prototype.readUInt16BE=function(e,t){return e=e>>>0,t||K(e,2,this.length),this[e]<<8|this[e+1]};A.prototype.readUint32LE=A.prototype.readUInt32LE=function(e,t){return e=e>>>0,t||K(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+this[e+3]*16777216};A.prototype.readUint32BE=A.prototype.readUInt32BE=function(e,t){return e=e>>>0,t||K(e,4,this.length),this[e]*16777216+(this[e+1]<<16|this[e+2]<<8|this[e+3])};A.prototype.readBigUInt64LE=_e(function(e){e=e>>>0,rt(e,"offset");let t=this[e],r=this[e+7];(t===void 0||r===void 0)&&Ct(e,this.length-8);let n=t+this[++e]*2**8+this[++e]*2**16+this[++e]*2**24,i=this[++e]+this[++e]*2**8+this[++e]*2**16+r*2**24;return BigInt(n)+(BigInt(i)<>>0,rt(e,"offset");let t=this[e],r=this[e+7];(t===void 0||r===void 0)&&Ct(e,this.length-8);let n=t*2**24+this[++e]*2**16+this[++e]*2**8+this[++e],i=this[++e]*2**24+this[++e]*2**16+this[++e]*2**8+r;return(BigInt(n)<>>0,t=t>>>0,r||K(e,t,this.length);let n=this[e],i=1,o=0;for(;++o=i&&(n-=Math.pow(2,8*t)),n};A.prototype.readIntBE=function(e,t,r){e=e>>>0,t=t>>>0,r||K(e,t,this.length);let n=t,i=1,o=this[e+--n];for(;n>0&&(i*=256);)o+=this[e+--n]*i;return i*=128,o>=i&&(o-=Math.pow(2,8*t)),o};A.prototype.readInt8=function(e,t){return e=e>>>0,t||K(e,1,this.length),this[e]&128?(255-this[e]+1)*-1:this[e]};A.prototype.readInt16LE=function(e,t){e=e>>>0,t||K(e,2,this.length);let r=this[e]|this[e+1]<<8;return r&32768?r|4294901760:r};A.prototype.readInt16BE=function(e,t){e=e>>>0,t||K(e,2,this.length);let r=this[e+1]|this[e]<<8;return r&32768?r|4294901760:r};A.prototype.readInt32LE=function(e,t){return e=e>>>0,t||K(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24};A.prototype.readInt32BE=function(e,t){return e=e>>>0,t||K(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]};A.prototype.readBigInt64LE=_e(function(e){e=e>>>0,rt(e,"offset");let t=this[e],r=this[e+7];(t===void 0||r===void 0)&&Ct(e,this.length-8);let n=this[e+4]+this[e+5]*2**8+this[e+6]*2**16+(r<<24);return(BigInt(n)<>>0,rt(e,"offset");let t=this[e],r=this[e+7];(t===void 0||r===void 0)&&Ct(e,this.length-8);let n=(t<<24)+this[++e]*2**16+this[++e]*2**8+this[++e];return(BigInt(n)<>>0,t||K(e,4,this.length),tt.read(this,e,!0,23,4)};A.prototype.readFloatBE=function(e,t){return e=e>>>0,t||K(e,4,this.length),tt.read(this,e,!1,23,4)};A.prototype.readDoubleLE=function(e,t){return e=e>>>0,t||K(e,8,this.length),tt.read(this,e,!0,52,8)};A.prototype.readDoubleBE=function(e,t){return e=e>>>0,t||K(e,8,this.length),tt.read(this,e,!1,52,8)};function oe(e,t,r,n,i,o){if(!A.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>i||te.length)throw new RangeError("Index out of range")}A.prototype.writeUintLE=A.prototype.writeUIntLE=function(e,t,r,n){if(e=+e,t=t>>>0,r=r>>>0,!n){let s=Math.pow(2,8*r)-1;oe(this,e,t,r,s,0)}let i=1,o=0;for(this[t]=e&255;++o>>0,r=r>>>0,!n){let s=Math.pow(2,8*r)-1;oe(this,e,t,r,s,0)}let i=r-1,o=1;for(this[t+i]=e&255;--i>=0&&(o*=256);)this[t+i]=e/o&255;return t+r};A.prototype.writeUint8=A.prototype.writeUInt8=function(e,t,r){return e=+e,t=t>>>0,r||oe(this,e,t,1,255,0),this[t]=e&255,t+1};A.prototype.writeUint16LE=A.prototype.writeUInt16LE=function(e,t,r){return e=+e,t=t>>>0,r||oe(this,e,t,2,65535,0),this[t]=e&255,this[t+1]=e>>>8,t+2};A.prototype.writeUint16BE=A.prototype.writeUInt16BE=function(e,t,r){return e=+e,t=t>>>0,r||oe(this,e,t,2,65535,0),this[t]=e>>>8,this[t+1]=e&255,t+2};A.prototype.writeUint32LE=A.prototype.writeUInt32LE=function(e,t,r){return e=+e,t=t>>>0,r||oe(this,e,t,4,4294967295,0),this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=e&255,t+4};A.prototype.writeUint32BE=A.prototype.writeUInt32BE=function(e,t,r){return e=+e,t=t>>>0,r||oe(this,e,t,4,4294967295,0),this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=e&255,t+4};function gi(e,t,r,n,i){Ei(t,n,i,e,r,7);let o=Number(t&BigInt(4294967295));e[r++]=o,o=o>>8,e[r++]=o,o=o>>8,e[r++]=o,o=o>>8,e[r++]=o;let s=Number(t>>BigInt(32)&BigInt(4294967295));return e[r++]=s,s=s>>8,e[r++]=s,s=s>>8,e[r++]=s,s=s>>8,e[r++]=s,r}function hi(e,t,r,n,i){Ei(t,n,i,e,r,7);let o=Number(t&BigInt(4294967295));e[r+7]=o,o=o>>8,e[r+6]=o,o=o>>8,e[r+5]=o,o=o>>8,e[r+4]=o;let s=Number(t>>BigInt(32)&BigInt(4294967295));return e[r+3]=s,s=s>>8,e[r+2]=s,s=s>>8,e[r+1]=s,s=s>>8,e[r]=s,r+8}A.prototype.writeBigUInt64LE=_e(function(e,t=0){return gi(this,e,t,BigInt(0),BigInt("0xffffffffffffffff"))});A.prototype.writeBigUInt64BE=_e(function(e,t=0){return hi(this,e,t,BigInt(0),BigInt("0xffffffffffffffff"))});A.prototype.writeIntLE=function(e,t,r,n){if(e=+e,t=t>>>0,!n){let a=Math.pow(2,8*r-1);oe(this,e,t,r,a-1,-a)}let i=0,o=1,s=0;for(this[t]=e&255;++i>0)-s&255;return t+r};A.prototype.writeIntBE=function(e,t,r,n){if(e=+e,t=t>>>0,!n){let a=Math.pow(2,8*r-1);oe(this,e,t,r,a-1,-a)}let i=r-1,o=1,s=0;for(this[t+i]=e&255;--i>=0&&(o*=256);)e<0&&s===0&&this[t+i+1]!==0&&(s=1),this[t+i]=(e/o>>0)-s&255;return t+r};A.prototype.writeInt8=function(e,t,r){return e=+e,t=t>>>0,r||oe(this,e,t,1,127,-128),e<0&&(e=255+e+1),this[t]=e&255,t+1};A.prototype.writeInt16LE=function(e,t,r){return e=+e,t=t>>>0,r||oe(this,e,t,2,32767,-32768),this[t]=e&255,this[t+1]=e>>>8,t+2};A.prototype.writeInt16BE=function(e,t,r){return e=+e,t=t>>>0,r||oe(this,e,t,2,32767,-32768),this[t]=e>>>8,this[t+1]=e&255,t+2};A.prototype.writeInt32LE=function(e,t,r){return e=+e,t=t>>>0,r||oe(this,e,t,4,2147483647,-2147483648),this[t]=e&255,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24,t+4};A.prototype.writeInt32BE=function(e,t,r){return e=+e,t=t>>>0,r||oe(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=e&255,t+4};A.prototype.writeBigInt64LE=_e(function(e,t=0){return gi(this,e,t,-BigInt("0x8000000000000000"),BigInt("0x7fffffffffffffff"))});A.prototype.writeBigInt64BE=_e(function(e,t=0){return hi(this,e,t,-BigInt("0x8000000000000000"),BigInt("0x7fffffffffffffff"))});function yi(e,t,r,n,i,o){if(r+n>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function wi(e,t,r,n,i){return t=+t,r=r>>>0,i||yi(e,t,r,4,34028234663852886e22,-34028234663852886e22),tt.write(e,t,r,n,23,4),r+4}A.prototype.writeFloatLE=function(e,t,r){return wi(this,e,t,!0,r)};A.prototype.writeFloatBE=function(e,t,r){return wi(this,e,t,!1,r)};function bi(e,t,r,n,i){return t=+t,r=r>>>0,i||yi(e,t,r,8,17976931348623157e292,-17976931348623157e292),tt.write(e,t,r,n,52,8),r+8}A.prototype.writeDoubleLE=function(e,t,r){return bi(this,e,t,!0,r)};A.prototype.writeDoubleBE=function(e,t,r){return bi(this,e,t,!1,r)};A.prototype.copy=function(e,t,r,n){if(!A.isBuffer(e))throw new TypeError("argument should be a Buffer");if(r||(r=0),!n&&n!==0&&(n=this.length),t>=e.length&&(t=e.length),t||(t=0),n>0&&n=this.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),e.length-t>>0,r=r===void 0?this.length:r>>>0,e||(e=0);let i;if(typeof e=="number")for(i=t;i2**32?i=ai(String(r)):typeof r=="bigint"&&(i=String(r),(r>BigInt(2)**BigInt(32)||r<-(BigInt(2)**BigInt(32)))&&(i=ai(i)),i+="n"),n+=` It must be ${t}. Received ${i}`,n},RangeError);function ai(e){let t="",r=e.length,n=e[0]==="-"?1:0;for(;r>=n+4;r-=3)t=`_${e.slice(r-3,r)}${t}`;return`${e.slice(0,r)}${t}`}function $a(e,t,r){rt(t,"offset"),(e[t]===void 0||e[t+r]===void 0)&&Ct(t,e.length-(r+1))}function Ei(e,t,r,n,i,o){if(e>r||e3?t===0||t===BigInt(0)?a=`>= 0${s} and < 2${s} ** ${(o+1)*8}${s}`:a=`>= -(2${s} ** ${(o+1)*8-1}${s}) and < 2 ** ${(o+1)*8-1}${s}`:a=`>= ${t}${s} and <= ${r}${s}`,new et.ERR_OUT_OF_RANGE("value",a,e)}$a(n,i,o)}function rt(e,t){if(typeof e!="number")throw new et.ERR_INVALID_ARG_TYPE(t,"number",e)}function Ct(e,t,r){throw Math.floor(e)!==e?(rt(e,r),new et.ERR_OUT_OF_RANGE(r||"offset","an integer",e)):t<0?new et.ERR_BUFFER_OUT_OF_BOUNDS:new et.ERR_OUT_OF_RANGE(r||"offset",`>= ${r?1:0} and <= ${t}`,e)}var Va=/[^+/0-9A-Za-z-_]/g;function Qa(e){if(e=e.split("=")[0],e=e.trim().replace(Va,""),e.length<2)return"";for(;e.length%4!==0;)e=e+"=";return e}function tn(e,t){t=t||1/0;let r,n=e.length,i=null,o=[];for(let s=0;s55295&&r<57344){if(!i){if(r>56319){(t-=3)>-1&&o.push(239,191,189);continue}else if(s+1===n){(t-=3)>-1&&o.push(239,191,189);continue}i=r;continue}if(r<56320){(t-=3)>-1&&o.push(239,191,189),i=r;continue}r=(i-55296<<10|r-56320)+65536}else i&&(t-=3)>-1&&o.push(239,191,189);if(i=null,r<128){if((t-=1)<0)break;o.push(r)}else if(r<2048){if((t-=2)<0)break;o.push(r>>6|192,r&63|128)}else if(r<65536){if((t-=3)<0)break;o.push(r>>12|224,r>>6&63|128,r&63|128)}else if(r<1114112){if((t-=4)<0)break;o.push(r>>18|240,r>>12&63|128,r>>6&63|128,r&63|128)}else throw new Error("Invalid code point")}return o}function Ja(e){let t=[];for(let r=0;r>8,i=r%256,o.push(i),o.push(n);return o}function xi(e){return Xr.toByteArray(Qa(e))}function ir(e,t,r,n){let i;for(i=0;i=t.length||i>=e.length);++i)t[i+r]=e[i];return i}function ye(e,t){return e instanceof t||e!=null&&e.constructor!=null&&e.constructor.name!=null&&e.constructor.name===t.name}function sn(e){return e!==e}var Wa=function(){let e="0123456789abcdef",t=new Array(256);for(let r=0;r<16;++r){let n=r*16;for(let i=0;i<16;++i)t[n+i]=e[r]+e[i]}return t}();function _e(e){return typeof BigInt>"u"?Ka:e}function Ka(){throw new Error("BigInt not supported")}});var w,m=he(()=>{"use strict";w=Qe(Pi())});function hl(){return!1}function pn(){return{dev:0,ino:0,mode:0,nlink:0,uid:0,gid:0,rdev:0,size:0,blksize:0,blocks:0,atimeMs:0,mtimeMs:0,ctimeMs:0,birthtimeMs:0,atime:new Date,mtime:new Date,ctime:new Date,birthtime:new Date}}function yl(){return pn()}function wl(){return[]}function bl(e){e(null,[])}function El(){return""}function xl(){return""}function Pl(){}function vl(){}function Tl(){}function Al(){}function Cl(){}function Sl(){}function Rl(){}function Ol(){}function kl(){return{close:()=>{},on:()=>{},removeAllListeners:()=>{}}}function Il(e,t){t(null,pn())}var Fl,Ml,sr,dn=he(()=>{"use strict";m();c();p();d();f();Fl={},Ml={existsSync:hl,lstatSync:pn,stat:Il,statSync:yl,readdirSync:wl,readdir:bl,readlinkSync:El,realpathSync:xl,chmodSync:Pl,renameSync:vl,mkdirSync:Tl,rmdirSync:Al,rmSync:Cl,unlinkSync:Sl,watchFile:Rl,unwatchFile:Ol,watch:kl,promises:Fl},sr=Ml});var Di=Ve((If,_l)=>{_l.exports={name:"@prisma/internals",version:"6.19.1",description:"This package is intended for Prisma's internal use",main:"dist/index.js",types:"dist/index.d.ts",repository:{type:"git",url:"https://github.com/prisma/prisma.git",directory:"packages/internals"},homepage:"https://www.prisma.io",author:"Tim Suchanek ",bugs:"https://github.com/prisma/prisma/issues",license:"Apache-2.0",scripts:{dev:"DEV=true tsx helpers/build.ts",build:"tsx helpers/build.ts",test:"dotenv -e ../../.db.env -- jest --silent",prepublishOnly:"pnpm run build"},files:["README.md","dist","!**/libquery_engine*","!dist/get-generators/engines/*","scripts"],devDependencies:{"@babel/helper-validator-identifier":"7.25.9","@opentelemetry/api":"1.9.0","@swc/core":"1.11.5","@swc/jest":"0.2.37","@types/babel__helper-validator-identifier":"7.15.2","@types/jest":"29.5.14","@types/node":"18.19.76","@types/resolve":"1.20.6",archiver:"6.0.2","checkpoint-client":"1.1.33","cli-truncate":"4.0.0",dotenv:"16.5.0",empathic:"2.0.0","escape-string-regexp":"5.0.0",execa:"8.0.1","fast-glob":"3.3.3","find-up":"7.0.0","fp-ts":"2.16.9","fs-extra":"11.3.0","global-directory":"4.0.0",globby:"11.1.0","identifier-regex":"1.0.0","indent-string":"4.0.0","is-windows":"1.0.2","is-wsl":"3.1.0",jest:"29.7.0","jest-junit":"16.0.0",kleur:"4.1.5","mock-stdin":"1.0.0","new-github-issue-url":"0.2.1","node-fetch":"3.3.2","npm-packlist":"5.1.3",open:"7.4.2","p-map":"4.0.0",resolve:"1.22.10","string-width":"7.2.0","strip-indent":"4.0.0","temp-dir":"2.0.0",tempy:"1.0.1","terminal-link":"4.0.0",tmp:"0.2.3","ts-pattern":"5.6.2","ts-toolbelt":"9.6.0",typescript:"5.4.5",yarn:"1.22.22"},dependencies:{"@prisma/config":"workspace:*","@prisma/debug":"workspace:*","@prisma/dmmf":"workspace:*","@prisma/driver-adapter-utils":"workspace:*","@prisma/engines":"workspace:*","@prisma/fetch-engine":"workspace:*","@prisma/generator":"workspace:*","@prisma/generator-helper":"workspace:*","@prisma/get-platform":"workspace:*","@prisma/prisma-schema-wasm":"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7","@prisma/schema-engine-wasm":"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7","@prisma/schema-files-loader":"workspace:*",arg:"5.0.2",prompts:"2.4.2"},peerDependencies:{typescript:">=5.1.0"},peerDependenciesMeta:{typescript:{optional:!0}},sideEffects:!1}});function Ll(...e){return e.join("/")}function Nl(...e){return e.join("/")}function ql(e){let t=Li(e),r=Ni(e),[n,i]=t.split(".");return{root:"/",dir:r,base:t,ext:i,name:n}}function Li(e){let t=e.split("/");return t[t.length-1]}function Ni(e){return e.split("/").slice(0,-1).join("/")}function jl(e){let t=e.split("/").filter(i=>i!==""&&i!=="."),r=[];for(let i of t)i===".."?r.pop():r.push(i);let n=r.join("/");return e.startsWith("/")?"/"+n:n}var qi,Bl,Ul,$l,Re,gn=he(()=>{"use strict";m();c();p();d();f();qi="/",Bl=":";Ul={sep:qi},$l={basename:Li,delimiter:Bl,dirname:Ni,join:Nl,normalize:jl,parse:ql,posix:Ul,resolve:Ll,sep:qi},Re=$l});var Ui=Ve((Dm,ji)=>{"use strict";m();c();p();d();f();ji.exports=e=>{let t=e.match(/^[ \t]*(?=\S)/gm);return t?t.reduce((r,n)=>Math.min(r,n.length),1/0):0}});var Gi=Ve((Xm,Ji)=>{"use strict";m();c();p();d();f();Ji.exports=(e,t=1,r)=>{if(r={indent:" ",includeEmptyLines:!1,...r},typeof e!="string")throw new TypeError(`Expected \`input\` to be a \`string\`, got \`${typeof e}\``);if(typeof t!="number")throw new TypeError(`Expected \`count\` to be a \`number\`, got \`${typeof t}\``);if(typeof r.indent!="string")throw new TypeError(`Expected \`options.indent\` to be a \`string\`, got \`${typeof r.indent}\``);if(t===0)return e;let n=r.includeEmptyLines?/^/gm:/^(?!\s*$)/gm;return e.replace(n,r.indent.repeat(t))}});var Ki=Ve((Vg,cr)=>{"use strict";m();c();p();d();f();cr.exports=(e={})=>{let t;if(e.repoUrl)t=e.repoUrl;else if(e.user&&e.repo)t=`https://github.com/${e.user}/${e.repo}`;else throw new Error("You need to specify either the `repoUrl` option or both the `user` and `repo` options");let r=new URL(`${t}/issues/new`),n=["body","title","labels","template","milestone","assignee","projects"];for(let i of n){let o=e[i];if(o!==void 0){if(i==="labels"||i==="projects"){if(!Array.isArray(o))throw new TypeError(`The \`${i}\` option should be an array`);o=o.join(",")}r.searchParams.set(i,o)}}return r.toString()};cr.exports.default=cr.exports});var In=Ve((o0,wo)=>{"use strict";m();c();p();d();f();wo.exports=function(){function e(t,r,n,i,o){return tn?n+1:t+1:i===o?r:r+1}return function(t,r){if(t===r)return 0;if(t.length>r.length){var n=t;t=r,r=n}for(var i=t.length,o=r.length;i>0&&t.charCodeAt(i-1)===r.charCodeAt(o-1);)i--,o--;for(var s=0;s{"use strict";m();c();p();d();f()});var To=he(()=>{"use strict";m();c();p();d();f()});var Ko=Ve((Ov,Uc)=>{Uc.exports={name:"@prisma/engines-version",version:"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7",main:"index.js",types:"index.d.ts",license:"Apache-2.0",author:"Tim Suchanek ",prisma:{enginesVersion:"c2990dca591cba766e3b7ef5d9e8a84796e47ab7"},repository:{type:"git",url:"https://github.com/prisma/engines-wrapper.git",directory:"packages/engines-version"},devDependencies:{"@types/node":"18.19.76",typescript:"4.9.5"},files:["index.js","index.d.ts"],scripts:{build:"tsc -d"}}});var jr,zo=he(()=>{"use strict";m();c();p();d();f();jr=class{events={};on(t,r){return this.events[t]||(this.events[t]=[]),this.events[t].push(r),this}emit(t,...r){return this.events[t]?(this.events[t].forEach(n=>{n(...r)}),!0):!1}}});var ad={};Xe(ad,{DMMF:()=>Bt,Debug:()=>z,Decimal:()=>Fe,Extensions:()=>an,MetricsClient:()=>bt,PrismaClientInitializationError:()=>Q,PrismaClientKnownRequestError:()=>se,PrismaClientRustPanicError:()=>ce,PrismaClientUnknownRequestError:()=>G,PrismaClientValidationError:()=>te,Public:()=>ln,Sql:()=>le,createParam:()=>jo,defineDmmfProperty:()=>Go,deserializeJsonResponse:()=>Pt,deserializeRawResult:()=>Hr,dmmfToRuntimeDataModel:()=>Zi,empty:()=>Yo,getPrismaClient:()=>fa,getRuntime:()=>Ds,join:()=>Ho,makeStrictEnum:()=>ma,makeTypedQueryFactory:()=>Wo,objectEnumValues:()=>kr,raw:()=>jn,serializeJsonQuery:()=>Nr,skip:()=>Lr,sqltag:()=>Un,warnEnvConflicts:()=>void 0,warnOnce:()=>Lt});module.exports=xa(ad);m();c();p();d();f();var an={};Xe(an,{defineExtension:()=>vi,getExtensionContext:()=>Ti});m();c();p();d();f();m();c();p();d();f();function vi(e){return typeof e=="function"?e:t=>t.$extends(e)}m();c();p();d();f();function Ti(e){return e}var ln={};Xe(ln,{validator:()=>Ai});m();c();p();d();f();m();c();p();d();f();function Ai(...e){return t=>t}m();c();p();d();f();m();c();p();d();f();var or={};Xe(or,{$:()=>ki,bgBlack:()=>il,bgBlue:()=>ll,bgCyan:()=>cl,bgGreen:()=>sl,bgMagenta:()=>ul,bgRed:()=>ol,bgWhite:()=>pl,bgYellow:()=>al,black:()=>el,blue:()=>We,bold:()=>de,cyan:()=>Se,dim:()=>St,gray:()=>It,green:()=>Ot,grey:()=>nl,hidden:()=>Za,inverse:()=>Ya,italic:()=>Ha,magenta:()=>tl,red:()=>Ge,reset:()=>za,strikethrough:()=>Xa,underline:()=>Rt,white:()=>rl,yellow:()=>kt});m();c();p();d();f();var un,Ci,Si,Ri,Oi=!0;typeof y<"u"&&({FORCE_COLOR:un,NODE_DISABLE_COLORS:Ci,NO_COLOR:Si,TERM:Ri}=y.env||{},Oi=y.stdout&&y.stdout.isTTY);var ki={enabled:!Ci&&Si==null&&Ri!=="dumb"&&(un!=null&&un!=="0"||Oi)};function V(e,t){let r=new RegExp(`\\x1b\\[${t}m`,"g"),n=`\x1B[${e}m`,i=`\x1B[${t}m`;return function(o){return!ki.enabled||o==null?o:n+(~(""+o).indexOf(i)?o.replace(r,i+n):o)+i}}var za=V(0,0),de=V(1,22),St=V(2,22),Ha=V(3,23),Rt=V(4,24),Ya=V(7,27),Za=V(8,28),Xa=V(9,29),el=V(30,39),Ge=V(31,39),Ot=V(32,39),kt=V(33,39),We=V(34,39),tl=V(35,39),Se=V(36,39),rl=V(37,39),It=V(90,39),nl=V(90,39),il=V(40,49),ol=V(41,49),sl=V(42,49),al=V(43,49),ll=V(44,49),ul=V(45,49),cl=V(46,49),pl=V(47,49);m();c();p();d();f();var dl=100,Ii=["green","yellow","blue","magenta","cyan","red"],Ft=[],Fi=Date.now(),fl=0,cn=typeof y<"u"?y.env:{};globalThis.DEBUG??=cn.DEBUG??"";globalThis.DEBUG_COLORS??=cn.DEBUG_COLORS?cn.DEBUG_COLORS==="true":!0;var Mt={enable(e){typeof e=="string"&&(globalThis.DEBUG=e)},disable(){let e=globalThis.DEBUG;return globalThis.DEBUG="",e},enabled(e){let t=globalThis.DEBUG.split(",").map(i=>i.replace(/[.+?^${}()|[\]\\]/g,"\\$&")),r=t.some(i=>i===""||i[0]==="-"?!1:e.match(RegExp(i.split("*").join(".*")+"$"))),n=t.some(i=>i===""||i[0]!=="-"?!1:e.match(RegExp(i.slice(1).split("*").join(".*")+"$")));return r&&!n},log:(...e)=>{let[t,r,...n]=e;(console.warn??console.log)(`${t} ${r}`,...n)},formatters:{}};function ml(e){let t={color:Ii[fl++%Ii.length],enabled:Mt.enabled(e),namespace:e,log:Mt.log,extend:()=>{}},r=(...n)=>{let{enabled:i,namespace:o,color:s,log:a}=t;if(n.length!==0&&Ft.push([o,...n]),Ft.length>dl&&Ft.shift(),Mt.enabled(o)||i){let l=n.map(g=>typeof g=="string"?g:gl(g)),u=`+${Date.now()-Fi}ms`;Fi=Date.now(),globalThis.DEBUG_COLORS?a(or[s](de(o)),...l,or[s](u)):a(o,...l,u)}};return new Proxy(r,{get:(n,i)=>t[i],set:(n,i,o)=>t[i]=o})}var z=new Proxy(ml,{get:(e,t)=>Mt[t],set:(e,t,r)=>Mt[t]=r});function gl(e,t=2){let r=new Set;return JSON.stringify(e,(n,i)=>{if(typeof i=="object"&&i!==null){if(r.has(i))return"[Circular *]";r.add(i)}else if(typeof i=="bigint")return i.toString();return i},t)}function Mi(e=7500){let t=Ft.map(([r,...n])=>`${r} ${n.map(i=>typeof i=="string"?i:JSON.stringify(i)).join(" ")}`).join(` -`);return t.length{let r={adapterName:e.adapterName,errorRegistry:t,queryRaw:Oe(t,e.queryRaw.bind(e)),executeRaw:Oe(t,e.executeRaw.bind(e)),executeScript:Oe(t,e.executeScript.bind(e)),dispose:Oe(t,e.dispose.bind(e)),provider:e.provider,startTransaction:async(...n)=>(await Oe(t,e.startTransaction.bind(e))(...n)).map(o=>Jl(t,o))};return e.getConnectionInfo&&(r.getConnectionInfo=Gl(t,e.getConnectionInfo.bind(e))),r},Jl=(e,t)=>({adapterName:t.adapterName,provider:t.provider,options:t.options,queryRaw:Oe(e,t.queryRaw.bind(t)),executeRaw:Oe(e,t.executeRaw.bind(t)),commit:Oe(e,t.commit.bind(t)),rollback:Oe(e,t.rollback.bind(t))});function Oe(e,t){return async(...r)=>{try{return ar(await t(...r))}catch(n){if(Bi("[error@wrapAsync]",n),hn(n))return Ke(n.cause);let i=e.registerNewError(n);return Ke({kind:"GenericJs",id:i})}}}function Gl(e,t){return(...r)=>{try{return ar(t(...r))}catch(n){if(Bi("[error@wrapSync]",n),hn(n))return Ke(n.cause);let i=e.registerNewError(n);return Ke({kind:"GenericJs",id:i})}}}m();c();p();d();f();var $i=Qe(Ui(),1);function wn(e){let t=(0,$i.default)(e);if(t===0)return e;let r=new RegExp(`^[ \\t]{${t}}`,"gm");return e.replace(r,"")}m();c();p();d();f();var Vi="prisma+postgres",Qi=`${Vi}:`;function bn(e){return e?.toString().startsWith(`${Qi}//`)??!1}var Dt={};Xe(Dt,{error:()=>zl,info:()=>Kl,log:()=>Wl,query:()=>Hl,should:()=>Wi,tags:()=>_t,warn:()=>En});m();c();p();d();f();var _t={error:Ge("prisma:error"),warn:kt("prisma:warn"),info:Se("prisma:info"),query:We("prisma:query")},Wi={warn:()=>!y.env.PRISMA_DISABLE_WARNINGS};function Wl(...e){console.log(...e)}function En(e,...t){Wi.warn()&&console.warn(`${_t.warn} ${e}`,...t)}function Kl(e,...t){console.info(`${_t.info} ${e}`,...t)}function zl(e,...t){console.error(`${_t.error} ${e}`,...t)}function Hl(e,...t){console.log(`${_t.query} ${e}`,...t)}m();c();p();d();f();function ur(e,t){if(!e)throw new Error(`${t}. This should never happen. If you see this error, please, open an issue at https://pris.ly/prisma-prisma-bug-report`)}m();c();p();d();f();function ze(e,t){throw new Error(t)}m();c();p();d();f();m();c();p();d();f();function xn({onlyFirst:e=!1}={}){let r=["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?(?:\\u0007|\\u001B\\u005C|\\u009C))","(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"].join("|");return new RegExp(r,e?void 0:"g")}var Yl=xn();function ot(e){if(typeof e!="string")throw new TypeError(`Expected a \`string\`, got \`${typeof e}\``);return e.replace(Yl,"")}m();c();p();d();f();gn();function Pn(e){return Re.sep===Re.posix.sep?e:e.split(Re.sep).join(Re.posix.sep)}m();c();p();d();f();function vn(e,t){return Object.prototype.hasOwnProperty.call(e,t)}m();c();p();d();f();function pr(e,t){let r={};for(let n of Object.keys(e))r[n]=t(e[n],n);return r}m();c();p();d();f();function Tn(e,t){if(e.length===0)return;let r=e[0];for(let n=1;n{zi.has(e)||(zi.add(e),En(t,...r))};var Q=class e extends Error{clientVersion;errorCode;retryable;constructor(t,r,n){super(t),this.name="PrismaClientInitializationError",this.clientVersion=r,this.errorCode=n,Error.captureStackTrace(e)}get[Symbol.toStringTag](){return"PrismaClientInitializationError"}};ue(Q,"PrismaClientInitializationError");m();c();p();d();f();var se=class extends Error{code;meta;clientVersion;batchRequestIdx;constructor(t,{code:r,clientVersion:n,meta:i,batchRequestIdx:o}){super(t),this.name="PrismaClientKnownRequestError",this.code=r,this.clientVersion=n,this.meta=i,Object.defineProperty(this,"batchRequestIdx",{value:o,enumerable:!1,writable:!0})}get[Symbol.toStringTag](){return"PrismaClientKnownRequestError"}};ue(se,"PrismaClientKnownRequestError");m();c();p();d();f();var ce=class extends Error{clientVersion;constructor(t,r){super(t),this.name="PrismaClientRustPanicError",this.clientVersion=r}get[Symbol.toStringTag](){return"PrismaClientRustPanicError"}};ue(ce,"PrismaClientRustPanicError");m();c();p();d();f();var G=class extends Error{clientVersion;batchRequestIdx;constructor(t,{clientVersion:r,batchRequestIdx:n}){super(t),this.name="PrismaClientUnknownRequestError",this.clientVersion=r,Object.defineProperty(this,"batchRequestIdx",{value:n,writable:!0,enumerable:!1})}get[Symbol.toStringTag](){return"PrismaClientUnknownRequestError"}};ue(G,"PrismaClientUnknownRequestError");m();c();p();d();f();var te=class extends Error{name="PrismaClientValidationError";clientVersion;constructor(t,{clientVersion:r}){super(t),this.clientVersion=r}get[Symbol.toStringTag](){return"PrismaClientValidationError"}};ue(te,"PrismaClientValidationError");m();c();p();d();f();m();c();p();d();f();m();c();p();d();f();var we=class{_map=new Map;get(t){return this._map.get(t)?.value}set(t,r){this._map.set(t,{value:r})}getOrCreate(t,r){let n=this._map.get(t);if(n)return n.value;let i=r();return this.set(t,i),i}};m();c();p();d();f();function De(e){return e.substring(0,1).toLowerCase()+e.substring(1)}m();c();p();d();f();function Yi(e,t){let r={};for(let n of e){let i=n[t];r[i]=n}return r}m();c();p();d();f();function Nt(e){let t;return{get(){return t||(t={value:e()}),t.value}}}m();c();p();d();f();function Zi(e){return{models:An(e.models),enums:An(e.enums),types:An(e.types)}}function An(e){let t={};for(let{name:r,...n}of e)t[r]=n;return t}m();c();p();d();f();function st(e){return e instanceof Date||Object.prototype.toString.call(e)==="[object Date]"}function dr(e){return e.toString()!=="Invalid Date"}m();c();p();d();f();m();c();p();d();f();var at=9e15,Be=1e9,Cn="0123456789abcdef",gr="2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058",hr="3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789",Sn={precision:20,rounding:4,modulo:1,toExpNeg:-7,toExpPos:21,minE:-at,maxE:at,crypto:!1},ro,ke,D=!0,wr="[DecimalError] ",qe=wr+"Invalid argument: ",no=wr+"Precision limit exceeded",io=wr+"crypto unavailable",oo="[object Decimal]",re=Math.floor,W=Math.pow,Zl=/^0b([01]+(\.[01]*)?|\.[01]+)(p[+-]?\d+)?$/i,Xl=/^0x([0-9a-f]+(\.[0-9a-f]*)?|\.[0-9a-f]+)(p[+-]?\d+)?$/i,eu=/^0o([0-7]+(\.[0-7]*)?|\.[0-7]+)(p[+-]?\d+)?$/i,so=/^(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i,fe=1e7,M=7,tu=9007199254740991,ru=gr.length-1,Rn=hr.length-1,R={toStringTag:oo};R.absoluteValue=R.abs=function(){var e=new this.constructor(this);return e.s<0&&(e.s=1),I(e)};R.ceil=function(){return I(new this.constructor(this),this.e+1,2)};R.clampedTo=R.clamp=function(e,t){var r,n=this,i=n.constructor;if(e=new i(e),t=new i(t),!e.s||!t.s)return new i(NaN);if(e.gt(t))throw Error(qe+t);return r=n.cmp(e),r<0?e:n.cmp(t)>0?t:new i(n)};R.comparedTo=R.cmp=function(e){var t,r,n,i,o=this,s=o.d,a=(e=new o.constructor(e)).d,l=o.s,u=e.s;if(!s||!a)return!l||!u?NaN:l!==u?l:s===a?0:!s^l<0?1:-1;if(!s[0]||!a[0])return s[0]?l:a[0]?-u:0;if(l!==u)return l;if(o.e!==e.e)return o.e>e.e^l<0?1:-1;for(n=s.length,i=a.length,t=0,r=na[t]^l<0?1:-1;return n===i?0:n>i^l<0?1:-1};R.cosine=R.cos=function(){var e,t,r=this,n=r.constructor;return r.d?r.d[0]?(e=n.precision,t=n.rounding,n.precision=e+Math.max(r.e,r.sd())+M,n.rounding=1,r=nu(n,po(n,r)),n.precision=e,n.rounding=t,I(ke==2||ke==3?r.neg():r,e,t,!0)):new n(1):new n(NaN)};R.cubeRoot=R.cbrt=function(){var e,t,r,n,i,o,s,a,l,u,g=this,h=g.constructor;if(!g.isFinite()||g.isZero())return new h(g);for(D=!1,o=g.s*W(g.s*g,1/3),!o||Math.abs(o)==1/0?(r=Z(g.d),e=g.e,(o=(e-r.length+1)%3)&&(r+=o==1||o==-2?"0":"00"),o=W(r,1/3),e=re((e+1)/3)-(e%3==(e<0?-1:2)),o==1/0?r="5e"+e:(r=o.toExponential(),r=r.slice(0,r.indexOf("e")+1)+e),n=new h(r),n.s=g.s):n=new h(o.toString()),s=(e=h.precision)+3;;)if(a=n,l=a.times(a).times(a),u=l.plus(g),n=U(u.plus(g).times(a),u.plus(l),s+2,1),Z(a.d).slice(0,s)===(r=Z(n.d)).slice(0,s))if(r=r.slice(s-3,s+1),r=="9999"||!i&&r=="4999"){if(!i&&(I(a,e+1,0),a.times(a).times(a).eq(g))){n=a;break}s+=4,i=1}else{(!+r||!+r.slice(1)&&r.charAt(0)=="5")&&(I(n,e+1,1),t=!n.times(n).times(n).eq(g));break}return D=!0,I(n,e,h.rounding,t)};R.decimalPlaces=R.dp=function(){var e,t=this.d,r=NaN;if(t){if(e=t.length-1,r=(e-re(this.e/M))*M,e=t[e],e)for(;e%10==0;e/=10)r--;r<0&&(r=0)}return r};R.dividedBy=R.div=function(e){return U(this,new this.constructor(e))};R.dividedToIntegerBy=R.divToInt=function(e){var t=this,r=t.constructor;return I(U(t,new r(e),0,1,1),r.precision,r.rounding)};R.equals=R.eq=function(e){return this.cmp(e)===0};R.floor=function(){return I(new this.constructor(this),this.e+1,3)};R.greaterThan=R.gt=function(e){return this.cmp(e)>0};R.greaterThanOrEqualTo=R.gte=function(e){var t=this.cmp(e);return t==1||t===0};R.hyperbolicCosine=R.cosh=function(){var e,t,r,n,i,o=this,s=o.constructor,a=new s(1);if(!o.isFinite())return new s(o.s?1/0:NaN);if(o.isZero())return a;r=s.precision,n=s.rounding,s.precision=r+Math.max(o.e,o.sd())+4,s.rounding=1,i=o.d.length,i<32?(e=Math.ceil(i/3),t=(1/Er(4,e)).toString()):(e=16,t="2.3283064365386962890625e-10"),o=lt(s,1,o.times(t),new s(1),!0);for(var l,u=e,g=new s(8);u--;)l=o.times(o),o=a.minus(l.times(g.minus(l.times(g))));return I(o,s.precision=r,s.rounding=n,!0)};R.hyperbolicSine=R.sinh=function(){var e,t,r,n,i=this,o=i.constructor;if(!i.isFinite()||i.isZero())return new o(i);if(t=o.precision,r=o.rounding,o.precision=t+Math.max(i.e,i.sd())+4,o.rounding=1,n=i.d.length,n<3)i=lt(o,2,i,i,!0);else{e=1.4*Math.sqrt(n),e=e>16?16:e|0,i=i.times(1/Er(5,e)),i=lt(o,2,i,i,!0);for(var s,a=new o(5),l=new o(16),u=new o(20);e--;)s=i.times(i),i=i.times(a.plus(s.times(l.times(s).plus(u))))}return o.precision=t,o.rounding=r,I(i,t,r,!0)};R.hyperbolicTangent=R.tanh=function(){var e,t,r=this,n=r.constructor;return r.isFinite()?r.isZero()?new n(r):(e=n.precision,t=n.rounding,n.precision=e+7,n.rounding=1,U(r.sinh(),r.cosh(),n.precision=e,n.rounding=t)):new n(r.s)};R.inverseCosine=R.acos=function(){var e=this,t=e.constructor,r=e.abs().cmp(1),n=t.precision,i=t.rounding;return r!==-1?r===0?e.isNeg()?be(t,n,i):new t(0):new t(NaN):e.isZero()?be(t,n+4,i).times(.5):(t.precision=n+6,t.rounding=1,e=new t(1).minus(e).div(e.plus(1)).sqrt().atan(),t.precision=n,t.rounding=i,e.times(2))};R.inverseHyperbolicCosine=R.acosh=function(){var e,t,r=this,n=r.constructor;return r.lte(1)?new n(r.eq(1)?0:NaN):r.isFinite()?(e=n.precision,t=n.rounding,n.precision=e+Math.max(Math.abs(r.e),r.sd())+4,n.rounding=1,D=!1,r=r.times(r).minus(1).sqrt().plus(r),D=!0,n.precision=e,n.rounding=t,r.ln()):new n(r)};R.inverseHyperbolicSine=R.asinh=function(){var e,t,r=this,n=r.constructor;return!r.isFinite()||r.isZero()?new n(r):(e=n.precision,t=n.rounding,n.precision=e+2*Math.max(Math.abs(r.e),r.sd())+6,n.rounding=1,D=!1,r=r.times(r).plus(1).sqrt().plus(r),D=!0,n.precision=e,n.rounding=t,r.ln())};R.inverseHyperbolicTangent=R.atanh=function(){var e,t,r,n,i=this,o=i.constructor;return i.isFinite()?i.e>=0?new o(i.abs().eq(1)?i.s/0:i.isZero()?i:NaN):(e=o.precision,t=o.rounding,n=i.sd(),Math.max(n,e)<2*-i.e-1?I(new o(i),e,t,!0):(o.precision=r=n-i.e,i=U(i.plus(1),new o(1).minus(i),r+e,1),o.precision=e+4,o.rounding=1,i=i.ln(),o.precision=e,o.rounding=t,i.times(.5))):new o(NaN)};R.inverseSine=R.asin=function(){var e,t,r,n,i=this,o=i.constructor;return i.isZero()?new o(i):(t=i.abs().cmp(1),r=o.precision,n=o.rounding,t!==-1?t===0?(e=be(o,r+4,n).times(.5),e.s=i.s,e):new o(NaN):(o.precision=r+6,o.rounding=1,i=i.div(new o(1).minus(i.times(i)).sqrt().plus(1)).atan(),o.precision=r,o.rounding=n,i.times(2)))};R.inverseTangent=R.atan=function(){var e,t,r,n,i,o,s,a,l,u=this,g=u.constructor,h=g.precision,T=g.rounding;if(u.isFinite()){if(u.isZero())return new g(u);if(u.abs().eq(1)&&h+4<=Rn)return s=be(g,h+4,T).times(.25),s.s=u.s,s}else{if(!u.s)return new g(NaN);if(h+4<=Rn)return s=be(g,h+4,T).times(.5),s.s=u.s,s}for(g.precision=a=h+10,g.rounding=1,r=Math.min(28,a/M+2|0),e=r;e;--e)u=u.div(u.times(u).plus(1).sqrt().plus(1));for(D=!1,t=Math.ceil(a/M),n=1,l=u.times(u),s=new g(u),i=u;e!==-1;)if(i=i.times(l),o=s.minus(i.div(n+=2)),i=i.times(l),s=o.plus(i.div(n+=2)),s.d[t]!==void 0)for(e=t;s.d[e]===o.d[e]&&e--;);return r&&(s=s.times(2<this.d.length-2};R.isNaN=function(){return!this.s};R.isNegative=R.isNeg=function(){return this.s<0};R.isPositive=R.isPos=function(){return this.s>0};R.isZero=function(){return!!this.d&&this.d[0]===0};R.lessThan=R.lt=function(e){return this.cmp(e)<0};R.lessThanOrEqualTo=R.lte=function(e){return this.cmp(e)<1};R.logarithm=R.log=function(e){var t,r,n,i,o,s,a,l,u=this,g=u.constructor,h=g.precision,T=g.rounding,O=5;if(e==null)e=new g(10),t=!0;else{if(e=new g(e),r=e.d,e.s<0||!r||!r[0]||e.eq(1))return new g(NaN);t=e.eq(10)}if(r=u.d,u.s<0||!r||!r[0]||u.eq(1))return new g(r&&!r[0]?-1/0:u.s!=1?NaN:r?0:1/0);if(t)if(r.length>1)o=!0;else{for(i=r[0];i%10===0;)i/=10;o=i!==1}if(D=!1,a=h+O,s=Ne(u,a),n=t?yr(g,a+10):Ne(e,a),l=U(s,n,a,1),qt(l.d,i=h,T))do if(a+=10,s=Ne(u,a),n=t?yr(g,a+10):Ne(e,a),l=U(s,n,a,1),!o){+Z(l.d).slice(i+1,i+15)+1==1e14&&(l=I(l,h+1,0));break}while(qt(l.d,i+=10,T));return D=!0,I(l,h,T)};R.minus=R.sub=function(e){var t,r,n,i,o,s,a,l,u,g,h,T,O=this,C=O.constructor;if(e=new C(e),!O.d||!e.d)return!O.s||!e.s?e=new C(NaN):O.d?e.s=-e.s:e=new C(e.d||O.s!==e.s?O:NaN),e;if(O.s!=e.s)return e.s=-e.s,O.plus(e);if(u=O.d,T=e.d,a=C.precision,l=C.rounding,!u[0]||!T[0]){if(T[0])e.s=-e.s;else if(u[0])e=new C(O);else return new C(l===3?-0:0);return D?I(e,a,l):e}if(r=re(e.e/M),g=re(O.e/M),u=u.slice(),o=g-r,o){for(h=o<0,h?(t=u,o=-o,s=T.length):(t=T,r=g,s=u.length),n=Math.max(Math.ceil(a/M),s)+2,o>n&&(o=n,t.length=1),t.reverse(),n=o;n--;)t.push(0);t.reverse()}else{for(n=u.length,s=T.length,h=n0;--n)u[s++]=0;for(n=T.length;n>o;){if(u[--n]s?o+1:s+1,i>s&&(i=s,r.length=1),r.reverse();i--;)r.push(0);r.reverse()}for(s=u.length,i=g.length,s-i<0&&(i=s,r=g,g=u,u=r),t=0;i;)t=(u[--i]=u[i]+g[i]+t)/fe|0,u[i]%=fe;for(t&&(u.unshift(t),++n),s=u.length;u[--s]==0;)u.pop();return e.d=u,e.e=br(u,n),D?I(e,a,l):e};R.precision=R.sd=function(e){var t,r=this;if(e!==void 0&&e!==!!e&&e!==1&&e!==0)throw Error(qe+e);return r.d?(t=ao(r.d),e&&r.e+1>t&&(t=r.e+1)):t=NaN,t};R.round=function(){var e=this,t=e.constructor;return I(new t(e),e.e+1,t.rounding)};R.sine=R.sin=function(){var e,t,r=this,n=r.constructor;return r.isFinite()?r.isZero()?new n(r):(e=n.precision,t=n.rounding,n.precision=e+Math.max(r.e,r.sd())+M,n.rounding=1,r=ou(n,po(n,r)),n.precision=e,n.rounding=t,I(ke>2?r.neg():r,e,t,!0)):new n(NaN)};R.squareRoot=R.sqrt=function(){var e,t,r,n,i,o,s=this,a=s.d,l=s.e,u=s.s,g=s.constructor;if(u!==1||!a||!a[0])return new g(!u||u<0&&(!a||a[0])?NaN:a?s:1/0);for(D=!1,u=Math.sqrt(+s),u==0||u==1/0?(t=Z(a),(t.length+l)%2==0&&(t+="0"),u=Math.sqrt(t),l=re((l+1)/2)-(l<0||l%2),u==1/0?t="5e"+l:(t=u.toExponential(),t=t.slice(0,t.indexOf("e")+1)+l),n=new g(t)):n=new g(u.toString()),r=(l=g.precision)+3;;)if(o=n,n=o.plus(U(s,o,r+2,1)).times(.5),Z(o.d).slice(0,r)===(t=Z(n.d)).slice(0,r))if(t=t.slice(r-3,r+1),t=="9999"||!i&&t=="4999"){if(!i&&(I(o,l+1,0),o.times(o).eq(s))){n=o;break}r+=4,i=1}else{(!+t||!+t.slice(1)&&t.charAt(0)=="5")&&(I(n,l+1,1),e=!n.times(n).eq(s));break}return D=!0,I(n,l,g.rounding,e)};R.tangent=R.tan=function(){var e,t,r=this,n=r.constructor;return r.isFinite()?r.isZero()?new n(r):(e=n.precision,t=n.rounding,n.precision=e+10,n.rounding=1,r=r.sin(),r.s=1,r=U(r,new n(1).minus(r.times(r)).sqrt(),e+10,0),n.precision=e,n.rounding=t,I(ke==2||ke==4?r.neg():r,e,t,!0)):new n(NaN)};R.times=R.mul=function(e){var t,r,n,i,o,s,a,l,u,g=this,h=g.constructor,T=g.d,O=(e=new h(e)).d;if(e.s*=g.s,!T||!T[0]||!O||!O[0])return new h(!e.s||T&&!T[0]&&!O||O&&!O[0]&&!T?NaN:!T||!O?e.s/0:e.s*0);for(r=re(g.e/M)+re(e.e/M),l=T.length,u=O.length,l=0;){for(t=0,i=l+n;i>n;)a=o[i]+O[n]*T[i-n-1]+t,o[i--]=a%fe|0,t=a/fe|0;o[i]=(o[i]+t)%fe|0}for(;!o[--s];)o.pop();return t?++r:o.shift(),e.d=o,e.e=br(o,r),D?I(e,h.precision,h.rounding):e};R.toBinary=function(e,t){return kn(this,2,e,t)};R.toDecimalPlaces=R.toDP=function(e,t){var r=this,n=r.constructor;return r=new n(r),e===void 0?r:(ae(e,0,Be),t===void 0?t=n.rounding:ae(t,0,8),I(r,e+r.e+1,t))};R.toExponential=function(e,t){var r,n=this,i=n.constructor;return e===void 0?r=Ee(n,!0):(ae(e,0,Be),t===void 0?t=i.rounding:ae(t,0,8),n=I(new i(n),e+1,t),r=Ee(n,!0,e+1)),n.isNeg()&&!n.isZero()?"-"+r:r};R.toFixed=function(e,t){var r,n,i=this,o=i.constructor;return e===void 0?r=Ee(i):(ae(e,0,Be),t===void 0?t=o.rounding:ae(t,0,8),n=I(new o(i),e+i.e+1,t),r=Ee(n,!1,e+n.e+1)),i.isNeg()&&!i.isZero()?"-"+r:r};R.toFraction=function(e){var t,r,n,i,o,s,a,l,u,g,h,T,O=this,C=O.d,S=O.constructor;if(!C)return new S(O);if(u=r=new S(1),n=l=new S(0),t=new S(n),o=t.e=ao(C)-O.e-1,s=o%M,t.d[0]=W(10,s<0?M+s:s),e==null)e=o>0?t:u;else{if(a=new S(e),!a.isInt()||a.lt(u))throw Error(qe+a);e=a.gt(t)?o>0?t:u:a}for(D=!1,a=new S(Z(C)),g=S.precision,S.precision=o=C.length*M*2;h=U(a,t,0,1,1),i=r.plus(h.times(n)),i.cmp(e)!=1;)r=n,n=i,i=u,u=l.plus(h.times(i)),l=i,i=t,t=a.minus(h.times(i)),a=i;return i=U(e.minus(r),n,0,1,1),l=l.plus(i.times(u)),r=r.plus(i.times(n)),l.s=u.s=O.s,T=U(u,n,o,1).minus(O).abs().cmp(U(l,r,o,1).minus(O).abs())<1?[u,n]:[l,r],S.precision=g,D=!0,T};R.toHexadecimal=R.toHex=function(e,t){return kn(this,16,e,t)};R.toNearest=function(e,t){var r=this,n=r.constructor;if(r=new n(r),e==null){if(!r.d)return r;e=new n(1),t=n.rounding}else{if(e=new n(e),t===void 0?t=n.rounding:ae(t,0,8),!r.d)return e.s?r:e;if(!e.d)return e.s&&(e.s=r.s),e}return e.d[0]?(D=!1,r=U(r,e,0,t,1).times(e),D=!0,I(r)):(e.s=r.s,r=e),r};R.toNumber=function(){return+this};R.toOctal=function(e,t){return kn(this,8,e,t)};R.toPower=R.pow=function(e){var t,r,n,i,o,s,a=this,l=a.constructor,u=+(e=new l(e));if(!a.d||!e.d||!a.d[0]||!e.d[0])return new l(W(+a,u));if(a=new l(a),a.eq(1))return a;if(n=l.precision,o=l.rounding,e.eq(1))return I(a,n,o);if(t=re(e.e/M),t>=e.d.length-1&&(r=u<0?-u:u)<=tu)return i=lo(l,a,r,n),e.s<0?new l(1).div(i):I(i,n,o);if(s=a.s,s<0){if(tl.maxE+1||t0?s/0:0):(D=!1,l.rounding=a.s=1,r=Math.min(12,(t+"").length),i=On(e.times(Ne(a,n+r)),n),i.d&&(i=I(i,n+5,1),qt(i.d,n,o)&&(t=n+10,i=I(On(e.times(Ne(a,t+r)),t),t+5,1),+Z(i.d).slice(n+1,n+15)+1==1e14&&(i=I(i,n+1,0)))),i.s=s,D=!0,l.rounding=o,I(i,n,o))};R.toPrecision=function(e,t){var r,n=this,i=n.constructor;return e===void 0?r=Ee(n,n.e<=i.toExpNeg||n.e>=i.toExpPos):(ae(e,1,Be),t===void 0?t=i.rounding:ae(t,0,8),n=I(new i(n),e,t),r=Ee(n,e<=n.e||n.e<=i.toExpNeg,e)),n.isNeg()&&!n.isZero()?"-"+r:r};R.toSignificantDigits=R.toSD=function(e,t){var r=this,n=r.constructor;return e===void 0?(e=n.precision,t=n.rounding):(ae(e,1,Be),t===void 0?t=n.rounding:ae(t,0,8)),I(new n(r),e,t)};R.toString=function(){var e=this,t=e.constructor,r=Ee(e,e.e<=t.toExpNeg||e.e>=t.toExpPos);return e.isNeg()&&!e.isZero()?"-"+r:r};R.truncated=R.trunc=function(){return I(new this.constructor(this),this.e+1,1)};R.valueOf=R.toJSON=function(){var e=this,t=e.constructor,r=Ee(e,e.e<=t.toExpNeg||e.e>=t.toExpPos);return e.isNeg()?"-"+r:r};function Z(e){var t,r,n,i=e.length-1,o="",s=e[0];if(i>0){for(o+=s,t=1;tr)throw Error(qe+e)}function qt(e,t,r,n){var i,o,s,a;for(o=e[0];o>=10;o/=10)--t;return--t<0?(t+=M,i=0):(i=Math.ceil((t+1)/M),t%=M),o=W(10,M-t),a=e[i]%o|0,n==null?t<3?(t==0?a=a/100|0:t==1&&(a=a/10|0),s=r<4&&a==99999||r>3&&a==49999||a==5e4||a==0):s=(r<4&&a+1==o||r>3&&a+1==o/2)&&(e[i+1]/o/100|0)==W(10,t-2)-1||(a==o/2||a==0)&&(e[i+1]/o/100|0)==0:t<4?(t==0?a=a/1e3|0:t==1?a=a/100|0:t==2&&(a=a/10|0),s=(n||r<4)&&a==9999||!n&&r>3&&a==4999):s=((n||r<4)&&a+1==o||!n&&r>3&&a+1==o/2)&&(e[i+1]/o/1e3|0)==W(10,t-3)-1,s}function fr(e,t,r){for(var n,i=[0],o,s=0,a=e.length;sr-1&&(i[n+1]===void 0&&(i[n+1]=0),i[n+1]+=i[n]/r|0,i[n]%=r)}return i.reverse()}function nu(e,t){var r,n,i;if(t.isZero())return t;n=t.d.length,n<32?(r=Math.ceil(n/3),i=(1/Er(4,r)).toString()):(r=16,i="2.3283064365386962890625e-10"),e.precision+=r,t=lt(e,1,t.times(i),new e(1));for(var o=r;o--;){var s=t.times(t);t=s.times(s).minus(s).times(8).plus(1)}return e.precision-=r,t}var U=function(){function e(n,i,o){var s,a=0,l=n.length;for(n=n.slice();l--;)s=n[l]*i+a,n[l]=s%o|0,a=s/o|0;return a&&n.unshift(a),n}function t(n,i,o,s){var a,l;if(o!=s)l=o>s?1:-1;else for(a=l=0;ai[a]?1:-1;break}return l}function r(n,i,o,s){for(var a=0;o--;)n[o]-=a,a=n[o]1;)n.shift()}return function(n,i,o,s,a,l){var u,g,h,T,O,C,S,F,_,L,k,q,Y,$,At,J,ie,Ae,X,Ze,tr=n.constructor,Zr=n.s==i.s?1:-1,ee=n.d,B=i.d;if(!ee||!ee[0]||!B||!B[0])return new tr(!n.s||!i.s||(ee?B&&ee[0]==B[0]:!B)?NaN:ee&&ee[0]==0||!B?Zr*0:Zr/0);for(l?(O=1,g=n.e-i.e):(l=fe,O=M,g=re(n.e/O)-re(i.e/O)),X=B.length,ie=ee.length,_=new tr(Zr),L=_.d=[],h=0;B[h]==(ee[h]||0);h++);if(B[h]>(ee[h]||0)&&g--,o==null?($=o=tr.precision,s=tr.rounding):a?$=o+(n.e-i.e)+1:$=o,$<0)L.push(1),C=!0;else{if($=$/O+2|0,h=0,X==1){for(T=0,B=B[0],$++;(h1&&(B=e(B,T,l),ee=e(ee,T,l),X=B.length,ie=ee.length),J=X,k=ee.slice(0,X),q=k.length;q=l/2&&++Ae;do T=0,u=t(B,k,X,q),u<0?(Y=k[0],X!=q&&(Y=Y*l+(k[1]||0)),T=Y/Ae|0,T>1?(T>=l&&(T=l-1),S=e(B,T,l),F=S.length,q=k.length,u=t(S,k,F,q),u==1&&(T--,r(S,X=10;T/=10)h++;_.e=h+g*O-1,I(_,a?o+_.e+1:o,s,C)}return _}}();function I(e,t,r,n){var i,o,s,a,l,u,g,h,T,O=e.constructor;e:if(t!=null){if(h=e.d,!h)return e;for(i=1,a=h[0];a>=10;a/=10)i++;if(o=t-i,o<0)o+=M,s=t,g=h[T=0],l=g/W(10,i-s-1)%10|0;else if(T=Math.ceil((o+1)/M),a=h.length,T>=a)if(n){for(;a++<=T;)h.push(0);g=l=0,i=1,o%=M,s=o-M+1}else break e;else{for(g=a=h[T],i=1;a>=10;a/=10)i++;o%=M,s=o-M+i,l=s<0?0:g/W(10,i-s-1)%10|0}if(n=n||t<0||h[T+1]!==void 0||(s<0?g:g%W(10,i-s-1)),u=r<4?(l||n)&&(r==0||r==(e.s<0?3:2)):l>5||l==5&&(r==4||n||r==6&&(o>0?s>0?g/W(10,i-s):0:h[T-1])%10&1||r==(e.s<0?8:7)),t<1||!h[0])return h.length=0,u?(t-=e.e+1,h[0]=W(10,(M-t%M)%M),e.e=-t||0):h[0]=e.e=0,e;if(o==0?(h.length=T,a=1,T--):(h.length=T+1,a=W(10,M-o),h[T]=s>0?(g/W(10,i-s)%W(10,s)|0)*a:0),u)for(;;)if(T==0){for(o=1,s=h[0];s>=10;s/=10)o++;for(s=h[0]+=a,a=1;s>=10;s/=10)a++;o!=a&&(e.e++,h[0]==fe&&(h[0]=1));break}else{if(h[T]+=a,h[T]!=fe)break;h[T--]=0,a=1}for(o=h.length;h[--o]===0;)h.pop()}return D&&(e.e>O.maxE?(e.d=null,e.e=NaN):e.e0?o=o.charAt(0)+"."+o.slice(1)+Le(n):s>1&&(o=o.charAt(0)+"."+o.slice(1)),o=o+(e.e<0?"e":"e+")+e.e):i<0?(o="0."+Le(-i-1)+o,r&&(n=r-s)>0&&(o+=Le(n))):i>=s?(o+=Le(i+1-s),r&&(n=r-i-1)>0&&(o=o+"."+Le(n))):((n=i+1)0&&(i+1===s&&(o+="."),o+=Le(n))),o}function br(e,t){var r=e[0];for(t*=M;r>=10;r/=10)t++;return t}function yr(e,t,r){if(t>ru)throw D=!0,r&&(e.precision=r),Error(no);return I(new e(gr),t,1,!0)}function be(e,t,r){if(t>Rn)throw Error(no);return I(new e(hr),t,r,!0)}function ao(e){var t=e.length-1,r=t*M+1;if(t=e[t],t){for(;t%10==0;t/=10)r--;for(t=e[0];t>=10;t/=10)r++}return r}function Le(e){for(var t="";e--;)t+="0";return t}function lo(e,t,r,n){var i,o=new e(1),s=Math.ceil(n/M+4);for(D=!1;;){if(r%2&&(o=o.times(t),eo(o.d,s)&&(i=!0)),r=re(r/2),r===0){r=o.d.length-1,i&&o.d[r]===0&&++o.d[r];break}t=t.times(t),eo(t.d,s)}return D=!0,o}function Xi(e){return e.d[e.d.length-1]&1}function uo(e,t,r){for(var n,i,o=new e(t[0]),s=0;++s17)return new T(e.d?e.d[0]?e.s<0?0:1/0:1:e.s?e.s<0?0:e:NaN);for(t==null?(D=!1,l=C):l=t,a=new T(.03125);e.e>-2;)e=e.times(a),h+=5;for(n=Math.log(W(2,h))/Math.LN10*2+5|0,l+=n,r=o=s=new T(1),T.precision=l;;){if(o=I(o.times(e),l,1),r=r.times(++g),a=s.plus(U(o,r,l,1)),Z(a.d).slice(0,l)===Z(s.d).slice(0,l)){for(i=h;i--;)s=I(s.times(s),l,1);if(t==null)if(u<3&&qt(s.d,l-n,O,u))T.precision=l+=10,r=o=a=new T(1),g=0,u++;else return I(s,T.precision=C,O,D=!0);else return T.precision=C,s}s=a}}function Ne(e,t){var r,n,i,o,s,a,l,u,g,h,T,O=1,C=10,S=e,F=S.d,_=S.constructor,L=_.rounding,k=_.precision;if(S.s<0||!F||!F[0]||!S.e&&F[0]==1&&F.length==1)return new _(F&&!F[0]?-1/0:S.s!=1?NaN:F?0:S);if(t==null?(D=!1,g=k):g=t,_.precision=g+=C,r=Z(F),n=r.charAt(0),Math.abs(o=S.e)<15e14){for(;n<7&&n!=1||n==1&&r.charAt(1)>3;)S=S.times(e),r=Z(S.d),n=r.charAt(0),O++;o=S.e,n>1?(S=new _("0."+r),o++):S=new _(n+"."+r.slice(1))}else return u=yr(_,g+2,k).times(o+""),S=Ne(new _(n+"."+r.slice(1)),g-C).plus(u),_.precision=k,t==null?I(S,k,L,D=!0):S;for(h=S,l=s=S=U(S.minus(1),S.plus(1),g,1),T=I(S.times(S),g,1),i=3;;){if(s=I(s.times(T),g,1),u=l.plus(U(s,new _(i),g,1)),Z(u.d).slice(0,g)===Z(l.d).slice(0,g))if(l=l.times(2),o!==0&&(l=l.plus(yr(_,g+2,k).times(o+""))),l=U(l,new _(O),g,1),t==null)if(qt(l.d,g-C,L,a))_.precision=g+=C,u=s=S=U(h.minus(1),h.plus(1),g,1),T=I(S.times(S),g,1),i=a=1;else return I(l,_.precision=k,L,D=!0);else return _.precision=k,l;l=u,i+=2}}function co(e){return String(e.s*e.s/0)}function mr(e,t){var r,n,i;for((r=t.indexOf("."))>-1&&(t=t.replace(".","")),(n=t.search(/e/i))>0?(r<0&&(r=n),r+=+t.slice(n+1),t=t.substring(0,n)):r<0&&(r=t.length),n=0;t.charCodeAt(n)===48;n++);for(i=t.length;t.charCodeAt(i-1)===48;--i);if(t=t.slice(n,i),t){if(i-=n,e.e=r=r-n-1,e.d=[],n=(r+1)%M,r<0&&(n+=M),ne.constructor.maxE?(e.d=null,e.e=NaN):e.e-1){if(t=t.replace(/(\d)_(?=\d)/g,"$1"),so.test(t))return mr(e,t)}else if(t==="Infinity"||t==="NaN")return+t||(e.s=NaN),e.e=NaN,e.d=null,e;if(Xl.test(t))r=16,t=t.toLowerCase();else if(Zl.test(t))r=2;else if(eu.test(t))r=8;else throw Error(qe+t);for(o=t.search(/p/i),o>0?(l=+t.slice(o+1),t=t.substring(2,o)):t=t.slice(2),o=t.indexOf("."),s=o>=0,n=e.constructor,s&&(t=t.replace(".",""),a=t.length,o=a-o,i=lo(n,new n(r),o,o*2)),u=fr(t,r,fe),g=u.length-1,o=g;u[o]===0;--o)u.pop();return o<0?new n(e.s*0):(e.e=br(u,g),e.d=u,D=!1,s&&(e=U(e,i,a*4)),l&&(e=e.times(Math.abs(l)<54?W(2,l):Ie.pow(2,l))),D=!0,e)}function ou(e,t){var r,n=t.d.length;if(n<3)return t.isZero()?t:lt(e,2,t,t);r=1.4*Math.sqrt(n),r=r>16?16:r|0,t=t.times(1/Er(5,r)),t=lt(e,2,t,t);for(var i,o=new e(5),s=new e(16),a=new e(20);r--;)i=t.times(t),t=t.times(o.plus(i.times(s.times(i).minus(a))));return t}function lt(e,t,r,n,i){var o,s,a,l,u=1,g=e.precision,h=Math.ceil(g/M);for(D=!1,l=r.times(r),a=new e(n);;){if(s=U(a.times(l),new e(t++*t++),g,1),a=i?n.plus(s):n.minus(s),n=U(s.times(l),new e(t++*t++),g,1),s=a.plus(n),s.d[h]!==void 0){for(o=h;s.d[o]===a.d[o]&&o--;);if(o==-1)break}o=a,a=n,n=s,s=o,u++}return D=!0,s.d.length=h+1,s}function Er(e,t){for(var r=e;--t;)r*=e;return r}function po(e,t){var r,n=t.s<0,i=be(e,e.precision,1),o=i.times(.5);if(t=t.abs(),t.lte(o))return ke=n?4:1,t;if(r=t.divToInt(i),r.isZero())ke=n?3:2;else{if(t=t.minus(r.times(i)),t.lte(o))return ke=Xi(r)?n?2:3:n?4:1,t;ke=Xi(r)?n?1:4:n?3:2}return t.minus(i).abs()}function kn(e,t,r,n){var i,o,s,a,l,u,g,h,T,O=e.constructor,C=r!==void 0;if(C?(ae(r,1,Be),n===void 0?n=O.rounding:ae(n,0,8)):(r=O.precision,n=O.rounding),!e.isFinite())g=co(e);else{for(g=Ee(e),s=g.indexOf("."),C?(i=2,t==16?r=r*4-3:t==8&&(r=r*3-2)):i=t,s>=0&&(g=g.replace(".",""),T=new O(1),T.e=g.length-s,T.d=fr(Ee(T),10,i),T.e=T.d.length),h=fr(g,10,i),o=l=h.length;h[--l]==0;)h.pop();if(!h[0])g=C?"0p+0":"0";else{if(s<0?o--:(e=new O(e),e.d=h,e.e=o,e=U(e,T,r,n,0,i),h=e.d,o=e.e,u=ro),s=h[r],a=i/2,u=u||h[r+1]!==void 0,u=n<4?(s!==void 0||u)&&(n===0||n===(e.s<0?3:2)):s>a||s===a&&(n===4||u||n===6&&h[r-1]&1||n===(e.s<0?8:7)),h.length=r,u)for(;++h[--r]>i-1;)h[r]=0,r||(++o,h.unshift(1));for(l=h.length;!h[l-1];--l);for(s=0,g="";s1)if(t==16||t==8){for(s=t==16?4:3,--l;l%s;l++)g+="0";for(h=fr(g,i,t),l=h.length;!h[l-1];--l);for(s=1,g="1.";sl)for(o-=l;o--;)g+="0";else ot)return e.length=t,!0}function su(e){return new this(e).abs()}function au(e){return new this(e).acos()}function lu(e){return new this(e).acosh()}function uu(e,t){return new this(e).plus(t)}function cu(e){return new this(e).asin()}function pu(e){return new this(e).asinh()}function du(e){return new this(e).atan()}function fu(e){return new this(e).atanh()}function mu(e,t){e=new this(e),t=new this(t);var r,n=this.precision,i=this.rounding,o=n+4;return!e.s||!t.s?r=new this(NaN):!e.d&&!t.d?(r=be(this,o,1).times(t.s>0?.25:.75),r.s=e.s):!t.d||e.isZero()?(r=t.s<0?be(this,n,i):new this(0),r.s=e.s):!e.d||t.isZero()?(r=be(this,o,1).times(.5),r.s=e.s):t.s<0?(this.precision=o,this.rounding=1,r=this.atan(U(e,t,o,1)),t=be(this,o,1),this.precision=n,this.rounding=i,r=e.s<0?r.minus(t):r.plus(t)):r=this.atan(U(e,t,o,1)),r}function gu(e){return new this(e).cbrt()}function hu(e){return I(e=new this(e),e.e+1,2)}function yu(e,t,r){return new this(e).clamp(t,r)}function wu(e){if(!e||typeof e!="object")throw Error(wr+"Object expected");var t,r,n,i=e.defaults===!0,o=["precision",1,Be,"rounding",0,8,"toExpNeg",-at,0,"toExpPos",0,at,"maxE",0,at,"minE",-at,0,"modulo",0,9];for(t=0;t=o[t+1]&&n<=o[t+2])this[r]=n;else throw Error(qe+r+": "+n);if(r="crypto",i&&(this[r]=Sn[r]),(n=e[r])!==void 0)if(n===!0||n===!1||n===0||n===1)if(n)if(typeof crypto<"u"&&crypto&&(crypto.getRandomValues||crypto.randomBytes))this[r]=!0;else throw Error(io);else this[r]=!1;else throw Error(qe+r+": "+n);return this}function bu(e){return new this(e).cos()}function Eu(e){return new this(e).cosh()}function fo(e){var t,r,n;function i(o){var s,a,l,u=this;if(!(u instanceof i))return new i(o);if(u.constructor=i,to(o)){u.s=o.s,D?!o.d||o.e>i.maxE?(u.e=NaN,u.d=null):o.e=10;a/=10)s++;D?s>i.maxE?(u.e=NaN,u.d=null):s=429e7?t[o]=crypto.getRandomValues(new Uint32Array(1))[0]:a[o++]=i%1e7;else if(crypto.randomBytes){for(t=crypto.randomBytes(n*=4);o=214e7?crypto.randomBytes(4).copy(t,o):(a.push(i%1e7),o+=4);o=n/4}else throw Error(io);else for(;o=10;i/=10)n++;nct,datamodelEnumToSchemaEnum:()=>Ju});m();c();p();d();f();m();c();p();d();f();function Ju(e){return{name:e.name,values:e.values.map(t=>t.name)}}m();c();p();d();f();var ct=(k=>(k.findUnique="findUnique",k.findUniqueOrThrow="findUniqueOrThrow",k.findFirst="findFirst",k.findFirstOrThrow="findFirstOrThrow",k.findMany="findMany",k.create="create",k.createMany="createMany",k.createManyAndReturn="createManyAndReturn",k.update="update",k.updateMany="updateMany",k.updateManyAndReturn="updateManyAndReturn",k.upsert="upsert",k.delete="delete",k.deleteMany="deleteMany",k.groupBy="groupBy",k.count="count",k.aggregate="aggregate",k.findRaw="findRaw",k.aggregateRaw="aggregateRaw",k))(ct||{});var yo=Qe(Gi());m();c();p();d();f();dn();m();c();p();d();f();m();c();p();d();f();m();c();p();d();f();var mo={keyword:Se,entity:Se,value:e=>de(We(e)),punctuation:We,directive:Se,function:Se,variable:e=>de(We(e)),string:e=>de(Ot(e)),boolean:kt,number:Se,comment:It};var Gu=e=>e,xr={},Wu=0,N={manual:xr.Prism&&xr.Prism.manual,disableWorkerMessageHandler:xr.Prism&&xr.Prism.disableWorkerMessageHandler,util:{encode:function(e){if(e instanceof me){let t=e;return new me(t.type,N.util.encode(t.content),t.alias)}else return Array.isArray(e)?e.map(N.util.encode):e.replace(/&/g,"&").replace(/e.length)return;if(Ae instanceof me)continue;if(Y&&J!=t.length-1){L.lastIndex=ie;var h=L.exec(e);if(!h)break;var g=h.index+(q?h[1].length:0),T=h.index+h[0].length,a=J,l=ie;for(let B=t.length;a=l&&(++J,ie=l);if(t[J]instanceof me)continue;u=a-J,Ae=e.slice(ie,l),h.index-=ie}else{L.lastIndex=0;var h=L.exec(Ae),u=1}if(!h){if(o)break;continue}q&&($=h[1]?h[1].length:0);var g=h.index+$,h=h[0].slice($),T=g+h.length,O=Ae.slice(0,g),C=Ae.slice(T);let X=[J,u];O&&(++J,ie+=O.length,X.push(O));let Ze=new me(S,k?N.tokenize(h,k):h,At,h,Y);if(X.push(Ze),C&&X.push(C),Array.prototype.splice.apply(t,X),u!=1&&N.matchGrammar(e,t,r,J,ie,!0,S),o)break}}}},tokenize:function(e,t){let r=[e],n=t.rest;if(n){for(let i in n)t[i]=n[i];delete t.rest}return N.matchGrammar(e,r,t,0,0,!1),r},hooks:{all:{},add:function(e,t){let r=N.hooks.all;r[e]=r[e]||[],r[e].push(t)},run:function(e,t){let r=N.hooks.all[e];if(!(!r||!r.length))for(var n=0,i;i=r[n++];)i(t)}},Token:me};N.languages.clike={comment:[{pattern:/(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,lookbehind:!0},{pattern:/(^|[^\\:])\/\/.*/,lookbehind:!0,greedy:!0}],string:{pattern:/(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,greedy:!0},"class-name":{pattern:/((?:\b(?:class|interface|extends|implements|trait|instanceof|new)\s+)|(?:catch\s+\())[\w.\\]+/i,lookbehind:!0,inside:{punctuation:/[.\\]/}},keyword:/\b(?:if|else|while|do|for|return|in|instanceof|function|new|try|throw|catch|finally|null|break|continue)\b/,boolean:/\b(?:true|false)\b/,function:/\w+(?=\()/,number:/\b0x[\da-f]+\b|(?:\b\d+\.?\d*|\B\.\d+)(?:e[+-]?\d+)?/i,operator:/--?|\+\+?|!=?=?|<=?|>=?|==?=?|&&?|\|\|?|\?|\*|\/|~|\^|%/,punctuation:/[{}[\];(),.:]/};N.languages.javascript=N.languages.extend("clike",{"class-name":[N.languages.clike["class-name"],{pattern:/(^|[^$\w\xA0-\uFFFF])[_$A-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\.(?:prototype|constructor))/,lookbehind:!0}],keyword:[{pattern:/((?:^|})\s*)(?:catch|finally)\b/,lookbehind:!0},{pattern:/(^|[^.])\b(?:as|async(?=\s*(?:function\b|\(|[$\w\xA0-\uFFFF]|$))|await|break|case|class|const|continue|debugger|default|delete|do|else|enum|export|extends|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)\b/,lookbehind:!0}],number:/\b(?:(?:0[xX](?:[\dA-Fa-f](?:_[\dA-Fa-f])?)+|0[bB](?:[01](?:_[01])?)+|0[oO](?:[0-7](?:_[0-7])?)+)n?|(?:\d(?:_\d)?)+n|NaN|Infinity)\b|(?:\b(?:\d(?:_\d)?)+\.?(?:\d(?:_\d)?)*|\B\.(?:\d(?:_\d)?)+)(?:[Ee][+-]?(?:\d(?:_\d)?)+)?/,function:/[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,operator:/-[-=]?|\+[+=]?|!=?=?|<>?>?=?|=(?:==?|>)?|&[&=]?|\|[|=]?|\*\*?=?|\/=?|~|\^=?|%=?|\?|\.{3}/});N.languages.javascript["class-name"][0].pattern=/(\b(?:class|interface|extends|implements|instanceof|new)\s+)[\w.\\]+/;N.languages.insertBefore("javascript","keyword",{regex:{pattern:/((?:^|[^$\w\xA0-\uFFFF."'\])\s])\s*)\/(\[(?:[^\]\\\r\n]|\\.)*]|\\.|[^/\\\[\r\n])+\/[gimyus]{0,6}(?=\s*($|[\r\n,.;})\]]))/,lookbehind:!0,greedy:!0},"function-variable":{pattern:/[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|[_$a-zA-Z\xA0-\uFFFF][$\w\xA0-\uFFFF]*)\s*=>))/,alias:"function"},parameter:[{pattern:/(function(?:\s+[_$A-Za-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*)?\s*\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\))/,lookbehind:!0,inside:N.languages.javascript},{pattern:/[_$a-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*(?=\s*=>)/i,inside:N.languages.javascript},{pattern:/(\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\)\s*=>)/,lookbehind:!0,inside:N.languages.javascript},{pattern:/((?:\b|\s|^)(?!(?:as|async|await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|let|new|null|of|package|private|protected|public|return|set|static|super|switch|this|throw|try|typeof|undefined|var|void|while|with|yield)(?![$\w\xA0-\uFFFF]))(?:[_$A-Za-z\xA0-\uFFFF][$\w\xA0-\uFFFF]*\s*)\(\s*)(?!\s)(?:[^()]|\([^()]*\))+?(?=\s*\)\s*\{)/,lookbehind:!0,inside:N.languages.javascript}],constant:/\b[A-Z](?:[A-Z_]|\dx?)*\b/});N.languages.markup&&N.languages.markup.tag.addInlined("script","javascript");N.languages.js=N.languages.javascript;N.languages.typescript=N.languages.extend("javascript",{keyword:/\b(?:abstract|as|async|await|break|case|catch|class|const|constructor|continue|debugger|declare|default|delete|do|else|enum|export|extends|finally|for|from|function|get|if|implements|import|in|instanceof|interface|is|keyof|let|module|namespace|new|null|of|package|private|protected|public|readonly|return|require|set|static|super|switch|this|throw|try|type|typeof|var|void|while|with|yield)\b/,builtin:/\b(?:string|Function|any|number|boolean|Array|symbol|console|Promise|unknown|never)\b/});N.languages.ts=N.languages.typescript;function me(e,t,r,n,i){this.type=e,this.content=t,this.alias=r,this.length=(n||"").length|0,this.greedy=!!i}me.stringify=function(e,t){return typeof e=="string"?e:Array.isArray(e)?e.map(function(r){return me.stringify(r,t)}).join(""):Ku(e.type)(e.content)};function Ku(e){return mo[e]||Gu}function go(e){return zu(e,N.languages.javascript)}function zu(e,t){return N.tokenize(e,t).map(n=>me.stringify(n)).join("")}m();c();p();d();f();function ho(e){return wn(e)}var Pr=class e{firstLineNumber;lines;static read(t){let r;try{r=sr.readFileSync(t,"utf-8")}catch{return null}return e.fromContent(r)}static fromContent(t){let r=t.split(/\r?\n/);return new e(1,r)}constructor(t,r){this.firstLineNumber=t,this.lines=r}get lastLineNumber(){return this.firstLineNumber+this.lines.length-1}mapLineAt(t,r){if(tthis.lines.length+this.firstLineNumber)return this;let n=t-this.firstLineNumber,i=[...this.lines];return i[n]=r(i[n]),new e(this.firstLineNumber,i)}mapLines(t){return new e(this.firstLineNumber,this.lines.map((r,n)=>t(r,this.firstLineNumber+n)))}lineAt(t){return this.lines[t-this.firstLineNumber]}prependSymbolAt(t,r){return this.mapLines((n,i)=>i===t?`${r} ${n}`:` ${n}`)}slice(t,r){let n=this.lines.slice(t-1,r).join(` -`);return new e(t,ho(n).split(` -`))}highlight(){let t=go(this.toString());return new e(this.firstLineNumber,t.split(` -`))}toString(){return this.lines.join(` -`)}};var Hu={red:Ge,gray:It,dim:St,bold:de,underline:Rt,highlightSource:e=>e.highlight()},Yu={red:e=>e,gray:e=>e,dim:e=>e,bold:e=>e,underline:e=>e,highlightSource:e=>e};function Zu({message:e,originalMethod:t,isPanic:r,callArguments:n}){return{functionName:`prisma.${t}()`,message:e,isPanic:r??!1,callArguments:n}}function Xu({callsite:e,message:t,originalMethod:r,isPanic:n,callArguments:i},o){let s=Zu({message:t,originalMethod:r,isPanic:n,callArguments:i});if(!e||typeof window<"u"||y.env.NODE_ENV==="production")return s;let a=e.getLocation();if(!a||!a.lineNumber||!a.columnNumber)return s;let l=Math.max(1,a.lineNumber-3),u=Pr.read(a.fileName)?.slice(l,a.lineNumber),g=u?.lineAt(a.lineNumber);if(u&&g){let h=tc(g),T=ec(g);if(!T)return s;s.functionName=`${T.code})`,s.location=a,n||(u=u.mapLineAt(a.lineNumber,C=>C.slice(0,T.openingBraceIndex))),u=o.highlightSource(u);let O=String(u.lastLineNumber).length;if(s.contextLines=u.mapLines((C,S)=>o.gray(String(S).padStart(O))+" "+C).mapLines(C=>o.dim(C)).prependSymbolAt(a.lineNumber,o.bold(o.red("\u2192"))),i){let C=h+O+1;C+=2,s.callArguments=(0,yo.default)(i,C).slice(C)}}return s}function ec(e){let t=Object.keys(ct).join("|"),n=new RegExp(String.raw`\.(${t})\(`).exec(e);if(n){let i=n.index+n[0].length,o=e.lastIndexOf(" ",n.index)+1;return{code:e.slice(o,i),openingBraceIndex:i}}return null}function tc(e){let t=0;for(let r=0;r"Unknown error")}function Po(e){return e.errors.flatMap(t=>t.kind==="Union"?Po(t):[t])}function ic(e){let t=new Map,r=[];for(let n of e){if(n.kind!=="InvalidArgumentType"){r.push(n);continue}let i=`${n.selectionPath.join(".")}:${n.argumentPath.join(".")}`,o=t.get(i);o?t.set(i,{...n,argument:{...n.argument,typeNames:oc(o.argument.typeNames,n.argument.typeNames)}}):t.set(i,n)}return r.push(...t.values()),r}function oc(e,t){return[...new Set(e.concat(t))]}function sc(e){return Tn(e,(t,r)=>{let n=bo(t),i=bo(r);return n!==i?n-i:Eo(t)-Eo(r)})}function bo(e){let t=0;return Array.isArray(e.selectionPath)&&(t+=e.selectionPath.length),Array.isArray(e.argumentPath)&&(t+=e.argumentPath.length),t}function Eo(e){switch(e.kind){case"InvalidArgumentValue":case"ValueTooLarge":return 20;case"InvalidArgumentType":return 10;case"RequiredArgumentMissing":return-10;default:return 0}}m();c();p();d();f();var pe=class{constructor(t,r){this.name=t;this.value=r}isRequired=!1;makeRequired(){return this.isRequired=!0,this}write(t){let{colors:{green:r}}=t.context;t.addMarginSymbol(r(this.isRequired?"+":"?")),t.write(r(this.name)),this.isRequired||t.write(r("?")),t.write(r(": ")),typeof this.value=="string"?t.write(r(this.value)):t.write(this.value)}};m();c();p();d();f();m();c();p();d();f();To();m();c();p();d();f();var pt=class{constructor(t=0,r){this.context=r;this.currentIndent=t}lines=[];currentLine="";currentIndent=0;marginSymbol;afterNextNewLineCallback;write(t){return typeof t=="string"?this.currentLine+=t:t.write(this),this}writeJoined(t,r,n=(i,o)=>o.write(i)){let i=r.length-1;for(let o=0;o0&&this.currentIndent--,this}addMarginSymbol(t){return this.marginSymbol=t,this}toString(){return this.lines.concat(this.indentedCurrentLine()).join(` -`)}getCurrentLineLength(){return this.currentLine.length}indentedCurrentLine(){let t=this.currentLine.padStart(this.currentLine.length+2*this.currentIndent);return this.marginSymbol?this.marginSymbol+t.slice(1):t}};vo();m();c();p();d();f();m();c();p();d();f();var Ar=class{constructor(t){this.value=t}write(t){t.write(this.value)}markAsError(){this.value.markAsError()}};m();c();p();d();f();var Cr=e=>e,Sr={bold:Cr,red:Cr,green:Cr,dim:Cr,enabled:!1},Ao={bold:de,red:Ge,green:Ot,dim:St,enabled:!0},dt={write(e){e.writeLine(",")}};m();c();p();d();f();var xe=class{constructor(t){this.contents=t}isUnderlined=!1;color=t=>t;underline(){return this.isUnderlined=!0,this}setColor(t){return this.color=t,this}write(t){let r=t.getCurrentLineLength();t.write(this.color(this.contents)),this.isUnderlined&&t.afterNextNewline(()=>{t.write(" ".repeat(r)).writeLine(this.color("~".repeat(this.contents.length)))})}};m();c();p();d();f();var je=class{hasError=!1;markAsError(){return this.hasError=!0,this}};var ft=class extends je{items=[];addItem(t){return this.items.push(new Ar(t)),this}getField(t){return this.items[t]}getPrintWidth(){return this.items.length===0?2:Math.max(...this.items.map(r=>r.value.getPrintWidth()))+2}write(t){if(this.items.length===0){this.writeEmpty(t);return}this.writeWithItems(t)}writeEmpty(t){let r=new xe("[]");this.hasError&&r.setColor(t.context.colors.red).underline(),t.write(r)}writeWithItems(t){let{colors:r}=t.context;t.writeLine("[").withIndent(()=>t.writeJoined(dt,this.items).newLine()).write("]"),this.hasError&&t.afterNextNewline(()=>{t.writeLine(r.red("~".repeat(this.getPrintWidth())))})}asObject(){}};var mt=class e extends je{fields={};suggestions=[];addField(t){this.fields[t.name]=t}addSuggestion(t){this.suggestions.push(t)}getField(t){return this.fields[t]}getDeepField(t){let[r,...n]=t,i=this.getField(r);if(!i)return;let o=i;for(let s of n){let a;if(o.value instanceof e?a=o.value.getField(s):o.value instanceof ft&&(a=o.value.getField(Number(s))),!a)return;o=a}return o}getDeepFieldValue(t){return t.length===0?this:this.getDeepField(t)?.value}hasField(t){return!!this.getField(t)}removeAllFields(){this.fields={}}removeField(t){delete this.fields[t]}getFields(){return this.fields}isEmpty(){return Object.keys(this.fields).length===0}getFieldValue(t){return this.getField(t)?.value}getDeepSubSelectionValue(t){let r=this;for(let n of t){if(!(r instanceof e))return;let i=r.getSubSelectionValue(n);if(!i)return;r=i}return r}getDeepSelectionParent(t){let r=this.getSelectionParent();if(!r)return;let n=r;for(let i of t){let o=n.value.getFieldValue(i);if(!o||!(o instanceof e))return;let s=o.getSelectionParent();if(!s)return;n=s}return n}getSelectionParent(){let t=this.getField("select")?.value.asObject();if(t)return{kind:"select",value:t};let r=this.getField("include")?.value.asObject();if(r)return{kind:"include",value:r}}getSubSelectionValue(t){return this.getSelectionParent()?.value.fields[t].value}getPrintWidth(){let t=Object.values(this.fields);return t.length==0?2:Math.max(...t.map(n=>n.getPrintWidth()))+2}write(t){let r=Object.values(this.fields);if(r.length===0&&this.suggestions.length===0){this.writeEmpty(t);return}this.writeWithContents(t,r)}asObject(){return this}writeEmpty(t){let r=new xe("{}");this.hasError&&r.setColor(t.context.colors.red).underline(),t.write(r)}writeWithContents(t,r){t.writeLine("{").withIndent(()=>{t.writeJoined(dt,[...r,...this.suggestions]).newLine()}),t.write("}"),this.hasError&&t.afterNextNewline(()=>{t.writeLine(t.context.colors.red("~".repeat(this.getPrintWidth())))})}};m();c();p();d();f();var H=class extends je{constructor(r){super();this.text=r}getPrintWidth(){return this.text.length}write(r){let n=new xe(this.text);this.hasError&&n.underline().setColor(r.context.colors.red),r.write(n)}asObject(){}};m();c();p();d();f();var jt=class{fields=[];addField(t,r){return this.fields.push({write(n){let{green:i,dim:o}=n.context.colors;n.write(i(o(`${t}: ${r}`))).addMarginSymbol(i(o("+")))}}),this}write(t){let{colors:{green:r}}=t.context;t.writeLine(r("{")).withIndent(()=>{t.writeJoined(dt,this.fields).newLine()}).write(r("}")).addMarginSymbol(r("+"))}};function Tr(e,t,r){switch(e.kind){case"MutuallyExclusiveFields":ac(e,t);break;case"IncludeOnScalar":lc(e,t);break;case"EmptySelection":uc(e,t,r);break;case"UnknownSelectionField":fc(e,t);break;case"InvalidSelectionValue":mc(e,t);break;case"UnknownArgument":gc(e,t);break;case"UnknownInputField":hc(e,t);break;case"RequiredArgumentMissing":yc(e,t);break;case"InvalidArgumentType":wc(e,t);break;case"InvalidArgumentValue":bc(e,t);break;case"ValueTooLarge":Ec(e,t);break;case"SomeFieldsMissing":xc(e,t);break;case"TooManyFieldsGiven":Pc(e,t);break;case"Union":xo(e,t,r);break;default:throw new Error("not implemented: "+e.kind)}}function ac(e,t){let r=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();r&&(r.getField(e.firstField)?.markAsError(),r.getField(e.secondField)?.markAsError()),t.addErrorMessage(n=>`Please ${n.bold("either")} use ${n.green(`\`${e.firstField}\``)} or ${n.green(`\`${e.secondField}\``)}, but ${n.red("not both")} at the same time.`)}function lc(e,t){let[r,n]=gt(e.selectionPath),i=e.outputType,o=t.arguments.getDeepSelectionParent(r)?.value;if(o&&(o.getField(n)?.markAsError(),i))for(let s of i.fields)s.isRelation&&o.addSuggestion(new pe(s.name,"true"));t.addErrorMessage(s=>{let a=`Invalid scalar field ${s.red(`\`${n}\``)} for ${s.bold("include")} statement`;return i?a+=` on model ${s.bold(i.name)}. ${Ut(s)}`:a+=".",a+=` -Note that ${s.bold("include")} statements only accept relation fields.`,a})}function uc(e,t,r){let n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(n){let i=n.getField("omit")?.value.asObject();if(i){cc(e,t,i);return}if(n.hasField("select")){pc(e,t);return}}if(r?.[De(e.outputType.name)]){dc(e,t);return}t.addErrorMessage(()=>`Unknown field at "${e.selectionPath.join(".")} selection"`)}function cc(e,t,r){r.removeAllFields();for(let n of e.outputType.fields)r.addSuggestion(new pe(n.name,"false"));t.addErrorMessage(n=>`The ${n.red("omit")} statement includes every field of the model ${n.bold(e.outputType.name)}. At least one field must be included in the result`)}function pc(e,t){let r=e.outputType,n=t.arguments.getDeepSelectionParent(e.selectionPath)?.value,i=n?.isEmpty()??!1;n&&(n.removeAllFields(),Oo(n,r)),t.addErrorMessage(o=>i?`The ${o.red("`select`")} statement for type ${o.bold(r.name)} must not be empty. ${Ut(o)}`:`The ${o.red("`select`")} statement for type ${o.bold(r.name)} needs ${o.bold("at least one truthy value")}.`)}function dc(e,t){let r=new jt;for(let i of e.outputType.fields)i.isRelation||r.addField(i.name,"false");let n=new pe("omit",r).makeRequired();if(e.selectionPath.length===0)t.arguments.addSuggestion(n);else{let[i,o]=gt(e.selectionPath),a=t.arguments.getDeepSelectionParent(i)?.value.asObject()?.getField(o);if(a){let l=a?.value.asObject()??new mt;l.addSuggestion(n),a.value=l}}t.addErrorMessage(i=>`The global ${i.red("omit")} configuration excludes every field of the model ${i.bold(e.outputType.name)}. At least one field must be included in the result`)}function fc(e,t){let r=ko(e.selectionPath,t);if(r.parentKind!=="unknown"){r.field.markAsError();let n=r.parent;switch(r.parentKind){case"select":Oo(n,e.outputType);break;case"include":vc(n,e.outputType);break;case"omit":Tc(n,e.outputType);break}}t.addErrorMessage(n=>{let i=[`Unknown field ${n.red(`\`${r.fieldName}\``)}`];return r.parentKind!=="unknown"&&i.push(`for ${n.bold(r.parentKind)} statement`),i.push(`on model ${n.bold(`\`${e.outputType.name}\``)}.`),i.push(Ut(n)),i.join(" ")})}function mc(e,t){let r=ko(e.selectionPath,t);r.parentKind!=="unknown"&&r.field.value.markAsError(),t.addErrorMessage(n=>`Invalid value for selection field \`${n.red(r.fieldName)}\`: ${e.underlyingError}`)}function gc(e,t){let r=e.argumentPath[0],n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();n&&(n.getField(r)?.markAsError(),Ac(n,e.arguments)),t.addErrorMessage(i=>So(i,r,e.arguments.map(o=>o.name)))}function hc(e,t){let[r,n]=gt(e.argumentPath),i=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(i){i.getDeepField(e.argumentPath)?.markAsError();let o=i.getDeepFieldValue(r)?.asObject();o&&Io(o,e.inputType)}t.addErrorMessage(o=>So(o,n,e.inputType.fields.map(s=>s.name)))}function So(e,t,r){let n=[`Unknown argument \`${e.red(t)}\`.`],i=Sc(t,r);return i&&n.push(`Did you mean \`${e.green(i)}\`?`),r.length>0&&n.push(Ut(e)),n.join(" ")}function yc(e,t){let r;t.addErrorMessage(l=>r?.value instanceof H&&r.value.text==="null"?`Argument \`${l.green(o)}\` must not be ${l.red("null")}.`:`Argument \`${l.green(o)}\` is missing.`);let n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(!n)return;let[i,o]=gt(e.argumentPath),s=new jt,a=n.getDeepFieldValue(i)?.asObject();if(a){if(r=a.getField(o),r&&a.removeField(o),e.inputTypes.length===1&&e.inputTypes[0].kind==="object"){for(let l of e.inputTypes[0].fields)s.addField(l.name,l.typeNames.join(" | "));a.addSuggestion(new pe(o,s).makeRequired())}else{let l=e.inputTypes.map(Ro).join(" | ");a.addSuggestion(new pe(o,l).makeRequired())}if(e.dependentArgumentPath){n.getDeepField(e.dependentArgumentPath)?.markAsError();let[,l]=gt(e.dependentArgumentPath);t.addErrorMessage(u=>`Argument \`${u.green(o)}\` is required because argument \`${u.green(l)}\` was provided.`)}}}function Ro(e){return e.kind==="list"?`${Ro(e.elementType)}[]`:e.name}function wc(e,t){let r=e.argument.name,n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();n&&n.getDeepFieldValue(e.argumentPath)?.markAsError(),t.addErrorMessage(i=>{let o=Rr("or",e.argument.typeNames.map(s=>i.green(s)));return`Argument \`${i.bold(r)}\`: Invalid value provided. Expected ${o}, provided ${i.red(e.inferredType)}.`})}function bc(e,t){let r=e.argument.name,n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();n&&n.getDeepFieldValue(e.argumentPath)?.markAsError(),t.addErrorMessage(i=>{let o=[`Invalid value for argument \`${i.bold(r)}\``];if(e.underlyingError&&o.push(`: ${e.underlyingError}`),o.push("."),e.argument.typeNames.length>0){let s=Rr("or",e.argument.typeNames.map(a=>i.green(a)));o.push(` Expected ${s}.`)}return o.join("")})}function Ec(e,t){let r=e.argument.name,n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject(),i;if(n){let s=n.getDeepField(e.argumentPath)?.value;s?.markAsError(),s instanceof H&&(i=s.text)}t.addErrorMessage(o=>{let s=["Unable to fit value"];return i&&s.push(o.red(i)),s.push(`into a 64-bit signed integer for field \`${o.bold(r)}\``),s.join(" ")})}function xc(e,t){let r=e.argumentPath[e.argumentPath.length-1],n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(n){let i=n.getDeepFieldValue(e.argumentPath)?.asObject();i&&Io(i,e.inputType)}t.addErrorMessage(i=>{let o=[`Argument \`${i.bold(r)}\` of type ${i.bold(e.inputType.name)} needs`];return e.constraints.minFieldCount===1?e.constraints.requiredFields?o.push(`${i.green("at least one of")} ${Rr("or",e.constraints.requiredFields.map(s=>`\`${i.bold(s)}\``))} arguments.`):o.push(`${i.green("at least one")} argument.`):o.push(`${i.green(`at least ${e.constraints.minFieldCount}`)} arguments.`),o.push(Ut(i)),o.join(" ")})}function Pc(e,t){let r=e.argumentPath[e.argumentPath.length-1],n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject(),i=[];if(n){let o=n.getDeepFieldValue(e.argumentPath)?.asObject();o&&(o.markAsError(),i=Object.keys(o.getFields()))}t.addErrorMessage(o=>{let s=[`Argument \`${o.bold(r)}\` of type ${o.bold(e.inputType.name)} needs`];return e.constraints.minFieldCount===1&&e.constraints.maxFieldCount==1?s.push(`${o.green("exactly one")} argument,`):e.constraints.maxFieldCount==1?s.push(`${o.green("at most one")} argument,`):s.push(`${o.green(`at most ${e.constraints.maxFieldCount}`)} arguments,`),s.push(`but you provided ${Rr("and",i.map(a=>o.red(a)))}. Please choose`),e.constraints.maxFieldCount===1?s.push("one."):s.push(`${e.constraints.maxFieldCount}.`),s.join(" ")})}function Oo(e,t){for(let r of t.fields)e.hasField(r.name)||e.addSuggestion(new pe(r.name,"true"))}function vc(e,t){for(let r of t.fields)r.isRelation&&!e.hasField(r.name)&&e.addSuggestion(new pe(r.name,"true"))}function Tc(e,t){for(let r of t.fields)!e.hasField(r.name)&&!r.isRelation&&e.addSuggestion(new pe(r.name,"true"))}function Ac(e,t){for(let r of t)e.hasField(r.name)||e.addSuggestion(new pe(r.name,r.typeNames.join(" | ")))}function ko(e,t){let[r,n]=gt(e),i=t.arguments.getDeepSubSelectionValue(r)?.asObject();if(!i)return{parentKind:"unknown",fieldName:n};let o=i.getFieldValue("select")?.asObject(),s=i.getFieldValue("include")?.asObject(),a=i.getFieldValue("omit")?.asObject(),l=o?.getField(n);return o&&l?{parentKind:"select",parent:o,field:l,fieldName:n}:(l=s?.getField(n),s&&l?{parentKind:"include",field:l,parent:s,fieldName:n}:(l=a?.getField(n),a&&l?{parentKind:"omit",field:l,parent:a,fieldName:n}:{parentKind:"unknown",fieldName:n}))}function Io(e,t){if(t.kind==="object")for(let r of t.fields)e.hasField(r.name)||e.addSuggestion(new pe(r.name,r.typeNames.join(" | ")))}function gt(e){let t=[...e],r=t.pop();if(!r)throw new Error("unexpected empty path");return[t,r]}function Ut({green:e,enabled:t}){return"Available options are "+(t?`listed in ${e("green")}`:"marked with ?")+"."}function Rr(e,t){if(t.length===1)return t[0];let r=[...t],n=r.pop();return`${r.join(", ")} ${e} ${n}`}var Cc=3;function Sc(e,t){let r=1/0,n;for(let i of t){let o=(0,Co.default)(e,i);o>Cc||o`}};function ht(e){return e instanceof $t}m();c();p();d();f();var Or=Symbol(),Mn=new WeakMap,Me=class{constructor(t){t===Or?Mn.set(this,`Prisma.${this._getName()}`):Mn.set(this,`new Prisma.${this._getNamespace()}.${this._getName()}()`)}_getName(){return this.constructor.name}toString(){return Mn.get(this)}},Vt=class extends Me{_getNamespace(){return"NullTypes"}},Qt=class extends Vt{#e};_n(Qt,"DbNull");var Jt=class extends Vt{#e};_n(Jt,"JsonNull");var Gt=class extends Vt{#e};_n(Gt,"AnyNull");var kr={classes:{DbNull:Qt,JsonNull:Jt,AnyNull:Gt},instances:{DbNull:new Qt(Or),JsonNull:new Jt(Or),AnyNull:new Gt(Or)}};function _n(e,t){Object.defineProperty(e,"name",{value:t,configurable:!0})}m();c();p();d();f();var Fo=": ",Ir=class{constructor(t,r){this.name=t;this.value=r}hasError=!1;markAsError(){this.hasError=!0}getPrintWidth(){return this.name.length+this.value.getPrintWidth()+Fo.length}write(t){let r=new xe(this.name);this.hasError&&r.underline().setColor(t.context.colors.red),t.write(r).write(Fo).write(this.value)}};var Dn=class{arguments;errorMessages=[];constructor(t){this.arguments=t}write(t){t.write(this.arguments)}addErrorMessage(t){this.errorMessages.push(t)}renderAllMessages(t){return this.errorMessages.map(r=>r(t)).join(` -`)}};function yt(e){return new Dn(Mo(e))}function Mo(e){let t=new mt;for(let[r,n]of Object.entries(e)){let i=new Ir(r,_o(n));t.addField(i)}return t}function _o(e){if(typeof e=="string")return new H(JSON.stringify(e));if(typeof e=="number"||typeof e=="boolean")return new H(String(e));if(typeof e=="bigint")return new H(`${e}n`);if(e===null)return new H("null");if(e===void 0)return new H("undefined");if(ut(e))return new H(`new Prisma.Decimal("${e.toFixed()}")`);if(e instanceof Uint8Array)return w.Buffer.isBuffer(e)?new H(`Buffer.alloc(${e.byteLength})`):new H(`new Uint8Array(${e.byteLength})`);if(e instanceof Date){let t=dr(e)?e.toISOString():"Invalid Date";return new H(`new Date("${t}")`)}return e instanceof Me?new H(`Prisma.${e._getName()}`):ht(e)?new H(`prisma.${De(e.modelName)}.$fields.${e.name}`):Array.isArray(e)?Rc(e):typeof e=="object"?Mo(e):new H(Object.prototype.toString.call(e))}function Rc(e){let t=new ft;for(let r of e)t.addItem(_o(r));return t}function Fr(e,t){let r=t==="pretty"?Ao:Sr,n=e.renderAllMessages(r),i=new pt(0,{colors:r}).write(e).toString();return{message:n,args:i}}function Mr({args:e,errors:t,errorFormat:r,callsite:n,originalMethod:i,clientVersion:o,globalOmit:s}){let a=yt(e);for(let h of t)Tr(h,a,s);let{message:l,args:u}=Fr(a,r),g=vr({message:l,callsite:n,originalMethod:i,showColors:r==="pretty",callArguments:u});throw new te(g,{clientVersion:o})}m();c();p();d();f();m();c();p();d();f();function Pe(e){return e.replace(/^./,t=>t.toLowerCase())}m();c();p();d();f();function Lo(e,t,r){let n=Pe(r);return!t.result||!(t.result.$allModels||t.result[n])?e:Oc({...e,...Do(t.name,e,t.result.$allModels),...Do(t.name,e,t.result[n])})}function Oc(e){let t=new we,r=(n,i)=>t.getOrCreate(n,()=>i.has(n)?[n]:(i.add(n),e[n]?e[n].needs.flatMap(o=>r(o,i)):[n]));return pr(e,n=>({...n,needs:r(n.name,new Set)}))}function Do(e,t,r){return r?pr(r,({needs:n,compute:i},o)=>({name:o,needs:n?Object.keys(n).filter(s=>n[s]):[],compute:kc(t,o,i)})):{}}function kc(e,t,r){let n=e?.[t]?.compute;return n?i=>r({...i,[t]:n(i)}):r}function No(e,t){if(!t)return e;let r={...e};for(let n of Object.values(t))if(e[n.name])for(let i of n.needs)r[i]=!0;return r}function qo(e,t){if(!t)return e;let r={...e};for(let n of Object.values(t))if(!e[n.name])for(let i of n.needs)delete r[i];return r}var _r=class{constructor(t,r){this.extension=t;this.previous=r}computedFieldsCache=new we;modelExtensionsCache=new we;queryCallbacksCache=new we;clientExtensions=Nt(()=>this.extension.client?{...this.previous?.getAllClientExtensions(),...this.extension.client}:this.previous?.getAllClientExtensions());batchCallbacks=Nt(()=>{let t=this.previous?.getAllBatchQueryCallbacks()??[],r=this.extension.query?.$__internalBatch;return r?t.concat(r):t});getAllComputedFields(t){return this.computedFieldsCache.getOrCreate(t,()=>Lo(this.previous?.getAllComputedFields(t),this.extension,t))}getAllClientExtensions(){return this.clientExtensions.get()}getAllModelExtensions(t){return this.modelExtensionsCache.getOrCreate(t,()=>{let r=Pe(t);return!this.extension.model||!(this.extension.model[r]||this.extension.model.$allModels)?this.previous?.getAllModelExtensions(t):{...this.previous?.getAllModelExtensions(t),...this.extension.model.$allModels,...this.extension.model[r]}})}getAllQueryCallbacks(t,r){return this.queryCallbacksCache.getOrCreate(`${t}:${r}`,()=>{let n=this.previous?.getAllQueryCallbacks(t,r)??[],i=[],o=this.extension.query;return!o||!(o[t]||o.$allModels||o[r]||o.$allOperations)?n:(o[t]!==void 0&&(o[t][r]!==void 0&&i.push(o[t][r]),o[t].$allOperations!==void 0&&i.push(o[t].$allOperations)),t!=="$none"&&o.$allModels!==void 0&&(o.$allModels[r]!==void 0&&i.push(o.$allModels[r]),o.$allModels.$allOperations!==void 0&&i.push(o.$allModels.$allOperations)),o[r]!==void 0&&i.push(o[r]),o.$allOperations!==void 0&&i.push(o.$allOperations),n.concat(i))})}getAllBatchQueryCallbacks(){return this.batchCallbacks.get()}},wt=class e{constructor(t){this.head=t}static empty(){return new e}static single(t){return new e(new _r(t))}isEmpty(){return this.head===void 0}append(t){return new e(new _r(t,this.head))}getAllComputedFields(t){return this.head?.getAllComputedFields(t)}getAllClientExtensions(){return this.head?.getAllClientExtensions()}getAllModelExtensions(t){return this.head?.getAllModelExtensions(t)}getAllQueryCallbacks(t,r){return this.head?.getAllQueryCallbacks(t,r)??[]}getAllBatchQueryCallbacks(){return this.head?.getAllBatchQueryCallbacks()??[]}};m();c();p();d();f();var Dr=class{constructor(t){this.name=t}};function Bo(e){return e instanceof Dr}function jo(e){return new Dr(e)}m();c();p();d();f();m();c();p();d();f();var Uo=Symbol(),Wt=class{constructor(t){if(t!==Uo)throw new Error("Skip instance can not be constructed directly")}ifUndefined(t){return t===void 0?Lr:t}},Lr=new Wt(Uo);function ve(e){return e instanceof Wt}var Ic={findUnique:"findUnique",findUniqueOrThrow:"findUniqueOrThrow",findFirst:"findFirst",findFirstOrThrow:"findFirstOrThrow",findMany:"findMany",count:"aggregate",create:"createOne",createMany:"createMany",createManyAndReturn:"createManyAndReturn",update:"updateOne",updateMany:"updateMany",updateManyAndReturn:"updateManyAndReturn",upsert:"upsertOne",delete:"deleteOne",deleteMany:"deleteMany",executeRaw:"executeRaw",queryRaw:"queryRaw",aggregate:"aggregate",groupBy:"groupBy",runCommandRaw:"runCommandRaw",findRaw:"findRaw",aggregateRaw:"aggregateRaw"},$o="explicitly `undefined` values are not allowed";function Nr({modelName:e,action:t,args:r,runtimeDataModel:n,extensions:i=wt.empty(),callsite:o,clientMethod:s,errorFormat:a,clientVersion:l,previewFeatures:u,globalOmit:g}){let h=new Ln({runtimeDataModel:n,modelName:e,action:t,rootArgs:r,callsite:o,extensions:i,selectionPath:[],argumentPath:[],originalMethod:s,errorFormat:a,clientVersion:l,previewFeatures:u,globalOmit:g});return{modelName:e,action:Ic[t],query:Kt(r,h)}}function Kt({select:e,include:t,...r}={},n){let i=r.omit;return delete r.omit,{arguments:Qo(r,n),selection:Fc(e,t,i,n)}}function Fc(e,t,r,n){return e?(t?n.throwValidationError({kind:"MutuallyExclusiveFields",firstField:"include",secondField:"select",selectionPath:n.getSelectionPath()}):r&&n.throwValidationError({kind:"MutuallyExclusiveFields",firstField:"omit",secondField:"select",selectionPath:n.getSelectionPath()}),Lc(e,n)):Mc(n,t,r)}function Mc(e,t,r){let n={};return e.modelOrType&&!e.isRawAction()&&(n.$composites=!0,n.$scalars=!0),t&&_c(n,t,e),Dc(n,r,e),n}function _c(e,t,r){for(let[n,i]of Object.entries(t)){if(ve(i))continue;let o=r.nestSelection(n);if(Nn(i,o),i===!1||i===void 0){e[n]=!1;continue}let s=r.findField(n);if(s&&s.kind!=="object"&&r.throwValidationError({kind:"IncludeOnScalar",selectionPath:r.getSelectionPath().concat(n),outputType:r.getOutputTypeDescription()}),s){e[n]=Kt(i===!0?{}:i,o);continue}if(i===!0){e[n]=!0;continue}e[n]=Kt(i,o)}}function Dc(e,t,r){let n=r.getComputedFields(),i={...r.getGlobalOmit(),...t},o=qo(i,n);for(let[s,a]of Object.entries(o)){if(ve(a))continue;Nn(a,r.nestSelection(s));let l=r.findField(s);n?.[s]&&!l||(e[s]=!a)}}function Lc(e,t){let r={},n=t.getComputedFields(),i=No(e,n);for(let[o,s]of Object.entries(i)){if(ve(s))continue;let a=t.nestSelection(o);Nn(s,a);let l=t.findField(o);if(!(n?.[o]&&!l)){if(s===!1||s===void 0||ve(s)){r[o]=!1;continue}if(s===!0){l?.kind==="object"?r[o]=Kt({},a):r[o]=!0;continue}r[o]=Kt(s,a)}}return r}function Vo(e,t){if(e===null)return null;if(typeof e=="string"||typeof e=="number"||typeof e=="boolean")return e;if(typeof e=="bigint")return{$type:"BigInt",value:String(e)};if(st(e)){if(dr(e))return{$type:"DateTime",value:e.toISOString()};t.throwValidationError({kind:"InvalidArgumentValue",selectionPath:t.getSelectionPath(),argumentPath:t.getArgumentPath(),argument:{name:t.getArgumentName(),typeNames:["Date"]},underlyingError:"Provided Date object is invalid"})}if(Bo(e))return{$type:"Param",value:e.name};if(ht(e))return{$type:"FieldRef",value:{_ref:e.name,_container:e.modelName}};if(Array.isArray(e))return Nc(e,t);if(ArrayBuffer.isView(e)){let{buffer:r,byteOffset:n,byteLength:i}=e;return{$type:"Bytes",value:w.Buffer.from(r,n,i).toString("base64")}}if(qc(e))return e.values;if(ut(e))return{$type:"Decimal",value:e.toFixed()};if(e instanceof Me){if(e!==kr.instances[e._getName()])throw new Error("Invalid ObjectEnumValue");return{$type:"Enum",value:e._getName()}}if(Bc(e))return e.toJSON();if(typeof e=="object")return Qo(e,t);t.throwValidationError({kind:"InvalidArgumentValue",selectionPath:t.getSelectionPath(),argumentPath:t.getArgumentPath(),argument:{name:t.getArgumentName(),typeNames:[]},underlyingError:`We could not serialize ${Object.prototype.toString.call(e)} value. Serialize the object to JSON or implement a ".toJSON()" method on it`})}function Qo(e,t){if(e.$type)return{$type:"Raw",value:e};let r={};for(let n in e){let i=e[n],o=t.nestArgument(n);ve(i)||(i!==void 0?r[n]=Vo(i,o):t.isPreviewFeatureOn("strictUndefinedChecks")&&t.throwValidationError({kind:"InvalidArgumentValue",argumentPath:o.getArgumentPath(),selectionPath:t.getSelectionPath(),argument:{name:t.getArgumentName(),typeNames:[]},underlyingError:$o}))}return r}function Nc(e,t){let r=[];for(let n=0;n({name:t.name,typeName:"boolean",isRelation:t.kind==="object"}))}}isRawAction(){return["executeRaw","queryRaw","runCommandRaw","findRaw","aggregateRaw"].includes(this.params.action)}isPreviewFeatureOn(t){return this.params.previewFeatures.includes(t)}getComputedFields(){if(this.params.modelName)return this.params.extensions.getAllComputedFields(this.params.modelName)}findField(t){return this.modelOrType?.fields.find(r=>r.name===t)}nestSelection(t){let r=this.findField(t),n=r?.kind==="object"?r.type:void 0;return new e({...this.params,modelName:n,selectionPath:this.params.selectionPath.concat(t)})}getGlobalOmit(){return this.params.modelName&&this.shouldApplyGlobalOmit()?this.params.globalOmit?.[De(this.params.modelName)]??{}:{}}shouldApplyGlobalOmit(){switch(this.params.action){case"findFirst":case"findFirstOrThrow":case"findUniqueOrThrow":case"findMany":case"upsert":case"findUnique":case"createManyAndReturn":case"create":case"update":case"updateManyAndReturn":case"delete":return!0;case"executeRaw":case"aggregateRaw":case"runCommandRaw":case"findRaw":case"createMany":case"deleteMany":case"groupBy":case"updateMany":case"count":case"aggregate":case"queryRaw":return!1;default:ze(this.params.action,"Unknown action")}}nestArgument(t){return new e({...this.params,argumentPath:this.params.argumentPath.concat(t)})}};m();c();p();d();f();function Jo(e){if(!e._hasPreviewFlag("metrics"))throw new te("`metrics` preview feature must be enabled in order to access metrics API",{clientVersion:e._clientVersion})}var bt=class{_client;constructor(t){this._client=t}prometheus(t){return Jo(this._client),this._client._engine.metrics({format:"prometheus",...t})}json(t){return Jo(this._client),this._client._engine.metrics({format:"json",...t})}};m();c();p();d();f();function Go(e,t){let r=Nt(()=>jc(t));Object.defineProperty(e,"dmmf",{get:()=>r.get()})}function jc(e){return{datamodel:{models:qn(e.models),enums:qn(e.enums),types:qn(e.types)}}}function qn(e){return Object.entries(e).map(([t,r])=>({name:t,...r}))}m();c();p();d();f();var Bn=new WeakMap,qr="$$PrismaTypedSql",zt=class{constructor(t,r){Bn.set(this,{sql:t,values:r}),Object.defineProperty(this,qr,{value:qr})}get sql(){return Bn.get(this).sql}get values(){return Bn.get(this).values}};function Wo(e){return(...t)=>new zt(e,t)}function Br(e){return e!=null&&e[qr]===qr}m();c();p();d();f();var da=Qe(Ko());m();c();p();d();f();zo();dn();gn();m();c();p();d();f();var le=class e{constructor(t,r){if(t.length-1!==r.length)throw t.length===0?new TypeError("Expected at least 1 string"):new TypeError(`Expected ${t.length} strings to have ${t.length-1} values`);let n=r.reduce((s,a)=>s+(a instanceof e?a.values.length:1),0);this.values=new Array(n),this.strings=new Array(n+1),this.strings[0]=t[0];let i=0,o=0;for(;ie.getPropertyValue(r))},getPropertyDescriptor(r){return e.getPropertyDescriptor?.(r)}}}m();c();p();d();f();m();c();p();d();f();var Ur={enumerable:!0,configurable:!0,writable:!0};function $r(e){let t=new Set(e);return{getPrototypeOf:()=>Object.prototype,getOwnPropertyDescriptor:()=>Ur,has:(r,n)=>t.has(n),set:(r,n,i)=>t.add(n)&&Reflect.set(r,n,i),ownKeys:()=>[...t]}}var Zo=Symbol.for("nodejs.util.inspect.custom");function ge(e,t){let r=$c(t),n=new Set,i=new Proxy(e,{get(o,s){if(n.has(s))return o[s];let a=r.get(s);return a?a.getPropertyValue(s):o[s]},has(o,s){if(n.has(s))return!0;let a=r.get(s);return a?a.has?.(s)??!0:Reflect.has(o,s)},ownKeys(o){let s=Xo(Reflect.ownKeys(o),r),a=Xo(Array.from(r.keys()),r);return[...new Set([...s,...a,...n])]},set(o,s,a){return r.get(s)?.getPropertyDescriptor?.(s)?.writable===!1?!1:(n.add(s),Reflect.set(o,s,a))},getOwnPropertyDescriptor(o,s){let a=Reflect.getOwnPropertyDescriptor(o,s);if(a&&!a.configurable)return a;let l=r.get(s);return l?l.getPropertyDescriptor?{...Ur,...l?.getPropertyDescriptor(s)}:Ur:a},defineProperty(o,s,a){return n.add(s),Reflect.defineProperty(o,s,a)},getPrototypeOf:()=>Object.prototype});return i[Zo]=function(){let o={...this};return delete o[Zo],o},i}function $c(e){let t=new Map;for(let r of e){let n=r.getKeys();for(let i of n)t.set(i,r)}return t}function Xo(e,t){return e.filter(r=>t.get(r)?.has?.(r)??!0)}m();c();p();d();f();function Et(e){return{getKeys(){return e},has(){return!1},getPropertyValue(){}}}m();c();p();d();f();function Vr(e,t){return{batch:e,transaction:t?.kind==="batch"?{isolationLevel:t.options.isolationLevel}:void 0}}m();c();p();d();f();function es(e){if(e===void 0)return"";let t=yt(e);return new pt(0,{colors:Sr}).write(t).toString()}m();c();p();d();f();var Vc="P2037";function Qr({error:e,user_facing_error:t},r,n){return t.error_code?new se(Qc(t,n),{code:t.error_code,clientVersion:r,meta:t.meta,batchRequestIdx:t.batch_request_idx}):new G(e,{clientVersion:r,batchRequestIdx:t.batch_request_idx})}function Qc(e,t){let r=e.message;return(t==="postgresql"||t==="postgres"||t==="mysql")&&e.error_code===Vc&&(r+=` -Prisma Accelerate has built-in connection pooling to prevent such errors: https://pris.ly/client/error-accelerate`),r}m();c();p();d();f();m();c();p();d();f();m();c();p();d();f();m();c();p();d();f();m();c();p();d();f();var Yt="";function ts(e){var t=e.split(` -`);return t.reduce(function(r,n){var i=Wc(n)||zc(n)||Zc(n)||rp(n)||ep(n);return i&&r.push(i),r},[])}var Jc=/^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack|rsc||\/|[a-z]:\\|\\\\).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i,Gc=/\((\S*)(?::(\d+))(?::(\d+))\)/;function Wc(e){var t=Jc.exec(e);if(!t)return null;var r=t[2]&&t[2].indexOf("native")===0,n=t[2]&&t[2].indexOf("eval")===0,i=Gc.exec(t[2]);return n&&i!=null&&(t[2]=i[1],t[3]=i[2],t[4]=i[3]),{file:r?null:t[2],methodName:t[1]||Yt,arguments:r?[t[2]]:[],lineNumber:t[3]?+t[3]:null,column:t[4]?+t[4]:null}}var Kc=/^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|rsc|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i;function zc(e){var t=Kc.exec(e);return t?{file:t[2],methodName:t[1]||Yt,arguments:[],lineNumber:+t[3],column:t[4]?+t[4]:null}:null}var Hc=/^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|rsc|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i,Yc=/(\S+) line (\d+)(?: > eval line \d+)* > eval/i;function Zc(e){var t=Hc.exec(e);if(!t)return null;var r=t[3]&&t[3].indexOf(" > eval")>-1,n=Yc.exec(t[3]);return r&&n!=null&&(t[3]=n[1],t[4]=n[2],t[5]=null),{file:t[3],methodName:t[1]||Yt,arguments:t[2]?t[2].split(","):[],lineNumber:t[4]?+t[4]:null,column:t[5]?+t[5]:null}}var Xc=/^\s*(?:([^@]*)(?:\((.*?)\))?@)?(\S.*?):(\d+)(?::(\d+))?\s*$/i;function ep(e){var t=Xc.exec(e);return t?{file:t[3],methodName:t[1]||Yt,arguments:[],lineNumber:+t[4],column:t[5]?+t[5]:null}:null}var tp=/^\s*at (?:((?:\[object object\])?[^\\/]+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$/i;function rp(e){var t=tp.exec(e);return t?{file:t[2],methodName:t[1]||Yt,arguments:[],lineNumber:+t[3],column:t[4]?+t[4]:null}:null}var $n=class{getLocation(){return null}},Vn=class{_error;constructor(){this._error=new Error}getLocation(){let t=this._error.stack;if(!t)return null;let n=ts(t).find(i=>{if(!i.file)return!1;let o=Pn(i.file);return o!==""&&!o.includes("@prisma")&&!o.includes("/packages/client/src/runtime/")&&!o.endsWith("/runtime/binary.js")&&!o.endsWith("/runtime/library.js")&&!o.endsWith("/runtime/edge.js")&&!o.endsWith("/runtime/edge-esm.js")&&!o.startsWith("internal/")&&!i.methodName.includes("new ")&&!i.methodName.includes("getCallSite")&&!i.methodName.includes("Proxy.")&&i.methodName.split(".").length<4});return!n||!n.file?null:{fileName:n.file,lineNumber:n.lineNumber,columnNumber:n.column}}};function Ue(e){return e==="minimal"?typeof $EnabledCallSite=="function"&&e!=="minimal"?new $EnabledCallSite:new $n:new Vn}m();c();p();d();f();m();c();p();d();f();m();c();p();d();f();var rs={_avg:!0,_count:!0,_sum:!0,_min:!0,_max:!0};function xt(e={}){let t=ip(e);return Object.entries(t).reduce((n,[i,o])=>(rs[i]!==void 0?n.select[i]={select:o}:n[i]=o,n),{select:{}})}function ip(e={}){return typeof e._count=="boolean"?{...e,_count:{_all:e._count}}:e}function Jr(e={}){return t=>(typeof e._count=="boolean"&&(t._count=t._count._all),t)}function ns(e,t){let r=Jr(e);return t({action:"aggregate",unpacker:r,argsMapper:xt})(e)}m();c();p();d();f();function op(e={}){let{select:t,...r}=e;return typeof t=="object"?xt({...r,_count:t}):xt({...r,_count:{_all:!0}})}function sp(e={}){return typeof e.select=="object"?t=>Jr(e)(t)._count:t=>Jr(e)(t)._count._all}function is(e,t){return t({action:"count",unpacker:sp(e),argsMapper:op})(e)}m();c();p();d();f();function ap(e={}){let t=xt(e);if(Array.isArray(t.by))for(let r of t.by)typeof r=="string"&&(t.select[r]=!0);else typeof t.by=="string"&&(t.select[t.by]=!0);return t}function lp(e={}){return t=>(typeof e?._count=="boolean"&&t.forEach(r=>{r._count=r._count._all}),t)}function os(e,t){return t({action:"groupBy",unpacker:lp(e),argsMapper:ap})(e)}function ss(e,t,r){if(t==="aggregate")return n=>ns(n,r);if(t==="count")return n=>is(n,r);if(t==="groupBy")return n=>os(n,r)}m();c();p();d();f();function as(e,t){let r=t.fields.filter(i=>!i.relationName),n=Yi(r,"name");return new Proxy({},{get(i,o){if(o in i||typeof o=="symbol")return i[o];let s=n[o];if(s)return new $t(e,o,s.type,s.isList,s.kind==="enum")},...$r(Object.keys(n))})}m();c();p();d();f();m();c();p();d();f();var ls=e=>Array.isArray(e)?e:e.split("."),Qn=(e,t)=>ls(t).reduce((r,n)=>r&&r[n],e),us=(e,t,r)=>ls(t).reduceRight((n,i,o,s)=>Object.assign({},Qn(e,s.slice(0,o)),{[i]:n}),r);function up(e,t){return e===void 0||t===void 0?[]:[...t,"select",e]}function cp(e,t,r){return t===void 0?e??{}:us(t,r,e||!0)}function Jn(e,t,r,n,i,o){let a=e._runtimeDataModel.models[t].fields.reduce((l,u)=>({...l,[u.name]:u}),{});return l=>{let u=Ue(e._errorFormat),g=up(n,i),h=cp(l,o,g),T=r({dataPath:g,callsite:u})(h),O=pp(e,t);return new Proxy(T,{get(C,S){if(!O.includes(S))return C[S];let _=[a[S].type,r,S],L=[g,h];return Jn(e,..._,...L)},...$r([...O,...Object.getOwnPropertyNames(T)])})}}function pp(e,t){return e._runtimeDataModel.models[t].fields.filter(r=>r.kind==="object").map(r=>r.name)}var dp=["findUnique","findUniqueOrThrow","findFirst","findFirstOrThrow","create","update","upsert","delete"],fp=["aggregate","count","groupBy"];function Gn(e,t){let r=e._extensions.getAllModelExtensions(t)??{},n=[mp(e,t),hp(e,t),Ht(r),ne("name",()=>t),ne("$name",()=>t),ne("$parent",()=>e._appliedParent)];return ge({},n)}function mp(e,t){let r=Pe(t),n=Object.keys(ct).concat("count");return{getKeys(){return n},getPropertyValue(i){let o=i,s=a=>l=>{let u=Ue(e._errorFormat);return e._createPrismaPromise(g=>{let h={args:l,dataPath:[],action:o,model:t,clientMethod:`${r}.${i}`,jsModelName:r,transaction:g,callsite:u};return e._request({...h,...a})},{action:o,args:l,model:t})};return dp.includes(o)?Jn(e,t,s):gp(i)?ss(e,i,s):s({})}}}function gp(e){return fp.includes(e)}function hp(e,t){return He(ne("fields",()=>{let r=e._runtimeDataModel.models[t];return as(t,r)}))}m();c();p();d();f();function cs(e){return e.replace(/^./,t=>t.toUpperCase())}var Wn=Symbol();function Zt(e){let t=[yp(e),wp(e),ne(Wn,()=>e),ne("$parent",()=>e._appliedParent)],r=e._extensions.getAllClientExtensions();return r&&t.push(Ht(r)),ge(e,t)}function yp(e){let t=Object.getPrototypeOf(e._originalClient),r=[...new Set(Object.getOwnPropertyNames(t))];return{getKeys(){return r},getPropertyValue(n){return e[n]}}}function wp(e){let t=Object.keys(e._runtimeDataModel.models),r=t.map(Pe),n=[...new Set(t.concat(r))];return He({getKeys(){return n},getPropertyValue(i){let o=cs(i);if(e._runtimeDataModel.models[o]!==void 0)return Gn(e,o);if(e._runtimeDataModel.models[i]!==void 0)return Gn(e,i)},getPropertyDescriptor(i){if(!r.includes(i))return{enumerable:!1}}})}function ps(e){return e[Wn]?e[Wn]:e}function ds(e){if(typeof e=="function")return e(this);if(e.client?.__AccelerateEngine){let r=e.client.__AccelerateEngine;this._originalClient._engine=new r(this._originalClient._accelerateEngineConfig)}let t=Object.create(this._originalClient,{_extensions:{value:this._extensions.append(e)},_appliedParent:{value:this,configurable:!0},$on:{value:void 0}});return Zt(t)}m();c();p();d();f();m();c();p();d();f();function fs({result:e,modelName:t,select:r,omit:n,extensions:i}){let o=i.getAllComputedFields(t);if(!o)return e;let s=[],a=[];for(let l of Object.values(o)){if(n){if(n[l.name])continue;let u=l.needs.filter(g=>n[g]);u.length>0&&a.push(Et(u))}else if(r){if(!r[l.name])continue;let u=l.needs.filter(g=>!r[g]);u.length>0&&a.push(Et(u))}bp(e,l.needs)&&s.push(Ep(l,ge(e,s)))}return s.length>0||a.length>0?ge(e,[...s,...a]):e}function bp(e,t){return t.every(r=>vn(e,r))}function Ep(e,t){return He(ne(e.name,()=>e.compute(t)))}m();c();p();d();f();function Gr({visitor:e,result:t,args:r,runtimeDataModel:n,modelName:i}){if(Array.isArray(t)){for(let s=0;sg.name===o);if(!l||l.kind!=="object"||!l.relationName)continue;let u=typeof s=="object"?s:{};t[o]=Gr({visitor:i,result:t[o],args:u,modelName:l.type,runtimeDataModel:n})}}function gs({result:e,modelName:t,args:r,extensions:n,runtimeDataModel:i,globalOmit:o}){return n.isEmpty()||e==null||typeof e!="object"||!i.models[t]?e:Gr({result:e,args:r??{},modelName:t,runtimeDataModel:i,visitor:(a,l,u)=>{let g=Pe(l);return fs({result:a,modelName:g,select:u.select,omit:u.select?void 0:{...o?.[g],...u.omit},extensions:n})}})}m();c();p();d();f();m();c();p();d();f();m();c();p();d();f();var xp=["$connect","$disconnect","$on","$transaction","$extends"],hs=xp;function ys(e){if(e instanceof le)return Pp(e);if(Br(e))return vp(e);if(Array.isArray(e)){let r=[e[0]];for(let n=1;n{let o=t.customDataProxyFetch;return"transaction"in t&&i!==void 0&&(t.transaction?.kind==="batch"&&t.transaction.lock.then(),t.transaction=i),n===r.length?e._executeRequest(t):r[n]({model:t.model,operation:t.model?t.action:t.clientMethod,args:ys(t.args??{}),__internalParams:t,query:(s,a=t)=>{let l=a.customDataProxyFetch;return a.customDataProxyFetch=vs(o,l),a.args=s,bs(e,a,r,n+1)}})})}function Es(e,t){let{jsModelName:r,action:n,clientMethod:i}=t,o=r?n:i;if(e._extensions.isEmpty())return e._executeRequest(t);let s=e._extensions.getAllQueryCallbacks(r??"$none",o);return bs(e,t,s)}function xs(e){return t=>{let r={requests:t},n=t[0].extensions.getAllBatchQueryCallbacks();return n.length?Ps(r,n,0,e):e(r)}}function Ps(e,t,r,n){if(r===t.length)return n(e);let i=e.customDataProxyFetch,o=e.requests[0].transaction;return t[r]({args:{queries:e.requests.map(s=>({model:s.modelName,operation:s.action,args:s.args})),transaction:o?{isolationLevel:o.kind==="batch"?o.isolationLevel:void 0}:void 0},__internalParams:e,query(s,a=e){let l=a.customDataProxyFetch;return a.customDataProxyFetch=vs(i,l),Ps(a,t,r+1,n)}})}var ws=e=>e;function vs(e=ws,t=ws){return r=>e(t(r))}m();c();p();d();f();var Ts=z("prisma:client"),As={Vercel:"vercel","Netlify CI":"netlify"};function Cs({postinstall:e,ciName:t,clientVersion:r,generator:n}){if(Ts("checkPlatformCaching:postinstall",e),Ts("checkPlatformCaching:ciName",t),e===!0&&!(n?.output&&typeof(n.output.fromEnvVar??n.output.value)=="string")&&t&&t in As){let i=`Prisma has detected that this project was built on ${t}, which caches dependencies. This leads to an outdated Prisma Client because Prisma's auto-generation isn't triggered. To fix this, make sure to run the \`prisma generate\` command during the build process. - -Learn how: https://pris.ly/d/${As[t]}-build`;throw console.error(i),new Q(i,r)}}m();c();p();d();f();function Ss(e,t){return e?e.datasources?e.datasources:e.datasourceUrl?{[t[0]]:{url:e.datasourceUrl}}:{}:{}}m();c();p();d();f();m();c();p();d();f();m();c();p();d();f();m();c();p();d();f();function Rs(e){return e?e.replace(/".*"/g,'"X"').replace(/[\s:\[]([+-]?([0-9]*[.])?[0-9]+)/g,t=>`${t[0]}5`):""}m();c();p();d();f();function Os(e){return e.split(` -`).map(t=>t.replace(/^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z)\s*/,"").replace(/\+\d+\s*ms$/,"")).join(` -`)}m();c();p();d();f();var ks=Qe(Ki());function Is({title:e,user:t="prisma",repo:r="prisma",template:n="bug_report.yml",body:i}){return(0,ks.default)({user:t,repo:r,template:n,title:e,body:i})}function Fs({version:e,binaryTarget:t,title:r,description:n,engineVersion:i,database:o,query:s}){let a=Mi(6e3-(s?.length??0)),l=Os(ot(a)),u=n?`# Description -\`\`\` -${n} -\`\`\``:"",g=ot(`Hi Prisma Team! My Prisma Client just crashed. This is the report: -## Versions - -| Name | Version | -|-----------------|--------------------| -| Node | ${y.version?.padEnd(19)}| -| OS | ${t?.padEnd(19)}| -| Prisma Client | ${e?.padEnd(19)}| -| Query Engine | ${i?.padEnd(19)}| -| Database | ${o?.padEnd(19)}| - -${u} - -## Logs -\`\`\` -${l} -\`\`\` - -## Client Snippet -\`\`\`ts -// PLEASE FILL YOUR CODE SNIPPET HERE -\`\`\` - -## Schema -\`\`\`prisma -// PLEASE ADD YOUR SCHEMA HERE IF POSSIBLE -\`\`\` - -## Prisma Engine Query -\`\`\` -${s?Rs(s):""} -\`\`\` -`),h=Is({title:r,body:g});return`${r} - -This is a non-recoverable error which probably happens when the Prisma Query Engine has a panic. - -${Rt(h)} - -If you want the Prisma team to look into it, please open the link above \u{1F64F} -To increase the chance of success, please post your schema and a snippet of -how you used Prisma Client in the issue. -`}m();c();p();d();f();m();c();p();d();f();m();c();p();d();f();function Ms(e,t){throw new Error(t)}function Tp(e){return e!==null&&typeof e=="object"&&typeof e.$type=="string"}function Ap(e,t){let r={};for(let n of Object.keys(e))r[n]=t(e[n],n);return r}function Pt(e){return e===null?e:Array.isArray(e)?e.map(Pt):typeof e=="object"?Tp(e)?Cp(e):e.constructor!==null&&e.constructor.name!=="Object"?e:Ap(e,Pt):e}function Cp({$type:e,value:t}){switch(e){case"BigInt":return BigInt(t);case"Bytes":{let{buffer:r,byteOffset:n,byteLength:i}=w.Buffer.from(t,"base64");return new Uint8Array(r,n,i)}case"DateTime":return new Date(t);case"Decimal":return new Ie(t);case"Json":return JSON.parse(t);default:Ms(t,"Unknown tagged value")}}var _s="6.19.1";m();c();p();d();f();m();c();p();d();f();var Rp=()=>globalThis.process?.release?.name==="node",Op=()=>!!globalThis.Bun||!!globalThis.process?.versions?.bun,kp=()=>!!globalThis.Deno,Ip=()=>typeof globalThis.Netlify=="object",Fp=()=>typeof globalThis.EdgeRuntime=="object",Mp=()=>globalThis.navigator?.userAgent==="Cloudflare-Workers";function _p(){return[[Ip,"netlify"],[Fp,"edge-light"],[Mp,"workerd"],[kp,"deno"],[Op,"bun"],[Rp,"node"]].flatMap(r=>r[0]()?[r[1]]:[]).at(0)??""}var Dp={node:"Node.js",workerd:"Cloudflare Workers",deno:"Deno and Deno Deploy",netlify:"Netlify Edge Functions","edge-light":"Edge Runtime (Vercel Edge Functions, Vercel Edge Middleware, Next.js (Pages Router) Edge API Routes, Next.js (App Router) Edge Route Handlers or Next.js Middleware)"};function Ds(){let e=_p();return{id:e,prettyName:Dp[e]||e,isEdge:["workerd","deno","netlify","edge-light"].includes(e)}}function Wr({inlineDatasources:e,overrideDatasources:t,env:r,clientVersion:n}){let i,o=Object.keys(e)[0],s=e[o]?.url,a=t[o]?.url;if(o===void 0?i=void 0:a?i=a:s?.value?i=s.value:s?.fromEnvVar&&(i=r[s.fromEnvVar]),s?.fromEnvVar!==void 0&&i===void 0)throw new Q(`error: Environment variable not found: ${s.fromEnvVar}.`,n);if(i===void 0)throw new Q("error: Missing URL environment variable, value, or override.",n);return i}m();c();p();d();f();m();c();p();d();f();function Ls(e){if(e?.kind==="itx")return e.options.id}m();c();p();d();f();var Kn=class{engineObject;constructor(t,r,n){this.engineObject=__PrismaProxy.create({datamodel:t.datamodel,env:y.env,ignoreEnvVarErrors:!0,datasourceOverrides:t.datasourceOverrides??{},logLevel:t.logLevel,logQueries:t.logQueries??!1,logCallback:r,enableTracing:t.enableTracing})}async connect(t,r){return __PrismaProxy.connect(this.engineObject,t,r)}async disconnect(t,r){return __PrismaProxy.disconnect(this.engineObject,t,r)}query(t,r,n,i){return __PrismaProxy.execute(this.engineObject,t,r,n,i)}compile(){throw new Error("not implemented")}sdlSchema(){return Promise.resolve("{}")}dmmf(t){return Promise.resolve("{}")}async startTransaction(t,r,n){return __PrismaProxy.startTransaction(this.engineObject,t,r,n)}async commitTransaction(t,r,n){return __PrismaProxy.commitTransaction(this.engineObject,t,r,n)}async rollbackTransaction(t,r,n){return __PrismaProxy.rollbackTransaction(this.engineObject,t,r,n)}metrics(t){return Promise.resolve("{}")}async applyPendingMigrations(){return __PrismaProxy.applyPendingMigrations(this.engineObject)}trace(t){return __PrismaProxy.trace(this.engineObject,t)}},Ns={async loadLibrary(e){if(!__PrismaProxy)throw new Q("__PrismaProxy not detected make sure React Native bindings are installed",e.clientVersion);return{debugPanic(){return Promise.reject("{}")},dmmf(){return Promise.resolve("{}")},version(){return{commit:"unknown",version:"unknown"}},QueryEngine:Kn}}};var Lp="P2036",Te=z("prisma:client:libraryEngine");function Np(e){return e.item_type==="query"&&"query"in e}function qp(e){return"level"in e?e.level==="error"&&e.message==="PANIC":!1}var TO=[...fn,"native"],Bp=0xffffffffffffffffn,zn=1n;function jp(){let e=zn++;return zn>Bp&&(zn=1n),e}var er=class{name="LibraryEngine";engine;libraryInstantiationPromise;libraryStartingPromise;libraryStoppingPromise;libraryStarted;executingQueryPromise;config;QueryEngineConstructor;libraryLoader;library;logEmitter;libQueryEnginePath;binaryTarget;datasourceOverrides;datamodel;logQueries;logLevel;lastQuery;loggerRustPanic;tracingHelper;adapterPromise;versionInfo;constructor(t,r){this.libraryLoader=Ns,this.config=t,this.libraryStarted=!1,this.logQueries=t.logQueries??!1,this.logLevel=t.logLevel??"error",this.logEmitter=t.logEmitter,this.datamodel=t.inlineSchema,this.tracingHelper=t.tracingHelper,t.enableDebugLogs&&(this.logLevel="debug");let n=Object.keys(t.overrideDatasources)[0],i=t.overrideDatasources[n]?.url;n!==void 0&&i!==void 0&&(this.datasourceOverrides={[n]:i}),this.libraryInstantiationPromise=this.instantiateLibrary()}wrapEngine(t){return{applyPendingMigrations:t.applyPendingMigrations?.bind(t),commitTransaction:this.withRequestId(t.commitTransaction.bind(t)),connect:this.withRequestId(t.connect.bind(t)),disconnect:this.withRequestId(t.disconnect.bind(t)),metrics:t.metrics?.bind(t),query:this.withRequestId(t.query.bind(t)),rollbackTransaction:this.withRequestId(t.rollbackTransaction.bind(t)),sdlSchema:t.sdlSchema?.bind(t),startTransaction:this.withRequestId(t.startTransaction.bind(t)),trace:t.trace.bind(t),free:t.free?.bind(t)}}withRequestId(t){return async(...r)=>{let n=jp().toString();try{return await t(...r,n)}finally{if(this.tracingHelper.isEnabled()){let i=await this.engine?.trace(n);if(i){let o=JSON.parse(i);this.tracingHelper.dispatchEngineSpans(o.spans)}}}}}async applyPendingMigrations(){await this.start(),await this.engine?.applyPendingMigrations()}async transaction(t,r,n){await this.start();let i=await this.adapterPromise,o=JSON.stringify(r),s;if(t==="start"){let l=JSON.stringify({max_wait:n.maxWait,timeout:n.timeout,isolation_level:n.isolationLevel});s=await this.engine?.startTransaction(l,o)}else t==="commit"?s=await this.engine?.commitTransaction(n.id,o):t==="rollback"&&(s=await this.engine?.rollbackTransaction(n.id,o));let a=this.parseEngineResponse(s);if(Up(a)){let l=this.getExternalAdapterError(a,i?.errorRegistry);throw l?l.error:new se(a.message,{code:a.error_code,clientVersion:this.config.clientVersion,meta:a.meta})}else if(typeof a.message=="string")throw new G(a.message,{clientVersion:this.config.clientVersion});return a}async instantiateLibrary(){if(Te("internalSetup"),this.libraryInstantiationPromise)return this.libraryInstantiationPromise;this.binaryTarget=await this.getCurrentBinaryTarget(),await this.tracingHelper.runInChildSpan("load_engine",()=>this.loadEngine()),this.version()}async getCurrentBinaryTarget(){}parseEngineResponse(t){if(!t)throw new G("Response from the Engine was empty",{clientVersion:this.config.clientVersion});try{return JSON.parse(t)}catch{throw new G("Unable to JSON.parse response from engine",{clientVersion:this.config.clientVersion})}}async loadEngine(){if(!this.engine){this.QueryEngineConstructor||(this.library=await this.libraryLoader.loadLibrary(this.config),this.QueryEngineConstructor=this.library.QueryEngine);try{let t=new b(this);this.adapterPromise||(this.adapterPromise=this.config.adapter?.connect()?.then(lr));let r=await this.adapterPromise;r&&Te("Using driver adapter: %O",r),this.engine=this.wrapEngine(new this.QueryEngineConstructor({datamodel:this.datamodel,env:y.env,logQueries:this.config.logQueries??!1,ignoreEnvVarErrors:!0,datasourceOverrides:this.datasourceOverrides??{},logLevel:this.logLevel,configDir:this.config.cwd,engineProtocol:"json",enableTracing:this.tracingHelper.isEnabled()},n=>{t.deref()?.logger(n)},r))}catch(t){let r=t,n=this.parseInitError(r.message);throw typeof n=="string"?r:new Q(n.message,this.config.clientVersion,n.error_code)}}}logger(t){let r=this.parseEngineResponse(t);r&&(r.level=r?.level.toLowerCase()??"unknown",Np(r)?this.logEmitter.emit("query",{timestamp:new Date,query:r.query,params:r.params,duration:Number(r.duration_ms),target:r.module_path}):qp(r)?this.loggerRustPanic=new ce(Hn(this,`${r.message}: ${r.reason} in ${r.file}:${r.line}:${r.column}`),this.config.clientVersion):this.logEmitter.emit(r.level,{timestamp:new Date,message:r.message,target:r.module_path}))}parseInitError(t){try{return JSON.parse(t)}catch{}return t}parseRequestError(t){try{return JSON.parse(t)}catch{}return t}onBeforeExit(){throw new Error('"beforeExit" hook is not applicable to the library engine since Prisma 5.0.0, it is only relevant and implemented for the binary engine. Please add your event listener to the `process` object directly instead.')}async start(){if(this.libraryInstantiationPromise||(this.libraryInstantiationPromise=this.instantiateLibrary()),await this.libraryInstantiationPromise,await this.libraryStoppingPromise,this.libraryStartingPromise)return Te(`library already starting, this.libraryStarted: ${this.libraryStarted}`),this.libraryStartingPromise;if(this.libraryStarted)return;let t=async()=>{Te("library starting");try{let r={traceparent:this.tracingHelper.getTraceParent()};await this.engine?.connect(JSON.stringify(r)),this.libraryStarted=!0,this.adapterPromise||(this.adapterPromise=this.config.adapter?.connect()?.then(lr)),await this.adapterPromise,Te("library started")}catch(r){let n=this.parseInitError(r.message);throw typeof n=="string"?r:new Q(n.message,this.config.clientVersion,n.error_code)}finally{this.libraryStartingPromise=void 0}};return this.libraryStartingPromise=this.tracingHelper.runInChildSpan("connect",t),this.libraryStartingPromise}async stop(){if(await this.libraryInstantiationPromise,await this.libraryStartingPromise,await this.executingQueryPromise,this.libraryStoppingPromise)return Te("library is already stopping"),this.libraryStoppingPromise;if(!this.libraryStarted){await(await this.adapterPromise)?.dispose(),this.adapterPromise=void 0;return}let t=async()=>{await new Promise(n=>setImmediate(n)),Te("library stopping");let r={traceparent:this.tracingHelper.getTraceParent()};await this.engine?.disconnect(JSON.stringify(r)),this.engine?.free&&this.engine.free(),this.engine=void 0,this.libraryStarted=!1,this.libraryStoppingPromise=void 0,this.libraryInstantiationPromise=void 0,await(await this.adapterPromise)?.dispose(),this.adapterPromise=void 0,Te("library stopped")};return this.libraryStoppingPromise=this.tracingHelper.runInChildSpan("disconnect",t),this.libraryStoppingPromise}version(){return this.versionInfo=this.library?.version(),this.versionInfo?.version??"unknown"}debugPanic(t){return this.library?.debugPanic(t)}async request(t,{traceparent:r,interactiveTransaction:n}){Te(`sending request, this.libraryStarted: ${this.libraryStarted}`);let i=JSON.stringify({traceparent:r}),o=JSON.stringify(t);try{await this.start();let s=await this.adapterPromise;this.executingQueryPromise=this.engine?.query(o,i,n?.id),this.lastQuery=o;let a=this.parseEngineResponse(await this.executingQueryPromise);if(a.errors)throw a.errors.length===1?this.buildQueryError(a.errors[0],s?.errorRegistry):new G(JSON.stringify(a.errors),{clientVersion:this.config.clientVersion});if(this.loggerRustPanic)throw this.loggerRustPanic;return{data:a}}catch(s){if(s instanceof Q)throw s;if(s.code==="GenericFailure"&&s.message?.startsWith("PANIC:"))throw new ce(Hn(this,s.message),this.config.clientVersion);let a=this.parseRequestError(s.message);throw typeof a=="string"?s:new G(`${a.message} -${a.backtrace}`,{clientVersion:this.config.clientVersion})}}async requestBatch(t,{transaction:r,traceparent:n}){Te("requestBatch");let i=Vr(t,r);await this.start();let o=await this.adapterPromise;this.lastQuery=JSON.stringify(i),this.executingQueryPromise=this.engine?.query(this.lastQuery,JSON.stringify({traceparent:n}),Ls(r));let s=await this.executingQueryPromise,a=this.parseEngineResponse(s);if(a.errors)throw a.errors.length===1?this.buildQueryError(a.errors[0],o?.errorRegistry):new G(JSON.stringify(a.errors),{clientVersion:this.config.clientVersion});let{batchResult:l,errors:u}=a;if(Array.isArray(l))return l.map(g=>g.errors&&g.errors.length>0?this.loggerRustPanic??this.buildQueryError(g.errors[0],o?.errorRegistry):{data:g});throw u&&u.length===1?new Error(u[0].error):new Error(JSON.stringify(a))}buildQueryError(t,r){if(t.user_facing_error.is_panic)return new ce(Hn(this,t.user_facing_error.message),this.config.clientVersion);let n=this.getExternalAdapterError(t.user_facing_error,r);return n?n.error:Qr(t,this.config.clientVersion,this.config.activeProvider)}getExternalAdapterError(t,r){if(t.error_code===Lp&&r){let n=t.meta?.id;ur(typeof n=="number","Malformed external JS error received from the engine");let i=r.consumeError(n);return ur(i,"External error with reported id was not registered"),i}}async metrics(t){await this.start();let r=await this.engine.metrics(JSON.stringify(t));return t.format==="prometheus"?r:this.parseEngineResponse(r)}};function Up(e){return typeof e=="object"&&e!==null&&e.error_code!==void 0}function Hn(e,t){return Fs({binaryTarget:e.binaryTarget,title:t,version:e.config.clientVersion,engineVersion:e.versionInfo?.commit,database:e.config.activeProvider,query:e.lastQuery})}m();c();p();d();f();function qs({url:e,adapter:t,copyEngine:r,targetBuildType:n}){let i=[],o=[],s=S=>{i.push({_tag:"warning",value:S})},a=S=>{let F=S.join(` -`);o.push({_tag:"error",value:F})},l=!!e?.startsWith("prisma://"),u=bn(e),g=!!t,h=l||u;!g&&r&&h&&n!=="client"&&n!=="wasm-compiler-edge"&&s(["recommend--no-engine","In production, we recommend using `prisma generate --no-engine` (See: `prisma generate --help`)"]);let T=h||!r;g&&(T||n==="edge")&&(n==="edge"?a(["Prisma Client was configured to use the `adapter` option but it was imported via its `/edge` endpoint.","Please either remove the `/edge` endpoint or remove the `adapter` from the Prisma Client constructor."]):h?a(["You've provided both a driver adapter and an Accelerate database URL. Driver adapters currently cannot connect to Accelerate.","Please provide either a driver adapter with a direct database URL or an Accelerate URL and no driver adapter."]):r||a(["Prisma Client was configured to use the `adapter` option but `prisma generate` was run with `--no-engine`.","Please run `prisma generate` without `--no-engine` to be able to use Prisma Client with the adapter."]));let O={accelerate:T,ppg:u,driverAdapters:g};function C(S){return S.length>0}return C(o)?{ok:!1,diagnostics:{warnings:i,errors:o},isUsing:O}:{ok:!0,diagnostics:{warnings:i},isUsing:O}}function Bs({copyEngine:e=!0},t){let r;try{r=Wr({inlineDatasources:t.inlineDatasources,overrideDatasources:t.overrideDatasources,env:{...t.env,...y.env},clientVersion:t.clientVersion})}catch{}let{ok:n,isUsing:i,diagnostics:o}=qs({url:r,adapter:t.adapter,copyEngine:e,targetBuildType:"react-native"});for(let h of o.warnings)Lt(...h.value);if(!n){let h=o.errors[0];throw new te(h.value,{clientVersion:t.clientVersion})}let s=it(t.generator),a=s==="library",l=s==="binary",u=s==="client",g=(i.accelerate||i.ppg)&&!i.driverAdapters;return new er(t)}m();c();p();d();f();function js({generator:e}){return e?.previewFeatures??[]}m();c();p();d();f();var Us=e=>({command:e});m();c();p();d();f();m();c();p();d();f();var $s=e=>e.strings.reduce((t,r,n)=>`${t}@P${n}${r}`);m();c();p();d();f();function vt(e){try{return Vs(e,"fast")}catch{return Vs(e,"slow")}}function Vs(e,t){return JSON.stringify(e.map(r=>Js(r,t)))}function Js(e,t){if(Array.isArray(e))return e.map(r=>Js(r,t));if(typeof e=="bigint")return{prisma__type:"bigint",prisma__value:e.toString()};if(st(e))return{prisma__type:"date",prisma__value:e.toJSON()};if(Fe.isDecimal(e))return{prisma__type:"decimal",prisma__value:e.toJSON()};if(w.Buffer.isBuffer(e))return{prisma__type:"bytes",prisma__value:e.toString("base64")};if($p(e))return{prisma__type:"bytes",prisma__value:w.Buffer.from(e).toString("base64")};if(ArrayBuffer.isView(e)){let{buffer:r,byteOffset:n,byteLength:i}=e;return{prisma__type:"bytes",prisma__value:w.Buffer.from(r,n,i).toString("base64")}}return typeof e=="object"&&t==="slow"?Gs(e):e}function $p(e){return e instanceof ArrayBuffer||e instanceof SharedArrayBuffer?!0:typeof e=="object"&&e!==null?e[Symbol.toStringTag]==="ArrayBuffer"||e[Symbol.toStringTag]==="SharedArrayBuffer":!1}function Gs(e){if(typeof e!="object"||e===null)return e;if(typeof e.toJSON=="function")return e.toJSON();if(Array.isArray(e))return e.map(Qs);let t={};for(let r of Object.keys(e))t[r]=Qs(e[r]);return t}function Qs(e){return typeof e=="bigint"?e.toString():Gs(e)}var Vp=/^(\s*alter\s)/i,Ws=z("prisma:client");function Yn(e,t,r,n){if(!(e!=="postgresql"&&e!=="cockroachdb")&&r.length>0&&Vp.exec(t))throw new Error(`Running ALTER using ${n} is not supported -Using the example below you can still execute your query with Prisma, but please note that it is vulnerable to SQL injection attacks and requires you to take care of input sanitization. - -Example: - await prisma.$executeRawUnsafe(\`ALTER USER prisma WITH PASSWORD '\${password}'\`) - -More Information: https://pris.ly/d/execute-raw -`)}var Zn=({clientMethod:e,activeProvider:t})=>r=>{let n="",i;if(Br(r))n=r.sql,i={values:vt(r.values),__prismaRawParameters__:!0};else if(Array.isArray(r)){let[o,...s]=r;n=o,i={values:vt(s||[]),__prismaRawParameters__:!0}}else switch(t){case"sqlite":case"mysql":{n=r.sql,i={values:vt(r.values),__prismaRawParameters__:!0};break}case"cockroachdb":case"postgresql":case"postgres":{n=r.text,i={values:vt(r.values),__prismaRawParameters__:!0};break}case"sqlserver":{n=$s(r),i={values:vt(r.values),__prismaRawParameters__:!0};break}default:throw new Error(`The ${t} provider does not support ${e}`)}return i?.values?Ws(`prisma.${e}(${n}, ${i.values})`):Ws(`prisma.${e}(${n})`),{query:n,parameters:i}},Ks={requestArgsToMiddlewareArgs(e){return[e.strings,...e.values]},middlewareArgsToRequestArgs(e){let[t,...r]=e;return new le(t,r)}},zs={requestArgsToMiddlewareArgs(e){return[e]},middlewareArgsToRequestArgs(e){return e[0]}};m();c();p();d();f();function Xn(e){return function(r,n){let i,o=(s=e)=>{try{return s===void 0||s?.kind==="itx"?i??=Hs(r(s)):Hs(r(s))}catch(a){return Promise.reject(a)}};return{get spec(){return n},then(s,a){return o().then(s,a)},catch(s){return o().catch(s)},finally(s){return o().finally(s)},requestTransaction(s){let a=o(s);return a.requestTransaction?a.requestTransaction(s):a},[Symbol.toStringTag]:"PrismaPromise"}}}function Hs(e){return typeof e.then=="function"?e:Promise.resolve(e)}m();c();p();d();f();var Qp=mn.split(".")[0],Jp={isEnabled(){return!1},getTraceParent(){return"00-10-10-00"},dispatchEngineSpans(){},getActiveContext(){},runInChildSpan(e,t){return t()}},ei=class{isEnabled(){return this.getGlobalTracingHelper().isEnabled()}getTraceParent(t){return this.getGlobalTracingHelper().getTraceParent(t)}dispatchEngineSpans(t){return this.getGlobalTracingHelper().dispatchEngineSpans(t)}getActiveContext(){return this.getGlobalTracingHelper().getActiveContext()}runInChildSpan(t,r){return this.getGlobalTracingHelper().runInChildSpan(t,r)}getGlobalTracingHelper(){let t=globalThis[`V${Qp}_PRISMA_INSTRUMENTATION`],r=globalThis.PRISMA_INSTRUMENTATION;return t?.helper??r?.helper??Jp}};function Ys(){return new ei}m();c();p();d();f();function Zs(e,t=()=>{}){let r,n=new Promise(i=>r=i);return{then(i){return--e===0&&r(t()),i?.(n)}}}m();c();p();d();f();function Xs(e){return typeof e=="string"?e:e.reduce((t,r)=>{let n=typeof r=="string"?r:r.level;return n==="query"?t:t&&(r==="info"||t==="info")?"info":n},void 0)}m();c();p();d();f();m();c();p();d();f();function Kr(e){return typeof e.batchRequestIdx=="number"}m();c();p();d();f();function ea(e){if(e.action!=="findUnique"&&e.action!=="findUniqueOrThrow")return;let t=[];return e.modelName&&t.push(e.modelName),e.query.arguments&&t.push(ti(e.query.arguments)),t.push(ti(e.query.selection)),t.join("")}function ti(e){return`(${Object.keys(e).sort().map(r=>{let n=e[r];return typeof n=="object"&&n!==null?`(${r} ${ti(n)})`:r}).join(" ")})`}m();c();p();d();f();var Gp={aggregate:!1,aggregateRaw:!1,createMany:!0,createManyAndReturn:!0,createOne:!0,deleteMany:!0,deleteOne:!0,executeRaw:!0,findFirst:!1,findFirstOrThrow:!1,findMany:!1,findRaw:!1,findUnique:!1,findUniqueOrThrow:!1,groupBy:!1,queryRaw:!1,runCommandRaw:!0,updateMany:!0,updateManyAndReturn:!0,updateOne:!0,upsertOne:!0};function ri(e){return Gp[e]}m();c();p();d();f();var zr=class{constructor(t){this.options=t;this.batches={}}batches;tickActive=!1;request(t){let r=this.options.batchBy(t);return r?(this.batches[r]||(this.batches[r]=[],this.tickActive||(this.tickActive=!0,y.nextTick(()=>{this.dispatchBatches(),this.tickActive=!1}))),new Promise((n,i)=>{this.batches[r].push({request:t,resolve:n,reject:i})})):this.options.singleLoader(t)}dispatchBatches(){for(let t in this.batches){let r=this.batches[t];delete this.batches[t],r.length===1?this.options.singleLoader(r[0].request).then(n=>{n instanceof Error?r[0].reject(n):r[0].resolve(n)}).catch(n=>{r[0].reject(n)}):(r.sort((n,i)=>this.options.batchOrder(n.request,i.request)),this.options.batchLoader(r.map(n=>n.request)).then(n=>{if(n instanceof Error)for(let i=0;i{for(let i=0;iYe("bigint",r));case"bytes-array":return t.map(r=>Ye("bytes",r));case"decimal-array":return t.map(r=>Ye("decimal",r));case"datetime-array":return t.map(r=>Ye("datetime",r));case"date-array":return t.map(r=>Ye("date",r));case"time-array":return t.map(r=>Ye("time",r));default:return t}}function Hr(e){let t=[],r=Wp(e);for(let n=0;n{let{transaction:o,otelParentCtx:s}=n[0],a=n.map(h=>h.protocolQuery),l=this.client._tracingHelper.getTraceParent(s),u=n.some(h=>ri(h.protocolQuery.action));return(await this.client._engine.requestBatch(a,{traceparent:l,transaction:zp(o),containsWrite:u,customDataProxyFetch:i})).map((h,T)=>{if(h instanceof Error)return h;try{return this.mapQueryEngineResult(n[T],h)}catch(O){return O}})}),singleLoader:async n=>{let i=n.transaction?.kind==="itx"?ta(n.transaction):void 0,o=await this.client._engine.request(n.protocolQuery,{traceparent:this.client._tracingHelper.getTraceParent(),interactiveTransaction:i,isWrite:ri(n.protocolQuery.action),customDataProxyFetch:n.customDataProxyFetch});return this.mapQueryEngineResult(n,o)},batchBy:n=>n.transaction?.id?`transaction-${n.transaction.id}`:ea(n.protocolQuery),batchOrder(n,i){return n.transaction?.kind==="batch"&&i.transaction?.kind==="batch"?n.transaction.index-i.transaction.index:0}})}async request(t){try{return await this.dataloader.request(t)}catch(r){let{clientMethod:n,callsite:i,transaction:o,args:s,modelName:a}=t;this.handleAndLogRequestError({error:r,clientMethod:n,callsite:i,transaction:o,args:s,modelName:a,globalOmit:t.globalOmit})}}mapQueryEngineResult({dataPath:t,unpacker:r},n){let i=n?.data,o=this.unpack(i,t,r);return y.env.PRISMA_CLIENT_GET_TIME?{data:o}:o}handleAndLogRequestError(t){try{this.handleRequestError(t)}catch(r){throw this.logEmitter&&this.logEmitter.emit("error",{message:r.message,target:t.clientMethod,timestamp:new Date}),r}}handleRequestError({error:t,clientMethod:r,callsite:n,transaction:i,args:o,modelName:s,globalOmit:a}){if(Kp(t),Hp(t,i))throw t;if(t instanceof se&&Yp(t)){let u=ra(t.meta);Mr({args:o,errors:[u],callsite:n,errorFormat:this.client._errorFormat,originalMethod:r,clientVersion:this.client._clientVersion,globalOmit:a})}let l=t.message;if(n&&(l=vr({callsite:n,originalMethod:r,isPanic:t.isPanic,showColors:this.client._errorFormat==="pretty",message:l})),l=this.sanitizeMessage(l),t.code){let u=s?{modelName:s,...t.meta}:t.meta;throw new se(l,{code:t.code,clientVersion:this.client._clientVersion,meta:u,batchRequestIdx:t.batchRequestIdx})}else{if(t.isPanic)throw new ce(l,this.client._clientVersion);if(t instanceof G)throw new G(l,{clientVersion:this.client._clientVersion,batchRequestIdx:t.batchRequestIdx});if(t instanceof Q)throw new Q(l,this.client._clientVersion);if(t instanceof ce)throw new ce(l,this.client._clientVersion)}throw t.clientVersion=this.client._clientVersion,t}sanitizeMessage(t){return this.client._errorFormat&&this.client._errorFormat!=="pretty"?ot(t):t}unpack(t,r,n){if(!t||(t.data&&(t=t.data),!t))return t;let i=Object.keys(t)[0],o=Object.values(t)[0],s=r.filter(u=>u!=="select"&&u!=="include"),a=Qn(o,s),l=i==="queryRaw"?Hr(a):Pt(a);return n?n(l):l}get[Symbol.toStringTag](){return"RequestHandler"}};function zp(e){if(e){if(e.kind==="batch")return{kind:"batch",options:{isolationLevel:e.isolationLevel}};if(e.kind==="itx")return{kind:"itx",options:ta(e)};ze(e,"Unknown transaction kind")}}function ta(e){return{id:e.id,payload:e.payload}}function Hp(e,t){return Kr(e)&&t?.kind==="batch"&&e.batchRequestIdx!==t.index}function Yp(e){return e.code==="P2009"||e.code==="P2012"}function ra(e){if(e.kind==="Union")return{kind:"Union",errors:e.errors.map(ra)};if(Array.isArray(e.selectionPath)){let[,...t]=e.selectionPath;return{...e,selectionPath:t}}return e}m();c();p();d();f();var na=_s;m();c();p();d();f();var la=Qe(In());m();c();p();d();f();var j=class extends Error{constructor(t){super(t+` -Read more at https://pris.ly/d/client-constructor`),this.name="PrismaClientConstructorValidationError"}get[Symbol.toStringTag](){return"PrismaClientConstructorValidationError"}};ue(j,"PrismaClientConstructorValidationError");var ia=["datasources","datasourceUrl","errorFormat","adapter","log","transactionOptions","omit","__internal"],oa=["pretty","colorless","minimal"],sa=["info","query","warn","error"],Zp={datasources:(e,{datasourceNames:t})=>{if(e){if(typeof e!="object"||Array.isArray(e))throw new j(`Invalid value ${JSON.stringify(e)} for "datasources" provided to PrismaClient constructor`);for(let[r,n]of Object.entries(e)){if(!t.includes(r)){let i=Tt(r,t)||` Available datasources: ${t.join(", ")}`;throw new j(`Unknown datasource ${r} provided to PrismaClient constructor.${i}`)}if(typeof n!="object"||Array.isArray(n))throw new j(`Invalid value ${JSON.stringify(e)} for datasource "${r}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`);if(n&&typeof n=="object")for(let[i,o]of Object.entries(n)){if(i!=="url")throw new j(`Invalid value ${JSON.stringify(e)} for datasource "${r}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`);if(typeof o!="string")throw new j(`Invalid value ${JSON.stringify(o)} for datasource "${r}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`)}}}},adapter:(e,t)=>{if(!e&&it(t.generator)==="client")throw new j('Using engine type "client" requires a driver adapter to be provided to PrismaClient constructor.');if(e!==null){if(e===void 0)throw new j('"adapter" property must not be undefined, use null to conditionally disable driver adapters.');if(it(t.generator)==="binary")throw new j('Cannot use a driver adapter with the "binary" Query Engine. Please use the "library" Query Engine.')}},datasourceUrl:e=>{if(typeof e<"u"&&typeof e!="string")throw new j(`Invalid value ${JSON.stringify(e)} for "datasourceUrl" provided to PrismaClient constructor. -Expected string or undefined.`)},errorFormat:e=>{if(e){if(typeof e!="string")throw new j(`Invalid value ${JSON.stringify(e)} for "errorFormat" provided to PrismaClient constructor.`);if(!oa.includes(e)){let t=Tt(e,oa);throw new j(`Invalid errorFormat ${e} provided to PrismaClient constructor.${t}`)}}},log:e=>{if(!e)return;if(!Array.isArray(e))throw new j(`Invalid value ${JSON.stringify(e)} for "log" provided to PrismaClient constructor.`);function t(r){if(typeof r=="string"&&!sa.includes(r)){let n=Tt(r,sa);throw new j(`Invalid log level "${r}" provided to PrismaClient constructor.${n}`)}}for(let r of e){t(r);let n={level:t,emit:i=>{let o=["stdout","event"];if(!o.includes(i)){let s=Tt(i,o);throw new j(`Invalid value ${JSON.stringify(i)} for "emit" in logLevel provided to PrismaClient constructor.${s}`)}}};if(r&&typeof r=="object")for(let[i,o]of Object.entries(r))if(n[i])n[i](o);else throw new j(`Invalid property ${i} for "log" provided to PrismaClient constructor`)}},transactionOptions:e=>{if(!e)return;let t=e.maxWait;if(t!=null&&t<=0)throw new j(`Invalid value ${t} for maxWait in "transactionOptions" provided to PrismaClient constructor. maxWait needs to be greater than 0`);let r=e.timeout;if(r!=null&&r<=0)throw new j(`Invalid value ${r} for timeout in "transactionOptions" provided to PrismaClient constructor. timeout needs to be greater than 0`)},omit:(e,t)=>{if(typeof e!="object")throw new j('"omit" option is expected to be an object.');if(e===null)throw new j('"omit" option can not be `null`');let r=[];for(let[n,i]of Object.entries(e)){let o=ed(n,t.runtimeDataModel);if(!o){r.push({kind:"UnknownModel",modelKey:n});continue}for(let[s,a]of Object.entries(i)){let l=o.fields.find(u=>u.name===s);if(!l){r.push({kind:"UnknownField",modelKey:n,fieldName:s});continue}if(l.relationName){r.push({kind:"RelationInOmit",modelKey:n,fieldName:s});continue}typeof a!="boolean"&&r.push({kind:"InvalidFieldValue",modelKey:n,fieldName:s})}}if(r.length>0)throw new j(td(e,r))},__internal:e=>{if(!e)return;let t=["debug","engine","configOverride"];if(typeof e!="object")throw new j(`Invalid value ${JSON.stringify(e)} for "__internal" to PrismaClient constructor`);for(let[r]of Object.entries(e))if(!t.includes(r)){let n=Tt(r,t);throw new j(`Invalid property ${JSON.stringify(r)} for "__internal" provided to PrismaClient constructor.${n}`)}}};function ua(e,t){for(let[r,n]of Object.entries(e)){if(!ia.includes(r)){let i=Tt(r,ia);throw new j(`Unknown property ${r} provided to PrismaClient constructor.${i}`)}Zp[r](n,t)}if(e.datasourceUrl&&e.datasources)throw new j('Can not use "datasourceUrl" and "datasources" options at the same time. Pick one of them')}function Tt(e,t){if(t.length===0||typeof e!="string")return"";let r=Xp(e,t);return r?` Did you mean "${r}"?`:""}function Xp(e,t){if(t.length===0)return null;let r=t.map(i=>({value:i,distance:(0,la.default)(e,i)}));r.sort((i,o)=>i.distanceDe(n)===t);if(r)return e[r]}function td(e,t){let r=yt(e);for(let o of t)switch(o.kind){case"UnknownModel":r.arguments.getField(o.modelKey)?.markAsError(),r.addErrorMessage(()=>`Unknown model name: ${o.modelKey}.`);break;case"UnknownField":r.arguments.getDeepField([o.modelKey,o.fieldName])?.markAsError(),r.addErrorMessage(()=>`Model "${o.modelKey}" does not have a field named "${o.fieldName}".`);break;case"RelationInOmit":r.arguments.getDeepField([o.modelKey,o.fieldName])?.markAsError(),r.addErrorMessage(()=>'Relations are already excluded by default and can not be specified in "omit".');break;case"InvalidFieldValue":r.arguments.getDeepFieldValue([o.modelKey,o.fieldName])?.markAsError(),r.addErrorMessage(()=>"Omit field option value must be a boolean.");break}let{message:n,args:i}=Fr(r,"colorless");return`Error validating "omit" option: - -${i} - -${n}`}m();c();p();d();f();function ca(e){return e.length===0?Promise.resolve([]):new Promise((t,r)=>{let n=new Array(e.length),i=null,o=!1,s=0,a=()=>{o||(s++,s===e.length&&(o=!0,i?r(i):t(n)))},l=u=>{o||(o=!0,r(u))};for(let u=0;u{n[u]=g,a()},g=>{if(!Kr(g)){l(g);return}g.batchRequestIdx===u?l(g):(i||(i=g),a())})})}var $e=z("prisma:client");typeof globalThis=="object"&&(globalThis.NODE_CLIENT=!0);var rd={requestArgsToMiddlewareArgs:e=>e,middlewareArgsToRequestArgs:e=>e},nd=Symbol.for("prisma.client.transaction.id"),id={id:0,nextId(){return++this.id}};function fa(e){class t{_originalClient=this;_runtimeDataModel;_requestHandler;_connectionPromise;_disconnectionPromise;_engineConfig;_accelerateEngineConfig;_clientVersion;_errorFormat;_tracingHelper;_previewFeatures;_activeProvider;_globalOmit;_extensions;_engine;_appliedParent;_createPrismaPromise=Xn();constructor(n){e=n?.__internal?.configOverride?.(e)??e,Cs(e),n&&ua(n,e);let i=new jr().on("error",()=>{});this._extensions=wt.empty(),this._previewFeatures=js(e),this._clientVersion=e.clientVersion??na,this._activeProvider=e.activeProvider,this._globalOmit=n?.omit,this._tracingHelper=Ys();let o=e.relativeEnvPaths&&{rootEnvPath:e.relativeEnvPaths.rootEnvPath&&Re.resolve(e.dirname,e.relativeEnvPaths.rootEnvPath),schemaEnvPath:e.relativeEnvPaths.schemaEnvPath&&Re.resolve(e.dirname,e.relativeEnvPaths.schemaEnvPath)},s;if(n?.adapter){s=n.adapter;let l=e.activeProvider==="postgresql"||e.activeProvider==="cockroachdb"?"postgres":e.activeProvider;if(s.provider!==l)throw new Q(`The Driver Adapter \`${s.adapterName}\`, based on \`${s.provider}\`, is not compatible with the provider \`${l}\` specified in the Prisma schema.`,this._clientVersion);if(n.datasources||n.datasourceUrl!==void 0)throw new Q("Custom datasource configuration is not compatible with Prisma Driver Adapters. Please define the database connection string directly in the Driver Adapter configuration.",this._clientVersion)}let a=e.injectableEdgeEnv?.();try{let l=n??{},u=l.__internal??{},g=u.debug===!0;g&&z.enable("prisma:client");let h=Re.resolve(e.dirname,e.relativePath);sr.existsSync(h)||(h=e.dirname),$e("dirname",e.dirname),$e("relativePath",e.relativePath),$e("cwd",h);let T=u.engine||{};if(l.errorFormat?this._errorFormat=l.errorFormat:y.env.NODE_ENV==="production"?this._errorFormat="minimal":y.env.NO_COLOR?this._errorFormat="colorless":this._errorFormat="colorless",this._runtimeDataModel=e.runtimeDataModel,this._engineConfig={cwd:h,dirname:e.dirname,enableDebugLogs:g,allowTriggerPanic:T.allowTriggerPanic,prismaPath:T.binaryPath??void 0,engineEndpoint:T.endpoint,generator:e.generator,showColors:this._errorFormat==="pretty",logLevel:l.log&&Xs(l.log),logQueries:l.log&&!!(typeof l.log=="string"?l.log==="query":l.log.find(O=>typeof O=="string"?O==="query":O.level==="query")),env:a?.parsed??{},flags:[],engineWasm:e.engineWasm,compilerWasm:e.compilerWasm,clientVersion:e.clientVersion,engineVersion:e.engineVersion,previewFeatures:this._previewFeatures,activeProvider:e.activeProvider,inlineSchema:e.inlineSchema,overrideDatasources:Ss(l,e.datasourceNames),inlineDatasources:e.inlineDatasources,inlineSchemaHash:e.inlineSchemaHash,tracingHelper:this._tracingHelper,transactionOptions:{maxWait:l.transactionOptions?.maxWait??2e3,timeout:l.transactionOptions?.timeout??5e3,isolationLevel:l.transactionOptions?.isolationLevel},logEmitter:i,isBundled:e.isBundled,adapter:s},this._accelerateEngineConfig={...this._engineConfig,accelerateUtils:{resolveDatasourceUrl:Wr,getBatchRequestPayload:Vr,prismaGraphQLToJSError:Qr,PrismaClientUnknownRequestError:G,PrismaClientInitializationError:Q,PrismaClientKnownRequestError:se,debug:z("prisma:client:accelerateEngine"),engineVersion:da.version,clientVersion:e.clientVersion}},$e("clientVersion",e.clientVersion),this._engine=Bs(e,this._engineConfig),this._requestHandler=new Yr(this,i),l.log)for(let O of l.log){let C=typeof O=="string"?O:O.emit==="stdout"?O.level:null;C&&this.$on(C,S=>{Dt.log(`${Dt.tags[C]??""}`,S.message||S.query)})}}catch(l){throw l.clientVersion=this._clientVersion,l}return this._appliedParent=Zt(this)}get[Symbol.toStringTag](){return"PrismaClient"}$on(n,i){return n==="beforeExit"?this._engine.onBeforeExit(i):n&&this._engineConfig.logEmitter.on(n,i),this}$connect(){try{return this._engine.start()}catch(n){throw n.clientVersion=this._clientVersion,n}}async $disconnect(){try{await this._engine.stop()}catch(n){throw n.clientVersion=this._clientVersion,n}finally{_i()}}$executeRawInternal(n,i,o,s){let a=this._activeProvider;return this._request({action:"executeRaw",args:o,transaction:n,clientMethod:i,argsMapper:Zn({clientMethod:i,activeProvider:a}),callsite:Ue(this._errorFormat),dataPath:[],middlewareArgsMapper:s})}$executeRaw(n,...i){return this._createPrismaPromise(o=>{if(n.raw!==void 0||n.sql!==void 0){let[s,a]=pa(n,i);return Yn(this._activeProvider,s.text,s.values,Array.isArray(n)?"prisma.$executeRaw``":"prisma.$executeRaw(sql``)"),this.$executeRawInternal(o,"$executeRaw",s,a)}throw new te("`$executeRaw` is a tag function, please use it like the following:\n```\nconst result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`\n```\n\nOr read our docs at https://www.prisma.io/docs/concepts/components/prisma-client/raw-database-access#executeraw\n",{clientVersion:this._clientVersion})})}$executeRawUnsafe(n,...i){return this._createPrismaPromise(o=>(Yn(this._activeProvider,n,i,"prisma.$executeRawUnsafe(, [...values])"),this.$executeRawInternal(o,"$executeRawUnsafe",[n,...i])))}$runCommandRaw(n){if(e.activeProvider!=="mongodb")throw new te(`The ${e.activeProvider} provider does not support $runCommandRaw. Use the mongodb provider.`,{clientVersion:this._clientVersion});return this._createPrismaPromise(i=>this._request({args:n,clientMethod:"$runCommandRaw",dataPath:[],action:"runCommandRaw",argsMapper:Us,callsite:Ue(this._errorFormat),transaction:i}))}async $queryRawInternal(n,i,o,s){let a=this._activeProvider;return this._request({action:"queryRaw",args:o,transaction:n,clientMethod:i,argsMapper:Zn({clientMethod:i,activeProvider:a}),callsite:Ue(this._errorFormat),dataPath:[],middlewareArgsMapper:s})}$queryRaw(n,...i){return this._createPrismaPromise(o=>{if(n.raw!==void 0||n.sql!==void 0)return this.$queryRawInternal(o,"$queryRaw",...pa(n,i));throw new te("`$queryRaw` is a tag function, please use it like the following:\n```\nconst result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`\n```\n\nOr read our docs at https://www.prisma.io/docs/concepts/components/prisma-client/raw-database-access#queryraw\n",{clientVersion:this._clientVersion})})}$queryRawTyped(n){return this._createPrismaPromise(i=>{if(!this._hasPreviewFlag("typedSql"))throw new te("`typedSql` preview feature must be enabled in order to access $queryRawTyped API",{clientVersion:this._clientVersion});return this.$queryRawInternal(i,"$queryRawTyped",n)})}$queryRawUnsafe(n,...i){return this._createPrismaPromise(o=>this.$queryRawInternal(o,"$queryRawUnsafe",[n,...i]))}_transactionWithArray({promises:n,options:i}){let o=id.nextId(),s=Zs(n.length),a=n.map((l,u)=>{if(l?.[Symbol.toStringTag]!=="PrismaPromise")throw new Error("All elements of the array need to be Prisma Client promises. Hint: Please make sure you are not awaiting the Prisma client calls you intended to pass in the $transaction function.");let g=i?.isolationLevel??this._engineConfig.transactionOptions.isolationLevel,h={kind:"batch",id:o,index:u,isolationLevel:g,lock:s};return l.requestTransaction?.(h)??l});return ca(a)}async _transactionWithCallback({callback:n,options:i}){let o={traceparent:this._tracingHelper.getTraceParent()},s={maxWait:i?.maxWait??this._engineConfig.transactionOptions.maxWait,timeout:i?.timeout??this._engineConfig.transactionOptions.timeout,isolationLevel:i?.isolationLevel??this._engineConfig.transactionOptions.isolationLevel},a=await this._engine.transaction("start",o,s),l;try{let u={kind:"itx",...a};l=await n(this._createItxClient(u)),await this._engine.transaction("commit",o,a)}catch(u){throw await this._engine.transaction("rollback",o,a).catch(()=>{}),u}return l}_createItxClient(n){return ge(Zt(ge(ps(this),[ne("_appliedParent",()=>this._appliedParent._createItxClient(n)),ne("_createPrismaPromise",()=>Xn(n)),ne(nd,()=>n.id)])),[Et(hs)])}$transaction(n,i){let o;typeof n=="function"?this._engineConfig.adapter?.adapterName==="@prisma/adapter-d1"?o=()=>{throw new Error("Cloudflare D1 does not support interactive transactions. We recommend you to refactor your queries with that limitation in mind, and use batch transactions with `prisma.$transactions([])` where applicable.")}:o=()=>this._transactionWithCallback({callback:n,options:i}):o=()=>this._transactionWithArray({promises:n,options:i});let s={name:"transaction",attributes:{method:"$transaction"}};return this._tracingHelper.runInChildSpan(s,o)}_request(n){n.otelParentCtx=this._tracingHelper.getActiveContext();let i=n.middlewareArgsMapper??rd,o={args:i.requestArgsToMiddlewareArgs(n.args),dataPath:n.dataPath,runInTransaction:!!n.transaction,action:n.action,model:n.model},s={operation:{name:"operation",attributes:{method:o.action,model:o.model,name:o.model?`${o.model}.${o.action}`:o.action}}},a=async l=>{let{runInTransaction:u,args:g,...h}=l,T={...n,...h};g&&(T.args=i.middlewareArgsToRequestArgs(g)),n.transaction!==void 0&&u===!1&&delete T.transaction;let O=await Es(this,T);return T.model?gs({result:O,modelName:T.model,args:T.args,extensions:this._extensions,runtimeDataModel:this._runtimeDataModel,globalOmit:this._globalOmit}):O};return this._tracingHelper.runInChildSpan(s.operation,()=>a(o))}async _executeRequest({args:n,clientMethod:i,dataPath:o,callsite:s,action:a,model:l,argsMapper:u,transaction:g,unpacker:h,otelParentCtx:T,customDataProxyFetch:O}){try{n=u?u(n):n;let C={name:"serialize"},S=this._tracingHelper.runInChildSpan(C,()=>Nr({modelName:l,runtimeDataModel:this._runtimeDataModel,action:a,args:n,clientMethod:i,callsite:s,extensions:this._extensions,errorFormat:this._errorFormat,clientVersion:this._clientVersion,previewFeatures:this._previewFeatures,globalOmit:this._globalOmit}));return z.enabled("prisma:client")&&($e("Prisma Client call:"),$e(`prisma.${i}(${es(n)})`),$e("Generated request:"),$e(JSON.stringify(S,null,2)+` -`)),g?.kind==="batch"&&await g.lock,this._requestHandler.request({protocolQuery:S,modelName:l,action:a,clientMethod:i,dataPath:o,callsite:s,args:n,extensions:this._extensions,transaction:g,unpacker:h,otelParentCtx:T,otelChildCtx:this._tracingHelper.getActiveContext(),globalOmit:this._globalOmit,customDataProxyFetch:O})}catch(C){throw C.clientVersion=this._clientVersion,C}}$metrics=new bt(this);_hasPreviewFlag(n){return!!this._engineConfig.previewFeatures?.includes(n)}$applyPendingMigrations(){return this._engine.applyPendingMigrations()}$extends=ds}return t}function pa(e,t){return od(e)?[new le(e,t),Ks]:[e,zs]}function od(e){return Array.isArray(e)&&Array.isArray(e.raw)}m();c();p();d();f();var sd=new Set(["toJSON","$$typeof","asymmetricMatch",Symbol.iterator,Symbol.toStringTag,Symbol.isConcatSpreadable,Symbol.toPrimitive]);function ma(e){return new Proxy(e,{get(t,r){if(r in t)return t[r];if(!sd.has(r))throw new TypeError(`Invalid enum value: ${String(r)}`)}})}m();c();p();d();f();0&&(module.exports={DMMF,Debug,Decimal,Extensions,MetricsClient,PrismaClientInitializationError,PrismaClientKnownRequestError,PrismaClientRustPanicError,PrismaClientUnknownRequestError,PrismaClientValidationError,Public,Sql,createParam,defineDmmfProperty,deserializeJsonResponse,deserializeRawResult,dmmfToRuntimeDataModel,empty,getPrismaClient,getRuntime,join,makeStrictEnum,makeTypedQueryFactory,objectEnumValues,raw,serializeJsonQuery,skip,sqltag,warnEnvConflicts,warnOnce}); -//# sourceMappingURL=react-native.js.map diff --git a/frontend/generated/prisma/runtime/wasm-compiler-edge.js b/frontend/generated/prisma/runtime/wasm-compiler-edge.js deleted file mode 100644 index 4f4bbb2..0000000 --- a/frontend/generated/prisma/runtime/wasm-compiler-edge.js +++ /dev/null @@ -1,85 +0,0 @@ - -/* !!! This is code generated by Prisma. Do not edit directly. !!! -/* eslint-disable */ -// biome-ignore-all lint: generated file -"use strict";var ou=Object.create;var Kr=Object.defineProperty;var su=Object.getOwnPropertyDescriptor;var au=Object.getOwnPropertyNames;var lu=Object.getPrototypeOf,cu=Object.prototype.hasOwnProperty;var ye=(e,t)=>()=>(e&&(t=e(e=0)),t);var me=(e,t)=>()=>(t||e((t={exports:{}}).exports,t),t.exports),pt=(e,t)=>{for(var r in t)Kr(e,r,{get:t[r],enumerable:!0})},Vo=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let i of au(t))!cu.call(e,i)&&i!==r&&Kr(e,i,{get:()=>t[i],enumerable:!(n=su(t,i))||n.enumerable});return e};var $e=(e,t,r)=>(r=e!=null?ou(lu(e)):{},Vo(t||!e||!e.__esModule?Kr(r,"default",{value:e,enumerable:!0}):r,e)),qo=e=>Vo(Kr({},"__esModule",{value:!0}),e);function ui(e,t){if(t=t.toLowerCase(),t==="utf8"||t==="utf-8")return new h(du.encode(e));if(t==="base64"||t==="base64url")return e=e.replace(/-/g,"+").replace(/_/g,"/"),e=e.replace(/[^A-Za-z0-9+/]/g,""),new h([...atob(e)].map(r=>r.charCodeAt(0)));if(t==="binary"||t==="ascii"||t==="latin1"||t==="latin-1")return new h([...e].map(r=>r.charCodeAt(0)));if(t==="ucs2"||t==="ucs-2"||t==="utf16le"||t==="utf-16le"){let r=new h(e.length*2),n=new DataView(r.buffer);for(let i=0;ia.startsWith("get")||a.startsWith("set")),n=r.map(a=>a.replace("get","read").replace("set","write")),i=(a,f)=>function(w=0){return Y(w,"offset"),de(w,"offset"),ee(w,"offset",this.length-1),new DataView(this.buffer)[r[a]](w,f)},o=(a,f)=>function(w,A=0){let R=r[a].match(/set(\w+\d+)/)[1].toLowerCase(),S=mu[R];return Y(A,"offset"),de(A,"offset"),ee(A,"offset",this.length-1),pu(w,"value",S[0],S[1]),new DataView(this.buffer)[r[a]](A,w,f),A+parseInt(r[a].match(/\d+/)[0])/8},s=a=>{a.forEach(f=>{f.includes("Uint")&&(e[f.replace("Uint","UInt")]=e[f]),f.includes("Float64")&&(e[f.replace("Float64","Double")]=e[f]),f.includes("Float32")&&(e[f.replace("Float32","Float")]=e[f])})};n.forEach((a,f)=>{a.startsWith("read")&&(e[a]=i(f,!1),e[a+"LE"]=i(f,!0),e[a+"BE"]=i(f,!1)),a.startsWith("write")&&(e[a]=o(f,!1),e[a+"LE"]=o(f,!0),e[a+"BE"]=o(f,!1)),s([a,a+"LE",a+"BE"])})}function jo(e){throw new Error(`Buffer polyfill does not implement "${e}"`)}function zr(e,t){if(!(e instanceof Uint8Array))throw new TypeError(`The "${t}" argument must be an instance of Buffer or Uint8Array`)}function ee(e,t,r=yu+1){if(e<0||e>r){let n=new RangeError(`The value of "${t}" is out of range. It must be >= 0 && <= ${r}. Received ${e}`);throw n.code="ERR_OUT_OF_RANGE",n}}function Y(e,t){if(typeof e!="number"){let r=new TypeError(`The "${t}" argument must be of type number. Received type ${typeof e}.`);throw r.code="ERR_INVALID_ARG_TYPE",r}}function de(e,t){if(!Number.isInteger(e)||Number.isNaN(e)){let r=new RangeError(`The value of "${t}" is out of range. It must be an integer. Received ${e}`);throw r.code="ERR_OUT_OF_RANGE",r}}function pu(e,t,r,n){if(en){let i=new RangeError(`The value of "${t}" is out of range. It must be >= ${r} and <= ${n}. Received ${e}`);throw i.code="ERR_OUT_OF_RANGE",i}}function Bo(e,t){if(typeof e!="string"){let r=new TypeError(`The "${t}" argument must be of type string. Received type ${typeof e}`);throw r.code="ERR_INVALID_ARG_TYPE",r}}function hu(e,t="utf8"){return h.from(e,t)}var h,mu,du,fu,gu,yu,y,pi,c=ye(()=>{"use strict";h=class e extends Uint8Array{_isBuffer=!0;get offset(){return this.byteOffset}static alloc(t,r=0,n="utf8"){return Bo(n,"encoding"),e.allocUnsafe(t).fill(r,n)}static allocUnsafe(t){return e.from(t)}static allocUnsafeSlow(t){return e.from(t)}static isBuffer(t){return t&&!!t._isBuffer}static byteLength(t,r="utf8"){if(typeof t=="string")return ui(t,r).byteLength;if(t&&t.byteLength)return t.byteLength;let n=new TypeError('The "string" argument must be of type string or an instance of Buffer or ArrayBuffer.');throw n.code="ERR_INVALID_ARG_TYPE",n}static isEncoding(t){return gu.includes(t)}static compare(t,r){zr(t,"buff1"),zr(r,"buff2");for(let n=0;nr[n])return 1}return t.length===r.length?0:t.length>r.length?1:-1}static from(t,r="utf8"){if(t&&typeof t=="object"&&t.type==="Buffer")return new e(t.data);if(typeof t=="number")return new e(new Uint8Array(t));if(typeof t=="string")return ui(t,r);if(ArrayBuffer.isView(t)){let{byteOffset:n,byteLength:i,buffer:o}=t;return"map"in t&&typeof t.map=="function"?new e(t.map(s=>s%256),n,i):new e(o,n,i)}if(t&&typeof t=="object"&&("length"in t||"byteLength"in t||"buffer"in t))return new e(t);throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.")}static concat(t,r){if(t.length===0)return e.alloc(0);let n=[].concat(...t.map(o=>[...o])),i=e.alloc(r!==void 0?r:n.length);return i.set(r!==void 0?n.slice(0,r):n),i}slice(t=0,r=this.length){return this.subarray(t,r)}subarray(t=0,r=this.length){return Object.setPrototypeOf(super.subarray(t,r),e.prototype)}reverse(){return super.reverse(),this}readIntBE(t,r){Y(t,"offset"),de(t,"offset"),ee(t,"offset",this.length-1),Y(r,"byteLength"),de(r,"byteLength");let n=new DataView(this.buffer,t,r),i=0;for(let o=0;o=0;o--)i.setUint8(o,t&255),t=t/256;return r+n}writeUintBE(t,r,n){return this.writeUIntBE(t,r,n)}writeUIntLE(t,r,n){Y(r,"offset"),de(r,"offset"),ee(r,"offset",this.length-1),Y(n,"byteLength"),de(n,"byteLength");let i=new DataView(this.buffer,r,n);for(let o=0;or===t[n])}copy(t,r=0,n=0,i=this.length){ee(r,"targetStart"),ee(n,"sourceStart",this.length),ee(i,"sourceEnd"),r>>>=0,n>>>=0,i>>>=0;let o=0;for(;n=this.length?this.length-a:t.length),a);return this}includes(t,r=null,n="utf-8"){return this.indexOf(t,r,n)!==-1}lastIndexOf(t,r=null,n="utf-8"){return this.indexOf(t,r,n,!0)}indexOf(t,r=null,n="utf-8",i=!1){let o=i?this.findLastIndex.bind(this):this.findIndex.bind(this);n=typeof r=="string"?r:n;let s=e.from(typeof t=="number"?[t]:t,n),a=typeof r=="string"?0:r;return a=typeof r=="number"?a:null,a=Number.isNaN(a)?null:a,a??=i?this.length:0,a=a<0?this.length+a:a,s.length===0&&i===!1?a>=this.length?this.length:a:s.length===0&&i===!0?(a>=this.length?this.length:a)||this.length:o((f,w)=>(i?w<=a:w>=a)&&this[w]===s[0]&&s.every((R,S)=>this[w+S]===R))}toString(t="utf8",r=0,n=this.length){if(r=r<0?0:r,t=t.toString().toLowerCase(),n<=0)return"";if(t==="utf8"||t==="utf-8")return fu.decode(this.slice(r,n));if(t==="base64"||t==="base64url"){let i=btoa(this.reduce((o,s)=>o+pi(s),""));return t==="base64url"?i.replace(/\+/g,"-").replace(/\//g,"_").replace(/=+$/,""):i}if(t==="binary"||t==="ascii"||t==="latin1"||t==="latin-1")return this.slice(r,n).reduce((i,o)=>i+pi(o&(t==="ascii"?127:255)),"");if(t==="ucs2"||t==="ucs-2"||t==="utf16le"||t==="utf-16le"){let i=new DataView(this.buffer.slice(r,n));return Array.from({length:i.byteLength/2},(o,s)=>s*2+1i+o.toString(16).padStart(2,"0"),"");jo(`encoding "${t}"`)}toLocaleString(){return this.toString()}inspect(){return``}};mu={int8:[-128,127],int16:[-32768,32767],int32:[-2147483648,2147483647],uint8:[0,255],uint16:[0,65535],uint32:[0,4294967295],float32:[-1/0,1/0],float64:[-1/0,1/0],bigint64:[-0x8000000000000000n,0x7fffffffffffffffn],biguint64:[0n,0xffffffffffffffffn]},du=new TextEncoder,fu=new TextDecoder,gu=["utf8","utf-8","hex","base64","ascii","binary","base64url","ucs2","ucs-2","utf16le","utf-16le","latin1","latin-1"],yu=4294967295;uu(h.prototype);y=new Proxy(hu,{construct(e,[t,r]){return h.from(t,r)},get(e,t){return h[t]}}),pi=String.fromCodePoint});var g,x,u=ye(()=>{"use strict";g={nextTick:(e,...t)=>{setTimeout(()=>{e(...t)},0)},env:{},version:"",cwd:()=>"/",stderr:{},argv:["/bin/node"],pid:1e4},{cwd:x}=g});var b,p=ye(()=>{"use strict";b=globalThis.performance??(()=>{let e=Date.now();return{now:()=>Date.now()-e}})()});var E,m=ye(()=>{"use strict";E=()=>{};E.prototype=E});var d=ye(()=>{"use strict"});function Jo(e,t){var r,n,i,o,s,a,f,w,A=e.constructor,R=A.precision;if(!e.s||!t.s)return t.s||(t=new A(e)),W?q(t,R):t;if(f=e.d,w=t.d,s=e.e,i=t.e,f=f.slice(),o=s-i,o){for(o<0?(n=f,o=-o,a=w.length):(n=w,i=s,a=f.length),s=Math.ceil(R/H),a=s>a?s+1:a+1,o>a&&(o=a,n.length=1),n.reverse();o--;)n.push(0);n.reverse()}for(a=f.length,o=w.length,a-o<0&&(o=a,n=w,w=f,f=n),r=0;o;)r=(f[--o]=f[o]+w[o]+r)/te|0,f[o]%=te;for(r&&(f.unshift(r),++i),a=f.length;f[--a]==0;)f.pop();return t.d=f,t.e=i,W?q(t,R):t}function Re(e,t,r){if(e!==~~e||er)throw Error(Ye+e)}function Ae(e){var t,r,n,i=e.length-1,o="",s=e[0];if(i>0){for(o+=s,t=1;t16)throw Error(di+Z(e));if(!e.s)return new A(he);for(t==null?(W=!1,a=R):a=t,s=new A(.03125);e.abs().gte(.1);)e=e.times(s),w+=5;for(n=Math.log(ze(2,w))/Math.LN10*2+5|0,a+=n,r=i=o=new A(he),A.precision=a;;){if(i=q(i.times(e),a),r=r.times(++f),s=o.plus(_e(i,r,a)),Ae(s.d).slice(0,a)===Ae(o.d).slice(0,a)){for(;w--;)o=q(o.times(o),a);return A.precision=R,t==null?(W=!0,q(o,R)):o}o=s}}function Z(e){for(var t=e.e*H,r=e.d[0];r>=10;r/=10)t++;return t}function mi(e,t,r){if(t>e.LN10.sd())throw W=!0,r&&(e.precision=r),Error(be+"LN10 precision limit exceeded");return q(new e(e.LN10),t)}function Ve(e){for(var t="";e--;)t+="0";return t}function Kt(e,t){var r,n,i,o,s,a,f,w,A,R=1,S=10,C=e,L=C.d,k=C.constructor,M=k.precision;if(C.s<1)throw Error(be+(C.s?"NaN":"-Infinity"));if(C.eq(he))return new k(0);if(t==null?(W=!1,w=M):w=t,C.eq(10))return t==null&&(W=!0),mi(k,w);if(w+=S,k.precision=w,r=Ae(L),n=r.charAt(0),o=Z(C),Math.abs(o)<15e14){for(;n<7&&n!=1||n==1&&r.charAt(1)>3;)C=C.times(e),r=Ae(C.d),n=r.charAt(0),R++;o=Z(C),n>1?(C=new k("0."+r),o++):C=new k(n+"."+r.slice(1))}else return f=mi(k,w+2,M).times(o+""),C=Kt(new k(n+"."+r.slice(1)),w-S).plus(f),k.precision=M,t==null?(W=!0,q(C,M)):C;for(a=s=C=_e(C.minus(he),C.plus(he),w),A=q(C.times(C),w),i=3;;){if(s=q(s.times(A),w),f=a.plus(_e(s,new k(i),w)),Ae(f.d).slice(0,w)===Ae(a.d).slice(0,w))return a=a.times(2),o!==0&&(a=a.plus(mi(k,w+2,M).times(o+""))),a=_e(a,new k(R),w),k.precision=M,t==null?(W=!0,q(a,M)):a;a=f,i+=2}}function Qo(e,t){var r,n,i;for((r=t.indexOf("."))>-1&&(t=t.replace(".","")),(n=t.search(/e/i))>0?(r<0&&(r=n),r+=+t.slice(n+1),t=t.substring(0,n)):r<0&&(r=t.length),n=0;t.charCodeAt(n)===48;)++n;for(i=t.length;t.charCodeAt(i-1)===48;)--i;if(t=t.slice(n,i),t){if(i-=n,r=r-n-1,e.e=dt(r/H),e.d=[],n=(r+1)%H,r<0&&(n+=H),nYr||e.e<-Yr))throw Error(di+r)}else e.s=0,e.e=0,e.d=[0];return e}function q(e,t,r){var n,i,o,s,a,f,w,A,R=e.d;for(s=1,o=R[0];o>=10;o/=10)s++;if(n=t-s,n<0)n+=H,i=t,w=R[A=0];else{if(A=Math.ceil((n+1)/H),o=R.length,A>=o)return e;for(w=o=R[A],s=1;o>=10;o/=10)s++;n%=H,i=n-H+s}if(r!==void 0&&(o=ze(10,s-i-1),a=w/o%10|0,f=t<0||R[A+1]!==void 0||w%o,f=r<4?(a||f)&&(r==0||r==(e.s<0?3:2)):a>5||a==5&&(r==4||f||r==6&&(n>0?i>0?w/ze(10,s-i):0:R[A-1])%10&1||r==(e.s<0?8:7))),t<1||!R[0])return f?(o=Z(e),R.length=1,t=t-o-1,R[0]=ze(10,(H-t%H)%H),e.e=dt(-t/H)||0):(R.length=1,R[0]=e.e=e.s=0),e;if(n==0?(R.length=A,o=1,A--):(R.length=A+1,o=ze(10,H-n),R[A]=i>0?(w/ze(10,s-i)%ze(10,i)|0)*o:0),f)for(;;)if(A==0){(R[0]+=o)==te&&(R[0]=1,++e.e);break}else{if(R[A]+=o,R[A]!=te)break;R[A--]=0,o=1}for(n=R.length;R[--n]===0;)R.pop();if(W&&(e.e>Yr||e.e<-Yr))throw Error(di+Z(e));return e}function Ko(e,t){var r,n,i,o,s,a,f,w,A,R,S=e.constructor,C=S.precision;if(!e.s||!t.s)return t.s?t.s=-t.s:t=new S(e),W?q(t,C):t;if(f=e.d,R=t.d,n=t.e,w=e.e,f=f.slice(),s=w-n,s){for(A=s<0,A?(r=f,s=-s,a=R.length):(r=R,n=w,a=f.length),i=Math.max(Math.ceil(C/H),a)+2,s>i&&(s=i,r.length=1),r.reverse(),i=s;i--;)r.push(0);r.reverse()}else{for(i=f.length,a=R.length,A=i0;--i)f[a++]=0;for(i=R.length;i>s;){if(f[--i]0?o=o.charAt(0)+"."+o.slice(1)+Ve(n):s>1&&(o=o.charAt(0)+"."+o.slice(1)),o=o+(i<0?"e":"e+")+i):i<0?(o="0."+Ve(-i-1)+o,r&&(n=r-s)>0&&(o+=Ve(n))):i>=s?(o+=Ve(i+1-s),r&&(n=r-i-1)>0&&(o=o+"."+Ve(n))):((n=i+1)0&&(i+1===s&&(o+="."),o+=Ve(n))),e.s<0?"-"+o:o}function Ho(e,t){if(e.length>t)return e.length=t,!0}function zo(e){var t,r,n;function i(o){var s=this;if(!(s instanceof i))return new i(o);if(s.constructor=i,o instanceof i){s.s=o.s,s.e=o.e,s.d=(o=o.d)?o.slice():o;return}if(typeof o=="number"){if(o*0!==0)throw Error(Ye+o);if(o>0)s.s=1;else if(o<0)o=-o,s.s=-1;else{s.s=0,s.e=0,s.d=[0];return}if(o===~~o&&o<1e7){s.e=0,s.d=[o];return}return Qo(s,o.toString())}else if(typeof o!="string")throw Error(Ye+o);if(o.charCodeAt(0)===45?(o=o.slice(1),s.s=-1):s.s=1,bu.test(o))Qo(s,o);else throw Error(Ye+o)}if(i.prototype=I,i.ROUND_UP=0,i.ROUND_DOWN=1,i.ROUND_CEIL=2,i.ROUND_FLOOR=3,i.ROUND_HALF_UP=4,i.ROUND_HALF_DOWN=5,i.ROUND_HALF_EVEN=6,i.ROUND_HALF_CEIL=7,i.ROUND_HALF_FLOOR=8,i.clone=zo,i.config=i.set=Eu,e===void 0&&(e={}),e)for(n=["precision","rounding","toExpNeg","toExpPos","LN10"],t=0;t=i[t+1]&&n<=i[t+2])this[r]=n;else throw Error(Ye+r+": "+n);if((n=e[r="LN10"])!==void 0)if(n==Math.LN10)this[r]=new this(n);else throw Error(Ye+r+": "+n);return this}var mt,wu,fi,W,be,Ye,di,dt,ze,bu,he,te,H,Go,Yr,I,_e,fi,Zr,Yo=ye(()=>{"use strict";c();u();p();m();d();l();mt=1e9,wu={precision:20,rounding:4,toExpNeg:-7,toExpPos:21,LN10:"2.302585092994045684017991454684364207601101488628772976033327900967572609677352480235997205089598298341967784042286"},W=!0,be="[DecimalError] ",Ye=be+"Invalid argument: ",di=be+"Exponent out of range: ",dt=Math.floor,ze=Math.pow,bu=/^(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i,te=1e7,H=7,Go=9007199254740991,Yr=dt(Go/H),I={};I.absoluteValue=I.abs=function(){var e=new this.constructor(this);return e.s&&(e.s=1),e};I.comparedTo=I.cmp=function(e){var t,r,n,i,o=this;if(e=new o.constructor(e),o.s!==e.s)return o.s||-e.s;if(o.e!==e.e)return o.e>e.e^o.s<0?1:-1;for(n=o.d.length,i=e.d.length,t=0,r=ne.d[t]^o.s<0?1:-1;return n===i?0:n>i^o.s<0?1:-1};I.decimalPlaces=I.dp=function(){var e=this,t=e.d.length-1,r=(t-e.e)*H;if(t=e.d[t],t)for(;t%10==0;t/=10)r--;return r<0?0:r};I.dividedBy=I.div=function(e){return _e(this,new this.constructor(e))};I.dividedToIntegerBy=I.idiv=function(e){var t=this,r=t.constructor;return q(_e(t,new r(e),0,1),r.precision)};I.equals=I.eq=function(e){return!this.cmp(e)};I.exponent=function(){return Z(this)};I.greaterThan=I.gt=function(e){return this.cmp(e)>0};I.greaterThanOrEqualTo=I.gte=function(e){return this.cmp(e)>=0};I.isInteger=I.isint=function(){return this.e>this.d.length-2};I.isNegative=I.isneg=function(){return this.s<0};I.isPositive=I.ispos=function(){return this.s>0};I.isZero=function(){return this.s===0};I.lessThan=I.lt=function(e){return this.cmp(e)<0};I.lessThanOrEqualTo=I.lte=function(e){return this.cmp(e)<1};I.logarithm=I.log=function(e){var t,r=this,n=r.constructor,i=n.precision,o=i+5;if(e===void 0)e=new n(10);else if(e=new n(e),e.s<1||e.eq(he))throw Error(be+"NaN");if(r.s<1)throw Error(be+(r.s?"NaN":"-Infinity"));return r.eq(he)?new n(0):(W=!1,t=_e(Kt(r,o),Kt(e,o),o),W=!0,q(t,i))};I.minus=I.sub=function(e){var t=this;return e=new t.constructor(e),t.s==e.s?Ko(t,e):Jo(t,(e.s=-e.s,e))};I.modulo=I.mod=function(e){var t,r=this,n=r.constructor,i=n.precision;if(e=new n(e),!e.s)throw Error(be+"NaN");return r.s?(W=!1,t=_e(r,e,0,1).times(e),W=!0,r.minus(t)):q(new n(r),i)};I.naturalExponential=I.exp=function(){return Wo(this)};I.naturalLogarithm=I.ln=function(){return Kt(this)};I.negated=I.neg=function(){var e=new this.constructor(this);return e.s=-e.s||0,e};I.plus=I.add=function(e){var t=this;return e=new t.constructor(e),t.s==e.s?Jo(t,e):Ko(t,(e.s=-e.s,e))};I.precision=I.sd=function(e){var t,r,n,i=this;if(e!==void 0&&e!==!!e&&e!==1&&e!==0)throw Error(Ye+e);if(t=Z(i)+1,n=i.d.length-1,r=n*H+1,n=i.d[n],n){for(;n%10==0;n/=10)r--;for(n=i.d[0];n>=10;n/=10)r++}return e&&t>r?t:r};I.squareRoot=I.sqrt=function(){var e,t,r,n,i,o,s,a=this,f=a.constructor;if(a.s<1){if(!a.s)return new f(0);throw Error(be+"NaN")}for(e=Z(a),W=!1,i=Math.sqrt(+a),i==0||i==1/0?(t=Ae(a.d),(t.length+e)%2==0&&(t+="0"),i=Math.sqrt(t),e=dt((e+1)/2)-(e<0||e%2),i==1/0?t="5e"+e:(t=i.toExponential(),t=t.slice(0,t.indexOf("e")+1)+e),n=new f(t)):n=new f(i.toString()),r=f.precision,i=s=r+3;;)if(o=n,n=o.plus(_e(a,o,s+2)).times(.5),Ae(o.d).slice(0,s)===(t=Ae(n.d)).slice(0,s)){if(t=t.slice(s-3,s+1),i==s&&t=="4999"){if(q(o,r+1,0),o.times(o).eq(a)){n=o;break}}else if(t!="9999")break;s+=4}return W=!0,q(n,r)};I.times=I.mul=function(e){var t,r,n,i,o,s,a,f,w,A=this,R=A.constructor,S=A.d,C=(e=new R(e)).d;if(!A.s||!e.s)return new R(0);for(e.s*=A.s,r=A.e+e.e,f=S.length,w=C.length,f=0;){for(t=0,i=f+n;i>n;)a=o[i]+C[n]*S[i-n-1]+t,o[i--]=a%te|0,t=a/te|0;o[i]=(o[i]+t)%te|0}for(;!o[--s];)o.pop();return t?++r:o.shift(),e.d=o,e.e=r,W?q(e,R.precision):e};I.toDecimalPlaces=I.todp=function(e,t){var r=this,n=r.constructor;return r=new n(r),e===void 0?r:(Re(e,0,mt),t===void 0?t=n.rounding:Re(t,0,8),q(r,e+Z(r)+1,t))};I.toExponential=function(e,t){var r,n=this,i=n.constructor;return e===void 0?r=Ze(n,!0):(Re(e,0,mt),t===void 0?t=i.rounding:Re(t,0,8),n=q(new i(n),e+1,t),r=Ze(n,!0,e+1)),r};I.toFixed=function(e,t){var r,n,i=this,o=i.constructor;return e===void 0?Ze(i):(Re(e,0,mt),t===void 0?t=o.rounding:Re(t,0,8),n=q(new o(i),e+Z(i)+1,t),r=Ze(n.abs(),!1,e+Z(n)+1),i.isneg()&&!i.isZero()?"-"+r:r)};I.toInteger=I.toint=function(){var e=this,t=e.constructor;return q(new t(e),Z(e)+1,t.rounding)};I.toNumber=function(){return+this};I.toPower=I.pow=function(e){var t,r,n,i,o,s,a=this,f=a.constructor,w=12,A=+(e=new f(e));if(!e.s)return new f(he);if(a=new f(a),!a.s){if(e.s<1)throw Error(be+"Infinity");return a}if(a.eq(he))return a;if(n=f.precision,e.eq(he))return q(a,n);if(t=e.e,r=e.d.length-1,s=t>=r,o=a.s,s){if((r=A<0?-A:A)<=Go){for(i=new f(he),t=Math.ceil(n/H+4),W=!1;r%2&&(i=i.times(a),Ho(i.d,t)),r=dt(r/2),r!==0;)a=a.times(a),Ho(a.d,t);return W=!0,e.s<0?new f(he).div(i):q(i,n)}}else if(o<0)throw Error(be+"NaN");return o=o<0&&e.d[Math.max(t,r)]&1?-1:1,a.s=1,W=!1,i=e.times(Kt(a,n+w)),W=!0,i=Wo(i),i.s=o,i};I.toPrecision=function(e,t){var r,n,i=this,o=i.constructor;return e===void 0?(r=Z(i),n=Ze(i,r<=o.toExpNeg||r>=o.toExpPos)):(Re(e,1,mt),t===void 0?t=o.rounding:Re(t,0,8),i=q(new o(i),e,t),r=Z(i),n=Ze(i,e<=r||r<=o.toExpNeg,e)),n};I.toSignificantDigits=I.tosd=function(e,t){var r=this,n=r.constructor;return e===void 0?(e=n.precision,t=n.rounding):(Re(e,1,mt),t===void 0?t=n.rounding:Re(t,0,8)),q(new n(r),e,t)};I.toString=I.valueOf=I.val=I.toJSON=I[Symbol.for("nodejs.util.inspect.custom")]=function(){var e=this,t=Z(e),r=e.constructor;return Ze(e,t<=r.toExpNeg||t>=r.toExpPos)};_e=function(){function e(n,i){var o,s=0,a=n.length;for(n=n.slice();a--;)o=n[a]*i+s,n[a]=o%te|0,s=o/te|0;return s&&n.unshift(s),n}function t(n,i,o,s){var a,f;if(o!=s)f=o>s?1:-1;else for(a=f=0;ai[a]?1:-1;break}return f}function r(n,i,o){for(var s=0;o--;)n[o]-=s,s=n[o]1;)n.shift()}return function(n,i,o,s){var a,f,w,A,R,S,C,L,k,M,De,ue,B,pe,Ke,ci,xe,Jr,Wr=n.constructor,iu=n.s==i.s?1:-1,ve=n.d,z=i.d;if(!n.s)return new Wr(n);if(!i.s)throw Error(be+"Division by zero");for(f=n.e-i.e,xe=z.length,Ke=ve.length,C=new Wr(iu),L=C.d=[],w=0;z[w]==(ve[w]||0);)++w;if(z[w]>(ve[w]||0)&&--f,o==null?ue=o=Wr.precision:s?ue=o+(Z(n)-Z(i))+1:ue=o,ue<0)return new Wr(0);if(ue=ue/H+2|0,w=0,xe==1)for(A=0,z=z[0],ue++;(w1&&(z=e(z,A),ve=e(ve,A),xe=z.length,Ke=ve.length),pe=xe,k=ve.slice(0,xe),M=k.length;M=te/2&&++ci;do A=0,a=t(z,k,xe,M),a<0?(De=k[0],xe!=M&&(De=De*te+(k[1]||0)),A=De/ci|0,A>1?(A>=te&&(A=te-1),R=e(z,A),S=R.length,M=k.length,a=t(R,k,S,M),a==1&&(A--,r(R,xe{"use strict";Yo();v=class extends Zr{static isDecimal(t){return t instanceof Zr}static random(t=20){{let n=globalThis.crypto.getRandomValues(new Uint8Array(t)).reduce((i,o)=>i+o,"");return new Zr(`0.${n.slice(0,t)}`)}}},se=v});function Ru(){return!1}function bi(){return{dev:0,ino:0,mode:0,nlink:0,uid:0,gid:0,rdev:0,size:0,blksize:0,blocks:0,atimeMs:0,mtimeMs:0,ctimeMs:0,birthtimeMs:0,atime:new Date,mtime:new Date,ctime:new Date,birthtime:new Date}}function Cu(){return bi()}function Su(){return[]}function Iu(e){e(null,[])}function ku(){return""}function Ou(){return""}function Du(){}function _u(){}function Mu(){}function Nu(){}function Lu(){}function Uu(){}function Fu(){}function $u(){}function Vu(){return{close:()=>{},on:()=>{},removeAllListeners:()=>{}}}function qu(e,t){t(null,bi())}var Bu,ju,fs,gs=ye(()=>{"use strict";c();u();p();m();d();l();Bu={},ju={existsSync:Ru,lstatSync:bi,stat:qu,statSync:Cu,readdirSync:Su,readdir:Iu,readlinkSync:ku,realpathSync:Ou,chmodSync:Du,renameSync:_u,mkdirSync:Mu,rmdirSync:Nu,rmSync:Lu,unlinkSync:Uu,watchFile:Fu,unwatchFile:$u,watch:Vu,promises:Bu},fs=ju});var ys=me(()=>{"use strict";c();u();p();m();d();l()});var hs=me((Vy,Qu)=>{Qu.exports={name:"@prisma/internals",version:"6.19.1",description:"This package is intended for Prisma's internal use",main:"dist/index.js",types:"dist/index.d.ts",repository:{type:"git",url:"https://github.com/prisma/prisma.git",directory:"packages/internals"},homepage:"https://www.prisma.io",author:"Tim Suchanek ",bugs:"https://github.com/prisma/prisma/issues",license:"Apache-2.0",scripts:{dev:"DEV=true tsx helpers/build.ts",build:"tsx helpers/build.ts",test:"dotenv -e ../../.db.env -- jest --silent",prepublishOnly:"pnpm run build"},files:["README.md","dist","!**/libquery_engine*","!dist/get-generators/engines/*","scripts"],devDependencies:{"@babel/helper-validator-identifier":"7.25.9","@opentelemetry/api":"1.9.0","@swc/core":"1.11.5","@swc/jest":"0.2.37","@types/babel__helper-validator-identifier":"7.15.2","@types/jest":"29.5.14","@types/node":"18.19.76","@types/resolve":"1.20.6",archiver:"6.0.2","checkpoint-client":"1.1.33","cli-truncate":"4.0.0",dotenv:"16.5.0",empathic:"2.0.0","escape-string-regexp":"5.0.0",execa:"8.0.1","fast-glob":"3.3.3","find-up":"7.0.0","fp-ts":"2.16.9","fs-extra":"11.3.0","global-directory":"4.0.0",globby:"11.1.0","identifier-regex":"1.0.0","indent-string":"4.0.0","is-windows":"1.0.2","is-wsl":"3.1.0",jest:"29.7.0","jest-junit":"16.0.0",kleur:"4.1.5","mock-stdin":"1.0.0","new-github-issue-url":"0.2.1","node-fetch":"3.3.2","npm-packlist":"5.1.3",open:"7.4.2","p-map":"4.0.0",resolve:"1.22.10","string-width":"7.2.0","strip-indent":"4.0.0","temp-dir":"2.0.0",tempy:"1.0.1","terminal-link":"4.0.0",tmp:"0.2.3","ts-pattern":"5.6.2","ts-toolbelt":"9.6.0",typescript:"5.4.5",yarn:"1.22.22"},dependencies:{"@prisma/config":"workspace:*","@prisma/debug":"workspace:*","@prisma/dmmf":"workspace:*","@prisma/driver-adapter-utils":"workspace:*","@prisma/engines":"workspace:*","@prisma/fetch-engine":"workspace:*","@prisma/generator":"workspace:*","@prisma/generator-helper":"workspace:*","@prisma/get-platform":"workspace:*","@prisma/prisma-schema-wasm":"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7","@prisma/schema-engine-wasm":"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7","@prisma/schema-files-loader":"workspace:*",arg:"5.0.2",prompts:"2.4.2"},peerDependencies:{typescript:">=5.1.0"},peerDependenciesMeta:{typescript:{optional:!0}},sideEffects:!1}});function Gu(...e){return e.join("/")}function Ju(...e){return e.join("/")}function Wu(e){let t=ws(e),r=bs(e),[n,i]=t.split(".");return{root:"/",dir:r,base:t,ext:i,name:n}}function ws(e){let t=e.split("/");return t[t.length-1]}function bs(e){return e.split("/").slice(0,-1).join("/")}function zu(e){let t=e.split("/").filter(i=>i!==""&&i!=="."),r=[];for(let i of t)i===".."?r.pop():r.push(i);let n=r.join("/");return e.startsWith("/")?"/"+n:n}var Es,Ku,Yu,Zu,rn,xs=ye(()=>{"use strict";c();u();p();m();d();l();Es="/",Ku=":";Yu={sep:Es},Zu={basename:ws,delimiter:Ku,dirname:bs,join:Ju,normalize:zu,parse:Wu,posix:Yu,resolve:Gu,sep:Es},rn=Zu});var xi={};pt(xi,{Hash:()=>Zt,createHash:()=>Ps,default:()=>yt,randomFillSync:()=>sn,randomUUID:()=>on,webcrypto:()=>Xt});function on(){return globalThis.crypto.randomUUID()}function sn(e,t,r){return t!==void 0&&(r!==void 0?e=e.subarray(t,t+r):e=e.subarray(t)),globalThis.crypto.getRandomValues(e)}function Ps(e){return new Zt(e)}var Xt,Zt,yt,Xe=ye(()=>{"use strict";c();u();p();m();d();l();Xt=globalThis.crypto;Zt=class{#t=[];#e;constructor(t){this.#e=t}update(t){this.#t.push(t)}async digest(){let t=new Uint8Array(this.#t.reduce((i,o)=>i+o.length,0)),r=0;for(let i of this.#t)t.set(i,r),r+=i.length;let n=await globalThis.crypto.subtle.digest(this.#e,t);return new Uint8Array(n)}},yt={webcrypto:Xt,randomUUID:on,randomFillSync:sn,createHash:Ps,Hash:Zt}});var Pi=me(($h,tp)=>{tp.exports={name:"@prisma/engines-version",version:"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7",main:"index.js",types:"index.d.ts",license:"Apache-2.0",author:"Tim Suchanek ",prisma:{enginesVersion:"c2990dca591cba766e3b7ef5d9e8a84796e47ab7"},repository:{type:"git",url:"https://github.com/prisma/engines-wrapper.git",directory:"packages/engines-version"},devDependencies:{"@types/node":"18.19.76",typescript:"4.9.5"},files:["index.js","index.d.ts"],scripts:{build:"tsc -d"}}});var Ts=me(an=>{"use strict";c();u();p();m();d();l();Object.defineProperty(an,"__esModule",{value:!0});an.enginesVersion=void 0;an.enginesVersion=Pi().prisma.enginesVersion});var Rs=me((ew,As)=>{"use strict";c();u();p();m();d();l();As.exports=(e,t=1,r)=>{if(r={indent:" ",includeEmptyLines:!1,...r},typeof e!="string")throw new TypeError(`Expected \`input\` to be a \`string\`, got \`${typeof e}\``);if(typeof t!="number")throw new TypeError(`Expected \`count\` to be a \`number\`, got \`${typeof t}\``);if(typeof r.indent!="string")throw new TypeError(`Expected \`options.indent\` to be a \`string\`, got \`${typeof r.indent}\``);if(t===0)return e;let n=r.includeEmptyLines?/^/gm:/^(?!\s*$)/gm;return e.replace(n,r.indent.repeat(t))}});var Ss=me((Lw,un)=>{"use strict";c();u();p();m();d();l();un.exports=(e={})=>{let t;if(e.repoUrl)t=e.repoUrl;else if(e.user&&e.repo)t=`https://github.com/${e.user}/${e.repo}`;else throw new Error("You need to specify either the `repoUrl` option or both the `user` and `repo` options");let r=new URL(`${t}/issues/new`),n=["body","title","labels","template","milestone","assignee","projects"];for(let i of n){let o=e[i];if(o!==void 0){if(i==="labels"||i==="projects"){if(!Array.isArray(o))throw new TypeError(`The \`${i}\` option should be an array`);o=o.join(",")}r.searchParams.set(i,o)}}return r.toString()};un.exports.default=un.exports});var Ii=me((SP,_s)=>{"use strict";c();u();p();m();d();l();_s.exports=function(){function e(t,r,n,i,o){return tn?n+1:t+1:i===o?r:r+1}return function(t,r){if(t===r)return 0;if(t.length>r.length){var n=t;t=r,r=n}for(var i=t.length,o=r.length;i>0&&t.charCodeAt(i-1)===r.charCodeAt(o-1);)i--,o--;for(var s=0;s{"use strict";c();u();p();m();d();l()});var $s=ye(()=>{"use strict";c();u();p();m();d();l()});var kn,ca=ye(()=>{"use strict";c();u();p();m();d();l();kn=class{events={};on(t,r){return this.events[t]||(this.events[t]=[]),this.events[t].push(r),this}emit(t,...r){return this.events[t]?(this.events[t].forEach(n=>{n(...r)}),!0):!1}}});var Xi=me(rt=>{"use strict";c();u();p();m();d();l();Object.defineProperty(rt,"__esModule",{value:!0});rt.anumber=Zi;rt.abytes=ol;rt.ahash=Nm;rt.aexists=Lm;rt.aoutput=Um;function Zi(e){if(!Number.isSafeInteger(e)||e<0)throw new Error("positive integer expected, got "+e)}function Mm(e){return e instanceof Uint8Array||ArrayBuffer.isView(e)&&e.constructor.name==="Uint8Array"}function ol(e,...t){if(!Mm(e))throw new Error("Uint8Array expected");if(t.length>0&&!t.includes(e.length))throw new Error("Uint8Array expected of length "+t+", got length="+e.length)}function Nm(e){if(typeof e!="function"||typeof e.create!="function")throw new Error("Hash should be wrapped by utils.wrapConstructor");Zi(e.outputLen),Zi(e.blockLen)}function Lm(e,t=!0){if(e.destroyed)throw new Error("Hash instance has been destroyed");if(t&&e.finished)throw new Error("Hash#digest() has already been called")}function Um(e,t){ol(e);let r=t.outputLen;if(e.length{"use strict";c();u();p();m();d();l();Object.defineProperty(_,"__esModule",{value:!0});_.add5L=_.add5H=_.add4H=_.add4L=_.add3H=_.add3L=_.rotlBL=_.rotlBH=_.rotlSL=_.rotlSH=_.rotr32L=_.rotr32H=_.rotrBL=_.rotrBH=_.rotrSL=_.rotrSH=_.shrSL=_.shrSH=_.toBig=void 0;_.fromBig=to;_.split=sl;_.add=El;var Fn=BigInt(2**32-1),eo=BigInt(32);function to(e,t=!1){return t?{h:Number(e&Fn),l:Number(e>>eo&Fn)}:{h:Number(e>>eo&Fn)|0,l:Number(e&Fn)|0}}function sl(e,t=!1){let r=new Uint32Array(e.length),n=new Uint32Array(e.length);for(let i=0;iBigInt(e>>>0)<>>0);_.toBig=al;var ll=(e,t,r)=>e>>>r;_.shrSH=ll;var cl=(e,t,r)=>e<<32-r|t>>>r;_.shrSL=cl;var ul=(e,t,r)=>e>>>r|t<<32-r;_.rotrSH=ul;var pl=(e,t,r)=>e<<32-r|t>>>r;_.rotrSL=pl;var ml=(e,t,r)=>e<<64-r|t>>>r-32;_.rotrBH=ml;var dl=(e,t,r)=>e>>>r-32|t<<64-r;_.rotrBL=dl;var fl=(e,t)=>t;_.rotr32H=fl;var gl=(e,t)=>e;_.rotr32L=gl;var yl=(e,t,r)=>e<>>32-r;_.rotlSH=yl;var hl=(e,t,r)=>t<>>32-r;_.rotlSL=hl;var wl=(e,t,r)=>t<>>64-r;_.rotlBH=wl;var bl=(e,t,r)=>e<>>64-r;_.rotlBL=bl;function El(e,t,r,n){let i=(t>>>0)+(n>>>0);return{h:e+r+(i/2**32|0)|0,l:i|0}}var xl=(e,t,r)=>(e>>>0)+(t>>>0)+(r>>>0);_.add3L=xl;var Pl=(e,t,r,n)=>t+r+n+(e/2**32|0)|0;_.add3H=Pl;var Tl=(e,t,r,n)=>(e>>>0)+(t>>>0)+(r>>>0)+(n>>>0);_.add4L=Tl;var vl=(e,t,r,n,i)=>t+r+n+i+(e/2**32|0)|0;_.add4H=vl;var Al=(e,t,r,n,i)=>(e>>>0)+(t>>>0)+(r>>>0)+(n>>>0)+(i>>>0);_.add5L=Al;var Rl=(e,t,r,n,i,o)=>t+r+n+i+o+(e/2**32|0)|0;_.add5H=Rl;var Fm={fromBig:to,split:sl,toBig:al,shrSH:ll,shrSL:cl,rotrSH:ul,rotrSL:pl,rotrBH:ml,rotrBL:dl,rotr32H:fl,rotr32L:gl,rotlSH:yl,rotlSL:hl,rotlBH:wl,rotlBL:bl,add:El,add3L:xl,add3H:Pl,add4L:Tl,add4H:vl,add5H:Rl,add5L:Al};_.default=Fm});var Sl=me($n=>{"use strict";c();u();p();m();d();l();Object.defineProperty($n,"__esModule",{value:!0});$n.crypto=void 0;var He=(Xe(),qo(xi));$n.crypto=He&&typeof He=="object"&&"webcrypto"in He?He.webcrypto:He&&typeof He=="object"&&"randomBytes"in He?He:void 0});var Ol=me(U=>{"use strict";c();u();p();m();d();l();Object.defineProperty(U,"__esModule",{value:!0});U.Hash=U.nextTick=U.byteSwapIfBE=U.isLE=void 0;U.isBytes=$m;U.u8=Vm;U.u32=qm;U.createView=Bm;U.rotr=jm;U.rotl=Qm;U.byteSwap=io;U.byteSwap32=Hm;U.bytesToHex=Jm;U.hexToBytes=Wm;U.asyncLoop=zm;U.utf8ToBytes=kl;U.toBytes=Vn;U.concatBytes=Ym;U.checkOpts=Zm;U.wrapConstructor=Xm;U.wrapConstructorWithOpts=ed;U.wrapXOFConstructorWithOpts=td;U.randomBytes=rd;var Mt=Sl(),no=Xi();function $m(e){return e instanceof Uint8Array||ArrayBuffer.isView(e)&&e.constructor.name==="Uint8Array"}function Vm(e){return new Uint8Array(e.buffer,e.byteOffset,e.byteLength)}function qm(e){return new Uint32Array(e.buffer,e.byteOffset,Math.floor(e.byteLength/4))}function Bm(e){return new DataView(e.buffer,e.byteOffset,e.byteLength)}function jm(e,t){return e<<32-t|e>>>t}function Qm(e,t){return e<>>32-t>>>0}U.isLE=new Uint8Array(new Uint32Array([287454020]).buffer)[0]===68;function io(e){return e<<24&4278190080|e<<8&16711680|e>>>8&65280|e>>>24&255}U.byteSwapIfBE=U.isLE?e=>e:e=>io(e);function Hm(e){for(let t=0;tt.toString(16).padStart(2,"0"));function Jm(e){(0,no.abytes)(e);let t="";for(let r=0;r=Le._0&&e<=Le._9)return e-Le._0;if(e>=Le.A&&e<=Le.F)return e-(Le.A-10);if(e>=Le.a&&e<=Le.f)return e-(Le.a-10)}function Wm(e){if(typeof e!="string")throw new Error("hex string expected, got "+typeof e);let t=e.length,r=t/2;if(t%2)throw new Error("hex string expected, got unpadded hex of length "+t);let n=new Uint8Array(r);for(let i=0,o=0;i{};U.nextTick=Km;async function zm(e,t,r){let n=Date.now();for(let i=0;i=0&&oe().update(Vn(n)).digest(),r=e();return t.outputLen=r.outputLen,t.blockLen=r.blockLen,t.create=()=>e(),t}function ed(e){let t=(n,i)=>e(i).update(Vn(n)).digest(),r=e({});return t.outputLen=r.outputLen,t.blockLen=r.blockLen,t.create=n=>e(n),t}function td(e){let t=(n,i)=>e(i).update(Vn(n)).digest(),r=e({});return t.outputLen=r.outputLen,t.blockLen=r.blockLen,t.create=n=>e(n),t}function rd(e=32){if(Mt.crypto&&typeof Mt.crypto.getRandomValues=="function")return Mt.crypto.getRandomValues(new Uint8Array(e));if(Mt.crypto&&typeof Mt.crypto.randomBytes=="function")return Mt.crypto.randomBytes(e);throw new Error("crypto.getRandomValues must be defined")}});var $l=me(J=>{"use strict";c();u();p();m();d();l();Object.defineProperty(J,"__esModule",{value:!0});J.shake256=J.shake128=J.keccak_512=J.keccak_384=J.keccak_256=J.keccak_224=J.sha3_512=J.sha3_384=J.sha3_256=J.sha3_224=J.Keccak=void 0;J.keccakP=Ul;var Nt=Xi(),Pr=Cl(),Ue=Ol(),Ml=[],Nl=[],Ll=[],nd=BigInt(0),xr=BigInt(1),id=BigInt(2),od=BigInt(7),sd=BigInt(256),ad=BigInt(113);for(let e=0,t=xr,r=1,n=0;e<24;e++){[r,n]=[n,(2*r+3*n)%5],Ml.push(2*(5*n+r)),Nl.push((e+1)*(e+2)/2%64);let i=nd;for(let o=0;o<7;o++)t=(t<>od)*ad)%sd,t&id&&(i^=xr<<(xr<r>32?(0,Pr.rotlBH)(e,t,r):(0,Pr.rotlSH)(e,t,r),_l=(e,t,r)=>r>32?(0,Pr.rotlBL)(e,t,r):(0,Pr.rotlSL)(e,t,r);function Ul(e,t=24){let r=new Uint32Array(10);for(let n=24-t;n<24;n++){for(let s=0;s<10;s++)r[s]=e[s]^e[s+10]^e[s+20]^e[s+30]^e[s+40];for(let s=0;s<10;s+=2){let a=(s+8)%10,f=(s+2)%10,w=r[f],A=r[f+1],R=Dl(w,A,1)^r[a],S=_l(w,A,1)^r[a+1];for(let C=0;C<50;C+=10)e[s+C]^=R,e[s+C+1]^=S}let i=e[2],o=e[3];for(let s=0;s<24;s++){let a=Nl[s],f=Dl(i,o,a),w=_l(i,o,a),A=Ml[s];i=e[A],o=e[A+1],e[A]=f,e[A+1]=w}for(let s=0;s<50;s+=10){for(let a=0;a<10;a++)r[a]=e[s+a];for(let a=0;a<10;a++)e[s+a]^=~r[(a+2)%10]&r[(a+4)%10]}e[0]^=ld[n],e[1]^=cd[n]}r.fill(0)}var Tr=class e extends Ue.Hash{constructor(t,r,n,i=!1,o=24){if(super(),this.blockLen=t,this.suffix=r,this.outputLen=n,this.enableXOF=i,this.rounds=o,this.pos=0,this.posOut=0,this.finished=!1,this.destroyed=!1,(0,Nt.anumber)(n),0>=this.blockLen||this.blockLen>=200)throw new Error("Sha3 supports only keccak-f1600 function");this.state=new Uint8Array(200),this.state32=(0,Ue.u32)(this.state)}keccak(){Ue.isLE||(0,Ue.byteSwap32)(this.state32),Ul(this.state32,this.rounds),Ue.isLE||(0,Ue.byteSwap32)(this.state32),this.posOut=0,this.pos=0}update(t){(0,Nt.aexists)(this);let{blockLen:r,state:n}=this;t=(0,Ue.toBytes)(t);let i=t.length;for(let o=0;o=n&&this.keccak();let s=Math.min(n-this.posOut,o-i);t.set(r.subarray(this.posOut,this.posOut+s),i),this.posOut+=s,i+=s}return t}xofInto(t){if(!this.enableXOF)throw new Error("XOF is not possible for this instance");return this.writeInto(t)}xof(t){return(0,Nt.anumber)(t),this.xofInto(new Uint8Array(t))}digestInto(t){if((0,Nt.aoutput)(t,this),this.finished)throw new Error("digest() was already called");return this.writeInto(t),this.destroy(),t}digest(){return this.digestInto(new Uint8Array(this.outputLen))}destroy(){this.destroyed=!0,this.state.fill(0)}_cloneInto(t){let{blockLen:r,suffix:n,outputLen:i,rounds:o,enableXOF:s}=this;return t||(t=new e(r,n,i,s,o)),t.state32.set(this.state32),t.pos=this.pos,t.posOut=this.posOut,t.finished=this.finished,t.rounds=o,t.suffix=n,t.outputLen=i,t.enableXOF=s,t.destroyed=this.destroyed,t}};J.Keccak=Tr;var Ge=(e,t,r)=>(0,Ue.wrapConstructor)(()=>new Tr(t,e,r));J.sha3_224=Ge(6,144,224/8);J.sha3_256=Ge(6,136,256/8);J.sha3_384=Ge(6,104,384/8);J.sha3_512=Ge(6,72,512/8);J.keccak_224=Ge(1,144,224/8);J.keccak_256=Ge(1,136,256/8);J.keccak_384=Ge(1,104,384/8);J.keccak_512=Ge(1,72,512/8);var Fl=(e,t,r)=>(0,Ue.wrapXOFConstructorWithOpts)((n={})=>new Tr(t,e,n.dkLen===void 0?r:n.dkLen,!0));J.shake128=Fl(31,168,128/8);J.shake256=Fl(31,136,256/8)});var Jl=me((RL,Je)=>{"use strict";c();u();p();m();d();l();var{sha3_512:ud}=$l(),ql=24,vr=32,oo=(e=4,t=Math.random)=>{let r="";for(;r.lengthBl(ud(e)).toString(36).slice(1),Vl=Array.from({length:26},(e,t)=>String.fromCharCode(t+97)),pd=e=>Vl[Math.floor(e()*Vl.length)],Ql=({globalObj:e=typeof globalThis<"u"?globalThis:typeof window<"u"?window:{},random:t=Math.random}={})=>{let r=Object.keys(e).toString(),n=r.length?r+oo(vr,t):oo(vr,t);return jl(n).substring(0,vr)},Hl=e=>()=>e++,md=476782367,Gl=({random:e=Math.random,counter:t=Hl(Math.floor(e()*md)),length:r=ql,fingerprint:n=Ql({random:e})}={})=>function(){let o=pd(e),s=Date.now().toString(36),a=t().toString(36),f=oo(r,e),w=`${s+f+a+n}`;return`${o+jl(w).substring(1,r)}`},dd=Gl(),fd=(e,{minLength:t=2,maxLength:r=vr}={})=>{let n=e.length,i=/^[0-9a-z]+$/;try{if(typeof e=="string"&&n>=t&&n<=r&&i.test(e))return!0}finally{}return!1};Je.exports.getConstants=()=>({defaultLength:ql,bigLength:vr});Je.exports.init=Gl;Je.exports.createId=dd;Je.exports.bufToBigInt=Bl;Je.exports.createCounter=Hl;Je.exports.createFingerprint=Ql;Je.exports.isCuid=fd});var Wl=me((_L,Ar)=>{"use strict";c();u();p();m();d();l();var{createId:gd,init:yd,getConstants:hd,isCuid:wd}=Jl();Ar.exports.createId=gd;Ar.exports.init=yd;Ar.exports.getConstants=hd;Ar.exports.isCuid=wd});var $f={};pt($f,{DMMF:()=>or,Debug:()=>K,Decimal:()=>se,Extensions:()=>gi,MetricsClient:()=>St,PrismaClientInitializationError:()=>F,PrismaClientKnownRequestError:()=>X,PrismaClientRustPanicError:()=>ae,PrismaClientUnknownRequestError:()=>ne,PrismaClientValidationError:()=>ie,Public:()=>yi,Sql:()=>fe,createParam:()=>ta,defineDmmfProperty:()=>aa,deserializeJsonResponse:()=>Qe,deserializeRawResult:()=>ai,dmmfToRuntimeDataModel:()=>Ds,empty:()=>pa,getPrismaClient:()=>tu,getRuntime:()=>ti,join:()=>ua,makeStrictEnum:()=>ru,makeTypedQueryFactory:()=>la,objectEnumValues:()=>En,raw:()=>Fi,serializeJsonQuery:()=>Cn,skip:()=>Rn,sqltag:()=>$i,warnEnvConflicts:()=>void 0,warnOnce:()=>rr});module.exports=qo($f);c();u();p();m();d();l();var gi={};pt(gi,{defineExtension:()=>Zo,getExtensionContext:()=>Xo});c();u();p();m();d();l();c();u();p();m();d();l();function Zo(e){return typeof e=="function"?e:t=>t.$extends(e)}c();u();p();m();d();l();function Xo(e){return e}var yi={};pt(yi,{validator:()=>es});c();u();p();m();d();l();c();u();p();m();d();l();function es(...e){return t=>t}c();u();p();m();d();l();c();u();p();m();d();l();c();u();p();m();d();l();var hi,ts,rs,ns,is=!0;typeof g<"u"&&({FORCE_COLOR:hi,NODE_DISABLE_COLORS:ts,NO_COLOR:rs,TERM:ns}=g.env||{},is=g.stdout&&g.stdout.isTTY);var xu={enabled:!ts&&rs==null&&ns!=="dumb"&&(hi!=null&&hi!=="0"||is)};function j(e,t){let r=new RegExp(`\\x1b\\[${t}m`,"g"),n=`\x1B[${e}m`,i=`\x1B[${t}m`;return function(o){return!xu.enabled||o==null?o:n+(~(""+o).indexOf(i)?o.replace(r,i+n):o)+i}}var Ug=j(0,0),Xr=j(1,22),en=j(2,22),Fg=j(3,23),tn=j(4,24),$g=j(7,27),Vg=j(8,28),qg=j(9,29),Bg=j(30,39),ft=j(31,39),os=j(32,39),ss=j(33,39),as=j(34,39),jg=j(35,39),ls=j(36,39),Qg=j(37,39),cs=j(90,39),Hg=j(90,39),Gg=j(40,49),Jg=j(41,49),Wg=j(42,49),Kg=j(43,49),zg=j(44,49),Yg=j(45,49),Zg=j(46,49),Xg=j(47,49);c();u();p();m();d();l();var Pu=100,us=["green","yellow","blue","magenta","cyan","red"],zt=[],ps=Date.now(),Tu=0,wi=typeof g<"u"?g.env:{};globalThis.DEBUG??=wi.DEBUG??"";globalThis.DEBUG_COLORS??=wi.DEBUG_COLORS?wi.DEBUG_COLORS==="true":!0;var Yt={enable(e){typeof e=="string"&&(globalThis.DEBUG=e)},disable(){let e=globalThis.DEBUG;return globalThis.DEBUG="",e},enabled(e){let t=globalThis.DEBUG.split(",").map(i=>i.replace(/[.+?^${}()|[\]\\]/g,"\\$&")),r=t.some(i=>i===""||i[0]==="-"?!1:e.match(RegExp(i.split("*").join(".*")+"$"))),n=t.some(i=>i===""||i[0]!=="-"?!1:e.match(RegExp(i.slice(1).split("*").join(".*")+"$")));return r&&!n},log:(...e)=>{let[t,r,...n]=e;(console.warn??console.log)(`${t} ${r}`,...n)},formatters:{}};function vu(e){let t={color:us[Tu++%us.length],enabled:Yt.enabled(e),namespace:e,log:Yt.log,extend:()=>{}},r=(...n)=>{let{enabled:i,namespace:o,color:s,log:a}=t;if(n.length!==0&&zt.push([o,...n]),zt.length>Pu&&zt.shift(),Yt.enabled(o)||i){let f=n.map(A=>typeof A=="string"?A:Au(A)),w=`+${Date.now()-ps}ms`;ps=Date.now(),a(o,...f,w)}};return new Proxy(r,{get:(n,i)=>t[i],set:(n,i,o)=>t[i]=o})}var K=new Proxy(vu,{get:(e,t)=>Yt[t],set:(e,t,r)=>Yt[t]=r});function Au(e,t=2){let r=new Set;return JSON.stringify(e,(n,i)=>{if(typeof i=="object"&&i!==null){if(r.has(i))return"[Circular *]";r.add(i)}else if(typeof i=="bigint")return i.toString();return i},t)}function ms(e=7500){let t=zt.map(([r,...n])=>`${r} ${n.map(i=>typeof i=="string"?i:JSON.stringify(i)).join(" ")}`).join(` -`);return t.lengthip,info:()=>np,log:()=>rp,query:()=>op,should:()=>Cs,tags:()=>er,warn:()=>vi});c();u();p();m();d();l();var er={error:ft("prisma:error"),warn:ss("prisma:warn"),info:ls("prisma:info"),query:as("prisma:query")},Cs={warn:()=>!g.env.PRISMA_DISABLE_WARNINGS};function rp(...e){console.log(...e)}function vi(e,...t){Cs.warn()&&console.warn(`${er.warn} ${e}`,...t)}function np(e,...t){console.info(`${er.info} ${e}`,...t)}function ip(e,...t){console.error(`${er.error} ${e}`,...t)}function op(e,...t){console.log(`${er.query} ${e}`,...t)}c();u();p();m();d();l();function Me(e,t){throw new Error(t)}c();u();p();m();d();l();c();u();p();m();d();l();function Ai({onlyFirst:e=!1}={}){let r=["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?(?:\\u0007|\\u001B\\u005C|\\u009C))","(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"].join("|");return new RegExp(r,e?void 0:"g")}var sp=Ai();function ht(e){if(typeof e!="string")throw new TypeError(`Expected a \`string\`, got \`${typeof e}\``);return e.replace(sp,"")}c();u();p();m();d();l();function Ri(e,t){return Object.prototype.hasOwnProperty.call(e,t)}c();u();p();m();d();l();function pn(e,t){let r={};for(let n of Object.keys(e))r[n]=t(e[n],n);return r}c();u();p();m();d();l();function Ci(e,t){if(e.length===0)return;let r=e[0];for(let n=1;n{Is.has(e)||(Is.add(e),vi(t,...r))};var F=class e extends Error{clientVersion;errorCode;retryable;constructor(t,r,n){super(t),this.name="PrismaClientInitializationError",this.clientVersion=r,this.errorCode=n,Error.captureStackTrace(e)}get[Symbol.toStringTag](){return"PrismaClientInitializationError"}};D(F,"PrismaClientInitializationError");c();u();p();m();d();l();var X=class extends Error{code;meta;clientVersion;batchRequestIdx;constructor(t,{code:r,clientVersion:n,meta:i,batchRequestIdx:o}){super(t),this.name="PrismaClientKnownRequestError",this.code=r,this.clientVersion=n,this.meta=i,Object.defineProperty(this,"batchRequestIdx",{value:o,enumerable:!1,writable:!0})}get[Symbol.toStringTag](){return"PrismaClientKnownRequestError"}};D(X,"PrismaClientKnownRequestError");c();u();p();m();d();l();var ae=class extends Error{clientVersion;constructor(t,r){super(t),this.name="PrismaClientRustPanicError",this.clientVersion=r}get[Symbol.toStringTag](){return"PrismaClientRustPanicError"}};D(ae,"PrismaClientRustPanicError");c();u();p();m();d();l();var ne=class extends Error{clientVersion;batchRequestIdx;constructor(t,{clientVersion:r,batchRequestIdx:n}){super(t),this.name="PrismaClientUnknownRequestError",this.clientVersion=r,Object.defineProperty(this,"batchRequestIdx",{value:n,writable:!0,enumerable:!1})}get[Symbol.toStringTag](){return"PrismaClientUnknownRequestError"}};D(ne,"PrismaClientUnknownRequestError");c();u();p();m();d();l();var ie=class extends Error{name="PrismaClientValidationError";clientVersion;constructor(t,{clientVersion:r}){super(t),this.clientVersion=r}get[Symbol.toStringTag](){return"PrismaClientValidationError"}};D(ie,"PrismaClientValidationError");c();u();p();m();d();l();c();u();p();m();d();l();c();u();p();m();d();l();var Ce=class{_map=new Map;get(t){return this._map.get(t)?.value}set(t,r){this._map.set(t,{value:r})}getOrCreate(t,r){let n=this._map.get(t);if(n)return n.value;let i=r();return this.set(t,i),i}};c();u();p();m();d();l();function qe(e){return e.substring(0,1).toLowerCase()+e.substring(1)}c();u();p();m();d();l();function Os(e,t){let r={};for(let n of e){let i=n[t];r[i]=n}return r}c();u();p();m();d();l();function nr(e){let t;return{get(){return t||(t={value:e()}),t.value}}}c();u();p();m();d();l();function Ds(e){return{models:Si(e.models),enums:Si(e.enums),types:Si(e.types)}}function Si(e){let t={};for(let{name:r,...n}of e)t[r]=n;return t}c();u();p();m();d();l();function wt(e){return e instanceof Date||Object.prototype.toString.call(e)==="[object Date]"}function mn(e){return e.toString()!=="Invalid Date"}c();u();p();m();d();l();l();function bt(e){return v.isDecimal(e)?!0:e!==null&&typeof e=="object"&&typeof e.s=="number"&&typeof e.e=="number"&&typeof e.toFixed=="function"&&Array.isArray(e.d)}c();u();p();m();d();l();c();u();p();m();d();l();var or={};pt(or,{ModelAction:()=>ir,datamodelEnumToSchemaEnum:()=>ap});c();u();p();m();d();l();c();u();p();m();d();l();function ap(e){return{name:e.name,values:e.values.map(t=>t.name)}}c();u();p();m();d();l();var ir=(B=>(B.findUnique="findUnique",B.findUniqueOrThrow="findUniqueOrThrow",B.findFirst="findFirst",B.findFirstOrThrow="findFirstOrThrow",B.findMany="findMany",B.create="create",B.createMany="createMany",B.createManyAndReturn="createManyAndReturn",B.update="update",B.updateMany="updateMany",B.updateManyAndReturn="updateManyAndReturn",B.upsert="upsert",B.delete="delete",B.deleteMany="deleteMany",B.groupBy="groupBy",B.count="count",B.aggregate="aggregate",B.findRaw="findRaw",B.aggregateRaw="aggregateRaw",B))(ir||{});var lp=$e(Rs());var cp={red:ft,gray:cs,dim:en,bold:Xr,underline:tn,highlightSource:e=>e.highlight()},up={red:e=>e,gray:e=>e,dim:e=>e,bold:e=>e,underline:e=>e,highlightSource:e=>e};function pp({message:e,originalMethod:t,isPanic:r,callArguments:n}){return{functionName:`prisma.${t}()`,message:e,isPanic:r??!1,callArguments:n}}function mp({functionName:e,location:t,message:r,isPanic:n,contextLines:i,callArguments:o},s){let a=[""],f=t?" in":":";if(n?(a.push(s.red(`Oops, an unknown error occurred! This is ${s.bold("on us")}, you did nothing wrong.`)),a.push(s.red(`It occurred in the ${s.bold(`\`${e}\``)} invocation${f}`))):a.push(s.red(`Invalid ${s.bold(`\`${e}\``)} invocation${f}`)),t&&a.push(s.underline(dp(t))),i){a.push("");let w=[i.toString()];o&&(w.push(o),w.push(s.dim(")"))),a.push(w.join("")),o&&a.push("")}else a.push(""),o&&a.push(o),a.push("");return a.push(r),a.join(` -`)}function dp(e){let t=[e.fileName];return e.lineNumber&&t.push(String(e.lineNumber)),e.columnNumber&&t.push(String(e.columnNumber)),t.join(":")}function dn(e){let t=e.showColors?cp:up,r;return typeof $getTemplateParameters<"u"?r=$getTemplateParameters(e,t):r=pp(e),mp(r,t)}c();u();p();m();d();l();var qs=$e(Ii());c();u();p();m();d();l();function Ls(e,t,r){let n=Us(e),i=fp(n),o=yp(i);o?fn(o,t,r):t.addErrorMessage(()=>"Unknown error")}function Us(e){return e.errors.flatMap(t=>t.kind==="Union"?Us(t):[t])}function fp(e){let t=new Map,r=[];for(let n of e){if(n.kind!=="InvalidArgumentType"){r.push(n);continue}let i=`${n.selectionPath.join(".")}:${n.argumentPath.join(".")}`,o=t.get(i);o?t.set(i,{...n,argument:{...n.argument,typeNames:gp(o.argument.typeNames,n.argument.typeNames)}}):t.set(i,n)}return r.push(...t.values()),r}function gp(e,t){return[...new Set(e.concat(t))]}function yp(e){return Ci(e,(t,r)=>{let n=Ms(t),i=Ms(r);return n!==i?n-i:Ns(t)-Ns(r)})}function Ms(e){let t=0;return Array.isArray(e.selectionPath)&&(t+=e.selectionPath.length),Array.isArray(e.argumentPath)&&(t+=e.argumentPath.length),t}function Ns(e){switch(e.kind){case"InvalidArgumentValue":case"ValueTooLarge":return 20;case"InvalidArgumentType":return 10;case"RequiredArgumentMissing":return-10;default:return 0}}c();u();p();m();d();l();var we=class{constructor(t,r){this.name=t;this.value=r}isRequired=!1;makeRequired(){return this.isRequired=!0,this}write(t){let{colors:{green:r}}=t.context;t.addMarginSymbol(r(this.isRequired?"+":"?")),t.write(r(this.name)),this.isRequired||t.write(r("?")),t.write(r(": ")),typeof this.value=="string"?t.write(r(this.value)):t.write(this.value)}};c();u();p();m();d();l();c();u();p();m();d();l();$s();c();u();p();m();d();l();var Et=class{constructor(t=0,r){this.context=r;this.currentIndent=t}lines=[];currentLine="";currentIndent=0;marginSymbol;afterNextNewLineCallback;write(t){return typeof t=="string"?this.currentLine+=t:t.write(this),this}writeJoined(t,r,n=(i,o)=>o.write(i)){let i=r.length-1;for(let o=0;o0&&this.currentIndent--,this}addMarginSymbol(t){return this.marginSymbol=t,this}toString(){return this.lines.concat(this.indentedCurrentLine()).join(` -`)}getCurrentLineLength(){return this.currentLine.length}indentedCurrentLine(){let t=this.currentLine.padStart(this.currentLine.length+2*this.currentIndent);return this.marginSymbol?this.marginSymbol+t.slice(1):t}};Fs();c();u();p();m();d();l();c();u();p();m();d();l();var gn=class{constructor(t){this.value=t}write(t){t.write(this.value)}markAsError(){this.value.markAsError()}};c();u();p();m();d();l();var yn=e=>e,hn={bold:yn,red:yn,green:yn,dim:yn,enabled:!1},Vs={bold:Xr,red:ft,green:os,dim:en,enabled:!0},xt={write(e){e.writeLine(",")}};c();u();p();m();d();l();var Se=class{constructor(t){this.contents=t}isUnderlined=!1;color=t=>t;underline(){return this.isUnderlined=!0,this}setColor(t){return this.color=t,this}write(t){let r=t.getCurrentLineLength();t.write(this.color(this.contents)),this.isUnderlined&&t.afterNextNewline(()=>{t.write(" ".repeat(r)).writeLine(this.color("~".repeat(this.contents.length)))})}};c();u();p();m();d();l();var Be=class{hasError=!1;markAsError(){return this.hasError=!0,this}};var Pt=class extends Be{items=[];addItem(t){return this.items.push(new gn(t)),this}getField(t){return this.items[t]}getPrintWidth(){return this.items.length===0?2:Math.max(...this.items.map(r=>r.value.getPrintWidth()))+2}write(t){if(this.items.length===0){this.writeEmpty(t);return}this.writeWithItems(t)}writeEmpty(t){let r=new Se("[]");this.hasError&&r.setColor(t.context.colors.red).underline(),t.write(r)}writeWithItems(t){let{colors:r}=t.context;t.writeLine("[").withIndent(()=>t.writeJoined(xt,this.items).newLine()).write("]"),this.hasError&&t.afterNextNewline(()=>{t.writeLine(r.red("~".repeat(this.getPrintWidth())))})}asObject(){}};var Tt=class e extends Be{fields={};suggestions=[];addField(t){this.fields[t.name]=t}addSuggestion(t){this.suggestions.push(t)}getField(t){return this.fields[t]}getDeepField(t){let[r,...n]=t,i=this.getField(r);if(!i)return;let o=i;for(let s of n){let a;if(o.value instanceof e?a=o.value.getField(s):o.value instanceof Pt&&(a=o.value.getField(Number(s))),!a)return;o=a}return o}getDeepFieldValue(t){return t.length===0?this:this.getDeepField(t)?.value}hasField(t){return!!this.getField(t)}removeAllFields(){this.fields={}}removeField(t){delete this.fields[t]}getFields(){return this.fields}isEmpty(){return Object.keys(this.fields).length===0}getFieldValue(t){return this.getField(t)?.value}getDeepSubSelectionValue(t){let r=this;for(let n of t){if(!(r instanceof e))return;let i=r.getSubSelectionValue(n);if(!i)return;r=i}return r}getDeepSelectionParent(t){let r=this.getSelectionParent();if(!r)return;let n=r;for(let i of t){let o=n.value.getFieldValue(i);if(!o||!(o instanceof e))return;let s=o.getSelectionParent();if(!s)return;n=s}return n}getSelectionParent(){let t=this.getField("select")?.value.asObject();if(t)return{kind:"select",value:t};let r=this.getField("include")?.value.asObject();if(r)return{kind:"include",value:r}}getSubSelectionValue(t){return this.getSelectionParent()?.value.fields[t].value}getPrintWidth(){let t=Object.values(this.fields);return t.length==0?2:Math.max(...t.map(n=>n.getPrintWidth()))+2}write(t){let r=Object.values(this.fields);if(r.length===0&&this.suggestions.length===0){this.writeEmpty(t);return}this.writeWithContents(t,r)}asObject(){return this}writeEmpty(t){let r=new Se("{}");this.hasError&&r.setColor(t.context.colors.red).underline(),t.write(r)}writeWithContents(t,r){t.writeLine("{").withIndent(()=>{t.writeJoined(xt,[...r,...this.suggestions]).newLine()}),t.write("}"),this.hasError&&t.afterNextNewline(()=>{t.writeLine(t.context.colors.red("~".repeat(this.getPrintWidth())))})}};c();u();p();m();d();l();var re=class extends Be{constructor(r){super();this.text=r}getPrintWidth(){return this.text.length}write(r){let n=new Se(this.text);this.hasError&&n.underline().setColor(r.context.colors.red),r.write(n)}asObject(){}};c();u();p();m();d();l();var sr=class{fields=[];addField(t,r){return this.fields.push({write(n){let{green:i,dim:o}=n.context.colors;n.write(i(o(`${t}: ${r}`))).addMarginSymbol(i(o("+")))}}),this}write(t){let{colors:{green:r}}=t.context;t.writeLine(r("{")).withIndent(()=>{t.writeJoined(xt,this.fields).newLine()}).write(r("}")).addMarginSymbol(r("+"))}};function fn(e,t,r){switch(e.kind){case"MutuallyExclusiveFields":hp(e,t);break;case"IncludeOnScalar":wp(e,t);break;case"EmptySelection":bp(e,t,r);break;case"UnknownSelectionField":Tp(e,t);break;case"InvalidSelectionValue":vp(e,t);break;case"UnknownArgument":Ap(e,t);break;case"UnknownInputField":Rp(e,t);break;case"RequiredArgumentMissing":Cp(e,t);break;case"InvalidArgumentType":Sp(e,t);break;case"InvalidArgumentValue":Ip(e,t);break;case"ValueTooLarge":kp(e,t);break;case"SomeFieldsMissing":Op(e,t);break;case"TooManyFieldsGiven":Dp(e,t);break;case"Union":Ls(e,t,r);break;default:throw new Error("not implemented: "+e.kind)}}function hp(e,t){let r=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();r&&(r.getField(e.firstField)?.markAsError(),r.getField(e.secondField)?.markAsError()),t.addErrorMessage(n=>`Please ${n.bold("either")} use ${n.green(`\`${e.firstField}\``)} or ${n.green(`\`${e.secondField}\``)}, but ${n.red("not both")} at the same time.`)}function wp(e,t){let[r,n]=vt(e.selectionPath),i=e.outputType,o=t.arguments.getDeepSelectionParent(r)?.value;if(o&&(o.getField(n)?.markAsError(),i))for(let s of i.fields)s.isRelation&&o.addSuggestion(new we(s.name,"true"));t.addErrorMessage(s=>{let a=`Invalid scalar field ${s.red(`\`${n}\``)} for ${s.bold("include")} statement`;return i?a+=` on model ${s.bold(i.name)}. ${ar(s)}`:a+=".",a+=` -Note that ${s.bold("include")} statements only accept relation fields.`,a})}function bp(e,t,r){let n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(n){let i=n.getField("omit")?.value.asObject();if(i){Ep(e,t,i);return}if(n.hasField("select")){xp(e,t);return}}if(r?.[qe(e.outputType.name)]){Pp(e,t);return}t.addErrorMessage(()=>`Unknown field at "${e.selectionPath.join(".")} selection"`)}function Ep(e,t,r){r.removeAllFields();for(let n of e.outputType.fields)r.addSuggestion(new we(n.name,"false"));t.addErrorMessage(n=>`The ${n.red("omit")} statement includes every field of the model ${n.bold(e.outputType.name)}. At least one field must be included in the result`)}function xp(e,t){let r=e.outputType,n=t.arguments.getDeepSelectionParent(e.selectionPath)?.value,i=n?.isEmpty()??!1;n&&(n.removeAllFields(),Qs(n,r)),t.addErrorMessage(o=>i?`The ${o.red("`select`")} statement for type ${o.bold(r.name)} must not be empty. ${ar(o)}`:`The ${o.red("`select`")} statement for type ${o.bold(r.name)} needs ${o.bold("at least one truthy value")}.`)}function Pp(e,t){let r=new sr;for(let i of e.outputType.fields)i.isRelation||r.addField(i.name,"false");let n=new we("omit",r).makeRequired();if(e.selectionPath.length===0)t.arguments.addSuggestion(n);else{let[i,o]=vt(e.selectionPath),a=t.arguments.getDeepSelectionParent(i)?.value.asObject()?.getField(o);if(a){let f=a?.value.asObject()??new Tt;f.addSuggestion(n),a.value=f}}t.addErrorMessage(i=>`The global ${i.red("omit")} configuration excludes every field of the model ${i.bold(e.outputType.name)}. At least one field must be included in the result`)}function Tp(e,t){let r=Hs(e.selectionPath,t);if(r.parentKind!=="unknown"){r.field.markAsError();let n=r.parent;switch(r.parentKind){case"select":Qs(n,e.outputType);break;case"include":_p(n,e.outputType);break;case"omit":Mp(n,e.outputType);break}}t.addErrorMessage(n=>{let i=[`Unknown field ${n.red(`\`${r.fieldName}\``)}`];return r.parentKind!=="unknown"&&i.push(`for ${n.bold(r.parentKind)} statement`),i.push(`on model ${n.bold(`\`${e.outputType.name}\``)}.`),i.push(ar(n)),i.join(" ")})}function vp(e,t){let r=Hs(e.selectionPath,t);r.parentKind!=="unknown"&&r.field.value.markAsError(),t.addErrorMessage(n=>`Invalid value for selection field \`${n.red(r.fieldName)}\`: ${e.underlyingError}`)}function Ap(e,t){let r=e.argumentPath[0],n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();n&&(n.getField(r)?.markAsError(),Np(n,e.arguments)),t.addErrorMessage(i=>Bs(i,r,e.arguments.map(o=>o.name)))}function Rp(e,t){let[r,n]=vt(e.argumentPath),i=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(i){i.getDeepField(e.argumentPath)?.markAsError();let o=i.getDeepFieldValue(r)?.asObject();o&&Gs(o,e.inputType)}t.addErrorMessage(o=>Bs(o,n,e.inputType.fields.map(s=>s.name)))}function Bs(e,t,r){let n=[`Unknown argument \`${e.red(t)}\`.`],i=Up(t,r);return i&&n.push(`Did you mean \`${e.green(i)}\`?`),r.length>0&&n.push(ar(e)),n.join(" ")}function Cp(e,t){let r;t.addErrorMessage(f=>r?.value instanceof re&&r.value.text==="null"?`Argument \`${f.green(o)}\` must not be ${f.red("null")}.`:`Argument \`${f.green(o)}\` is missing.`);let n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(!n)return;let[i,o]=vt(e.argumentPath),s=new sr,a=n.getDeepFieldValue(i)?.asObject();if(a){if(r=a.getField(o),r&&a.removeField(o),e.inputTypes.length===1&&e.inputTypes[0].kind==="object"){for(let f of e.inputTypes[0].fields)s.addField(f.name,f.typeNames.join(" | "));a.addSuggestion(new we(o,s).makeRequired())}else{let f=e.inputTypes.map(js).join(" | ");a.addSuggestion(new we(o,f).makeRequired())}if(e.dependentArgumentPath){n.getDeepField(e.dependentArgumentPath)?.markAsError();let[,f]=vt(e.dependentArgumentPath);t.addErrorMessage(w=>`Argument \`${w.green(o)}\` is required because argument \`${w.green(f)}\` was provided.`)}}}function js(e){return e.kind==="list"?`${js(e.elementType)}[]`:e.name}function Sp(e,t){let r=e.argument.name,n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();n&&n.getDeepFieldValue(e.argumentPath)?.markAsError(),t.addErrorMessage(i=>{let o=wn("or",e.argument.typeNames.map(s=>i.green(s)));return`Argument \`${i.bold(r)}\`: Invalid value provided. Expected ${o}, provided ${i.red(e.inferredType)}.`})}function Ip(e,t){let r=e.argument.name,n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();n&&n.getDeepFieldValue(e.argumentPath)?.markAsError(),t.addErrorMessage(i=>{let o=[`Invalid value for argument \`${i.bold(r)}\``];if(e.underlyingError&&o.push(`: ${e.underlyingError}`),o.push("."),e.argument.typeNames.length>0){let s=wn("or",e.argument.typeNames.map(a=>i.green(a)));o.push(` Expected ${s}.`)}return o.join("")})}function kp(e,t){let r=e.argument.name,n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject(),i;if(n){let s=n.getDeepField(e.argumentPath)?.value;s?.markAsError(),s instanceof re&&(i=s.text)}t.addErrorMessage(o=>{let s=["Unable to fit value"];return i&&s.push(o.red(i)),s.push(`into a 64-bit signed integer for field \`${o.bold(r)}\``),s.join(" ")})}function Op(e,t){let r=e.argumentPath[e.argumentPath.length-1],n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject();if(n){let i=n.getDeepFieldValue(e.argumentPath)?.asObject();i&&Gs(i,e.inputType)}t.addErrorMessage(i=>{let o=[`Argument \`${i.bold(r)}\` of type ${i.bold(e.inputType.name)} needs`];return e.constraints.minFieldCount===1?e.constraints.requiredFields?o.push(`${i.green("at least one of")} ${wn("or",e.constraints.requiredFields.map(s=>`\`${i.bold(s)}\``))} arguments.`):o.push(`${i.green("at least one")} argument.`):o.push(`${i.green(`at least ${e.constraints.minFieldCount}`)} arguments.`),o.push(ar(i)),o.join(" ")})}function Dp(e,t){let r=e.argumentPath[e.argumentPath.length-1],n=t.arguments.getDeepSubSelectionValue(e.selectionPath)?.asObject(),i=[];if(n){let o=n.getDeepFieldValue(e.argumentPath)?.asObject();o&&(o.markAsError(),i=Object.keys(o.getFields()))}t.addErrorMessage(o=>{let s=[`Argument \`${o.bold(r)}\` of type ${o.bold(e.inputType.name)} needs`];return e.constraints.minFieldCount===1&&e.constraints.maxFieldCount==1?s.push(`${o.green("exactly one")} argument,`):e.constraints.maxFieldCount==1?s.push(`${o.green("at most one")} argument,`):s.push(`${o.green(`at most ${e.constraints.maxFieldCount}`)} arguments,`),s.push(`but you provided ${wn("and",i.map(a=>o.red(a)))}. Please choose`),e.constraints.maxFieldCount===1?s.push("one."):s.push(`${e.constraints.maxFieldCount}.`),s.join(" ")})}function Qs(e,t){for(let r of t.fields)e.hasField(r.name)||e.addSuggestion(new we(r.name,"true"))}function _p(e,t){for(let r of t.fields)r.isRelation&&!e.hasField(r.name)&&e.addSuggestion(new we(r.name,"true"))}function Mp(e,t){for(let r of t.fields)!e.hasField(r.name)&&!r.isRelation&&e.addSuggestion(new we(r.name,"true"))}function Np(e,t){for(let r of t)e.hasField(r.name)||e.addSuggestion(new we(r.name,r.typeNames.join(" | ")))}function Hs(e,t){let[r,n]=vt(e),i=t.arguments.getDeepSubSelectionValue(r)?.asObject();if(!i)return{parentKind:"unknown",fieldName:n};let o=i.getFieldValue("select")?.asObject(),s=i.getFieldValue("include")?.asObject(),a=i.getFieldValue("omit")?.asObject(),f=o?.getField(n);return o&&f?{parentKind:"select",parent:o,field:f,fieldName:n}:(f=s?.getField(n),s&&f?{parentKind:"include",field:f,parent:s,fieldName:n}:(f=a?.getField(n),a&&f?{parentKind:"omit",field:f,parent:a,fieldName:n}:{parentKind:"unknown",fieldName:n}))}function Gs(e,t){if(t.kind==="object")for(let r of t.fields)e.hasField(r.name)||e.addSuggestion(new we(r.name,r.typeNames.join(" | ")))}function vt(e){let t=[...e],r=t.pop();if(!r)throw new Error("unexpected empty path");return[t,r]}function ar({green:e,enabled:t}){return"Available options are "+(t?`listed in ${e("green")}`:"marked with ?")+"."}function wn(e,t){if(t.length===1)return t[0];let r=[...t],n=r.pop();return`${r.join(", ")} ${e} ${n}`}var Lp=3;function Up(e,t){let r=1/0,n;for(let i of t){let o=(0,qs.default)(e,i);o>Lp||o`}};function At(e){return e instanceof lr}c();u();p();m();d();l();var bn=Symbol(),Oi=new WeakMap,Ne=class{constructor(t){t===bn?Oi.set(this,`Prisma.${this._getName()}`):Oi.set(this,`new Prisma.${this._getNamespace()}.${this._getName()}()`)}_getName(){return this.constructor.name}toString(){return Oi.get(this)}},cr=class extends Ne{_getNamespace(){return"NullTypes"}},ur=class extends cr{#t};Di(ur,"DbNull");var pr=class extends cr{#t};Di(pr,"JsonNull");var mr=class extends cr{#t};Di(mr,"AnyNull");var En={classes:{DbNull:ur,JsonNull:pr,AnyNull:mr},instances:{DbNull:new ur(bn),JsonNull:new pr(bn),AnyNull:new mr(bn)}};function Di(e,t){Object.defineProperty(e,"name",{value:t,configurable:!0})}c();u();p();m();d();l();var Js=": ",xn=class{constructor(t,r){this.name=t;this.value=r}hasError=!1;markAsError(){this.hasError=!0}getPrintWidth(){return this.name.length+this.value.getPrintWidth()+Js.length}write(t){let r=new Se(this.name);this.hasError&&r.underline().setColor(t.context.colors.red),t.write(r).write(Js).write(this.value)}};var _i=class{arguments;errorMessages=[];constructor(t){this.arguments=t}write(t){t.write(this.arguments)}addErrorMessage(t){this.errorMessages.push(t)}renderAllMessages(t){return this.errorMessages.map(r=>r(t)).join(` -`)}};function Rt(e){return new _i(Ws(e))}function Ws(e){let t=new Tt;for(let[r,n]of Object.entries(e)){let i=new xn(r,Ks(n));t.addField(i)}return t}function Ks(e){if(typeof e=="string")return new re(JSON.stringify(e));if(typeof e=="number"||typeof e=="boolean")return new re(String(e));if(typeof e=="bigint")return new re(`${e}n`);if(e===null)return new re("null");if(e===void 0)return new re("undefined");if(bt(e))return new re(`new Prisma.Decimal("${e.toFixed()}")`);if(e instanceof Uint8Array)return y.isBuffer(e)?new re(`Buffer.alloc(${e.byteLength})`):new re(`new Uint8Array(${e.byteLength})`);if(e instanceof Date){let t=mn(e)?e.toISOString():"Invalid Date";return new re(`new Date("${t}")`)}return e instanceof Ne?new re(`Prisma.${e._getName()}`):At(e)?new re(`prisma.${qe(e.modelName)}.$fields.${e.name}`):Array.isArray(e)?Fp(e):typeof e=="object"?Ws(e):new re(Object.prototype.toString.call(e))}function Fp(e){let t=new Pt;for(let r of e)t.addItem(Ks(r));return t}function Pn(e,t){let r=t==="pretty"?Vs:hn,n=e.renderAllMessages(r),i=new Et(0,{colors:r}).write(e).toString();return{message:n,args:i}}function Tn({args:e,errors:t,errorFormat:r,callsite:n,originalMethod:i,clientVersion:o,globalOmit:s}){let a=Rt(e);for(let R of t)fn(R,a,s);let{message:f,args:w}=Pn(a,r),A=dn({message:f,callsite:n,originalMethod:i,showColors:r==="pretty",callArguments:w});throw new ie(A,{clientVersion:o})}c();u();p();m();d();l();c();u();p();m();d();l();function Ie(e){return e.replace(/^./,t=>t.toLowerCase())}c();u();p();m();d();l();function Ys(e,t,r){let n=Ie(r);return!t.result||!(t.result.$allModels||t.result[n])?e:$p({...e,...zs(t.name,e,t.result.$allModels),...zs(t.name,e,t.result[n])})}function $p(e){let t=new Ce,r=(n,i)=>t.getOrCreate(n,()=>i.has(n)?[n]:(i.add(n),e[n]?e[n].needs.flatMap(o=>r(o,i)):[n]));return pn(e,n=>({...n,needs:r(n.name,new Set)}))}function zs(e,t,r){return r?pn(r,({needs:n,compute:i},o)=>({name:o,needs:n?Object.keys(n).filter(s=>n[s]):[],compute:Vp(t,o,i)})):{}}function Vp(e,t,r){let n=e?.[t]?.compute;return n?i=>r({...i,[t]:n(i)}):r}function Zs(e,t){if(!t)return e;let r={...e};for(let n of Object.values(t))if(e[n.name])for(let i of n.needs)r[i]=!0;return r}function Xs(e,t){if(!t)return e;let r={...e};for(let n of Object.values(t))if(!e[n.name])for(let i of n.needs)delete r[i];return r}var vn=class{constructor(t,r){this.extension=t;this.previous=r}computedFieldsCache=new Ce;modelExtensionsCache=new Ce;queryCallbacksCache=new Ce;clientExtensions=nr(()=>this.extension.client?{...this.previous?.getAllClientExtensions(),...this.extension.client}:this.previous?.getAllClientExtensions());batchCallbacks=nr(()=>{let t=this.previous?.getAllBatchQueryCallbacks()??[],r=this.extension.query?.$__internalBatch;return r?t.concat(r):t});getAllComputedFields(t){return this.computedFieldsCache.getOrCreate(t,()=>Ys(this.previous?.getAllComputedFields(t),this.extension,t))}getAllClientExtensions(){return this.clientExtensions.get()}getAllModelExtensions(t){return this.modelExtensionsCache.getOrCreate(t,()=>{let r=Ie(t);return!this.extension.model||!(this.extension.model[r]||this.extension.model.$allModels)?this.previous?.getAllModelExtensions(t):{...this.previous?.getAllModelExtensions(t),...this.extension.model.$allModels,...this.extension.model[r]}})}getAllQueryCallbacks(t,r){return this.queryCallbacksCache.getOrCreate(`${t}:${r}`,()=>{let n=this.previous?.getAllQueryCallbacks(t,r)??[],i=[],o=this.extension.query;return!o||!(o[t]||o.$allModels||o[r]||o.$allOperations)?n:(o[t]!==void 0&&(o[t][r]!==void 0&&i.push(o[t][r]),o[t].$allOperations!==void 0&&i.push(o[t].$allOperations)),t!=="$none"&&o.$allModels!==void 0&&(o.$allModels[r]!==void 0&&i.push(o.$allModels[r]),o.$allModels.$allOperations!==void 0&&i.push(o.$allModels.$allOperations)),o[r]!==void 0&&i.push(o[r]),o.$allOperations!==void 0&&i.push(o.$allOperations),n.concat(i))})}getAllBatchQueryCallbacks(){return this.batchCallbacks.get()}},Ct=class e{constructor(t){this.head=t}static empty(){return new e}static single(t){return new e(new vn(t))}isEmpty(){return this.head===void 0}append(t){return new e(new vn(t,this.head))}getAllComputedFields(t){return this.head?.getAllComputedFields(t)}getAllClientExtensions(){return this.head?.getAllClientExtensions()}getAllModelExtensions(t){return this.head?.getAllModelExtensions(t)}getAllQueryCallbacks(t,r){return this.head?.getAllQueryCallbacks(t,r)??[]}getAllBatchQueryCallbacks(){return this.head?.getAllBatchQueryCallbacks()??[]}};c();u();p();m();d();l();var An=class{constructor(t){this.name=t}};function ea(e){return e instanceof An}function ta(e){return new An(e)}c();u();p();m();d();l();c();u();p();m();d();l();var ra=Symbol(),dr=class{constructor(t){if(t!==ra)throw new Error("Skip instance can not be constructed directly")}ifUndefined(t){return t===void 0?Rn:t}},Rn=new dr(ra);function ke(e){return e instanceof dr}var qp={findUnique:"findUnique",findUniqueOrThrow:"findUniqueOrThrow",findFirst:"findFirst",findFirstOrThrow:"findFirstOrThrow",findMany:"findMany",count:"aggregate",create:"createOne",createMany:"createMany",createManyAndReturn:"createManyAndReturn",update:"updateOne",updateMany:"updateMany",updateManyAndReturn:"updateManyAndReturn",upsert:"upsertOne",delete:"deleteOne",deleteMany:"deleteMany",executeRaw:"executeRaw",queryRaw:"queryRaw",aggregate:"aggregate",groupBy:"groupBy",runCommandRaw:"runCommandRaw",findRaw:"findRaw",aggregateRaw:"aggregateRaw"},na="explicitly `undefined` values are not allowed";function Cn({modelName:e,action:t,args:r,runtimeDataModel:n,extensions:i=Ct.empty(),callsite:o,clientMethod:s,errorFormat:a,clientVersion:f,previewFeatures:w,globalOmit:A}){let R=new Mi({runtimeDataModel:n,modelName:e,action:t,rootArgs:r,callsite:o,extensions:i,selectionPath:[],argumentPath:[],originalMethod:s,errorFormat:a,clientVersion:f,previewFeatures:w,globalOmit:A});return{modelName:e,action:qp[t],query:fr(r,R)}}function fr({select:e,include:t,...r}={},n){let i=r.omit;return delete r.omit,{arguments:oa(r,n),selection:Bp(e,t,i,n)}}function Bp(e,t,r,n){return e?(t?n.throwValidationError({kind:"MutuallyExclusiveFields",firstField:"include",secondField:"select",selectionPath:n.getSelectionPath()}):r&&n.throwValidationError({kind:"MutuallyExclusiveFields",firstField:"omit",secondField:"select",selectionPath:n.getSelectionPath()}),Gp(e,n)):jp(n,t,r)}function jp(e,t,r){let n={};return e.modelOrType&&!e.isRawAction()&&(n.$composites=!0,n.$scalars=!0),t&&Qp(n,t,e),Hp(n,r,e),n}function Qp(e,t,r){for(let[n,i]of Object.entries(t)){if(ke(i))continue;let o=r.nestSelection(n);if(Ni(i,o),i===!1||i===void 0){e[n]=!1;continue}let s=r.findField(n);if(s&&s.kind!=="object"&&r.throwValidationError({kind:"IncludeOnScalar",selectionPath:r.getSelectionPath().concat(n),outputType:r.getOutputTypeDescription()}),s){e[n]=fr(i===!0?{}:i,o);continue}if(i===!0){e[n]=!0;continue}e[n]=fr(i,o)}}function Hp(e,t,r){let n=r.getComputedFields(),i={...r.getGlobalOmit(),...t},o=Xs(i,n);for(let[s,a]of Object.entries(o)){if(ke(a))continue;Ni(a,r.nestSelection(s));let f=r.findField(s);n?.[s]&&!f||(e[s]=!a)}}function Gp(e,t){let r={},n=t.getComputedFields(),i=Zs(e,n);for(let[o,s]of Object.entries(i)){if(ke(s))continue;let a=t.nestSelection(o);Ni(s,a);let f=t.findField(o);if(!(n?.[o]&&!f)){if(s===!1||s===void 0||ke(s)){r[o]=!1;continue}if(s===!0){f?.kind==="object"?r[o]=fr({},a):r[o]=!0;continue}r[o]=fr(s,a)}}return r}function ia(e,t){if(e===null)return null;if(typeof e=="string"||typeof e=="number"||typeof e=="boolean")return e;if(typeof e=="bigint")return{$type:"BigInt",value:String(e)};if(wt(e)){if(mn(e))return{$type:"DateTime",value:e.toISOString()};t.throwValidationError({kind:"InvalidArgumentValue",selectionPath:t.getSelectionPath(),argumentPath:t.getArgumentPath(),argument:{name:t.getArgumentName(),typeNames:["Date"]},underlyingError:"Provided Date object is invalid"})}if(ea(e))return{$type:"Param",value:e.name};if(At(e))return{$type:"FieldRef",value:{_ref:e.name,_container:e.modelName}};if(Array.isArray(e))return Jp(e,t);if(ArrayBuffer.isView(e)){let{buffer:r,byteOffset:n,byteLength:i}=e;return{$type:"Bytes",value:y.from(r,n,i).toString("base64")}}if(Wp(e))return e.values;if(bt(e))return{$type:"Decimal",value:e.toFixed()};if(e instanceof Ne){if(e!==En.instances[e._getName()])throw new Error("Invalid ObjectEnumValue");return{$type:"Enum",value:e._getName()}}if(Kp(e))return e.toJSON();if(typeof e=="object")return oa(e,t);t.throwValidationError({kind:"InvalidArgumentValue",selectionPath:t.getSelectionPath(),argumentPath:t.getArgumentPath(),argument:{name:t.getArgumentName(),typeNames:[]},underlyingError:`We could not serialize ${Object.prototype.toString.call(e)} value. Serialize the object to JSON or implement a ".toJSON()" method on it`})}function oa(e,t){if(e.$type)return{$type:"Raw",value:e};let r={};for(let n in e){let i=e[n],o=t.nestArgument(n);ke(i)||(i!==void 0?r[n]=ia(i,o):t.isPreviewFeatureOn("strictUndefinedChecks")&&t.throwValidationError({kind:"InvalidArgumentValue",argumentPath:o.getArgumentPath(),selectionPath:t.getSelectionPath(),argument:{name:t.getArgumentName(),typeNames:[]},underlyingError:na}))}return r}function Jp(e,t){let r=[];for(let n=0;n({name:t.name,typeName:"boolean",isRelation:t.kind==="object"}))}}isRawAction(){return["executeRaw","queryRaw","runCommandRaw","findRaw","aggregateRaw"].includes(this.params.action)}isPreviewFeatureOn(t){return this.params.previewFeatures.includes(t)}getComputedFields(){if(this.params.modelName)return this.params.extensions.getAllComputedFields(this.params.modelName)}findField(t){return this.modelOrType?.fields.find(r=>r.name===t)}nestSelection(t){let r=this.findField(t),n=r?.kind==="object"?r.type:void 0;return new e({...this.params,modelName:n,selectionPath:this.params.selectionPath.concat(t)})}getGlobalOmit(){return this.params.modelName&&this.shouldApplyGlobalOmit()?this.params.globalOmit?.[qe(this.params.modelName)]??{}:{}}shouldApplyGlobalOmit(){switch(this.params.action){case"findFirst":case"findFirstOrThrow":case"findUniqueOrThrow":case"findMany":case"upsert":case"findUnique":case"createManyAndReturn":case"create":case"update":case"updateManyAndReturn":case"delete":return!0;case"executeRaw":case"aggregateRaw":case"runCommandRaw":case"findRaw":case"createMany":case"deleteMany":case"groupBy":case"updateMany":case"count":case"aggregate":case"queryRaw":return!1;default:Me(this.params.action,"Unknown action")}}nestArgument(t){return new e({...this.params,argumentPath:this.params.argumentPath.concat(t)})}};c();u();p();m();d();l();function sa(e){if(!e._hasPreviewFlag("metrics"))throw new ie("`metrics` preview feature must be enabled in order to access metrics API",{clientVersion:e._clientVersion})}var St=class{_client;constructor(t){this._client=t}prometheus(t){return sa(this._client),this._client._engine.metrics({format:"prometheus",...t})}json(t){return sa(this._client),this._client._engine.metrics({format:"json",...t})}};c();u();p();m();d();l();function aa(e,t){let r=nr(()=>zp(t));Object.defineProperty(e,"dmmf",{get:()=>r.get()})}function zp(e){throw new Error("Prisma.dmmf is not available when running in edge runtimes.")}function Li(e){return Object.entries(e).map(([t,r])=>({name:t,...r}))}c();u();p();m();d();l();var Ui=new WeakMap,Sn="$$PrismaTypedSql",gr=class{constructor(t,r){Ui.set(this,{sql:t,values:r}),Object.defineProperty(this,Sn,{value:Sn})}get sql(){return Ui.get(this).sql}get values(){return Ui.get(this).values}};function la(e){return(...t)=>new gr(e,t)}function In(e){return e!=null&&e[Sn]===Sn}c();u();p();m();d();l();var eu=$e(Pi());c();u();p();m();d();l();ca();gs();xs();c();u();p();m();d();l();var fe=class e{constructor(t,r){if(t.length-1!==r.length)throw t.length===0?new TypeError("Expected at least 1 string"):new TypeError(`Expected ${t.length} strings to have ${t.length-1} values`);let n=r.reduce((s,a)=>s+(a instanceof e?a.values.length:1),0);this.values=new Array(n),this.strings=new Array(n+1),this.strings[0]=t[0];let i=0,o=0;for(;ie.getPropertyValue(r))},getPropertyDescriptor(r){return e.getPropertyDescriptor?.(r)}}}c();u();p();m();d();l();c();u();p();m();d();l();var On={enumerable:!0,configurable:!0,writable:!0};function Dn(e){let t=new Set(e);return{getPrototypeOf:()=>Object.prototype,getOwnPropertyDescriptor:()=>On,has:(r,n)=>t.has(n),set:(r,n,i)=>t.add(n)&&Reflect.set(r,n,i),ownKeys:()=>[...t]}}var ma=Symbol.for("nodejs.util.inspect.custom");function Pe(e,t){let r=Yp(t),n=new Set,i=new Proxy(e,{get(o,s){if(n.has(s))return o[s];let a=r.get(s);return a?a.getPropertyValue(s):o[s]},has(o,s){if(n.has(s))return!0;let a=r.get(s);return a?a.has?.(s)??!0:Reflect.has(o,s)},ownKeys(o){let s=da(Reflect.ownKeys(o),r),a=da(Array.from(r.keys()),r);return[...new Set([...s,...a,...n])]},set(o,s,a){return r.get(s)?.getPropertyDescriptor?.(s)?.writable===!1?!1:(n.add(s),Reflect.set(o,s,a))},getOwnPropertyDescriptor(o,s){let a=Reflect.getOwnPropertyDescriptor(o,s);if(a&&!a.configurable)return a;let f=r.get(s);return f?f.getPropertyDescriptor?{...On,...f?.getPropertyDescriptor(s)}:On:a},defineProperty(o,s,a){return n.add(s),Reflect.defineProperty(o,s,a)},getPrototypeOf:()=>Object.prototype});return i[ma]=function(){let o={...this};return delete o[ma],o},i}function Yp(e){let t=new Map;for(let r of e){let n=r.getKeys();for(let i of n)t.set(i,r)}return t}function da(e,t){return e.filter(r=>t.get(r)?.has?.(r)??!0)}c();u();p();m();d();l();function It(e){return{getKeys(){return e},has(){return!1},getPropertyValue(){}}}c();u();p();m();d();l();function kt(e,t){return{batch:e,transaction:t?.kind==="batch"?{isolationLevel:t.options.isolationLevel}:void 0}}c();u();p();m();d();l();function fa(e){if(e===void 0)return"";let t=Rt(e);return new Et(0,{colors:hn}).write(t).toString()}c();u();p();m();d();l();var Zp="P2037";function _n({error:e,user_facing_error:t},r,n){return t.error_code?new X(Xp(t,n),{code:t.error_code,clientVersion:r,meta:t.meta,batchRequestIdx:t.batch_request_idx}):new ne(e,{clientVersion:r,batchRequestIdx:t.batch_request_idx})}function Xp(e,t){let r=e.message;return(t==="postgresql"||t==="postgres"||t==="mysql")&&e.error_code===Zp&&(r+=` -Prisma Accelerate has built-in connection pooling to prevent such errors: https://pris.ly/client/error-accelerate`),r}c();u();p();m();d();l();c();u();p();m();d();l();c();u();p();m();d();l();c();u();p();m();d();l();c();u();p();m();d();l();var Vi=class{getLocation(){return null}};function je(e){return typeof $EnabledCallSite=="function"&&e!=="minimal"?new $EnabledCallSite:new Vi}c();u();p();m();d();l();c();u();p();m();d();l();c();u();p();m();d();l();var ga={_avg:!0,_count:!0,_sum:!0,_min:!0,_max:!0};function Ot(e={}){let t=tm(e);return Object.entries(t).reduce((n,[i,o])=>(ga[i]!==void 0?n.select[i]={select:o}:n[i]=o,n),{select:{}})}function tm(e={}){return typeof e._count=="boolean"?{...e,_count:{_all:e._count}}:e}function Mn(e={}){return t=>(typeof e._count=="boolean"&&(t._count=t._count._all),t)}function ya(e,t){let r=Mn(e);return t({action:"aggregate",unpacker:r,argsMapper:Ot})(e)}c();u();p();m();d();l();function rm(e={}){let{select:t,...r}=e;return typeof t=="object"?Ot({...r,_count:t}):Ot({...r,_count:{_all:!0}})}function nm(e={}){return typeof e.select=="object"?t=>Mn(e)(t)._count:t=>Mn(e)(t)._count._all}function ha(e,t){return t({action:"count",unpacker:nm(e),argsMapper:rm})(e)}c();u();p();m();d();l();function im(e={}){let t=Ot(e);if(Array.isArray(t.by))for(let r of t.by)typeof r=="string"&&(t.select[r]=!0);else typeof t.by=="string"&&(t.select[t.by]=!0);return t}function om(e={}){return t=>(typeof e?._count=="boolean"&&t.forEach(r=>{r._count=r._count._all}),t)}function wa(e,t){return t({action:"groupBy",unpacker:om(e),argsMapper:im})(e)}function ba(e,t,r){if(t==="aggregate")return n=>ya(n,r);if(t==="count")return n=>ha(n,r);if(t==="groupBy")return n=>wa(n,r)}c();u();p();m();d();l();function Ea(e,t){let r=t.fields.filter(i=>!i.relationName),n=Os(r,"name");return new Proxy({},{get(i,o){if(o in i||typeof o=="symbol")return i[o];let s=n[o];if(s)return new lr(e,o,s.type,s.isList,s.kind==="enum")},...Dn(Object.keys(n))})}c();u();p();m();d();l();c();u();p();m();d();l();var xa=e=>Array.isArray(e)?e:e.split("."),qi=(e,t)=>xa(t).reduce((r,n)=>r&&r[n],e),Pa=(e,t,r)=>xa(t).reduceRight((n,i,o,s)=>Object.assign({},qi(e,s.slice(0,o)),{[i]:n}),r);function sm(e,t){return e===void 0||t===void 0?[]:[...t,"select",e]}function am(e,t,r){return t===void 0?e??{}:Pa(t,r,e||!0)}function Bi(e,t,r,n,i,o){let a=e._runtimeDataModel.models[t].fields.reduce((f,w)=>({...f,[w.name]:w}),{});return f=>{let w=je(e._errorFormat),A=sm(n,i),R=am(f,o,A),S=r({dataPath:A,callsite:w})(R),C=lm(e,t);return new Proxy(S,{get(L,k){if(!C.includes(k))return L[k];let De=[a[k].type,r,k],ue=[A,R];return Bi(e,...De,...ue)},...Dn([...C,...Object.getOwnPropertyNames(S)])})}}function lm(e,t){return e._runtimeDataModel.models[t].fields.filter(r=>r.kind==="object").map(r=>r.name)}var cm=["findUnique","findUniqueOrThrow","findFirst","findFirstOrThrow","create","update","upsert","delete"],um=["aggregate","count","groupBy"];function ji(e,t){let r=e._extensions.getAllModelExtensions(t)??{},n=[pm(e,t),dm(e,t),yr(r),le("name",()=>t),le("$name",()=>t),le("$parent",()=>e._appliedParent)];return Pe({},n)}function pm(e,t){let r=Ie(t),n=Object.keys(ir).concat("count");return{getKeys(){return n},getPropertyValue(i){let o=i,s=a=>f=>{let w=je(e._errorFormat);return e._createPrismaPromise(A=>{let R={args:f,dataPath:[],action:o,model:t,clientMethod:`${r}.${i}`,jsModelName:r,transaction:A,callsite:w};return e._request({...R,...a})},{action:o,args:f,model:t})};return cm.includes(o)?Bi(e,t,s):mm(i)?ba(e,i,s):s({})}}}function mm(e){return um.includes(e)}function dm(e,t){return et(le("fields",()=>{let r=e._runtimeDataModel.models[t];return Ea(t,r)}))}c();u();p();m();d();l();function Ta(e){return e.replace(/^./,t=>t.toUpperCase())}var Qi=Symbol();function hr(e){let t=[fm(e),gm(e),le(Qi,()=>e),le("$parent",()=>e._appliedParent)],r=e._extensions.getAllClientExtensions();return r&&t.push(yr(r)),Pe(e,t)}function fm(e){let t=Object.getPrototypeOf(e._originalClient),r=[...new Set(Object.getOwnPropertyNames(t))];return{getKeys(){return r},getPropertyValue(n){return e[n]}}}function gm(e){let t=Object.keys(e._runtimeDataModel.models),r=t.map(Ie),n=[...new Set(t.concat(r))];return et({getKeys(){return n},getPropertyValue(i){let o=Ta(i);if(e._runtimeDataModel.models[o]!==void 0)return ji(e,o);if(e._runtimeDataModel.models[i]!==void 0)return ji(e,i)},getPropertyDescriptor(i){if(!r.includes(i))return{enumerable:!1}}})}function va(e){return e[Qi]?e[Qi]:e}function Aa(e){if(typeof e=="function")return e(this);if(e.client?.__AccelerateEngine){let r=e.client.__AccelerateEngine;this._originalClient._engine=new r(this._originalClient._accelerateEngineConfig)}let t=Object.create(this._originalClient,{_extensions:{value:this._extensions.append(e)},_appliedParent:{value:this,configurable:!0},$on:{value:void 0}});return hr(t)}c();u();p();m();d();l();c();u();p();m();d();l();function Ra({result:e,modelName:t,select:r,omit:n,extensions:i}){let o=i.getAllComputedFields(t);if(!o)return e;let s=[],a=[];for(let f of Object.values(o)){if(n){if(n[f.name])continue;let w=f.needs.filter(A=>n[A]);w.length>0&&a.push(It(w))}else if(r){if(!r[f.name])continue;let w=f.needs.filter(A=>!r[A]);w.length>0&&a.push(It(w))}ym(e,f.needs)&&s.push(hm(f,Pe(e,s)))}return s.length>0||a.length>0?Pe(e,[...s,...a]):e}function ym(e,t){return t.every(r=>Ri(e,r))}function hm(e,t){return et(le(e.name,()=>e.compute(t)))}c();u();p();m();d();l();function Nn({visitor:e,result:t,args:r,runtimeDataModel:n,modelName:i}){if(Array.isArray(t)){for(let s=0;sA.name===o);if(!f||f.kind!=="object"||!f.relationName)continue;let w=typeof s=="object"?s:{};t[o]=Nn({visitor:i,result:t[o],args:w,modelName:f.type,runtimeDataModel:n})}}function Sa({result:e,modelName:t,args:r,extensions:n,runtimeDataModel:i,globalOmit:o}){return n.isEmpty()||e==null||typeof e!="object"||!i.models[t]?e:Nn({result:e,args:r??{},modelName:t,runtimeDataModel:i,visitor:(a,f,w)=>{let A=Ie(f);return Ra({result:a,modelName:A,select:w.select,omit:w.select?void 0:{...o?.[A],...w.omit},extensions:n})}})}c();u();p();m();d();l();c();u();p();m();d();l();l();c();u();p();m();d();l();var wm=["$connect","$disconnect","$on","$transaction","$extends"],Ia=wm;function ka(e){if(e instanceof fe)return bm(e);if(In(e))return Em(e);if(Array.isArray(e)){let r=[e[0]];for(let n=1;n{let o=t.customDataProxyFetch;return"transaction"in t&&i!==void 0&&(t.transaction?.kind==="batch"&&t.transaction.lock.then(),t.transaction=i),n===r.length?e._executeRequest(t):r[n]({model:t.model,operation:t.model?t.action:t.clientMethod,args:ka(t.args??{}),__internalParams:t,query:(s,a=t)=>{let f=a.customDataProxyFetch;return a.customDataProxyFetch=La(o,f),a.args=s,Da(e,a,r,n+1)}})})}function _a(e,t){let{jsModelName:r,action:n,clientMethod:i}=t,o=r?n:i;if(e._extensions.isEmpty())return e._executeRequest(t);let s=e._extensions.getAllQueryCallbacks(r??"$none",o);return Da(e,t,s)}function Ma(e){return t=>{let r={requests:t},n=t[0].extensions.getAllBatchQueryCallbacks();return n.length?Na(r,n,0,e):e(r)}}function Na(e,t,r,n){if(r===t.length)return n(e);let i=e.customDataProxyFetch,o=e.requests[0].transaction;return t[r]({args:{queries:e.requests.map(s=>({model:s.modelName,operation:s.action,args:s.args})),transaction:o?{isolationLevel:o.kind==="batch"?o.isolationLevel:void 0}:void 0},__internalParams:e,query(s,a=e){let f=a.customDataProxyFetch;return a.customDataProxyFetch=La(i,f),Na(a,t,r+1,n)}})}var Oa=e=>e;function La(e=Oa,t=Oa){return r=>e(t(r))}c();u();p();m();d();l();var Ua=K("prisma:client"),Fa={Vercel:"vercel","Netlify CI":"netlify"};function $a({postinstall:e,ciName:t,clientVersion:r,generator:n}){if(Ua("checkPlatformCaching:postinstall",e),Ua("checkPlatformCaching:ciName",t),e===!0&&!(n?.output&&typeof(n.output.fromEnvVar??n.output.value)=="string")&&t&&t in Fa){let i=`Prisma has detected that this project was built on ${t}, which caches dependencies. This leads to an outdated Prisma Client because Prisma's auto-generation isn't triggered. To fix this, make sure to run the \`prisma generate\` command during the build process. - -Learn how: https://pris.ly/d/${Fa[t]}-build`;throw console.error(i),new F(i,r)}}c();u();p();m();d();l();function Va(e,t){return e?e.datasources?e.datasources:e.datasourceUrl?{[t[0]]:{url:e.datasourceUrl}}:{}:{}}c();u();p();m();d();l();c();u();p();m();d();l();c();u();p();m();d();l();c();u();p();m();d();l();function qa(e){return e?e.replace(/".*"/g,'"X"').replace(/[\s:\[]([+-]?([0-9]*[.])?[0-9]+)/g,t=>`${t[0]}5`):""}c();u();p();m();d();l();function Ba(e){return e.split(` -`).map(t=>t.replace(/^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z)\s*/,"").replace(/\+\d+\s*ms$/,"")).join(` -`)}c();u();p();m();d();l();var ja=$e(Ss());function Qa({title:e,user:t="prisma",repo:r="prisma",template:n="bug_report.yml",body:i}){return(0,ja.default)({user:t,repo:r,template:n,title:e,body:i})}function Ha({version:e,binaryTarget:t,title:r,description:n,engineVersion:i,database:o,query:s}){let a=ms(6e3-(s?.length??0)),f=Ba(ht(a)),w=n?`# Description -\`\`\` -${n} -\`\`\``:"",A=ht(`Hi Prisma Team! My Prisma Client just crashed. This is the report: -## Versions - -| Name | Version | -|-----------------|--------------------| -| Node | ${g.version?.padEnd(19)}| -| OS | ${t?.padEnd(19)}| -| Prisma Client | ${e?.padEnd(19)}| -| Query Engine | ${i?.padEnd(19)}| -| Database | ${o?.padEnd(19)}| - -${w} - -## Logs -\`\`\` -${f} -\`\`\` - -## Client Snippet -\`\`\`ts -// PLEASE FILL YOUR CODE SNIPPET HERE -\`\`\` - -## Schema -\`\`\`prisma -// PLEASE ADD YOUR SCHEMA HERE IF POSSIBLE -\`\`\` - -## Prisma Engine Query -\`\`\` -${s?qa(s):""} -\`\`\` -`),R=Qa({title:r,body:A});return`${r} - -This is a non-recoverable error which probably happens when the Prisma Query Engine has a panic. - -${tn(R)} - -If you want the Prisma team to look into it, please open the link above \u{1F64F} -To increase the chance of success, please post your schema and a snippet of -how you used Prisma Client in the issue. -`}c();u();p();m();d();l();c();u();p();m();d();l();c();u();p();m();d();l();c();u();p();m();d();l();l();c();u();p();m();d();l();l();function $(e,t){throw new Error(t)}function Hi(e,t){return e===t||e!==null&&t!==null&&typeof e=="object"&&typeof t=="object"&&Object.keys(e).length===Object.keys(t).length&&Object.keys(e).every(r=>Hi(e[r],t[r]))}function Dt(e,t){let r=Object.keys(e),n=Object.keys(t);return(r.length{if(typeof e[o]==typeof t[o]&&typeof e[o]!="object")return e[o]===t[o];if(se.isDecimal(e[o])||se.isDecimal(t[o])){let s=Ga(e[o]),a=Ga(t[o]);return s&&a&&s.equals(a)}else if(e[o]instanceof Uint8Array||t[o]instanceof Uint8Array){let s=Ja(e[o]),a=Ja(t[o]);return s&&a&&s.equals(a)}else{if(e[o]instanceof Date||t[o]instanceof Date)return Wa(e[o])?.getTime()===Wa(t[o])?.getTime();if(typeof e[o]=="bigint"||typeof t[o]=="bigint")return Ka(e[o])===Ka(t[o]);if(typeof e[o]=="number"||typeof t[o]=="number")return za(e[o])===za(t[o])}return Hi(e[o],t[o])})}function Ga(e){return se.isDecimal(e)?e:typeof e=="number"||typeof e=="string"?new se(e):void 0}function Ja(e){return y.isBuffer(e)?e:e instanceof Uint8Array?y.from(e.buffer,e.byteOffset,e.byteLength):typeof e=="string"?y.from(e,"base64"):void 0}function Wa(e){return e instanceof Date?e:typeof e=="string"||typeof e=="number"?new Date(e):void 0}function Ka(e){return typeof e=="bigint"?e:typeof e=="number"||typeof e=="string"?BigInt(e):void 0}function za(e){return typeof e=="number"?e:typeof e=="string"?Number(e):void 0}function br(e){return JSON.stringify(e,(t,r)=>typeof r=="bigint"?r.toString():ArrayBuffer.isView(r)?y.from(r.buffer,r.byteOffset,r.byteLength).toString("base64"):r)}function xm(e){return e!==null&&typeof e=="object"&&typeof e.$type=="string"}function Pm(e,t){let r={};for(let n of Object.keys(e))r[n]=t(e[n],n);return r}function Qe(e){return e===null?e:Array.isArray(e)?e.map(Qe):typeof e=="object"?xm(e)?Tm(e):e.constructor!==null&&e.constructor.name!=="Object"?e:Pm(e,Qe):e}function Tm({$type:e,value:t}){switch(e){case"BigInt":return BigInt(t);case"Bytes":{let{buffer:r,byteOffset:n,byteLength:i}=y.from(t,"base64");return new Uint8Array(r,n,i)}case"DateTime":return new Date(t);case"Decimal":return new v(t);case"Json":return JSON.parse(t);default:$(t,"Unknown tagged value")}}c();u();p();m();d();l();var ce=class extends Error{name="UserFacingError";code;meta;constructor(t,r,n){super(t),this.code=r,this.meta=n??{}}toQueryResponseErrorObject(){return{error:this.message,user_facing_error:{is_panic:!1,message:this.message,meta:this.meta,error_code:this.code}}}};function _t(e){if(!nn(e))throw e;let t=vm(e),r=Ya(e);throw!t||!r?e:new ce(r,t,{driverAdapterError:e})}function Ji(e){throw nn(e)?new ce(`Raw query failed. Code: \`${e.cause.originalCode??"N/A"}\`. Message: \`${e.cause.originalMessage??Ya(e)}\``,"P2010",{driverAdapterError:e}):e}function vm(e){switch(e.cause.kind){case"AuthenticationFailed":return"P1000";case"DatabaseNotReachable":return"P1001";case"DatabaseDoesNotExist":return"P1003";case"SocketTimeout":return"P1008";case"DatabaseAlreadyExists":return"P1009";case"DatabaseAccessDenied":return"P1010";case"TlsConnectionError":return"P1011";case"ConnectionClosed":return"P1017";case"TransactionAlreadyClosed":return"P1018";case"LengthMismatch":return"P2000";case"UniqueConstraintViolation":return"P2002";case"ForeignKeyConstraintViolation":return"P2003";case"UnsupportedNativeDataType":return"P2010";case"NullConstraintViolation":return"P2011";case"ValueOutOfRange":return"P2020";case"TableDoesNotExist":return"P2021";case"ColumnNotFound":return"P2022";case"InvalidIsolationLevel":case"InconsistentColumnData":return"P2023";case"MissingFullTextSearchIndex":return"P2030";case"TransactionWriteConflict":return"P2034";case"GenericJs":return"P2036";case"TooManyConnections":return"P2037";case"postgres":case"sqlite":case"mysql":case"mssql":return;default:$(e.cause,`Unknown error: ${e.cause}`)}}function Ya(e){switch(e.cause.kind){case"AuthenticationFailed":return`Authentication failed against the database server, the provided database credentials for \`${e.cause.user??"(not available)"}\` are not valid`;case"DatabaseNotReachable":{let t=e.cause.host&&e.cause.port?`${e.cause.host}:${e.cause.port}`:e.cause.host;return`Can't reach database server${t?` at ${t}`:""}`}case"DatabaseDoesNotExist":return`Database \`${e.cause.db??"(not available)"}\` does not exist on the database server`;case"SocketTimeout":return"Operation has timed out";case"DatabaseAlreadyExists":return`Database \`${e.cause.db??"(not available)"}\` already exists on the database server`;case"DatabaseAccessDenied":return`User was denied access on the database \`${e.cause.db??"(not available)"}\``;case"TlsConnectionError":return`Error opening a TLS connection: ${e.cause.reason}`;case"ConnectionClosed":return"Server has closed the connection.";case"TransactionAlreadyClosed":return e.cause.cause;case"LengthMismatch":return`The provided value for the column is too long for the column's type. Column: ${e.cause.column??"(not available)"}`;case"UniqueConstraintViolation":return`Unique constraint failed on the ${Gi(e.cause.constraint)}`;case"ForeignKeyConstraintViolation":return`Foreign key constraint violated on the ${Gi(e.cause.constraint)}`;case"UnsupportedNativeDataType":return`Failed to deserialize column of type '${e.cause.type}'. If you're using $queryRaw and this column is explicitly marked as \`Unsupported\` in your Prisma schema, try casting this column to any supported Prisma type such as \`String\`.`;case"NullConstraintViolation":return`Null constraint violation on the ${Gi(e.cause.constraint)}`;case"ValueOutOfRange":return`Value out of range for the type: ${e.cause.cause}`;case"TableDoesNotExist":return`The table \`${e.cause.table??"(not available)"}\` does not exist in the current database.`;case"ColumnNotFound":return`The column \`${e.cause.column??"(not available)"}\` does not exist in the current database.`;case"InvalidIsolationLevel":return`Error in connector: Conversion error: ${e.cause.level}`;case"InconsistentColumnData":return`Inconsistent column data: ${e.cause.cause}`;case"MissingFullTextSearchIndex":return"Cannot find a fulltext index to use for the native search, try adding a @@fulltext([Fields...]) to your schema";case"TransactionWriteConflict":return"Transaction failed due to a write conflict or a deadlock. Please retry your transaction";case"GenericJs":return`Error in external connector (id ${e.cause.id})`;case"TooManyConnections":return`Too many database connections opened: ${e.cause.cause}`;case"sqlite":case"postgres":case"mysql":case"mssql":return;default:$(e.cause,`Unknown error: ${e.cause}`)}}function Gi(e){return e&&"fields"in e?`fields: (${e.fields.map(t=>`\`${t}\``).join(", ")})`:e&&"index"in e?`constraint: \`${e.index}\``:e&&"foreignKey"in e?"foreign key":"(not available)"}function Za(e,t){let r=e.map(i=>t.keys.reduce((o,s)=>(o[s]=Qe(i[s]),o),{})),n=new Set(t.nestedSelection);return t.arguments.map(i=>{let o=r.findIndex(s=>Dt(s,i));if(o===-1)return t.expectNonEmpty?new ce("An operation failed because it depends on one or more records that were required but not found","P2025"):null;{let s=Object.entries(e[o]).filter(([a])=>n.has(a));return Object.fromEntries(s)}})}c();u();p();m();d();l();l();var G=class extends Error{name="DataMapperError"};function el(e,t,r){switch(t.type){case"affectedRows":if(typeof e!="number")throw new G(`Expected an affected rows count, got: ${typeof e} (${e})`);return{count:e};case"object":return Ki(e,t.fields,r,t.skipNulls);case"field":return Wi(e,"",t.fieldType,r);default:$(t,`Invalid data mapping type: '${t.type}'`)}}function Ki(e,t,r,n){if(e===null)return null;if(Array.isArray(e)){let i=e;return n&&(i=i.filter(o=>o!==null)),i.map(o=>Xa(o,t,r))}if(typeof e=="object")return Xa(e,t,r);if(typeof e=="string"){let i;try{i=JSON.parse(e)}catch(o){throw new G("Expected an array or object, got a string that is not valid JSON",{cause:o})}return Ki(i,t,r,n)}throw new G(`Expected an array or an object, got: ${typeof e}`)}function Xa(e,t,r){if(typeof e!="object")throw new G(`Expected an object, but got '${typeof e}'`);let n={};for(let[i,o]of Object.entries(t))switch(o.type){case"affectedRows":throw new G(`Unexpected 'AffectedRows' node in data mapping for field '${i}'`);case"object":{if(o.serializedName!==null&&!Object.hasOwn(e,o.serializedName))throw new G(`Missing data field (Object): '${i}'; node: ${JSON.stringify(o)}; data: ${JSON.stringify(e)}`);let s=o.serializedName!==null?e[o.serializedName]:e;n[i]=Ki(s,o.fields,r,o.skipNulls);break}case"field":{let s=o.dbName;if(Object.hasOwn(e,s))n[i]=Am(e[s],s,o.fieldType,r);else throw new G(`Missing data field (Value): '${s}'; node: ${JSON.stringify(o)}; data: ${JSON.stringify(e)}`)}break;default:$(o,`DataMapper: Invalid data mapping node type: '${o.type}'`)}return n}function Am(e,t,r,n){return e===null?r.arity==="list"?[]:null:r.arity==="list"?e.map((o,s)=>Wi(o,`${t}[${s}]`,r,n)):Wi(e,t,r,n)}function Wi(e,t,r,n){switch(r.type){case"unsupported":return e;case"string":{if(typeof e!="string")throw new G(`Expected a string in column '${t}', got ${typeof e}: ${e}`);return e}case"int":switch(typeof e){case"number":return Math.trunc(e);case"string":{let i=Math.trunc(Number(e));if(Number.isNaN(i)||!Number.isFinite(i))throw new G(`Expected an integer in column '${t}', got string: ${e}`);if(!Number.isSafeInteger(i))throw new G(`Integer value in column '${t}' is too large to represent as a JavaScript number without loss of precision, got: ${e}. Consider using BigInt type.`);return i}default:throw new G(`Expected an integer in column '${t}', got ${typeof e}: ${e}`)}case"bigint":{if(typeof e!="number"&&typeof e!="string")throw new G(`Expected a bigint in column '${t}', got ${typeof e}: ${e}`);return{$type:"BigInt",value:e}}case"float":{if(typeof e=="number")return e;if(typeof e=="string"){let i=Number(e);if(Number.isNaN(i)&&!/^[-+]?nan$/.test(e.toLowerCase()))throw new G(`Expected a float in column '${t}', got string: ${e}`);return i}throw new G(`Expected a float in column '${t}', got ${typeof e}: ${e}`)}case"boolean":{if(typeof e=="boolean")return e;if(typeof e=="number")return e===1;if(typeof e=="string"){if(e==="true"||e==="TRUE"||e==="1")return!0;if(e==="false"||e==="FALSE"||e==="0")return!1;throw new G(`Expected a boolean in column '${t}', got ${typeof e}: ${e}`)}if(Array.isArray(e)){for(let i of e)if(i!==0)return!0;return!1}throw new G(`Expected a boolean in column '${t}', got ${typeof e}: ${e}`)}case"decimal":if(typeof e!="number"&&typeof e!="string"&&!se.isDecimal(e))throw new G(`Expected a decimal in column '${t}', got ${typeof e}: ${e}`);return{$type:"Decimal",value:e};case"datetime":{if(typeof e=="string")return{$type:"DateTime",value:Cm(e)};if(typeof e=="number"||e instanceof Date)return{$type:"DateTime",value:e};throw new G(`Expected a date in column '${t}', got ${typeof e}: ${e}`)}case"object":return{$type:"Json",value:br(e)};case"json":return{$type:"Json",value:`${e}`};case"bytes":{switch(r.encoding){case"base64":if(typeof e!="string")throw new G(`Expected a base64-encoded byte array in column '${t}', got ${typeof e}: ${e}`);return{$type:"Bytes",value:e};case"hex":if(typeof e!="string"||!e.startsWith("\\x"))throw new G(`Expected a hex-encoded byte array in column '${t}', got ${typeof e}: ${e}`);return{$type:"Bytes",value:y.from(e.slice(2),"hex").toString("base64")};case"array":if(Array.isArray(e))return{$type:"Bytes",value:y.from(e).toString("base64")};if(e instanceof Uint8Array)return{$type:"Bytes",value:y.from(e).toString("base64")};throw new G(`Expected a byte array in column '${t}', got ${typeof e}: ${e}`);default:$(r.encoding,`DataMapper: Unknown bytes encoding: ${r.encoding}`)}break}case"enum":{let i=n[r.name];if(i===void 0)throw new G(`Unknown enum '${r.name}'`);let o=i[`${e}`];if(o===void 0)throw new G(`Value '${e}' not found in enum '${r.name}'`);return o}default:$(r,`DataMapper: Unknown result type: ${r.type}`)}}var Rm=/\d{2}:\d{2}:\d{2}(?:\.\d+)?(Z|[+-]\d{2}(:?\d{2})?)?$/;function Cm(e){let t=Rm.exec(e);if(t===null)return`${e}T00:00:00Z`;let r=e,[n,i,o]=t;if(i!==void 0&&i!=="Z"&&o===void 0?r=`${e}:00`:i===void 0&&(r=`${e}Z`),n.length===e.length)return`1970-01-01T${r}`;let s=t.index-1;return r[s]===" "&&(r=`${r.slice(0,s)}T${r.slice(s+1)}`),r}c();u();p();m();d();l();c();u();p();m();d();l();c();u();p();m();d();l();c();u();p();m();d();l();var Er;(function(e){e[e.INTERNAL=0]="INTERNAL",e[e.SERVER=1]="SERVER",e[e.CLIENT=2]="CLIENT",e[e.PRODUCER=3]="PRODUCER",e[e.CONSUMER=4]="CONSUMER"})(Er||(Er={}));function Sm(e){switch(e){case"postgresql":case"postgres":case"prisma+postgres":return"postgresql";case"sqlserver":return"mssql";case"mysql":case"sqlite":case"cockroachdb":case"mongodb":return e;default:$(e,`Unknown provider: ${e}`)}}async function Ln({query:e,tracingHelper:t,provider:r,onQuery:n,execute:i}){return await t.runInChildSpan({name:"db_query",kind:Er.CLIENT,attributes:{"db.query.text":e.sql,"db.system.name":Sm(r)}},async()=>{let o=new Date,s=b.now(),a=await i(),f=b.now();return n?.({timestamp:o,duration:f-s,query:e.sql,params:e.args}),a})}c();u();p();m();d();l();c();u();p();m();d();l();c();u();p();m();d();l();c();u();p();m();d();l();function tt(e,t){var r="000000000"+e;return r.substr(r.length-t)}var tl=$e(ys(),1);function Im(){try{return tl.default.hostname()}catch{return g.env._CLUSTER_NETWORK_NAME_||g.env.COMPUTERNAME||"hostname"}}var rl=2,km=tt(g.pid.toString(36),rl),nl=Im(),Om=nl.length,Dm=tt(nl.split("").reduce(function(e,t){return+e+t.charCodeAt(0)},+Om+36).toString(36),rl);function zi(){return km+Dm}c();u();p();m();d();l();c();u();p();m();d();l();function Un(e){return typeof e=="string"&&/^c[a-z0-9]{20,32}$/.test(e)}function Yi(e){let n=Math.pow(36,4),i=0;function o(){return tt((Math.random()*n<<0).toString(36),4)}function s(){return i=int.length&&(Xt.getRandomValues(nt),Lt=0),Lt+=e}function so(e=21){Ed(e|=0);let t="";for(let r=Lt-e;r{let n=new Uint8Array(1);return r.getRandomValues(n),n[0]/255};if(typeof r?.randomBytes=="function")return()=>r.randomBytes(1).readUInt8()/255;if(yt?.randomBytes)return()=>yt.randomBytes(1).readUInt8()/255;throw new ot(it.PRNGDetectFailure,"Failed to find a reliable PRNG")}function vd(){return Cd()?self:typeof window<"u"?window:typeof globalThis<"u"||typeof globalThis<"u"?globalThis:null}function Ad(e,t){let r="";for(;e>0;e--)r=Pd(t)+r;return r}function Rd(e,t=Zl){if(isNaN(e))throw new ot(it.EncodeTimeValueMalformed,`Time must be a number: ${e}`);if(e>zl)throw new ot(it.EncodeTimeSizeExceeded,`Cannot encode a time larger than ${zl}: ${e}`);if(e<0)throw new ot(it.EncodeTimeNegative,`Time must be positive: ${e}`);if(Number.isInteger(e)===!1)throw new ot(it.EncodeTimeValueMalformed,`Time must be an integer: ${e}`);let r,n="";for(let i=t;i>0;i--)r=e%Rr,n=Yl.charAt(r)+n,e=(e-r)/Rr;return n}function Cd(){return typeof WorkerGlobalScope<"u"&&self instanceof WorkerGlobalScope}function Xl(e,t){let r=t||Td(),n=!e||isNaN(e)?Date.now():e;return Rd(n,Zl)+Ad(xd,r)}c();u();p();m();d();l();c();u();p();m();d();l();var oe=[];for(let e=0;e<256;++e)oe.push((e+256).toString(16).slice(1));function qn(e,t=0){return(oe[e[t+0]]+oe[e[t+1]]+oe[e[t+2]]+oe[e[t+3]]+"-"+oe[e[t+4]]+oe[e[t+5]]+"-"+oe[e[t+6]]+oe[e[t+7]]+"-"+oe[e[t+8]]+oe[e[t+9]]+"-"+oe[e[t+10]]+oe[e[t+11]]+oe[e[t+12]]+oe[e[t+13]]+oe[e[t+14]]+oe[e[t+15]]).toLowerCase()}c();u();p();m();d();l();Xe();var jn=new Uint8Array(256),Bn=jn.length;function Ut(){return Bn>jn.length-16&&(sn(jn),Bn=0),jn.slice(Bn,Bn+=16)}c();u();p();m();d();l();c();u();p();m();d();l();Xe();var ao={randomUUID:on};function Sd(e,t,r){if(ao.randomUUID&&!t&&!e)return ao.randomUUID();e=e||{};let n=e.random??e.rng?.()??Ut();if(n.length<16)throw new Error("Random bytes length must be >= 16");if(n[6]=n[6]&15|64,n[8]=n[8]&63|128,t){if(r=r||0,r<0||r+16>t.length)throw new RangeError(`UUID byte range ${r}:${r+15} is out of buffer bounds`);for(let i=0;i<16;++i)t[r+i]=n[i];return t}return qn(n)}var lo=Sd;c();u();p();m();d();l();var co={};function Id(e,t,r){let n;if(e)n=ec(e.random??e.rng?.()??Ut(),e.msecs,e.seq,t,r);else{let i=Date.now(),o=Ut();kd(co,i,o),n=ec(o,co.msecs,co.seq,t,r)}return t??qn(n)}function kd(e,t,r){return e.msecs??=-1/0,e.seq??=0,t>e.msecs?(e.seq=r[6]<<23|r[7]<<16|r[8]<<8|r[9],e.msecs=t):(e.seq=e.seq+1|0,e.seq===0&&e.msecs++),e}function ec(e,t,r,n,i=0){if(e.length<16)throw new Error("Random bytes length must be >= 16");if(!n)n=new Uint8Array(16),i=0;else if(i<0||i+16>n.length)throw new RangeError(`UUID byte range ${i}:${i+15} is out of buffer bounds`);return t??=Date.now(),r??=e[6]*127<<24|e[7]<<16|e[8]<<8|e[9],n[i++]=t/1099511627776&255,n[i++]=t/4294967296&255,n[i++]=t/16777216&255,n[i++]=t/65536&255,n[i++]=t/256&255,n[i++]=t&255,n[i++]=112|r>>>28&15,n[i++]=r>>>20&255,n[i++]=128|r>>>14&63,n[i++]=r>>>6&255,n[i++]=r<<2&255|e[10]&3,n[i++]=e[11],n[i++]=e[12],n[i++]=e[13],n[i++]=e[14],n[i++]=e[15],n}var uo=Id;var Qn=class{#t={};constructor(){this.register("uuid",new mo),this.register("cuid",new fo),this.register("ulid",new go),this.register("nanoid",new yo),this.register("product",new ho)}snapshot(){return Object.create(this.#t,{now:{value:new po}})}register(t,r){this.#t[t]=r}},po=class{#t=new Date;generate(){return this.#t.toISOString()}},mo=class{generate(t){if(t===4)return lo();if(t===7)return uo();throw new Error("Invalid UUID generator arguments")}},fo=class{generate(t){if(t===1)return il();if(t===2)return(0,tc.createId)();throw new Error("Invalid CUID generator arguments")}},go=class{generate(){return Xl()}},yo=class{generate(t){if(typeof t=="number")return so(t);if(t===void 0)return so();throw new Error("Invalid Nanoid generator arguments")}},ho=class{generate(t,r){if(t===void 0||r===void 0)throw new Error("Invalid Product generator arguments");return Array.isArray(t)&&Array.isArray(r)?t.flatMap(n=>r.map(i=>[n,i])):Array.isArray(t)?t.map(n=>[n,r]):Array.isArray(r)?r.map(n=>[t,n]):[[t,r]]}};c();u();p();m();d();l();function Hn(e,t){return e==null?e:typeof e=="string"?Hn(JSON.parse(e),t):Array.isArray(e)?Dd(e,t):Od(e,t)}function Od(e,t){if(t.pagination){let{skip:r,take:n,cursor:i}=t.pagination;if(r!==null&&r>0||n===0||i!==null&&!Dt(e,i))return null}return nc(e,t.nested)}function nc(e,t){for(let[r,n]of Object.entries(t))e[r]=Hn(e[r],n);return e}function Dd(e,t){if(t.distinct!==null){let r=t.linkingFields!==null?[...t.distinct,...t.linkingFields]:t.distinct;e=_d(e,r)}return t.pagination&&(e=Md(e,t.pagination,t.linkingFields)),t.reverse&&e.reverse(),Object.keys(t.nested).length===0?e:e.map(r=>nc(r,t.nested))}function _d(e,t){let r=new Set,n=[];for(let i of e){let o=Ft(i,t);r.has(o)||(r.add(o),n.push(i))}return n}function Md(e,t,r){if(r===null)return rc(e,t);let n=new Map;for(let o of e){let s=Ft(o,r);n.has(s)||n.set(s,[]),n.get(s).push(o)}let i=Array.from(n.entries());return i.sort(([o],[s])=>os?1:0),i.flatMap(([,o])=>rc(o,t))}function rc(e,{cursor:t,skip:r,take:n}){let i=t!==null?e.findIndex(a=>Dt(a,t)):0;if(i===-1)return[];let o=i+(r??0),s=n!==null?o+n:e.length;return e.slice(o,s)}function Ft(e,t){return JSON.stringify(t.map(r=>e[r]))}c();u();p();m();d();l();c();u();p();m();d();l();function wo(e){return typeof e=="object"&&e!==null&&e.prisma__type==="param"}function bo(e){return typeof e=="object"&&e!==null&&e.prisma__type==="generatorCall"}function Po(e,t,r,n){let i=e.args.map(o=>Te(o,t,r));switch(e.type){case"rawSql":return[Ud(e.sql,i,e.argTypes)];case"templateSql":return(e.chunkable?$d(e.fragments,i,n):[i]).map(s=>{if(n!==void 0&&s.length>n)throw new ce("The query parameter limit supported by your database is exceeded.","P2029");return Nd(e.fragments,e.placeholderFormat,s,e.argTypes)});default:$(e.type,"Invalid query type")}}function Te(e,t,r){for(;Fd(e);)if(wo(e)){let n=t[e.prisma__value.name];if(n===void 0)throw new Error(`Missing value for query variable ${e.prisma__value.name}`);e=n}else if(bo(e)){let{name:n,args:i}=e.prisma__value,o=r[n];if(!o)throw new Error(`Encountered an unknown generator '${n}'`);e=o.generate(...i.map(s=>Te(s,t,r)))}else $(e,`Unexpected unevaluated value type: ${e}`);return Array.isArray(e)&&(e=e.map(n=>Te(n,t,r))),e}function Nd(e,t,r,n){let i="",o={placeholderNumber:1},s=[],a=[];for(let f of xo(e,r,n)){if(i+=Ld(f,t,o),f.type==="stringChunk")continue;let w=s.length,A=s.push(...ic(f))-w;if(f.argType.arity==="tuple"){if(A%f.argType.elements.length!==0)throw new Error(`Malformed query template. Expected the number of parameters to match the tuple arity, but got ${A} parameters for a tuple of arity ${f.argType.elements.length}.`);for(let R=0;REo(t,r.placeholderNumber++)).join(",")})`;case"parameterTupleList":return e.value.map(i=>{let o=i.map(()=>Eo(t,r.placeholderNumber++)).join(e.itemSeparator);return`${e.itemPrefix}${o}${e.itemSuffix}`}).join(e.groupSeparator);default:$(n,"Invalid fragment type")}}function Eo(e,t){return e.hasNumbering?`${e.prefix}${t}`:e.prefix}function Ud(e,t,r){return{sql:e,args:t,argTypes:r}}function Fd(e){return wo(e)||bo(e)}function*xo(e,t,r){let n=0;for(let i of e)switch(i.type){case"parameter":{if(n>=t.length)throw new Error(`Malformed query template. Fragments attempt to read over ${t.length} parameters.`);yield{...i,value:t[n],argType:r?.[n]},n++;break}case"stringChunk":{yield i;break}case"parameterTuple":{if(n>=t.length)throw new Error(`Malformed query template. Fragments attempt to read over ${t.length} parameters.`);let o=t[n];yield{...i,value:Array.isArray(o)?o:[o],argType:r?.[n]},n++;break}case"parameterTupleList":{if(n>=t.length)throw new Error(`Malformed query template. Fragments attempt to read over ${t.length} parameters.`);let o=t[n];if(!Array.isArray(o))throw new Error("Malformed query template. Tuple list expected.");if(o.length===0)throw new Error("Malformed query template. Tuple list cannot be empty.");for(let s of o)if(!Array.isArray(s))throw new Error("Malformed query template. Tuple expected.");yield{...i,value:o,argType:r?.[n]},n++;break}}}function*ic(e){switch(e.type){case"parameter":yield e.value;break;case"stringChunk":break;case"parameterTuple":yield*e.value;break;case"parameterTupleList":for(let t of e.value)yield*t;break}}function $d(e,t,r){let n=0,i=0;for(let s of xo(e,t,void 0)){let a=0;for(let f of ic(s))a++;i=Math.max(i,a),n+=a}let o=[[]];for(let s of xo(e,t,void 0))switch(s.type){case"parameter":{for(let a of o)a.push(s.value);break}case"stringChunk":break;case"parameterTuple":{let a=s.value.length,f=[];if(r&&o.length===1&&a===i&&n>r&&n-af.map(A=>[...w,A]));break}case"parameterTupleList":{let a=s.value.reduce((R,S)=>R+S.length,0),f=[],w=[],A=0;for(let R of s.value)r&&o.length===1&&a===i&&w.length>0&&n-a+A+R.length>r&&(f.push(w),w=[],A=0),w.push(R),A+=R.length;w.length>0&&f.push(w),o=o.flatMap(R=>f.map(S=>[...R,S]));break}}return o}function Vd(e,t){let r=[];for(let n=0;nt.reduce((r,n,i)=>(r[e.columnNames[i]]=n,r),{}))}function sc(e){return{columns:e.columnNames,types:e.columnTypes.map(t=>qd(t)),rows:e.rows.map(t=>t.map((r,n)=>$t(r,e.columnTypes[n])))}}function $t(e,t){if(e===null)return null;switch(t){case O.Int32:switch(typeof e){case"number":return Math.trunc(e);case"string":return Math.trunc(Number(e));default:throw new Error(`Cannot serialize value of type ${typeof e} as Int32`)}case O.Int32Array:if(!Array.isArray(e))throw new Error(`Cannot serialize value of type ${typeof e} as Int32Array`);return e.map(r=>$t(r,O.Int32));case O.Int64:switch(typeof e){case"number":return BigInt(Math.trunc(e));case"string":return e;default:throw new Error(`Cannot serialize value of type ${typeof e} as Int64`)}case O.Int64Array:if(!Array.isArray(e))throw new Error(`Cannot serialize value of type ${typeof e} as Int64Array`);return e.map(r=>$t(r,O.Int64));case O.Json:switch(typeof e){case"string":return JSON.parse(e);default:throw new Error(`Cannot serialize value of type ${typeof e} as Json`)}case O.JsonArray:if(!Array.isArray(e))throw new Error(`Cannot serialize value of type ${typeof e} as JsonArray`);return e.map(r=>$t(r,O.Json));case O.Bytes:if(Array.isArray(e))return new Uint8Array(e);throw new Error(`Cannot serialize value of type ${typeof e} as Bytes`);case O.BytesArray:if(!Array.isArray(e))throw new Error(`Cannot serialize value of type ${typeof e} as BytesArray`);return e.map(r=>$t(r,O.Bytes));case O.Boolean:switch(typeof e){case"boolean":return e;case"string":return e==="true"||e==="1";case"number":return e===1;default:throw new Error(`Cannot serialize value of type ${typeof e} as Boolean`)}case O.BooleanArray:if(!Array.isArray(e))throw new Error(`Cannot serialize value of type ${typeof e} as BooleanArray`);return e.map(r=>$t(r,O.Boolean));default:return e}}function qd(e){switch(e){case O.Int32:return"int";case O.Int64:return"bigint";case O.Float:return"float";case O.Double:return"double";case O.Text:return"string";case O.Enum:return"enum";case O.Bytes:return"bytes";case O.Boolean:return"bool";case O.Character:return"char";case O.Numeric:return"decimal";case O.Json:return"json";case O.Uuid:return"uuid";case O.DateTime:return"datetime";case O.Date:return"date";case O.Time:return"time";case O.Int32Array:return"int-array";case O.Int64Array:return"bigint-array";case O.FloatArray:return"float-array";case O.DoubleArray:return"double-array";case O.TextArray:return"string-array";case O.EnumArray:return"string-array";case O.BytesArray:return"bytes-array";case O.BooleanArray:return"bool-array";case O.CharacterArray:return"char-array";case O.NumericArray:return"decimal-array";case O.JsonArray:return"json-array";case O.UuidArray:return"uuid-array";case O.DateTimeArray:return"datetime-array";case O.DateArray:return"date-array";case O.TimeArray:return"time-array";case O.UnknownNumber:return"unknown";case O.Set:return"string";default:$(e,`Unexpected column type: ${e}`)}}c();u();p();m();d();l();function ac(e,t,r){if(!t.every(n=>To(e,n))){let n=Bd(e,r),i=jd(r);throw new ce(n,i,r.context)}}function To(e,t){switch(t.type){case"rowCountEq":return Array.isArray(e)?e.length===t.args:e===null?t.args===0:t.args===1;case"rowCountNeq":return Array.isArray(e)?e.length!==t.args:e===null?t.args!==0:t.args!==1;case"affectedRowCountEq":return e===t.args;case"never":return!1;default:$(t,`Unknown rule type: ${t.type}`)}}function Bd(e,t){switch(t.error_identifier){case"RELATION_VIOLATION":return`The change you are trying to make would violate the required relation '${t.context.relation}' between the \`${t.context.modelA}\` and \`${t.context.modelB}\` models.`;case"MISSING_RECORD":return`An operation failed because it depends on one or more records that were required but not found. No record was found for ${t.context.operation}.`;case"MISSING_RELATED_RECORD":{let r=t.context.neededFor?` (needed to ${t.context.neededFor})`:"";return`An operation failed because it depends on one or more records that were required but not found. No '${t.context.model}' record${r} was found for ${t.context.operation} on ${t.context.relationType} relation '${t.context.relation}'.`}case"INCOMPLETE_CONNECT_INPUT":return`An operation failed because it depends on one or more records that were required but not found. Expected ${t.context.expectedRows} records to be connected, found only ${Array.isArray(e)?e.length:e}.`;case"INCOMPLETE_CONNECT_OUTPUT":return`The required connected records were not found. Expected ${t.context.expectedRows} records to be connected after connect operation on ${t.context.relationType} relation '${t.context.relation}', found ${Array.isArray(e)?e.length:e}.`;case"RECORDS_NOT_CONNECTED":return`The records for relation \`${t.context.relation}\` between the \`${t.context.parent}\` and \`${t.context.child}\` models are not connected.`;default:$(t,`Unknown error identifier: ${t}`)}}function jd(e){switch(e.error_identifier){case"RELATION_VIOLATION":return"P2014";case"RECORDS_NOT_CONNECTED":return"P2017";case"INCOMPLETE_CONNECT_OUTPUT":return"P2018";case"MISSING_RECORD":case"MISSING_RELATED_RECORD":case"INCOMPLETE_CONNECT_INPUT":return"P2025";default:$(e,`Unknown error identifier: ${e}`)}}var Cr=class e{#t;#e;#r;#n=new Qn;#s;#i;#a;#o;#c;constructor({transactionManager:t,placeholderValues:r,onQuery:n,tracingHelper:i,serializer:o,rawSerializer:s,provider:a,connectionInfo:f}){this.#t=t,this.#e=r,this.#r=n,this.#s=i,this.#i=o,this.#a=s??o,this.#o=a,this.#c=f}static forSql(t){return new e({transactionManager:t.transactionManager,placeholderValues:t.placeholderValues,onQuery:t.onQuery,tracingHelper:t.tracingHelper,serializer:oc,rawSerializer:sc,provider:t.provider,connectionInfo:t.connectionInfo})}async run(t,r){let{value:n}=await this.interpretNode(t,r,this.#e,this.#n.snapshot()).catch(i=>_t(i));return n}async interpretNode(t,r,n,i){switch(t.type){case"value":return{value:Te(t.args,n,i)};case"seq":{let o;for(let s of t.args)o=await this.interpretNode(s,r,n,i);return o??{value:void 0}}case"get":return{value:n[t.args.name]};case"let":{let o=Object.create(n);for(let s of t.args.bindings){let{value:a}=await this.interpretNode(s.expr,r,o,i);o[s.name]=a}return this.interpretNode(t.args.expr,r,o,i)}case"getFirstNonEmpty":{for(let o of t.args.names){let s=n[o];if(!lc(s))return{value:s}}return{value:[]}}case"concat":{let o=await Promise.all(t.args.map(s=>this.interpretNode(s,r,n,i).then(a=>a.value)));return{value:o.length>0?o.reduce((s,a)=>s.concat(vo(a)),[]):[]}}case"sum":{let o=await Promise.all(t.args.map(s=>this.interpretNode(s,r,n,i).then(a=>a.value)));return{value:o.length>0?o.reduce((s,a)=>Oe(s)+Oe(a)):0}}case"execute":{let o=Po(t.args,n,i,this.#l()),s=0;for(let a of o)s+=await this.#u(a,r,()=>r.executeRaw(a).catch(f=>t.args.type==="rawSql"?Ji(f):_t(f)));return{value:s}}case"query":{let o=Po(t.args,n,i,this.#l()),s;for(let a of o){let f=await this.#u(a,r,()=>r.queryRaw(a).catch(w=>t.args.type==="rawSql"?Ji(w):_t(w)));s===void 0?s=f:(s.rows.push(...f.rows),s.lastInsertId=f.lastInsertId)}return{value:t.args.type==="rawSql"?this.#a(s):this.#i(s),lastInsertId:s?.lastInsertId}}case"reverse":{let{value:o,lastInsertId:s}=await this.interpretNode(t.args,r,n,i);return{value:Array.isArray(o)?o.reverse():o,lastInsertId:s}}case"unique":{let{value:o,lastInsertId:s}=await this.interpretNode(t.args,r,n,i);if(!Array.isArray(o))return{value:o,lastInsertId:s};if(o.length>1)throw new Error(`Expected zero or one element, got ${o.length}`);return{value:o[0]??null,lastInsertId:s}}case"required":{let{value:o,lastInsertId:s}=await this.interpretNode(t.args,r,n,i);if(lc(o))throw new Error("Required value is empty");return{value:o,lastInsertId:s}}case"mapField":{let{value:o,lastInsertId:s}=await this.interpretNode(t.args.records,r,n,i);return{value:cc(o,t.args.field),lastInsertId:s}}case"join":{let{value:o,lastInsertId:s}=await this.interpretNode(t.args.parent,r,n,i);if(o===null)return{value:null,lastInsertId:s};let a=await Promise.all(t.args.children.map(async f=>({joinExpr:f,childRecords:(await this.interpretNode(f.child,r,n,i)).value})));return{value:Qd(o,a),lastInsertId:s}}case"transaction":{if(!this.#t.enabled)return this.interpretNode(t.args,r,n,i);let o=this.#t.manager,s=await o.startInternalTransaction(),a=await o.getTransaction(s,"query");try{let f=await this.interpretNode(t.args,a,n,i);return await o.commitTransaction(s.id),f}catch(f){throw await o.rollbackTransaction(s.id),f}}case"dataMap":{let{value:o,lastInsertId:s}=await this.interpretNode(t.args.expr,r,n,i);return{value:el(o,t.args.structure,t.args.enums),lastInsertId:s}}case"validate":{let{value:o,lastInsertId:s}=await this.interpretNode(t.args.expr,r,n,i);return ac(o,t.args.rules,t.args),{value:o,lastInsertId:s}}case"if":{let{value:o}=await this.interpretNode(t.args.value,r,n,i);return To(o,t.args.rule)?await this.interpretNode(t.args.then,r,n,i):await this.interpretNode(t.args.else,r,n,i)}case"unit":return{value:void 0};case"diff":{let{value:o}=await this.interpretNode(t.args.from,r,n,i),{value:s}=await this.interpretNode(t.args.to,r,n,i),a=w=>w!==null?Ft(Gn(w),t.args.fields):null,f=new Set(vo(s).map(a));return{value:vo(o).filter(w=>!f.has(a(w)))}}case"process":{let{value:o,lastInsertId:s}=await this.interpretNode(t.args.expr,r,n,i);return{value:Hn(o,t.args.operations),lastInsertId:s}}case"initializeRecord":{let{lastInsertId:o}=await this.interpretNode(t.args.expr,r,n,i),s={};for(let[a,f]of Object.entries(t.args.fields))s[a]=Hd(f,o,n,i);return{value:s,lastInsertId:o}}case"mapRecord":{let{value:o,lastInsertId:s}=await this.interpretNode(t.args.expr,r,n,i),a=o===null?{}:Gn(o);for(let[f,w]of Object.entries(t.args.fields))a[f]=Gd(w,a[f],n,i);return{value:a,lastInsertId:s}}default:$(t,`Unexpected node type: ${t.type}`)}}#l(){return this.#c?.maxBindValues!==void 0?this.#c.maxBindValues:this.#p()}#p(){if(this.#o!==void 0)switch(this.#o){case"cockroachdb":case"postgres":case"postgresql":case"prisma+postgres":return 32766;case"mysql":return 65535;case"sqlite":return 999;case"sqlserver":return 2098;case"mongodb":return;default:$(this.#o,`Unexpected provider: ${this.#o}`)}}#u(t,r,n){return Ln({query:t,execute:n,provider:this.#o??r.provider,tracingHelper:this.#s,onQuery:this.#r})}};function lc(e){return Array.isArray(e)?e.length===0:e==null}function vo(e){return Array.isArray(e)?e:[e]}function Oe(e){if(typeof e=="number")return e;if(typeof e=="string")return Number(e);throw new Error(`Expected number, got ${typeof e}`)}function Gn(e){if(typeof e=="object"&&e!==null)return e;throw new Error(`Expected object, got ${typeof e}`)}function cc(e,t){return Array.isArray(e)?e.map(r=>cc(r,t)):typeof e=="object"&&e!==null?e[t]??null:e}function Qd(e,t){for(let{joinExpr:r,childRecords:n}of t){let i=r.on.map(([a])=>a),o=r.on.map(([,a])=>a),s={};for(let a of Array.isArray(e)?e:[e]){let f=Gn(a),w=Ft(f,i);s[w]||(s[w]=[]),s[w].push(f),r.isRelationUnique?f[r.parentField]=null:f[r.parentField]=[]}for(let a of Array.isArray(n)?n:[n]){if(a===null)continue;let f=Ft(Gn(a),o);for(let w of s[f]??[])r.isRelationUnique?w[r.parentField]=a:w[r.parentField].push(a)}}return e}function Hd(e,t,r,n){switch(e.type){case"value":return Te(e.value,r,n);case"lastInsertId":return t;default:$(e,`Unexpected field initializer type: ${e.type}`)}}function Gd(e,t,r,n){switch(e.type){case"set":return Te(e.value,r,n);case"add":return Oe(t)+Oe(Te(e.value,r,n));case"subtract":return Oe(t)-Oe(Te(e.value,r,n));case"multiply":return Oe(t)*Oe(Te(e.value,r,n));case"divide":{let i=Oe(t),o=Oe(Te(e.value,r,n));return o===0?null:i/o}default:$(e,`Unexpected field operation type: ${e.type}`)}}c();u();p();m();d();l();c();u();p();m();d();l();async function Jd(){return globalThis.crypto??await Promise.resolve().then(()=>(Xe(),xi))}async function uc(){return(await Jd()).randomUUID()}c();u();p();m();d();l();var Ee=class extends ce{name="TransactionManagerError";constructor(t,r){super("Transaction API error: "+t,"P2028",r)}},Sr=class extends Ee{constructor(){super("Transaction not found. Transaction ID is invalid, refers to an old closed transaction Prisma doesn't have information about anymore, or was obtained before disconnecting.")}},Jn=class extends Ee{constructor(t){super(`Transaction already closed: A ${t} cannot be executed on a committed transaction.`)}},Wn=class extends Ee{constructor(t){super(`Transaction already closed: A ${t} cannot be executed on a transaction that was rolled back.`)}},Kn=class extends Ee{constructor(){super("Unable to start a transaction in the given time.")}},zn=class extends Ee{constructor(t,{timeout:r,timeTaken:n}){super(`A ${t} cannot be executed on an expired transaction. The timeout for this transaction was ${r} ms, however ${n} ms passed since the start of the transaction. Consider increasing the interactive transaction timeout or doing less work in the transaction.`,{operation:t,timeout:r,timeTaken:n})}},Vt=class extends Ee{constructor(t){super(`Internal Consistency Error: ${t}`)}},Yn=class extends Ee{constructor(t){super(`Invalid isolation level: ${t}`,{isolationLevel:t})}};var Wd=100,Ir=K("prisma:client:transactionManager"),Kd=()=>({sql:"COMMIT",args:[],argTypes:[]}),zd=()=>({sql:"ROLLBACK",args:[],argTypes:[]}),Yd=()=>({sql:'-- Implicit "COMMIT" query via underlying driver',args:[],argTypes:[]}),Zd=()=>({sql:'-- Implicit "ROLLBACK" query via underlying driver',args:[],argTypes:[]}),kr=class{transactions=new Map;closedTransactions=[];driverAdapter;transactionOptions;tracingHelper;#t;#e;constructor({driverAdapter:t,transactionOptions:r,tracingHelper:n,onQuery:i,provider:o}){this.driverAdapter=t,this.transactionOptions=r,this.tracingHelper=n,this.#t=i,this.#e=o}async startInternalTransaction(t){let r=t!==void 0?this.#a(t):{};return await this.tracingHelper.runInChildSpan("start_transaction",()=>this.#r(r))}async startTransaction(t){let r=t!==void 0?this.#a(t):this.transactionOptions;return await this.tracingHelper.runInChildSpan("start_transaction",()=>this.#r(r))}async#r(t){let r={id:await uc(),status:"waiting",timer:void 0,timeout:t.timeout,startedAt:Date.now(),transaction:void 0};this.transactions.set(r.id,r);let n=!1,i=pc(()=>n=!0,t.maxWait);switch(i?.unref?.(),r.transaction=await this.driverAdapter.startTransaction(t.isolationLevel).catch(_t),clearTimeout(i),r.status){case"waiting":if(n)throw await this.#i(r,"timed_out"),new Kn;return r.status="running",r.timer=this.#s(r.id,t.timeout),{id:r.id};case"timed_out":case"running":case"committed":case"rolled_back":throw new Vt(`Transaction in invalid state ${r.status} although it just finished startup.`);default:$(r.status,"Unknown transaction status.")}}async commitTransaction(t){return await this.tracingHelper.runInChildSpan("commit_transaction",async()=>{let r=this.#n(t,"commit");await this.#i(r,"committed")})}async rollbackTransaction(t){return await this.tracingHelper.runInChildSpan("rollback_transaction",async()=>{let r=this.#n(t,"rollback");await this.#i(r,"rolled_back")})}async getTransaction(t,r){let n=this.#n(t.id,r);if(n.status==="closing"&&(await n.closing,n=this.#n(t.id,r)),!n.transaction)throw new Sr;return n.transaction}#n(t,r){let n=this.transactions.get(t);if(!n){let i=this.closedTransactions.find(o=>o.id===t);if(i)switch(Ir("Transaction already closed.",{transactionId:t,status:i.status}),i.status){case"closing":case"waiting":case"running":throw new Vt("Active transaction found in closed transactions list.");case"committed":throw new Jn(r);case"rolled_back":throw new Wn(r);case"timed_out":throw new zn(r,{timeout:i.timeout,timeTaken:Date.now()-i.startedAt})}else throw Ir("Transaction not found.",t),new Sr}if(["committed","rolled_back","timed_out"].includes(n.status))throw new Vt("Closed transaction found in active transactions map.");return n}async cancelAllTransactions(){await Promise.allSettled([...this.transactions.values()].map(t=>this.#i(t,"rolled_back")))}#s(t,r){let n=Date.now(),i=pc(async()=>{Ir("Transaction timed out.",{transactionId:t,timeoutStartedAt:n,timeout:r});let o=this.transactions.get(t);o&&["running","waiting"].includes(o.status)?await this.#i(o,"timed_out"):Ir("Transaction already committed or rolled back when timeout happened.",t)},r);return i?.unref?.(),i}async#i(t,r){let n=async()=>{Ir("Closing transaction.",{transactionId:t.id,status:r});try{if(t.transaction&&r==="committed")if(t.transaction.options.usePhantomQuery)await this.#o(Yd(),t.transaction,()=>t.transaction.commit());else{let i=Kd();await this.#o(i,t.transaction,()=>t.transaction.executeRaw(i)),await t.transaction.commit()}else if(t.transaction)if(t.transaction.options.usePhantomQuery)await this.#o(Zd(),t.transaction,()=>t.transaction.rollback());else{let i=zd();await this.#o(i,t.transaction,()=>t.transaction.executeRaw(i)),await t.transaction.rollback()}}finally{t.status=r,clearTimeout(t.timer),t.timer=void 0,this.transactions.delete(t.id),this.closedTransactions.push(t),this.closedTransactions.length>Wd&&this.closedTransactions.shift()}};t.status==="closing"?(await t.closing,this.#n(t.id,r==="committed"?"commit":"rollback")):await Object.assign(t,{status:"closing",reason:r,closing:n()}).closing}#a(t){if(!t.timeout)throw new Ee("timeout is required");if(!t.maxWait)throw new Ee("maxWait is required");if(t.isolationLevel==="SNAPSHOT")throw new Yn(t.isolationLevel);return{...t,timeout:t.timeout,maxWait:t.maxWait}}#o(t,r,n){return Ln({query:t,execute:n,provider:this.#e??r.provider,tracingHelper:this.tracingHelper,onQuery:this.#t})}};function pc(e,t){return t!==void 0?setTimeout(e,t):void 0}var Zn="6.19.1";c();u();p();m();d();l();var Xn=class e{#t;#e;#r;#n;constructor(t,r,n){this.#t=t,this.#e=r,this.#r=n,this.#n=r.getConnectionInfo?.()}static async connect(t){let r,n;try{r=await t.driverAdapterFactory.connect(),n=new kr({driverAdapter:r,transactionOptions:t.transactionOptions,tracingHelper:t.tracingHelper,onQuery:t.onQuery,provider:t.provider})}catch(i){throw await r?.dispose(),i}return new e(t,r,n)}getConnectionInfo(){let t=this.#n??{supportsRelationJoins:!1};return Promise.resolve({provider:this.#e.provider,connectionInfo:t})}async execute({plan:t,placeholderValues:r,transaction:n,batchIndex:i}){let o=n?await this.#r.getTransaction(n,i!==void 0?"batch query":"query"):this.#e;return await Cr.forSql({transactionManager:n?{enabled:!1}:{enabled:!0,manager:this.#r},placeholderValues:r,onQuery:this.#t.onQuery,tracingHelper:this.#t.tracingHelper,provider:this.#t.provider,connectionInfo:this.#n}).run(t,o)}async startTransaction(t){return{...await this.#r.startTransaction(t),payload:void 0}}async commitTransaction(t){await this.#r.commitTransaction(t.id)}async rollbackTransaction(t){await this.#r.rollbackTransaction(t.id)}async disconnect(){try{await this.#r.cancelAllTransactions()}finally{await this.#e.dispose()}}apiKey(){return null}};c();u();p();m();d();l();c();u();p();m();d();l();var ei=/^[\u0009\u0020-\u007E\u0080-\u00FF]+$/;function mc(e,t,r){let n=r||{},i=n.encode||encodeURIComponent;if(typeof i!="function")throw new TypeError("option encode is invalid");if(!ei.test(e))throw new TypeError("argument name is invalid");let o=i(t);if(o&&!ei.test(o))throw new TypeError("argument val is invalid");let s=e+"="+o;if(n.maxAge!==void 0&&n.maxAge!==null){let a=n.maxAge-0;if(Number.isNaN(a)||!Number.isFinite(a))throw new TypeError("option maxAge is invalid");s+="; Max-Age="+Math.floor(a)}if(n.domain){if(!ei.test(n.domain))throw new TypeError("option domain is invalid");s+="; Domain="+n.domain}if(n.path){if(!ei.test(n.path))throw new TypeError("option path is invalid");s+="; Path="+n.path}if(n.expires){if(!ef(n.expires)||Number.isNaN(n.expires.valueOf()))throw new TypeError("option expires is invalid");s+="; Expires="+n.expires.toUTCString()}if(n.httpOnly&&(s+="; HttpOnly"),n.secure&&(s+="; Secure"),n.priority)switch(typeof n.priority=="string"?n.priority.toLowerCase():n.priority){case"low":{s+="; Priority=Low";break}case"medium":{s+="; Priority=Medium";break}case"high":{s+="; Priority=High";break}default:throw new TypeError("option priority is invalid")}if(n.sameSite)switch(typeof n.sameSite=="string"?n.sameSite.toLowerCase():n.sameSite){case!0:{s+="; SameSite=Strict";break}case"lax":{s+="; SameSite=Lax";break}case"strict":{s+="; SameSite=Strict";break}case"none":{s+="; SameSite=None";break}default:throw new TypeError("option sameSite is invalid")}return n.partitioned&&(s+="; Partitioned"),s}function ef(e){return Object.prototype.toString.call(e)==="[object Date]"||e instanceof Date}function dc(e,t){let r=(e||"").split(";").filter(f=>typeof f=="string"&&!!f.trim()),n=r.shift()||"",i=tf(n),o=i.name,s=i.value;try{s=t?.decode===!1?s:(t?.decode||decodeURIComponent)(s)}catch{}let a={name:o,value:s};for(let f of r){let w=f.split("="),A=(w.shift()||"").trimStart().toLowerCase(),R=w.join("=");switch(A){case"expires":{a.expires=new Date(R);break}case"max-age":{a.maxAge=Number.parseInt(R,10);break}case"secure":{a.secure=!0;break}case"httponly":{a.httpOnly=!0;break}case"samesite":{a.sameSite=R;break}default:a[A]=R}}return a}function tf(e){let t="",r="",n=e.split("=");return n.length>1?(t=n.shift(),r=n.join("=")):r=e,{name:t,value:r}}c();u();p();m();d();l();c();u();p();m();d();l();c();u();p();m();d();l();var rf=()=>globalThis.process?.release?.name==="node",nf=()=>!!globalThis.Bun||!!globalThis.process?.versions?.bun,of=()=>!!globalThis.Deno,sf=()=>typeof globalThis.Netlify=="object",af=()=>typeof globalThis.EdgeRuntime=="object",lf=()=>globalThis.navigator?.userAgent==="Cloudflare-Workers";function cf(){return[[sf,"netlify"],[af,"edge-light"],[lf,"workerd"],[of,"deno"],[nf,"bun"],[rf,"node"]].flatMap(r=>r[0]()?[r[1]]:[]).at(0)??""}var uf={node:"Node.js",workerd:"Cloudflare Workers",deno:"Deno and Deno Deploy",netlify:"Netlify Edge Functions","edge-light":"Edge Runtime (Vercel Edge Functions, Vercel Edge Middleware, Next.js (Pages Router) Edge API Routes, Next.js (App Router) Edge Route Handlers or Next.js Middleware)"};function ti(){let e=cf();return{id:e,prettyName:uf[e]||e,isEdge:["workerd","deno","netlify","edge-light"].includes(e)}}function qt({inlineDatasources:e,overrideDatasources:t,env:r,clientVersion:n}){let i,o=Object.keys(e)[0],s=e[o]?.url,a=t[o]?.url;if(o===void 0?i=void 0:a?i=a:s?.value?i=s.value:s?.fromEnvVar&&(i=r[s.fromEnvVar]),s?.fromEnvVar!==void 0&&i===void 0)throw ti().id==="workerd"?new F(`error: Environment variable not found: ${s.fromEnvVar}. - -In Cloudflare module Workers, environment variables are available only in the Worker's \`env\` parameter of \`fetch\`. -To solve this, provide the connection string directly: https://pris.ly/d/cloudflare-datasource-url`,n):new F(`error: Environment variable not found: ${s.fromEnvVar}.`,n);if(i===void 0)throw new F("error: Missing URL environment variable, value, or override.",n);return i}c();u();p();m();d();l();c();u();p();m();d();l();c();u();p();m();d();l();var ri=class extends Error{clientVersion;cause;constructor(t,r){super(t),this.clientVersion=r.clientVersion,this.cause=r.cause}get[Symbol.toStringTag](){return this.name}};var ge=class extends ri{isRetryable;constructor(t,r){super(t,r),this.isRetryable=r.isRetryable??!0}};c();u();p();m();d();l();function N(e,t){return{...e,isRetryable:t}}var st=class extends ge{name="InvalidDatasourceError";code="P6001";constructor(t,r){super(t,N(r,!1))}};D(st,"InvalidDatasourceError");function ni(e){let t={clientVersion:e.clientVersion},r=Object.keys(e.inlineDatasources)[0],n=qt({inlineDatasources:e.inlineDatasources,overrideDatasources:e.overrideDatasources,clientVersion:e.clientVersion,env:{...e.env,...typeof g<"u"?g.env:{}}}),i;try{i=new URL(n)}catch{throw new st(`Error validating datasource \`${r}\`: the URL must start with the protocol \`prisma://\``,t)}let{protocol:o,searchParams:s}=i;if(o!=="prisma:"&&o!==ln)throw new st(`Error validating datasource \`${r}\`: the URL must start with the protocol \`prisma://\` or \`prisma+postgres://\``,t);let a=s.get("api_key");if(a===null||a.length<1)throw new st(`Error validating datasource \`${r}\`: the URL must contain a valid API key`,t);let f=Ti(i)?"http:":"https:";g.env.TEST_CLIENT_ENGINE_REMOTE_EXECUTOR&&i.searchParams.has("use_http")&&(f="http:");let w=new URL(i.href.replace(o,f));return{apiKey:a,url:w}}c();u();p();m();d();l();var fc=$e(Ts()),Bt=class{apiKey;tracingHelper;logLevel;logQueries;engineHash;constructor({apiKey:t,tracingHelper:r,logLevel:n,logQueries:i,engineHash:o}){this.apiKey=t,this.tracingHelper=r,this.logLevel=n,this.logQueries=i,this.engineHash=o}build({traceparent:t,transactionId:r}={}){let n={Accept:"application/json",Authorization:`Bearer ${this.apiKey}`,"Content-Type":"application/json","Prisma-Engine-Hash":this.engineHash,"Prisma-Engine-Version":fc.enginesVersion};this.tracingHelper.isEnabled()&&(n.traceparent=t??this.tracingHelper.getTraceParent()),r&&(n["X-Transaction-Id"]=r);let i=this.#t();return i.length>0&&(n["X-Capture-Telemetry"]=i.join(", ")),n}#t(){let t=[];return this.tracingHelper.isEnabled()&&t.push("tracing"),this.logLevel&&t.push(this.logLevel),this.logQueries&&t.push("query"),t}};c();u();p();m();d();l();function pf(e){return e[0]*1e3+e[1]/1e6}function jt(e){return new Date(pf(e))}var gc=K("prisma:client:clientEngine:remoteExecutor"),ii=class{#t;#e;#r;#n;#s;constructor(t){this.#t=t.clientVersion,this.#n=t.logEmitter,this.#s=t.tracingHelper;let{url:r,apiKey:n}=ni({clientVersion:t.clientVersion,env:t.env,inlineDatasources:t.inlineDatasources,overrideDatasources:t.overrideDatasources});this.#r=new Ao(r),this.#e=new Bt({apiKey:n,engineHash:t.clientVersion,logLevel:t.logLevel,logQueries:t.logQueries,tracingHelper:t.tracingHelper})}async getConnectionInfo(){return await this.#i({path:"/connection-info",method:"GET"})}async execute({plan:t,placeholderValues:r,batchIndex:n,model:i,operation:o,transaction:s,customFetch:a}){return(await this.#i({path:s?`/transaction/${s.id}/query`:"/query",method:"POST",body:{model:i,operation:o,plan:t,params:r},batchRequestIdx:n,fetch:a})).data}async startTransaction(t){return{...await this.#i({path:"/transaction/start",method:"POST",body:t}),payload:void 0}}async commitTransaction(t){await this.#i({path:`/transaction/${t.id}/commit`,method:"POST"})}async rollbackTransaction(t){await this.#i({path:`/transaction/${t.id}/rollback`,method:"POST"})}disconnect(){return Promise.resolve()}apiKey(){return this.#e.apiKey}async#i({path:t,method:r,body:n,fetch:i=globalThis.fetch,batchRequestIdx:o}){let s=await this.#r.request({method:r,path:t,headers:this.#e.build(),body:n,fetch:i});s.ok||await this.#a(s,o);let a=await s.json();return typeof a.extensions=="object"&&a.extensions!==null&&this.#o(a.extensions),a}async#a(t,r){let n=t.headers.get("Prisma-Error-Code"),i=await t.text(),o,s=i;try{o=JSON.parse(i)}catch{o={}}typeof o.code=="string"&&(n=o.code),typeof o.error=="string"?s=o.error:typeof o.message=="string"?s=o.message:typeof o.InvalidRequestError=="object"&&o.InvalidRequestError!==null&&typeof o.InvalidRequestError.reason=="string"&&(s=o.InvalidRequestError.reason),s=s||`HTTP ${t.status}: ${t.statusText}`;let a=typeof o.meta=="object"&&o.meta!==null?o.meta:o;throw new X(s,{clientVersion:this.#t,code:n??"P6000",batchRequestIdx:r,meta:a})}#o(t){if(t.logs)for(let r of t.logs)this.#c(r);t.traces&&this.#s.dispatchEngineSpans(t.traces)}#c(t){switch(t.level){case"debug":case"trace":gc(t);break;case"error":case"warn":case"info":{this.#n.emit(t.level,{timestamp:jt(t.timestamp),message:t.attributes.message??"",target:t.target??"RemoteExecutor"});break}case"query":{this.#n.emit("query",{query:t.attributes.query??"",timestamp:jt(t.timestamp),duration:t.attributes.duration_ms??0,params:t.attributes.params??"",target:t.target??"RemoteExecutor"});break}default:throw new Error(`Unexpected log level: ${t.level}`)}}},Ao=class{#t;#e;#r;constructor(t){this.#t=t,this.#e=new Map}async request({method:t,path:r,headers:n,body:i,fetch:o}){let s=new URL(r,this.#t),a=this.#n(s);a&&(n.Cookie=a),this.#r&&(n["Accelerate-Query-Engine-Jwt"]=this.#r);let f=await o(s.href,{method:t,body:i!==void 0?JSON.stringify(i):void 0,headers:n});return gc(t,s,f.status,f.statusText),this.#r=f.headers.get("Accelerate-Query-Engine-Jwt")??void 0,this.#s(s,f),f}#n(t){let r=[],n=new Date;for(let[i,o]of this.#e){if(o.expires&&o.expires0?r.join("; "):void 0}#s(t,r){let n=r.headers.getSetCookie?.()||[];if(n.length===0){let i=r.headers.get("Set-Cookie");i&&n.push(i)}for(let i of n){let o=dc(i),s=o.domain??t.hostname,a=o.path??"/",f=`${s}:${a}:${o.name}`;this.#e.set(f,{name:o.name,value:o.value,domain:s,path:a,expires:o.expires})}}};c();u();p();m();d();l();var Ro={},yc={async loadQueryCompiler(e){let{clientVersion:t,compilerWasm:r}=e;if(r===void 0)throw new F("WASM query compiler was unexpectedly `undefined`",t);let n;return e.activeProvider===void 0||Ro[e.activeProvider]===void 0?(n=(async()=>{let i=await r.getRuntime(),o=await r.getQueryCompilerWasmModule();if(o==null)throw new F("The loaded wasm module was unexpectedly `undefined` or `null` once loaded",t);let s={"./query_compiler_bg.js":i},a=new WebAssembly.Instance(o,s),f=a.exports.__wbindgen_start;return i.__wbg_set_wasm(a.exports),f(),i.QueryCompiler})(),e.activeProvider!==void 0&&(Ro[e.activeProvider]=n)):n=Ro[e.activeProvider],await n}};var mf="P2038",Or=K("prisma:client:clientEngine"),wc=globalThis;wc.PRISMA_WASM_PANIC_REGISTRY={set_message(e){throw new ae(e,Zn)}};var Dr=class{name="ClientEngine";#t;#e={type:"disconnected"};#r;#n;config;datamodel;logEmitter;logQueries;logLevel;tracingHelper;#s;constructor(t,r,n){if(r)this.#n={remote:!0};else if(t.adapter)this.#n={remote:!1,driverAdapterFactory:t.adapter},Or("Using driver adapter: %O",t.adapter);else throw new F("Missing configured driver adapter. Engine type `client` requires an active driver adapter. Please check your PrismaClient initialization code.",t.clientVersion,mf);this.#r=n??yc,this.config=t,this.logQueries=t.logQueries??!1,this.logLevel=t.logLevel??"error",this.logEmitter=t.logEmitter,this.datamodel=t.inlineSchema,this.tracingHelper=t.tracingHelper,t.enableDebugLogs&&(this.logLevel="debug"),this.logQueries&&(this.#s=i=>{this.logEmitter.emit("query",{...i,params:br(i.params),target:"ClientEngine"})})}applyPendingMigrations(){throw new Error("Cannot call applyPendingMigrations on engine type client.")}async#i(){switch(this.#e.type){case"disconnected":{let t=this.tracingHelper.runInChildSpan("connect",async()=>{let r,n;try{r=await this.#a(),n=await this.#o(r)}catch(o){throw this.#e={type:"disconnected"},n?.free(),await r?.disconnect(),o}let i={executor:r,queryCompiler:n};return this.#e={type:"connected",engine:i},i});return this.#e={type:"connecting",promise:t},await t}case"connecting":return await this.#e.promise;case"connected":return this.#e.engine;case"disconnecting":return await this.#e.promise,await this.#i()}}async#a(){return this.#n.remote?new ii({clientVersion:this.config.clientVersion,env:this.config.env,inlineDatasources:this.config.inlineDatasources,logEmitter:this.logEmitter,logLevel:this.logLevel,logQueries:this.logQueries,overrideDatasources:this.config.overrideDatasources,tracingHelper:this.tracingHelper}):await Xn.connect({driverAdapterFactory:this.#n.driverAdapterFactory,tracingHelper:this.tracingHelper,transactionOptions:{...this.config.transactionOptions,isolationLevel:this.#m(this.config.transactionOptions.isolationLevel)},onQuery:this.#s,provider:this.config.activeProvider})}async#o(t){let r=this.#t;r===void 0&&(r=await this.#r.loadQueryCompiler(this.config),this.#t=r);let{provider:n,connectionInfo:i}=await t.getConnectionInfo();try{return this.#u(()=>new r({datamodel:this.datamodel,provider:n,connectionInfo:i}),void 0,!1)}catch(o){throw this.#c(o)}}#c(t){if(t instanceof ae)return t;try{let r=JSON.parse(t.message);return new F(r.message,this.config.clientVersion,r.error_code)}catch{return t}}#l(t,r){if(t instanceof F)return t;if(t.code==="GenericFailure"&&t.message?.startsWith("PANIC:"))return new ae(hc(this,t.message,r),this.config.clientVersion);if(t instanceof ce)return new X(t.message,{code:t.code,meta:t.meta,clientVersion:this.config.clientVersion});try{let n=JSON.parse(t);return new ne(`${n.message} -${n.backtrace}`,{clientVersion:this.config.clientVersion})}catch{return t}}#p(t){return t instanceof ae?t:typeof t.message=="string"&&typeof t.code=="string"?new X(t.message,{code:t.code,meta:t.meta,clientVersion:this.config.clientVersion}):typeof t.message=="string"?new ne(t.message,{clientVersion:this.config.clientVersion}):t}#u(t,r,n=!0){let i=wc.PRISMA_WASM_PANIC_REGISTRY.set_message,o;globalThis.PRISMA_WASM_PANIC_REGISTRY.set_message=s=>{o=s};try{return t()}finally{if(globalThis.PRISMA_WASM_PANIC_REGISTRY.set_message=i,o)throw this.#t=void 0,n&&this.stop().catch(s=>Or("failed to disconnect:",s)),new ae(hc(this,o,r),this.config.clientVersion)}}onBeforeExit(){throw new Error('"beforeExit" hook is not applicable to the client engine, it is only relevant and implemented for the binary engine. Please add your event listener to the `process` object directly instead.')}async start(){await this.#i()}async stop(){switch(this.#e.type){case"disconnected":return;case"connecting":return await this.#e.promise,await this.stop();case"connected":{let t=this.#e.engine,r=this.tracingHelper.runInChildSpan("disconnect",async()=>{try{await t.executor.disconnect(),t.queryCompiler.free()}finally{this.#e={type:"disconnected"}}});return this.#e={type:"disconnecting",promise:r},await r}case"disconnecting":return await this.#e.promise}}version(){return"unknown"}async transaction(t,r,n){let i,{executor:o}=await this.#i();try{if(t==="start"){let s=n;i=await o.startTransaction({...s,isolationLevel:this.#m(s.isolationLevel)})}else if(t==="commit"){let s=n;await o.commitTransaction(s)}else if(t==="rollback"){let s=n;await o.rollbackTransaction(s)}else Me(t,"Invalid transaction action.")}catch(s){throw this.#l(s)}return i?{id:i.id,payload:void 0}:void 0}async request(t,{interactiveTransaction:r,customDataProxyFetch:n}){Or("sending request");let i=JSON.stringify(t),{executor:o,queryCompiler:s}=await this.#i().catch(f=>{throw this.#l(f,i)}),a;try{a=this.#u(()=>this.#d({queries:[t],execute:()=>s.compile(i)}))}catch(f){throw this.#p(f)}try{Or("query plan created",a);let f={},w=await o.execute({plan:a,model:t.modelName,operation:t.action,placeholderValues:f,transaction:r,batchIndex:void 0,customFetch:n?.(globalThis.fetch)});return Or("query plan executed"),{data:{[t.action]:w}}}catch(f){throw this.#l(f,i)}}async requestBatch(t,{transaction:r,customDataProxyFetch:n}){if(t.length===0)return[];let i=t[0].action,o=JSON.stringify(kt(t,r)),{executor:s,queryCompiler:a}=await this.#i().catch(w=>{throw this.#l(w,o)}),f;try{f=this.#u(()=>this.#d({queries:t,execute:()=>a.compileBatch(o)}))}catch(w){throw this.#p(w)}try{let w;r?.kind==="itx"&&(w=r.options);let A={};switch(f.type){case"multi":{if(r?.kind!=="itx"){let C=r?.options.isolationLevel?{...this.config.transactionOptions,isolationLevel:r.options.isolationLevel}:this.config.transactionOptions;w=await this.transaction("start",{},C)}let R=[],S=!1;for(let[C,L]of f.plans.entries())try{let k=await s.execute({plan:L,placeholderValues:A,model:t[C].modelName,operation:t[C].action,batchIndex:C,transaction:w,customFetch:n?.(globalThis.fetch)});R.push({data:{[t[C].action]:k}})}catch(k){R.push(k),S=!0;break}return w!==void 0&&r?.kind!=="itx"&&(S?await this.transaction("rollback",{},w):await this.transaction("commit",{},w)),R}case"compacted":{if(!t.every(C=>C.action===i))throw new Error("All queries in a batch must have the same action");let R=await s.execute({plan:f.plan,placeholderValues:A,model:t[0].modelName,operation:i,batchIndex:void 0,transaction:w,customFetch:n?.(globalThis.fetch)});return Za(R,f).map(C=>({data:{[i]:C}}))}}}catch(w){throw this.#l(w,o)}}metrics(t){throw new Error("Method not implemented.")}async apiKey(){let{executor:t}=await this.#i();return t.apiKey()}#m(t){switch(t){case void 0:return;case"ReadUncommitted":return"READ UNCOMMITTED";case"ReadCommitted":return"READ COMMITTED";case"RepeatableRead":return"REPEATABLE READ";case"Serializable":return"SERIALIZABLE";case"Snapshot":return"SNAPSHOT";default:throw new X(`Inconsistent column data: Conversion failed: Invalid isolation level \`${t}\``,{code:"P2023",clientVersion:this.config.clientVersion,meta:{providedIsolationLevel:t}})}}#d({queries:t,execute:r}){return this.tracingHelper.runInChildSpan({name:"compile",attributes:{models:t.map(n=>n.modelName).filter(n=>n!==void 0),actions:t.map(n=>n.action)}},r)}};function hc(e,t,r){return Ha({binaryTarget:void 0,title:t,version:e.config.clientVersion,engineVersion:"unknown",database:e.config.activeProvider,query:r})}c();u();p();m();d();l();c();u();p();m();d();l();var Qt=class extends ge{name="ForcedRetryError";code="P5001";constructor(t){super("This request must be retried",N(t,!0))}};D(Qt,"ForcedRetryError");c();u();p();m();d();l();var at=class extends ge{name="NotImplementedYetError";code="P5004";constructor(t,r){super(t,N(r,!1))}};D(at,"NotImplementedYetError");c();u();p();m();d();l();c();u();p();m();d();l();var Q=class extends ge{response;constructor(t,r){super(t,r),this.response=r.response;let n=this.response.headers.get("prisma-request-id");if(n){let i=`(The request id was: ${n})`;this.message=this.message+" "+i}}};var lt=class extends Q{name="SchemaMissingError";code="P5005";constructor(t){super("Schema needs to be uploaded",N(t,!0))}};D(lt,"SchemaMissingError");c();u();p();m();d();l();c();u();p();m();d();l();var Co="This request could not be understood by the server",_r=class extends Q{name="BadRequestError";code="P5000";constructor(t,r,n){super(r||Co,N(t,!1)),n&&(this.code=n)}};D(_r,"BadRequestError");c();u();p();m();d();l();var Mr=class extends Q{name="HealthcheckTimeoutError";code="P5013";logs;constructor(t,r){super("Engine not started: healthcheck timeout",N(t,!0)),this.logs=r}};D(Mr,"HealthcheckTimeoutError");c();u();p();m();d();l();var Nr=class extends Q{name="EngineStartupError";code="P5014";logs;constructor(t,r,n){super(r,N(t,!0)),this.logs=n}};D(Nr,"EngineStartupError");c();u();p();m();d();l();var Lr=class extends Q{name="EngineVersionNotSupportedError";code="P5012";constructor(t){super("Engine version is not supported",N(t,!1))}};D(Lr,"EngineVersionNotSupportedError");c();u();p();m();d();l();var So="Request timed out",Ur=class extends Q{name="GatewayTimeoutError";code="P5009";constructor(t,r=So){super(r,N(t,!1))}};D(Ur,"GatewayTimeoutError");c();u();p();m();d();l();var df="Interactive transaction error",Fr=class extends Q{name="InteractiveTransactionError";code="P5015";constructor(t,r=df){super(r,N(t,!1))}};D(Fr,"InteractiveTransactionError");c();u();p();m();d();l();var ff="Request parameters are invalid",$r=class extends Q{name="InvalidRequestError";code="P5011";constructor(t,r=ff){super(r,N(t,!1))}};D($r,"InvalidRequestError");c();u();p();m();d();l();var Io="Requested resource does not exist",Vr=class extends Q{name="NotFoundError";code="P5003";constructor(t,r=Io){super(r,N(t,!1))}};D(Vr,"NotFoundError");c();u();p();m();d();l();var ko="Unknown server error",Ht=class extends Q{name="ServerError";code="P5006";logs;constructor(t,r,n){super(r||ko,N(t,!0)),this.logs=n}};D(Ht,"ServerError");c();u();p();m();d();l();var Oo="Unauthorized, check your connection string",qr=class extends Q{name="UnauthorizedError";code="P5007";constructor(t,r=Oo){super(r,N(t,!1))}};D(qr,"UnauthorizedError");c();u();p();m();d();l();var Do="Usage exceeded, retry again later",Br=class extends Q{name="UsageExceededError";code="P5008";constructor(t,r=Do){super(r,N(t,!0))}};D(Br,"UsageExceededError");async function gf(e){let t;try{t=await e.text()}catch{return{type:"EmptyError"}}try{let r=JSON.parse(t);if(typeof r=="string")switch(r){case"InternalDataProxyError":return{type:"DataProxyError",body:r};default:return{type:"UnknownTextError",body:r}}if(typeof r=="object"&&r!==null){if("is_panic"in r&&"message"in r&&"error_code"in r)return{type:"QueryEngineError",body:r};if("EngineNotStarted"in r||"InteractiveTransactionMisrouted"in r||"InvalidRequestError"in r){let n=Object.values(r)[0].reason;return typeof n=="string"&&!["SchemaMissing","EngineVersionNotSupported"].includes(n)?{type:"UnknownJsonError",body:r}:{type:"DataProxyError",body:r}}}return{type:"UnknownJsonError",body:r}}catch{return t===""?{type:"EmptyError"}:{type:"UnknownTextError",body:t}}}async function jr(e,t){if(e.ok)return;let r={clientVersion:t,response:e},n=await gf(e);if(n.type==="QueryEngineError")throw new X(n.body.message,{code:n.body.error_code,clientVersion:t});if(n.type==="DataProxyError"){if(n.body==="InternalDataProxyError")throw new Ht(r,"Internal Data Proxy error");if("EngineNotStarted"in n.body){if(n.body.EngineNotStarted.reason==="SchemaMissing")return new lt(r);if(n.body.EngineNotStarted.reason==="EngineVersionNotSupported")throw new Lr(r);if("EngineStartupError"in n.body.EngineNotStarted.reason){let{msg:i,logs:o}=n.body.EngineNotStarted.reason.EngineStartupError;throw new Nr(r,i,o)}if("KnownEngineStartupError"in n.body.EngineNotStarted.reason){let{msg:i,error_code:o}=n.body.EngineNotStarted.reason.KnownEngineStartupError;throw new F(i,t,o)}if("HealthcheckTimeout"in n.body.EngineNotStarted.reason){let{logs:i}=n.body.EngineNotStarted.reason.HealthcheckTimeout;throw new Mr(r,i)}}if("InteractiveTransactionMisrouted"in n.body){let i={IDParseError:"Could not parse interactive transaction ID",NoQueryEngineFoundError:"Could not find Query Engine for the specified host and transaction ID",TransactionStartError:"Could not start interactive transaction"};throw new Fr(r,i[n.body.InteractiveTransactionMisrouted.reason])}if("InvalidRequestError"in n.body)throw new $r(r,n.body.InvalidRequestError.reason)}if(e.status===401||e.status===403)throw new qr(r,Gt(Oo,n));if(e.status===404)return new Vr(r,Gt(Io,n));if(e.status===429)throw new Br(r,Gt(Do,n));if(e.status===504)throw new Ur(r,Gt(So,n));if(e.status>=500)throw new Ht(r,Gt(ko,n));if(e.status>=400)throw new _r(r,Gt(Co,n))}function Gt(e,t){return t.type==="EmptyError"?e:`${e}: ${JSON.stringify(t)}`}c();u();p();m();d();l();function bc(e){let t=Math.pow(2,e)*50,r=Math.ceil(Math.random()*t)-Math.ceil(t/2),n=t+r;return new Promise(i=>setTimeout(()=>i(n),n))}c();u();p();m();d();l();var Fe="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";function Ec(e){let t=new TextEncoder().encode(e),r="",n=t.byteLength,i=n%3,o=n-i,s,a,f,w,A;for(let R=0;R>18,a=(A&258048)>>12,f=(A&4032)>>6,w=A&63,r+=Fe[s]+Fe[a]+Fe[f]+Fe[w];return i==1?(A=t[o],s=(A&252)>>2,a=(A&3)<<4,r+=Fe[s]+Fe[a]+"=="):i==2&&(A=t[o]<<8|t[o+1],s=(A&64512)>>10,a=(A&1008)>>4,f=(A&15)<<2,r+=Fe[s]+Fe[a]+Fe[f]+"="),r}c();u();p();m();d();l();function xc(e){if(!!e.generator?.previewFeatures.some(r=>r.toLowerCase().includes("metrics")))throw new F("The `metrics` preview feature is not yet available with Accelerate.\nPlease remove `metrics` from the `previewFeatures` in your schema.\n\nMore information about Accelerate: https://pris.ly/d/accelerate",e.clientVersion)}c();u();p();m();d();l();var Pc={"@prisma/debug":"workspace:*","@prisma/engines-version":"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7","@prisma/fetch-engine":"workspace:*","@prisma/get-platform":"workspace:*"};c();u();p();m();d();l();c();u();p();m();d();l();var Qr=class extends ge{name="RequestError";code="P5010";constructor(t,r){super(`Cannot fetch data from service: -${t}`,N(r,!0))}};D(Qr,"RequestError");async function ct(e,t,r=n=>n){let{clientVersion:n,...i}=t,o=r(fetch);try{return await o(e,i)}catch(s){let a=s.message??"Unknown error";throw new Qr(a,{clientVersion:n,cause:s})}}var hf=/^[1-9][0-9]*\.[0-9]+\.[0-9]+$/,Tc=K("prisma:client:dataproxyEngine");async function wf(e,t){let r=Pc["@prisma/engines-version"],n=t.clientVersion??"unknown";if(g.env.PRISMA_CLIENT_DATA_PROXY_CLIENT_VERSION||globalThis.PRISMA_CLIENT_DATA_PROXY_CLIENT_VERSION)return g.env.PRISMA_CLIENT_DATA_PROXY_CLIENT_VERSION||globalThis.PRISMA_CLIENT_DATA_PROXY_CLIENT_VERSION;if(e.includes("accelerate")&&n!=="0.0.0"&&n!=="in-memory")return n;let[i,o]=n?.split("-")??[];if(o===void 0&&hf.test(i))return i;if(o!==void 0||n==="0.0.0"||n==="in-memory"){let[s]=r.split("-")??[],[a,f,w]=s.split("."),A=bf(`<=${a}.${f}.${w}`),R=await ct(A,{clientVersion:n});if(!R.ok)throw new Error(`Failed to fetch stable Prisma version, unpkg.com status ${R.status} ${R.statusText}, response body: ${await R.text()||""}`);let S=await R.text();Tc("length of body fetched from unpkg.com",S.length);let C;try{C=JSON.parse(S)}catch(L){throw console.error("JSON.parse error: body fetched from unpkg.com: ",S),L}return C.version}throw new at("Only `major.minor.patch` versions are supported by Accelerate.",{clientVersion:n})}async function vc(e,t){let r=await wf(e,t);return Tc("version",r),r}function bf(e){return encodeURI(`https://unpkg.com/prisma@${e}/package.json`)}var Ac=3,Hr=K("prisma:client:dataproxyEngine"),Gr=class{name="DataProxyEngine";inlineSchema;inlineSchemaHash;inlineDatasources;config;logEmitter;env;clientVersion;engineHash;tracingHelper;remoteClientVersion;host;headerBuilder;startPromise;protocol;constructor(t){xc(t),this.config=t,this.env=t.env,this.inlineSchema=Ec(t.inlineSchema),this.inlineDatasources=t.inlineDatasources,this.inlineSchemaHash=t.inlineSchemaHash,this.clientVersion=t.clientVersion,this.engineHash=t.engineVersion,this.logEmitter=t.logEmitter,this.tracingHelper=t.tracingHelper}apiKey(){return this.headerBuilder.apiKey}version(){return this.engineHash}async start(){this.startPromise!==void 0&&await this.startPromise,this.startPromise=(async()=>{let{apiKey:t,url:r}=this.getURLAndAPIKey();this.host=r.host,this.protocol=r.protocol,this.headerBuilder=new Bt({apiKey:t,tracingHelper:this.tracingHelper,logLevel:this.config.logLevel??"error",logQueries:this.config.logQueries,engineHash:this.engineHash}),this.remoteClientVersion=await vc(this.host,this.config),Hr("host",this.host),Hr("protocol",this.protocol)})(),await this.startPromise}async stop(){}propagateResponseExtensions(t){t?.logs?.length&&t.logs.forEach(r=>{switch(r.level){case"debug":case"trace":Hr(r);break;case"error":case"warn":case"info":{this.logEmitter.emit(r.level,{timestamp:jt(r.timestamp),message:r.attributes.message??"",target:r.target??"BinaryEngine"});break}case"query":{this.logEmitter.emit("query",{query:r.attributes.query??"",timestamp:jt(r.timestamp),duration:r.attributes.duration_ms??0,params:r.attributes.params??"",target:r.target??"BinaryEngine"});break}default:r.level}}),t?.traces?.length&&this.tracingHelper.dispatchEngineSpans(t.traces)}onBeforeExit(){throw new Error('"beforeExit" hook is not applicable to the remote query engine')}async url(t){return await this.start(),`${this.protocol}//${this.host}/${this.remoteClientVersion}/${this.inlineSchemaHash}/${t}`}async uploadSchema(){let t={name:"schemaUpload",internal:!0};return this.tracingHelper.runInChildSpan(t,async()=>{let r=await ct(await this.url("schema"),{method:"PUT",headers:this.headerBuilder.build(),body:this.inlineSchema,clientVersion:this.clientVersion});r.ok||Hr("schema response status",r.status);let n=await jr(r,this.clientVersion);if(n)throw this.logEmitter.emit("warn",{message:`Error while uploading schema: ${n.message}`,timestamp:new Date,target:""}),n;this.logEmitter.emit("info",{message:`Schema (re)uploaded (hash: ${this.inlineSchemaHash})`,timestamp:new Date,target:""})})}request(t,{traceparent:r,interactiveTransaction:n,customDataProxyFetch:i}){return this.requestInternal({body:t,traceparent:r,interactiveTransaction:n,customDataProxyFetch:i})}async requestBatch(t,{traceparent:r,transaction:n,customDataProxyFetch:i}){let o=n?.kind==="itx"?n.options:void 0,s=kt(t,n);return(await this.requestInternal({body:s,customDataProxyFetch:i,interactiveTransaction:o,traceparent:r})).map(f=>(f.extensions&&this.propagateResponseExtensions(f.extensions),"errors"in f?this.convertProtocolErrorsToClientError(f.errors):f))}requestInternal({body:t,traceparent:r,customDataProxyFetch:n,interactiveTransaction:i}){return this.withRetry({actionGerund:"querying",callback:async({logHttpCall:o})=>{let s=i?`${i.payload.endpoint}/graphql`:await this.url("graphql");o(s);let a=await ct(s,{method:"POST",headers:this.headerBuilder.build({traceparent:r,transactionId:i?.id}),body:JSON.stringify(t),clientVersion:this.clientVersion},n);a.ok||Hr("graphql response status",a.status),await this.handleError(await jr(a,this.clientVersion));let f=await a.json();if(f.extensions&&this.propagateResponseExtensions(f.extensions),"errors"in f)throw this.convertProtocolErrorsToClientError(f.errors);return"batchResult"in f?f.batchResult:f}})}async transaction(t,r,n){let i={start:"starting",commit:"committing",rollback:"rolling back"};return this.withRetry({actionGerund:`${i[t]} transaction`,callback:async({logHttpCall:o})=>{if(t==="start"){let s=JSON.stringify({max_wait:n.maxWait,timeout:n.timeout,isolation_level:n.isolationLevel}),a=await this.url("transaction/start");o(a);let f=await ct(a,{method:"POST",headers:this.headerBuilder.build({traceparent:r.traceparent}),body:s,clientVersion:this.clientVersion});await this.handleError(await jr(f,this.clientVersion));let w=await f.json(),{extensions:A}=w;A&&this.propagateResponseExtensions(A);let R=w.id,S=w["data-proxy"].endpoint;return{id:R,payload:{endpoint:S}}}else{let s=`${n.payload.endpoint}/${t}`;o(s);let a=await ct(s,{method:"POST",headers:this.headerBuilder.build({traceparent:r.traceparent}),clientVersion:this.clientVersion});await this.handleError(await jr(a,this.clientVersion));let f=await a.json(),{extensions:w}=f;w&&this.propagateResponseExtensions(w);return}}})}getURLAndAPIKey(){return ni({clientVersion:this.clientVersion,env:this.env,inlineDatasources:this.inlineDatasources,overrideDatasources:this.config.overrideDatasources})}metrics(){throw new at("Metrics are not yet supported for Accelerate",{clientVersion:this.clientVersion})}async withRetry(t){for(let r=0;;r++){let n=i=>{this.logEmitter.emit("info",{message:`Calling ${i} (n=${r})`,timestamp:new Date,target:""})};try{return await t.callback({logHttpCall:n})}catch(i){if(!(i instanceof ge)||!i.isRetryable)throw i;if(r>=Ac)throw i instanceof Qt?i.cause:i;this.logEmitter.emit("warn",{message:`Attempt ${r+1}/${Ac} failed for ${t.actionGerund}: ${i.message??"(unknown)"}`,timestamp:new Date,target:""});let o=await bc(r);this.logEmitter.emit("warn",{message:`Retrying after ${o}ms`,timestamp:new Date,target:""})}}}async handleError(t){if(t instanceof lt)throw await this.uploadSchema(),new Qt({clientVersion:this.clientVersion,cause:t});if(t)throw t}convertProtocolErrorsToClientError(t){return t.length===1?_n(t[0],this.config.clientVersion,this.config.activeProvider):new ne(JSON.stringify(t),{clientVersion:this.config.clientVersion})}applyPendingMigrations(){throw new Error("Method not implemented.")}};c();u();p();m();d();l();function Rc({url:e,adapter:t,copyEngine:r,targetBuildType:n}){let i=[],o=[],s=k=>{i.push({_tag:"warning",value:k})},a=k=>{let M=k.join(` -`);o.push({_tag:"error",value:M})},f=!!e?.startsWith("prisma://"),w=cn(e),A=!!t,R=f||w;!A&&r&&R&&n!=="client"&&n!=="wasm-compiler-edge"&&s(["recommend--no-engine","In production, we recommend using `prisma generate --no-engine` (See: `prisma generate --help`)"]);let S=R||!r;A&&(S||n==="edge")&&(n==="edge"?a(["Prisma Client was configured to use the `adapter` option but it was imported via its `/edge` endpoint.","Please either remove the `/edge` endpoint or remove the `adapter` from the Prisma Client constructor."]):R?a(["You've provided both a driver adapter and an Accelerate database URL. Driver adapters currently cannot connect to Accelerate.","Please provide either a driver adapter with a direct database URL or an Accelerate URL and no driver adapter."]):r||a(["Prisma Client was configured to use the `adapter` option but `prisma generate` was run with `--no-engine`.","Please run `prisma generate` without `--no-engine` to be able to use Prisma Client with the adapter."]));let C={accelerate:S,ppg:w,driverAdapters:A};function L(k){return k.length>0}return L(o)?{ok:!1,diagnostics:{warnings:i,errors:o},isUsing:C}:{ok:!0,diagnostics:{warnings:i},isUsing:C}}function Cc({copyEngine:e=!0},t){let r;try{r=qt({inlineDatasources:t.inlineDatasources,overrideDatasources:t.overrideDatasources,env:{...t.env,...g.env},clientVersion:t.clientVersion})}catch{}let{ok:n,isUsing:i,diagnostics:o}=Rc({url:r,adapter:t.adapter,copyEngine:e,targetBuildType:"wasm-compiler-edge"});for(let R of o.warnings)rr(...R.value);if(!n){let R=o.errors[0];throw new ie(R.value,{clientVersion:t.clientVersion})}let s=gt(t.generator),a=s==="library",f=s==="binary",w=s==="client",A=(i.accelerate||i.ppg)&&!i.driverAdapters;return w?new Dr(t,A):i.accelerate?new Gr(t):(i.driverAdapters,i.accelerate,new _o({clientVersion:t.clientVersion}))}var _o=class{constructor(t){return new Proxy(this,{get(r,n){let i=`In order to run Prisma Client on edge runtime, either: -- Use Prisma Accelerate: https://pris.ly/d/accelerate -- Use Driver Adapters: https://pris.ly/d/driver-adapters`;throw new ie(i,t)}})}};c();u();p();m();d();l();function Sc({generator:e}){return e?.previewFeatures??[]}c();u();p();m();d();l();var Ic=e=>({command:e});c();u();p();m();d();l();c();u();p();m();d();l();var kc=e=>e.strings.reduce((t,r,n)=>`${t}@P${n}${r}`);c();u();p();m();d();l();l();function Jt(e){try{return Oc(e,"fast")}catch{return Oc(e,"slow")}}function Oc(e,t){return JSON.stringify(e.map(r=>_c(r,t)))}function _c(e,t){if(Array.isArray(e))return e.map(r=>_c(r,t));if(typeof e=="bigint")return{prisma__type:"bigint",prisma__value:e.toString()};if(wt(e))return{prisma__type:"date",prisma__value:e.toJSON()};if(se.isDecimal(e))return{prisma__type:"decimal",prisma__value:e.toJSON()};if(y.isBuffer(e))return{prisma__type:"bytes",prisma__value:e.toString("base64")};if(Ef(e))return{prisma__type:"bytes",prisma__value:y.from(e).toString("base64")};if(ArrayBuffer.isView(e)){let{buffer:r,byteOffset:n,byteLength:i}=e;return{prisma__type:"bytes",prisma__value:y.from(r,n,i).toString("base64")}}return typeof e=="object"&&t==="slow"?Mc(e):e}function Ef(e){return e instanceof ArrayBuffer||e instanceof SharedArrayBuffer?!0:typeof e=="object"&&e!==null?e[Symbol.toStringTag]==="ArrayBuffer"||e[Symbol.toStringTag]==="SharedArrayBuffer":!1}function Mc(e){if(typeof e!="object"||e===null)return e;if(typeof e.toJSON=="function")return e.toJSON();if(Array.isArray(e))return e.map(Dc);let t={};for(let r of Object.keys(e))t[r]=Dc(e[r]);return t}function Dc(e){return typeof e=="bigint"?e.toString():Mc(e)}var xf=/^(\s*alter\s)/i,Nc=K("prisma:client");function Mo(e,t,r,n){if(!(e!=="postgresql"&&e!=="cockroachdb")&&r.length>0&&xf.exec(t))throw new Error(`Running ALTER using ${n} is not supported -Using the example below you can still execute your query with Prisma, but please note that it is vulnerable to SQL injection attacks and requires you to take care of input sanitization. - -Example: - await prisma.$executeRawUnsafe(\`ALTER USER prisma WITH PASSWORD '\${password}'\`) - -More Information: https://pris.ly/d/execute-raw -`)}var No=({clientMethod:e,activeProvider:t})=>r=>{let n="",i;if(In(r))n=r.sql,i={values:Jt(r.values),__prismaRawParameters__:!0};else if(Array.isArray(r)){let[o,...s]=r;n=o,i={values:Jt(s||[]),__prismaRawParameters__:!0}}else switch(t){case"sqlite":case"mysql":{n=r.sql,i={values:Jt(r.values),__prismaRawParameters__:!0};break}case"cockroachdb":case"postgresql":case"postgres":{n=r.text,i={values:Jt(r.values),__prismaRawParameters__:!0};break}case"sqlserver":{n=kc(r),i={values:Jt(r.values),__prismaRawParameters__:!0};break}default:throw new Error(`The ${t} provider does not support ${e}`)}return i?.values?Nc(`prisma.${e}(${n}, ${i.values})`):Nc(`prisma.${e}(${n})`),{query:n,parameters:i}},Lc={requestArgsToMiddlewareArgs(e){return[e.strings,...e.values]},middlewareArgsToRequestArgs(e){let[t,...r]=e;return new fe(t,r)}},Uc={requestArgsToMiddlewareArgs(e){return[e]},middlewareArgsToRequestArgs(e){return e[0]}};c();u();p();m();d();l();function Lo(e){return function(r,n){let i,o=(s=e)=>{try{return s===void 0||s?.kind==="itx"?i??=Fc(r(s)):Fc(r(s))}catch(a){return Promise.reject(a)}};return{get spec(){return n},then(s,a){return o().then(s,a)},catch(s){return o().catch(s)},finally(s){return o().finally(s)},requestTransaction(s){let a=o(s);return a.requestTransaction?a.requestTransaction(s):a},[Symbol.toStringTag]:"PrismaPromise"}}}function Fc(e){return typeof e.then=="function"?e:Promise.resolve(e)}c();u();p();m();d();l();var Pf=Ei.split(".")[0],Tf={isEnabled(){return!1},getTraceParent(){return"00-10-10-00"},dispatchEngineSpans(){},getActiveContext(){},runInChildSpan(e,t){return t()}},Uo=class{isEnabled(){return this.getGlobalTracingHelper().isEnabled()}getTraceParent(t){return this.getGlobalTracingHelper().getTraceParent(t)}dispatchEngineSpans(t){return this.getGlobalTracingHelper().dispatchEngineSpans(t)}getActiveContext(){return this.getGlobalTracingHelper().getActiveContext()}runInChildSpan(t,r){return this.getGlobalTracingHelper().runInChildSpan(t,r)}getGlobalTracingHelper(){let t=globalThis[`V${Pf}_PRISMA_INSTRUMENTATION`],r=globalThis.PRISMA_INSTRUMENTATION;return t?.helper??r?.helper??Tf}};function $c(){return new Uo}c();u();p();m();d();l();function Vc(e,t=()=>{}){let r,n=new Promise(i=>r=i);return{then(i){return--e===0&&r(t()),i?.(n)}}}c();u();p();m();d();l();function qc(e){return typeof e=="string"?e:e.reduce((t,r)=>{let n=typeof r=="string"?r:r.level;return n==="query"?t:t&&(r==="info"||t==="info")?"info":n},void 0)}c();u();p();m();d();l();c();u();p();m();d();l();function oi(e){return typeof e.batchRequestIdx=="number"}c();u();p();m();d();l();function Bc(e){if(e.action!=="findUnique"&&e.action!=="findUniqueOrThrow")return;let t=[];return e.modelName&&t.push(e.modelName),e.query.arguments&&t.push(Fo(e.query.arguments)),t.push(Fo(e.query.selection)),t.join("")}function Fo(e){return`(${Object.keys(e).sort().map(r=>{let n=e[r];return typeof n=="object"&&n!==null?`(${r} ${Fo(n)})`:r}).join(" ")})`}c();u();p();m();d();l();var vf={aggregate:!1,aggregateRaw:!1,createMany:!0,createManyAndReturn:!0,createOne:!0,deleteMany:!0,deleteOne:!0,executeRaw:!0,findFirst:!1,findFirstOrThrow:!1,findMany:!1,findRaw:!1,findUnique:!1,findUniqueOrThrow:!1,groupBy:!1,queryRaw:!1,runCommandRaw:!0,updateMany:!0,updateManyAndReturn:!0,updateOne:!0,upsertOne:!0};function $o(e){return vf[e]}c();u();p();m();d();l();var si=class{constructor(t){this.options=t;this.batches={}}batches;tickActive=!1;request(t){let r=this.options.batchBy(t);return r?(this.batches[r]||(this.batches[r]=[],this.tickActive||(this.tickActive=!0,g.nextTick(()=>{this.dispatchBatches(),this.tickActive=!1}))),new Promise((n,i)=>{this.batches[r].push({request:t,resolve:n,reject:i})})):this.options.singleLoader(t)}dispatchBatches(){for(let t in this.batches){let r=this.batches[t];delete this.batches[t],r.length===1?this.options.singleLoader(r[0].request).then(n=>{n instanceof Error?r[0].reject(n):r[0].resolve(n)}).catch(n=>{r[0].reject(n)}):(r.sort((n,i)=>this.options.batchOrder(n.request,i.request)),this.options.batchLoader(r.map(n=>n.request)).then(n=>{if(n instanceof Error)for(let i=0;i{for(let i=0;iut("bigint",r));case"bytes-array":return t.map(r=>ut("bytes",r));case"decimal-array":return t.map(r=>ut("decimal",r));case"datetime-array":return t.map(r=>ut("datetime",r));case"date-array":return t.map(r=>ut("date",r));case"time-array":return t.map(r=>ut("time",r));default:return t}}function ai(e){let t=[],r=Af(e);for(let n=0;n{let{transaction:o,otelParentCtx:s}=n[0],a=n.map(R=>R.protocolQuery),f=this.client._tracingHelper.getTraceParent(s),w=n.some(R=>$o(R.protocolQuery.action));return(await this.client._engine.requestBatch(a,{traceparent:f,transaction:Cf(o),containsWrite:w,customDataProxyFetch:i})).map((R,S)=>{if(R instanceof Error)return R;try{return this.mapQueryEngineResult(n[S],R)}catch(C){return C}})}),singleLoader:async n=>{let i=n.transaction?.kind==="itx"?jc(n.transaction):void 0,o=await this.client._engine.request(n.protocolQuery,{traceparent:this.client._tracingHelper.getTraceParent(),interactiveTransaction:i,isWrite:$o(n.protocolQuery.action),customDataProxyFetch:n.customDataProxyFetch});return this.mapQueryEngineResult(n,o)},batchBy:n=>n.transaction?.id?`transaction-${n.transaction.id}`:Bc(n.protocolQuery),batchOrder(n,i){return n.transaction?.kind==="batch"&&i.transaction?.kind==="batch"?n.transaction.index-i.transaction.index:0}})}async request(t){try{return await this.dataloader.request(t)}catch(r){let{clientMethod:n,callsite:i,transaction:o,args:s,modelName:a}=t;this.handleAndLogRequestError({error:r,clientMethod:n,callsite:i,transaction:o,args:s,modelName:a,globalOmit:t.globalOmit})}}mapQueryEngineResult({dataPath:t,unpacker:r},n){let i=n?.data,o=this.unpack(i,t,r);return g.env.PRISMA_CLIENT_GET_TIME?{data:o}:o}handleAndLogRequestError(t){try{this.handleRequestError(t)}catch(r){throw this.logEmitter&&this.logEmitter.emit("error",{message:r.message,target:t.clientMethod,timestamp:new Date}),r}}handleRequestError({error:t,clientMethod:r,callsite:n,transaction:i,args:o,modelName:s,globalOmit:a}){if(Rf(t),Sf(t,i))throw t;if(t instanceof X&&If(t)){let w=Qc(t.meta);Tn({args:o,errors:[w],callsite:n,errorFormat:this.client._errorFormat,originalMethod:r,clientVersion:this.client._clientVersion,globalOmit:a})}let f=t.message;if(n&&(f=dn({callsite:n,originalMethod:r,isPanic:t.isPanic,showColors:this.client._errorFormat==="pretty",message:f})),f=this.sanitizeMessage(f),t.code){let w=s?{modelName:s,...t.meta}:t.meta;throw new X(f,{code:t.code,clientVersion:this.client._clientVersion,meta:w,batchRequestIdx:t.batchRequestIdx})}else{if(t.isPanic)throw new ae(f,this.client._clientVersion);if(t instanceof ne)throw new ne(f,{clientVersion:this.client._clientVersion,batchRequestIdx:t.batchRequestIdx});if(t instanceof F)throw new F(f,this.client._clientVersion);if(t instanceof ae)throw new ae(f,this.client._clientVersion)}throw t.clientVersion=this.client._clientVersion,t}sanitizeMessage(t){return this.client._errorFormat&&this.client._errorFormat!=="pretty"?ht(t):t}unpack(t,r,n){if(!t||(t.data&&(t=t.data),!t))return t;let i=Object.keys(t)[0],o=Object.values(t)[0],s=r.filter(w=>w!=="select"&&w!=="include"),a=qi(o,s),f=i==="queryRaw"?ai(a):Qe(a);return n?n(f):f}get[Symbol.toStringTag](){return"RequestHandler"}};function Cf(e){if(e){if(e.kind==="batch")return{kind:"batch",options:{isolationLevel:e.isolationLevel}};if(e.kind==="itx")return{kind:"itx",options:jc(e)};Me(e,"Unknown transaction kind")}}function jc(e){return{id:e.id,payload:e.payload}}function Sf(e,t){return oi(e)&&t?.kind==="batch"&&e.batchRequestIdx!==t.index}function If(e){return e.code==="P2009"||e.code==="P2012"}function Qc(e){if(e.kind==="Union")return{kind:"Union",errors:e.errors.map(Qc)};if(Array.isArray(e.selectionPath)){let[,...t]=e.selectionPath;return{...e,selectionPath:t}}return e}c();u();p();m();d();l();var Hc=Zn;c();u();p();m();d();l();var zc=$e(Ii());c();u();p();m();d();l();var V=class extends Error{constructor(t){super(t+` -Read more at https://pris.ly/d/client-constructor`),this.name="PrismaClientConstructorValidationError"}get[Symbol.toStringTag](){return"PrismaClientConstructorValidationError"}};D(V,"PrismaClientConstructorValidationError");var Gc=["datasources","datasourceUrl","errorFormat","adapter","log","transactionOptions","omit","__internal"],Jc=["pretty","colorless","minimal"],Wc=["info","query","warn","error"],kf={datasources:(e,{datasourceNames:t})=>{if(e){if(typeof e!="object"||Array.isArray(e))throw new V(`Invalid value ${JSON.stringify(e)} for "datasources" provided to PrismaClient constructor`);for(let[r,n]of Object.entries(e)){if(!t.includes(r)){let i=Wt(r,t)||` Available datasources: ${t.join(", ")}`;throw new V(`Unknown datasource ${r} provided to PrismaClient constructor.${i}`)}if(typeof n!="object"||Array.isArray(n))throw new V(`Invalid value ${JSON.stringify(e)} for datasource "${r}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`);if(n&&typeof n=="object")for(let[i,o]of Object.entries(n)){if(i!=="url")throw new V(`Invalid value ${JSON.stringify(e)} for datasource "${r}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`);if(typeof o!="string")throw new V(`Invalid value ${JSON.stringify(o)} for datasource "${r}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`)}}}},adapter:(e,t)=>{if(!e&>(t.generator)==="client")throw new V('Using engine type "client" requires a driver adapter to be provided to PrismaClient constructor.');if(e!==null){if(e===void 0)throw new V('"adapter" property must not be undefined, use null to conditionally disable driver adapters.');if(gt(t.generator)==="binary")throw new V('Cannot use a driver adapter with the "binary" Query Engine. Please use the "library" Query Engine.')}},datasourceUrl:e=>{if(typeof e<"u"&&typeof e!="string")throw new V(`Invalid value ${JSON.stringify(e)} for "datasourceUrl" provided to PrismaClient constructor. -Expected string or undefined.`)},errorFormat:e=>{if(e){if(typeof e!="string")throw new V(`Invalid value ${JSON.stringify(e)} for "errorFormat" provided to PrismaClient constructor.`);if(!Jc.includes(e)){let t=Wt(e,Jc);throw new V(`Invalid errorFormat ${e} provided to PrismaClient constructor.${t}`)}}},log:e=>{if(!e)return;if(!Array.isArray(e))throw new V(`Invalid value ${JSON.stringify(e)} for "log" provided to PrismaClient constructor.`);function t(r){if(typeof r=="string"&&!Wc.includes(r)){let n=Wt(r,Wc);throw new V(`Invalid log level "${r}" provided to PrismaClient constructor.${n}`)}}for(let r of e){t(r);let n={level:t,emit:i=>{let o=["stdout","event"];if(!o.includes(i)){let s=Wt(i,o);throw new V(`Invalid value ${JSON.stringify(i)} for "emit" in logLevel provided to PrismaClient constructor.${s}`)}}};if(r&&typeof r=="object")for(let[i,o]of Object.entries(r))if(n[i])n[i](o);else throw new V(`Invalid property ${i} for "log" provided to PrismaClient constructor`)}},transactionOptions:e=>{if(!e)return;let t=e.maxWait;if(t!=null&&t<=0)throw new V(`Invalid value ${t} for maxWait in "transactionOptions" provided to PrismaClient constructor. maxWait needs to be greater than 0`);let r=e.timeout;if(r!=null&&r<=0)throw new V(`Invalid value ${r} for timeout in "transactionOptions" provided to PrismaClient constructor. timeout needs to be greater than 0`)},omit:(e,t)=>{if(typeof e!="object")throw new V('"omit" option is expected to be an object.');if(e===null)throw new V('"omit" option can not be `null`');let r=[];for(let[n,i]of Object.entries(e)){let o=Df(n,t.runtimeDataModel);if(!o){r.push({kind:"UnknownModel",modelKey:n});continue}for(let[s,a]of Object.entries(i)){let f=o.fields.find(w=>w.name===s);if(!f){r.push({kind:"UnknownField",modelKey:n,fieldName:s});continue}if(f.relationName){r.push({kind:"RelationInOmit",modelKey:n,fieldName:s});continue}typeof a!="boolean"&&r.push({kind:"InvalidFieldValue",modelKey:n,fieldName:s})}}if(r.length>0)throw new V(_f(e,r))},__internal:e=>{if(!e)return;let t=["debug","engine","configOverride"];if(typeof e!="object")throw new V(`Invalid value ${JSON.stringify(e)} for "__internal" to PrismaClient constructor`);for(let[r]of Object.entries(e))if(!t.includes(r)){let n=Wt(r,t);throw new V(`Invalid property ${JSON.stringify(r)} for "__internal" provided to PrismaClient constructor.${n}`)}}};function Yc(e,t){for(let[r,n]of Object.entries(e)){if(!Gc.includes(r)){let i=Wt(r,Gc);throw new V(`Unknown property ${r} provided to PrismaClient constructor.${i}`)}kf[r](n,t)}if(e.datasourceUrl&&e.datasources)throw new V('Can not use "datasourceUrl" and "datasources" options at the same time. Pick one of them')}function Wt(e,t){if(t.length===0||typeof e!="string")return"";let r=Of(e,t);return r?` Did you mean "${r}"?`:""}function Of(e,t){if(t.length===0)return null;let r=t.map(i=>({value:i,distance:(0,zc.default)(e,i)}));r.sort((i,o)=>i.distanceqe(n)===t);if(r)return e[r]}function _f(e,t){let r=Rt(e);for(let o of t)switch(o.kind){case"UnknownModel":r.arguments.getField(o.modelKey)?.markAsError(),r.addErrorMessage(()=>`Unknown model name: ${o.modelKey}.`);break;case"UnknownField":r.arguments.getDeepField([o.modelKey,o.fieldName])?.markAsError(),r.addErrorMessage(()=>`Model "${o.modelKey}" does not have a field named "${o.fieldName}".`);break;case"RelationInOmit":r.arguments.getDeepField([o.modelKey,o.fieldName])?.markAsError(),r.addErrorMessage(()=>'Relations are already excluded by default and can not be specified in "omit".');break;case"InvalidFieldValue":r.arguments.getDeepFieldValue([o.modelKey,o.fieldName])?.markAsError(),r.addErrorMessage(()=>"Omit field option value must be a boolean.");break}let{message:n,args:i}=Pn(r,"colorless");return`Error validating "omit" option: - -${i} - -${n}`}c();u();p();m();d();l();function Zc(e){return e.length===0?Promise.resolve([]):new Promise((t,r)=>{let n=new Array(e.length),i=null,o=!1,s=0,a=()=>{o||(s++,s===e.length&&(o=!0,i?r(i):t(n)))},f=w=>{o||(o=!0,r(w))};for(let w=0;w{n[w]=A,a()},A=>{if(!oi(A)){f(A);return}A.batchRequestIdx===w?f(A):(i||(i=A),a())})})}var We=K("prisma:client");typeof globalThis=="object"&&(globalThis.NODE_CLIENT=!0);var Mf={requestArgsToMiddlewareArgs:e=>e,middlewareArgsToRequestArgs:e=>e},Nf=Symbol.for("prisma.client.transaction.id"),Lf={id:0,nextId(){return++this.id}};function tu(e){class t{_originalClient=this;_runtimeDataModel;_requestHandler;_connectionPromise;_disconnectionPromise;_engineConfig;_accelerateEngineConfig;_clientVersion;_errorFormat;_tracingHelper;_previewFeatures;_activeProvider;_globalOmit;_extensions;_engine;_appliedParent;_createPrismaPromise=Lo();constructor(n){e=n?.__internal?.configOverride?.(e)??e,$a(e),n&&Yc(n,e);let i=new kn().on("error",()=>{});this._extensions=Ct.empty(),this._previewFeatures=Sc(e),this._clientVersion=e.clientVersion??Hc,this._activeProvider=e.activeProvider,this._globalOmit=n?.omit,this._tracingHelper=$c();let o=e.relativeEnvPaths&&{rootEnvPath:e.relativeEnvPaths.rootEnvPath&&rn.resolve(e.dirname,e.relativeEnvPaths.rootEnvPath),schemaEnvPath:e.relativeEnvPaths.schemaEnvPath&&rn.resolve(e.dirname,e.relativeEnvPaths.schemaEnvPath)},s;if(n?.adapter){s=n.adapter;let f=e.activeProvider==="postgresql"||e.activeProvider==="cockroachdb"?"postgres":e.activeProvider;if(s.provider!==f)throw new F(`The Driver Adapter \`${s.adapterName}\`, based on \`${s.provider}\`, is not compatible with the provider \`${f}\` specified in the Prisma schema.`,this._clientVersion);if(n.datasources||n.datasourceUrl!==void 0)throw new F("Custom datasource configuration is not compatible with Prisma Driver Adapters. Please define the database connection string directly in the Driver Adapter configuration.",this._clientVersion)}let a=e.injectableEdgeEnv?.();try{let f=n??{},w=f.__internal??{},A=w.debug===!0;A&&K.enable("prisma:client");let R=rn.resolve(e.dirname,e.relativePath);fs.existsSync(R)||(R=e.dirname),We("dirname",e.dirname),We("relativePath",e.relativePath),We("cwd",R);let S=w.engine||{};if(f.errorFormat?this._errorFormat=f.errorFormat:g.env.NODE_ENV==="production"?this._errorFormat="minimal":g.env.NO_COLOR?this._errorFormat="colorless":this._errorFormat="colorless",this._runtimeDataModel=e.runtimeDataModel,this._engineConfig={cwd:R,dirname:e.dirname,enableDebugLogs:A,allowTriggerPanic:S.allowTriggerPanic,prismaPath:S.binaryPath??void 0,engineEndpoint:S.endpoint,generator:e.generator,showColors:this._errorFormat==="pretty",logLevel:f.log&&qc(f.log),logQueries:f.log&&!!(typeof f.log=="string"?f.log==="query":f.log.find(C=>typeof C=="string"?C==="query":C.level==="query")),env:a?.parsed??{},flags:[],engineWasm:e.engineWasm,compilerWasm:e.compilerWasm,clientVersion:e.clientVersion,engineVersion:e.engineVersion,previewFeatures:this._previewFeatures,activeProvider:e.activeProvider,inlineSchema:e.inlineSchema,overrideDatasources:Va(f,e.datasourceNames),inlineDatasources:e.inlineDatasources,inlineSchemaHash:e.inlineSchemaHash,tracingHelper:this._tracingHelper,transactionOptions:{maxWait:f.transactionOptions?.maxWait??2e3,timeout:f.transactionOptions?.timeout??5e3,isolationLevel:f.transactionOptions?.isolationLevel},logEmitter:i,isBundled:e.isBundled,adapter:s},this._accelerateEngineConfig={...this._engineConfig,accelerateUtils:{resolveDatasourceUrl:qt,getBatchRequestPayload:kt,prismaGraphQLToJSError:_n,PrismaClientUnknownRequestError:ne,PrismaClientInitializationError:F,PrismaClientKnownRequestError:X,debug:K("prisma:client:accelerateEngine"),engineVersion:eu.version,clientVersion:e.clientVersion}},We("clientVersion",e.clientVersion),this._engine=Cc(e,this._engineConfig),this._requestHandler=new li(this,i),f.log)for(let C of f.log){let L=typeof C=="string"?C:C.emit==="stdout"?C.level:null;L&&this.$on(L,k=>{tr.log(`${tr.tags[L]??""}`,k.message||k.query)})}}catch(f){throw f.clientVersion=this._clientVersion,f}return this._appliedParent=hr(this)}get[Symbol.toStringTag](){return"PrismaClient"}$on(n,i){return n==="beforeExit"?this._engine.onBeforeExit(i):n&&this._engineConfig.logEmitter.on(n,i),this}$connect(){try{return this._engine.start()}catch(n){throw n.clientVersion=this._clientVersion,n}}async $disconnect(){try{await this._engine.stop()}catch(n){throw n.clientVersion=this._clientVersion,n}finally{ds()}}$executeRawInternal(n,i,o,s){let a=this._activeProvider;return this._request({action:"executeRaw",args:o,transaction:n,clientMethod:i,argsMapper:No({clientMethod:i,activeProvider:a}),callsite:je(this._errorFormat),dataPath:[],middlewareArgsMapper:s})}$executeRaw(n,...i){return this._createPrismaPromise(o=>{if(n.raw!==void 0||n.sql!==void 0){let[s,a]=Xc(n,i);return Mo(this._activeProvider,s.text,s.values,Array.isArray(n)?"prisma.$executeRaw``":"prisma.$executeRaw(sql``)"),this.$executeRawInternal(o,"$executeRaw",s,a)}throw new ie("`$executeRaw` is a tag function, please use it like the following:\n```\nconst result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`\n```\n\nOr read our docs at https://www.prisma.io/docs/concepts/components/prisma-client/raw-database-access#executeraw\n",{clientVersion:this._clientVersion})})}$executeRawUnsafe(n,...i){return this._createPrismaPromise(o=>(Mo(this._activeProvider,n,i,"prisma.$executeRawUnsafe(, [...values])"),this.$executeRawInternal(o,"$executeRawUnsafe",[n,...i])))}$runCommandRaw(n){if(e.activeProvider!=="mongodb")throw new ie(`The ${e.activeProvider} provider does not support $runCommandRaw. Use the mongodb provider.`,{clientVersion:this._clientVersion});return this._createPrismaPromise(i=>this._request({args:n,clientMethod:"$runCommandRaw",dataPath:[],action:"runCommandRaw",argsMapper:Ic,callsite:je(this._errorFormat),transaction:i}))}async $queryRawInternal(n,i,o,s){let a=this._activeProvider;return this._request({action:"queryRaw",args:o,transaction:n,clientMethod:i,argsMapper:No({clientMethod:i,activeProvider:a}),callsite:je(this._errorFormat),dataPath:[],middlewareArgsMapper:s})}$queryRaw(n,...i){return this._createPrismaPromise(o=>{if(n.raw!==void 0||n.sql!==void 0)return this.$queryRawInternal(o,"$queryRaw",...Xc(n,i));throw new ie("`$queryRaw` is a tag function, please use it like the following:\n```\nconst result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`\n```\n\nOr read our docs at https://www.prisma.io/docs/concepts/components/prisma-client/raw-database-access#queryraw\n",{clientVersion:this._clientVersion})})}$queryRawTyped(n){return this._createPrismaPromise(i=>{if(!this._hasPreviewFlag("typedSql"))throw new ie("`typedSql` preview feature must be enabled in order to access $queryRawTyped API",{clientVersion:this._clientVersion});return this.$queryRawInternal(i,"$queryRawTyped",n)})}$queryRawUnsafe(n,...i){return this._createPrismaPromise(o=>this.$queryRawInternal(o,"$queryRawUnsafe",[n,...i]))}_transactionWithArray({promises:n,options:i}){let o=Lf.nextId(),s=Vc(n.length),a=n.map((f,w)=>{if(f?.[Symbol.toStringTag]!=="PrismaPromise")throw new Error("All elements of the array need to be Prisma Client promises. Hint: Please make sure you are not awaiting the Prisma client calls you intended to pass in the $transaction function.");let A=i?.isolationLevel??this._engineConfig.transactionOptions.isolationLevel,R={kind:"batch",id:o,index:w,isolationLevel:A,lock:s};return f.requestTransaction?.(R)??f});return Zc(a)}async _transactionWithCallback({callback:n,options:i}){let o={traceparent:this._tracingHelper.getTraceParent()},s={maxWait:i?.maxWait??this._engineConfig.transactionOptions.maxWait,timeout:i?.timeout??this._engineConfig.transactionOptions.timeout,isolationLevel:i?.isolationLevel??this._engineConfig.transactionOptions.isolationLevel},a=await this._engine.transaction("start",o,s),f;try{let w={kind:"itx",...a};f=await n(this._createItxClient(w)),await this._engine.transaction("commit",o,a)}catch(w){throw await this._engine.transaction("rollback",o,a).catch(()=>{}),w}return f}_createItxClient(n){return Pe(hr(Pe(va(this),[le("_appliedParent",()=>this._appliedParent._createItxClient(n)),le("_createPrismaPromise",()=>Lo(n)),le(Nf,()=>n.id)])),[It(Ia)])}$transaction(n,i){let o;typeof n=="function"?this._engineConfig.adapter?.adapterName==="@prisma/adapter-d1"?o=()=>{throw new Error("Cloudflare D1 does not support interactive transactions. We recommend you to refactor your queries with that limitation in mind, and use batch transactions with `prisma.$transactions([])` where applicable.")}:o=()=>this._transactionWithCallback({callback:n,options:i}):o=()=>this._transactionWithArray({promises:n,options:i});let s={name:"transaction",attributes:{method:"$transaction"}};return this._tracingHelper.runInChildSpan(s,o)}_request(n){n.otelParentCtx=this._tracingHelper.getActiveContext();let i=n.middlewareArgsMapper??Mf,o={args:i.requestArgsToMiddlewareArgs(n.args),dataPath:n.dataPath,runInTransaction:!!n.transaction,action:n.action,model:n.model},s={operation:{name:"operation",attributes:{method:o.action,model:o.model,name:o.model?`${o.model}.${o.action}`:o.action}}},a=async f=>{let{runInTransaction:w,args:A,...R}=f,S={...n,...R};A&&(S.args=i.middlewareArgsToRequestArgs(A)),n.transaction!==void 0&&w===!1&&delete S.transaction;let C=await _a(this,S);return S.model?Sa({result:C,modelName:S.model,args:S.args,extensions:this._extensions,runtimeDataModel:this._runtimeDataModel,globalOmit:this._globalOmit}):C};return this._tracingHelper.runInChildSpan(s.operation,()=>a(o))}async _executeRequest({args:n,clientMethod:i,dataPath:o,callsite:s,action:a,model:f,argsMapper:w,transaction:A,unpacker:R,otelParentCtx:S,customDataProxyFetch:C}){try{n=w?w(n):n;let L={name:"serialize"},k=this._tracingHelper.runInChildSpan(L,()=>Cn({modelName:f,runtimeDataModel:this._runtimeDataModel,action:a,args:n,clientMethod:i,callsite:s,extensions:this._extensions,errorFormat:this._errorFormat,clientVersion:this._clientVersion,previewFeatures:this._previewFeatures,globalOmit:this._globalOmit}));return K.enabled("prisma:client")&&(We("Prisma Client call:"),We(`prisma.${i}(${fa(n)})`),We("Generated request:"),We(JSON.stringify(k,null,2)+` -`)),A?.kind==="batch"&&await A.lock,this._requestHandler.request({protocolQuery:k,modelName:f,action:a,clientMethod:i,dataPath:o,callsite:s,args:n,extensions:this._extensions,transaction:A,unpacker:R,otelParentCtx:S,otelChildCtx:this._tracingHelper.getActiveContext(),globalOmit:this._globalOmit,customDataProxyFetch:C})}catch(L){throw L.clientVersion=this._clientVersion,L}}$metrics=new St(this);_hasPreviewFlag(n){return!!this._engineConfig.previewFeatures?.includes(n)}$applyPendingMigrations(){return this._engine.applyPendingMigrations()}$extends=Aa}return t}function Xc(e,t){return Uf(e)?[new fe(e,t),Lc]:[e,Uc]}function Uf(e){return Array.isArray(e)&&Array.isArray(e.raw)}c();u();p();m();d();l();var Ff=new Set(["toJSON","$$typeof","asymmetricMatch",Symbol.iterator,Symbol.toStringTag,Symbol.isConcatSpreadable,Symbol.toPrimitive]);function ru(e){return new Proxy(e,{get(t,r){if(r in t)return t[r];if(!Ff.has(r))throw new TypeError(`Invalid enum value: ${String(r)}`)}})}c();u();p();m();d();l();l();0&&(module.exports={DMMF,Debug,Decimal,Extensions,MetricsClient,PrismaClientInitializationError,PrismaClientKnownRequestError,PrismaClientRustPanicError,PrismaClientUnknownRequestError,PrismaClientValidationError,Public,Sql,createParam,defineDmmfProperty,deserializeJsonResponse,deserializeRawResult,dmmfToRuntimeDataModel,empty,getPrismaClient,getRuntime,join,makeStrictEnum,makeTypedQueryFactory,objectEnumValues,raw,serializeJsonQuery,skip,sqltag,warnEnvConflicts,warnOnce}); -//# sourceMappingURL=wasm-compiler-edge.js.map diff --git a/frontend/generated/prisma/runtime/wasm-engine-edge.js b/frontend/generated/prisma/runtime/wasm-engine-edge.js deleted file mode 100644 index 4068e4e..0000000 --- a/frontend/generated/prisma/runtime/wasm-engine-edge.js +++ /dev/null @@ -1,37 +0,0 @@ - -/* !!! This is code generated by Prisma. Do not edit directly. !!! -/* eslint-disable */ -// biome-ignore-all lint: generated file -"use strict";var zo=Object.create;var St=Object.defineProperty;var Yo=Object.getOwnPropertyDescriptor;var Xo=Object.getOwnPropertyNames;var Zo=Object.getPrototypeOf,es=Object.prototype.hasOwnProperty;var ie=(t,e)=>()=>(t&&(e=t(t=0)),e);var Ot=(t,e)=>()=>(e||t((e={exports:{}}).exports,e),e.exports),rt=(t,e)=>{for(var r in e)St(t,r,{get:e[r],enumerable:!0})},dn=(t,e,r,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of Xo(e))!es.call(t,i)&&i!==r&&St(t,i,{get:()=>e[i],enumerable:!(n=Yo(e,i))||n.enumerable});return t};var kt=(t,e,r)=>(r=t!=null?zo(Zo(t)):{},dn(e||!t||!t.__esModule?St(r,"default",{value:t,enumerable:!0}):r,t)),ts=t=>dn(St({},"__esModule",{value:!0}),t);function xr(t,e){if(e=e.toLowerCase(),e==="utf8"||e==="utf-8")return new y(os.encode(t));if(e==="base64"||e==="base64url")return t=t.replace(/-/g,"+").replace(/_/g,"/"),t=t.replace(/[^A-Za-z0-9+/]/g,""),new y([...atob(t)].map(r=>r.charCodeAt(0)));if(e==="binary"||e==="ascii"||e==="latin1"||e==="latin-1")return new y([...t].map(r=>r.charCodeAt(0)));if(e==="ucs2"||e==="ucs-2"||e==="utf16le"||e==="utf-16le"){let r=new y(t.length*2),n=new DataView(r.buffer);for(let i=0;ia.startsWith("get")||a.startsWith("set")),n=r.map(a=>a.replace("get","read").replace("set","write")),i=(a,f)=>function(h=0){return V(h,"offset"),X(h,"offset"),$(h,"offset",this.length-1),new DataView(this.buffer)[r[a]](h,f)},o=(a,f)=>function(h,C=0){let A=r[a].match(/set(\w+\d+)/)[1].toLowerCase(),k=is[A];return V(C,"offset"),X(C,"offset"),$(C,"offset",this.length-1),ns(h,"value",k[0],k[1]),new DataView(this.buffer)[r[a]](C,h,f),C+parseInt(r[a].match(/\d+/)[0])/8},s=a=>{a.forEach(f=>{f.includes("Uint")&&(t[f.replace("Uint","UInt")]=t[f]),f.includes("Float64")&&(t[f.replace("Float64","Double")]=t[f]),f.includes("Float32")&&(t[f.replace("Float32","Float")]=t[f])})};n.forEach((a,f)=>{a.startsWith("read")&&(t[a]=i(f,!1),t[a+"LE"]=i(f,!0),t[a+"BE"]=i(f,!1)),a.startsWith("write")&&(t[a]=o(f,!1),t[a+"LE"]=o(f,!0),t[a+"BE"]=o(f,!1)),s([a,a+"LE",a+"BE"])})}function gn(t){throw new Error(`Buffer polyfill does not implement "${t}"`)}function Dt(t,e){if(!(t instanceof Uint8Array))throw new TypeError(`The "${e}" argument must be an instance of Buffer or Uint8Array`)}function $(t,e,r=ls+1){if(t<0||t>r){let n=new RangeError(`The value of "${e}" is out of range. It must be >= 0 && <= ${r}. Received ${t}`);throw n.code="ERR_OUT_OF_RANGE",n}}function V(t,e){if(typeof t!="number"){let r=new TypeError(`The "${e}" argument must be of type number. Received type ${typeof t}.`);throw r.code="ERR_INVALID_ARG_TYPE",r}}function X(t,e){if(!Number.isInteger(t)||Number.isNaN(t)){let r=new RangeError(`The value of "${e}" is out of range. It must be an integer. Received ${t}`);throw r.code="ERR_OUT_OF_RANGE",r}}function ns(t,e,r,n){if(tn){let i=new RangeError(`The value of "${e}" is out of range. It must be >= ${r} and <= ${n}. Received ${t}`);throw i.code="ERR_OUT_OF_RANGE",i}}function fn(t,e){if(typeof t!="string"){let r=new TypeError(`The "${e}" argument must be of type string. Received type ${typeof t}`);throw r.code="ERR_INVALID_ARG_TYPE",r}}function us(t,e="utf8"){return y.from(t,e)}var y,is,os,ss,as,ls,b,Er,u=ie(()=>{"use strict";y=class t extends Uint8Array{_isBuffer=!0;get offset(){return this.byteOffset}static alloc(e,r=0,n="utf8"){return fn(n,"encoding"),t.allocUnsafe(e).fill(r,n)}static allocUnsafe(e){return t.from(e)}static allocUnsafeSlow(e){return t.from(e)}static isBuffer(e){return e&&!!e._isBuffer}static byteLength(e,r="utf8"){if(typeof e=="string")return xr(e,r).byteLength;if(e&&e.byteLength)return e.byteLength;let n=new TypeError('The "string" argument must be of type string or an instance of Buffer or ArrayBuffer.');throw n.code="ERR_INVALID_ARG_TYPE",n}static isEncoding(e){return as.includes(e)}static compare(e,r){Dt(e,"buff1"),Dt(r,"buff2");for(let n=0;nr[n])return 1}return e.length===r.length?0:e.length>r.length?1:-1}static from(e,r="utf8"){if(e&&typeof e=="object"&&e.type==="Buffer")return new t(e.data);if(typeof e=="number")return new t(new Uint8Array(e));if(typeof e=="string")return xr(e,r);if(ArrayBuffer.isView(e)){let{byteOffset:n,byteLength:i,buffer:o}=e;return"map"in e&&typeof e.map=="function"?new t(e.map(s=>s%256),n,i):new t(o,n,i)}if(e&&typeof e=="object"&&("length"in e||"byteLength"in e||"buffer"in e))return new t(e);throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.")}static concat(e,r){if(e.length===0)return t.alloc(0);let n=[].concat(...e.map(o=>[...o])),i=t.alloc(r!==void 0?r:n.length);return i.set(r!==void 0?n.slice(0,r):n),i}slice(e=0,r=this.length){return this.subarray(e,r)}subarray(e=0,r=this.length){return Object.setPrototypeOf(super.subarray(e,r),t.prototype)}reverse(){return super.reverse(),this}readIntBE(e,r){V(e,"offset"),X(e,"offset"),$(e,"offset",this.length-1),V(r,"byteLength"),X(r,"byteLength");let n=new DataView(this.buffer,e,r),i=0;for(let o=0;o=0;o--)i.setUint8(o,e&255),e=e/256;return r+n}writeUintBE(e,r,n){return this.writeUIntBE(e,r,n)}writeUIntLE(e,r,n){V(r,"offset"),X(r,"offset"),$(r,"offset",this.length-1),V(n,"byteLength"),X(n,"byteLength");let i=new DataView(this.buffer,r,n);for(let o=0;or===e[n])}copy(e,r=0,n=0,i=this.length){$(r,"targetStart"),$(n,"sourceStart",this.length),$(i,"sourceEnd"),r>>>=0,n>>>=0,i>>>=0;let o=0;for(;n=this.length?this.length-a:e.length),a);return this}includes(e,r=null,n="utf-8"){return this.indexOf(e,r,n)!==-1}lastIndexOf(e,r=null,n="utf-8"){return this.indexOf(e,r,n,!0)}indexOf(e,r=null,n="utf-8",i=!1){let o=i?this.findLastIndex.bind(this):this.findIndex.bind(this);n=typeof r=="string"?r:n;let s=t.from(typeof e=="number"?[e]:e,n),a=typeof r=="string"?0:r;return a=typeof r=="number"?a:null,a=Number.isNaN(a)?null:a,a??=i?this.length:0,a=a<0?this.length+a:a,s.length===0&&i===!1?a>=this.length?this.length:a:s.length===0&&i===!0?(a>=this.length?this.length:a)||this.length:o((f,h)=>(i?h<=a:h>=a)&&this[h]===s[0]&&s.every((A,k)=>this[h+k]===A))}toString(e="utf8",r=0,n=this.length){if(r=r<0?0:r,e=e.toString().toLowerCase(),n<=0)return"";if(e==="utf8"||e==="utf-8")return ss.decode(this.slice(r,n));if(e==="base64"||e==="base64url"){let i=btoa(this.reduce((o,s)=>o+Er(s),""));return e==="base64url"?i.replace(/\+/g,"-").replace(/\//g,"_").replace(/=+$/,""):i}if(e==="binary"||e==="ascii"||e==="latin1"||e==="latin-1")return this.slice(r,n).reduce((i,o)=>i+Er(o&(e==="ascii"?127:255)),"");if(e==="ucs2"||e==="ucs-2"||e==="utf16le"||e==="utf-16le"){let i=new DataView(this.buffer.slice(r,n));return Array.from({length:i.byteLength/2},(o,s)=>s*2+1i+o.toString(16).padStart(2,"0"),"");gn(`encoding "${e}"`)}toLocaleString(){return this.toString()}inspect(){return``}};is={int8:[-128,127],int16:[-32768,32767],int32:[-2147483648,2147483647],uint8:[0,255],uint16:[0,65535],uint32:[0,4294967295],float32:[-1/0,1/0],float64:[-1/0,1/0],bigint64:[-0x8000000000000000n,0x7fffffffffffffffn],biguint64:[0n,0xffffffffffffffffn]},os=new TextEncoder,ss=new TextDecoder,as=["utf8","utf-8","hex","base64","ascii","binary","base64url","ucs2","ucs-2","utf16le","utf-16le","latin1","latin-1"],ls=4294967295;rs(y.prototype);b=new Proxy(us,{construct(t,[e,r]){return y.from(e,r)},get(t,e){return y[e]}}),Er=String.fromCodePoint});var g,E,c=ie(()=>{"use strict";g={nextTick:(t,...e)=>{setTimeout(()=>{t(...e)},0)},env:{},version:"",cwd:()=>"/",stderr:{},argv:["/bin/node"],pid:1e4},{cwd:E}=g});var P,m=ie(()=>{"use strict";P=globalThis.performance??(()=>{let t=Date.now();return{now:()=>Date.now()-t}})()});var x,p=ie(()=>{"use strict";x=()=>{};x.prototype=x});var w,d=ie(()=>{"use strict";w=class{value;constructor(e){this.value=e}deref(){return this.value}}});function wn(t,e){var r,n,i,o,s,a,f,h,C=t.constructor,A=C.precision;if(!t.s||!e.s)return e.s||(e=new C(t)),q?L(e,A):e;if(f=t.d,h=e.d,s=t.e,i=e.e,f=f.slice(),o=s-i,o){for(o<0?(n=f,o=-o,a=h.length):(n=h,i=s,a=f.length),s=Math.ceil(A/N),a=s>a?s+1:a+1,o>a&&(o=a,n.length=1),n.reverse();o--;)n.push(0);n.reverse()}for(a=f.length,o=h.length,a-o<0&&(o=a,n=h,h=f,f=n),r=0;o;)r=(f[--o]=f[o]+h[o]+r)/J|0,f[o]%=J;for(r&&(f.unshift(r),++i),a=f.length;f[--a]==0;)f.pop();return e.d=f,e.e=i,q?L(e,A):e}function ce(t,e,r){if(t!==~~t||tr)throw Error(Oe+t)}function ue(t){var e,r,n,i=t.length-1,o="",s=t[0];if(i>0){for(o+=s,e=1;e16)throw Error(vr+j(t));if(!t.s)return new C(te);for(e==null?(q=!1,a=A):a=e,s=new C(.03125);t.abs().gte(.1);)t=t.times(s),h+=5;for(n=Math.log(Se(2,h))/Math.LN10*2+5|0,a+=n,r=i=o=new C(te),C.precision=a;;){if(i=L(i.times(t),a),r=r.times(++f),s=o.plus(he(i,r,a)),ue(s.d).slice(0,a)===ue(o.d).slice(0,a)){for(;h--;)o=L(o.times(o),a);return C.precision=A,e==null?(q=!0,L(o,A)):o}o=s}}function j(t){for(var e=t.e*N,r=t.d[0];r>=10;r/=10)e++;return e}function Pr(t,e,r){if(e>t.LN10.sd())throw q=!0,r&&(t.precision=r),Error(oe+"LN10 precision limit exceeded");return L(new t(t.LN10),e)}function Pe(t){for(var e="";t--;)e+="0";return e}function nt(t,e){var r,n,i,o,s,a,f,h,C,A=1,k=10,R=t,_=R.d,O=R.constructor,D=O.precision;if(R.s<1)throw Error(oe+(R.s?"NaN":"-Infinity"));if(R.eq(te))return new O(0);if(e==null?(q=!1,h=D):h=e,R.eq(10))return e==null&&(q=!0),Pr(O,h);if(h+=k,O.precision=h,r=ue(_),n=r.charAt(0),o=j(R),Math.abs(o)<15e14){for(;n<7&&n!=1||n==1&&r.charAt(1)>3;)R=R.times(t),r=ue(R.d),n=r.charAt(0),A++;o=j(R),n>1?(R=new O("0."+r),o++):R=new O(n+"."+r.slice(1))}else return f=Pr(O,h+2,D).times(o+""),R=nt(new O(n+"."+r.slice(1)),h-k).plus(f),O.precision=D,e==null?(q=!0,L(R,D)):R;for(a=s=R=he(R.minus(te),R.plus(te),h),C=L(R.times(R),h),i=3;;){if(s=L(s.times(C),h),f=a.plus(he(s,new O(i),h)),ue(f.d).slice(0,h)===ue(a.d).slice(0,h))return a=a.times(2),o!==0&&(a=a.plus(Pr(O,h+2,D).times(o+""))),a=he(a,new O(A),h),O.precision=D,e==null?(q=!0,L(a,D)):a;a=f,i+=2}}function yn(t,e){var r,n,i;for((r=e.indexOf("."))>-1&&(e=e.replace(".","")),(n=e.search(/e/i))>0?(r<0&&(r=n),r+=+e.slice(n+1),e=e.substring(0,n)):r<0&&(r=e.length),n=0;e.charCodeAt(n)===48;)++n;for(i=e.length;e.charCodeAt(i-1)===48;)--i;if(e=e.slice(n,i),e){if(i-=n,r=r-n-1,t.e=Fe(r/N),t.d=[],n=(r+1)%N,r<0&&(n+=N),nIt||t.e<-It))throw Error(vr+r)}else t.s=0,t.e=0,t.d=[0];return t}function L(t,e,r){var n,i,o,s,a,f,h,C,A=t.d;for(s=1,o=A[0];o>=10;o/=10)s++;if(n=e-s,n<0)n+=N,i=e,h=A[C=0];else{if(C=Math.ceil((n+1)/N),o=A.length,C>=o)return t;for(h=o=A[C],s=1;o>=10;o/=10)s++;n%=N,i=n-N+s}if(r!==void 0&&(o=Se(10,s-i-1),a=h/o%10|0,f=e<0||A[C+1]!==void 0||h%o,f=r<4?(a||f)&&(r==0||r==(t.s<0?3:2)):a>5||a==5&&(r==4||f||r==6&&(n>0?i>0?h/Se(10,s-i):0:A[C-1])%10&1||r==(t.s<0?8:7))),e<1||!A[0])return f?(o=j(t),A.length=1,e=e-o-1,A[0]=Se(10,(N-e%N)%N),t.e=Fe(-e/N)||0):(A.length=1,A[0]=t.e=t.s=0),t;if(n==0?(A.length=C,o=1,C--):(A.length=C+1,o=Se(10,N-n),A[C]=i>0?(h/Se(10,s-i)%Se(10,i)|0)*o:0),f)for(;;)if(C==0){(A[0]+=o)==J&&(A[0]=1,++t.e);break}else{if(A[C]+=o,A[C]!=J)break;A[C--]=0,o=1}for(n=A.length;A[--n]===0;)A.pop();if(q&&(t.e>It||t.e<-It))throw Error(vr+j(t));return t}function En(t,e){var r,n,i,o,s,a,f,h,C,A,k=t.constructor,R=k.precision;if(!t.s||!e.s)return e.s?e.s=-e.s:e=new k(t),q?L(e,R):e;if(f=t.d,A=e.d,n=e.e,h=t.e,f=f.slice(),s=h-n,s){for(C=s<0,C?(r=f,s=-s,a=A.length):(r=A,n=h,a=f.length),i=Math.max(Math.ceil(R/N),a)+2,s>i&&(s=i,r.length=1),r.reverse(),i=s;i--;)r.push(0);r.reverse()}else{for(i=f.length,a=A.length,C=i0;--i)f[a++]=0;for(i=A.length;i>s;){if(f[--i]0?o=o.charAt(0)+"."+o.slice(1)+Pe(n):s>1&&(o=o.charAt(0)+"."+o.slice(1)),o=o+(i<0?"e":"e+")+i):i<0?(o="0."+Pe(-i-1)+o,r&&(n=r-s)>0&&(o+=Pe(n))):i>=s?(o+=Pe(i+1-s),r&&(n=r-i-1)>0&&(o=o+"."+Pe(n))):((n=i+1)0&&(i+1===s&&(o+="."),o+=Pe(n))),t.s<0?"-"+o:o}function hn(t,e){if(t.length>e)return t.length=e,!0}function Pn(t){var e,r,n;function i(o){var s=this;if(!(s instanceof i))return new i(o);if(s.constructor=i,o instanceof i){s.s=o.s,s.e=o.e,s.d=(o=o.d)?o.slice():o;return}if(typeof o=="number"){if(o*0!==0)throw Error(Oe+o);if(o>0)s.s=1;else if(o<0)o=-o,s.s=-1;else{s.s=0,s.e=0,s.d=[0];return}if(o===~~o&&o<1e7){s.e=0,s.d=[o];return}return yn(s,o.toString())}else if(typeof o!="string")throw Error(Oe+o);if(o.charCodeAt(0)===45?(o=o.slice(1),s.s=-1):s.s=1,ms.test(o))yn(s,o);else throw Error(Oe+o)}if(i.prototype=S,i.ROUND_UP=0,i.ROUND_DOWN=1,i.ROUND_CEIL=2,i.ROUND_FLOOR=3,i.ROUND_HALF_UP=4,i.ROUND_HALF_DOWN=5,i.ROUND_HALF_EVEN=6,i.ROUND_HALF_CEIL=7,i.ROUND_HALF_FLOOR=8,i.clone=Pn,i.config=i.set=ps,t===void 0&&(t={}),t)for(n=["precision","rounding","toExpNeg","toExpPos","LN10"],e=0;e=i[e+1]&&n<=i[e+2])this[r]=n;else throw Error(Oe+r+": "+n);if((n=t[r="LN10"])!==void 0)if(n==Math.LN10)this[r]=new this(n);else throw Error(Oe+r+": "+n);return this}var Le,cs,Tr,q,oe,Oe,vr,Fe,Se,ms,te,J,N,bn,It,S,he,Tr,Mt,vn=ie(()=>{"use strict";u();c();m();p();d();l();Le=1e9,cs={precision:20,rounding:4,toExpNeg:-7,toExpPos:21,LN10:"2.302585092994045684017991454684364207601101488628772976033327900967572609677352480235997205089598298341967784042286"},q=!0,oe="[DecimalError] ",Oe=oe+"Invalid argument: ",vr=oe+"Exponent out of range: ",Fe=Math.floor,Se=Math.pow,ms=/^(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i,J=1e7,N=7,bn=9007199254740991,It=Fe(bn/N),S={};S.absoluteValue=S.abs=function(){var t=new this.constructor(this);return t.s&&(t.s=1),t};S.comparedTo=S.cmp=function(t){var e,r,n,i,o=this;if(t=new o.constructor(t),o.s!==t.s)return o.s||-t.s;if(o.e!==t.e)return o.e>t.e^o.s<0?1:-1;for(n=o.d.length,i=t.d.length,e=0,r=nt.d[e]^o.s<0?1:-1;return n===i?0:n>i^o.s<0?1:-1};S.decimalPlaces=S.dp=function(){var t=this,e=t.d.length-1,r=(e-t.e)*N;if(e=t.d[e],e)for(;e%10==0;e/=10)r--;return r<0?0:r};S.dividedBy=S.div=function(t){return he(this,new this.constructor(t))};S.dividedToIntegerBy=S.idiv=function(t){var e=this,r=e.constructor;return L(he(e,new r(t),0,1),r.precision)};S.equals=S.eq=function(t){return!this.cmp(t)};S.exponent=function(){return j(this)};S.greaterThan=S.gt=function(t){return this.cmp(t)>0};S.greaterThanOrEqualTo=S.gte=function(t){return this.cmp(t)>=0};S.isInteger=S.isint=function(){return this.e>this.d.length-2};S.isNegative=S.isneg=function(){return this.s<0};S.isPositive=S.ispos=function(){return this.s>0};S.isZero=function(){return this.s===0};S.lessThan=S.lt=function(t){return this.cmp(t)<0};S.lessThanOrEqualTo=S.lte=function(t){return this.cmp(t)<1};S.logarithm=S.log=function(t){var e,r=this,n=r.constructor,i=n.precision,o=i+5;if(t===void 0)t=new n(10);else if(t=new n(t),t.s<1||t.eq(te))throw Error(oe+"NaN");if(r.s<1)throw Error(oe+(r.s?"NaN":"-Infinity"));return r.eq(te)?new n(0):(q=!1,e=he(nt(r,o),nt(t,o),o),q=!0,L(e,i))};S.minus=S.sub=function(t){var e=this;return t=new e.constructor(t),e.s==t.s?En(e,t):wn(e,(t.s=-t.s,t))};S.modulo=S.mod=function(t){var e,r=this,n=r.constructor,i=n.precision;if(t=new n(t),!t.s)throw Error(oe+"NaN");return r.s?(q=!1,e=he(r,t,0,1).times(t),q=!0,r.minus(e)):L(new n(r),i)};S.naturalExponential=S.exp=function(){return xn(this)};S.naturalLogarithm=S.ln=function(){return nt(this)};S.negated=S.neg=function(){var t=new this.constructor(this);return t.s=-t.s||0,t};S.plus=S.add=function(t){var e=this;return t=new e.constructor(t),e.s==t.s?wn(e,t):En(e,(t.s=-t.s,t))};S.precision=S.sd=function(t){var e,r,n,i=this;if(t!==void 0&&t!==!!t&&t!==1&&t!==0)throw Error(Oe+t);if(e=j(i)+1,n=i.d.length-1,r=n*N+1,n=i.d[n],n){for(;n%10==0;n/=10)r--;for(n=i.d[0];n>=10;n/=10)r++}return t&&e>r?e:r};S.squareRoot=S.sqrt=function(){var t,e,r,n,i,o,s,a=this,f=a.constructor;if(a.s<1){if(!a.s)return new f(0);throw Error(oe+"NaN")}for(t=j(a),q=!1,i=Math.sqrt(+a),i==0||i==1/0?(e=ue(a.d),(e.length+t)%2==0&&(e+="0"),i=Math.sqrt(e),t=Fe((t+1)/2)-(t<0||t%2),i==1/0?e="5e"+t:(e=i.toExponential(),e=e.slice(0,e.indexOf("e")+1)+t),n=new f(e)):n=new f(i.toString()),r=f.precision,i=s=r+3;;)if(o=n,n=o.plus(he(a,o,s+2)).times(.5),ue(o.d).slice(0,s)===(e=ue(n.d)).slice(0,s)){if(e=e.slice(s-3,s+1),i==s&&e=="4999"){if(L(o,r+1,0),o.times(o).eq(a)){n=o;break}}else if(e!="9999")break;s+=4}return q=!0,L(n,r)};S.times=S.mul=function(t){var e,r,n,i,o,s,a,f,h,C=this,A=C.constructor,k=C.d,R=(t=new A(t)).d;if(!C.s||!t.s)return new A(0);for(t.s*=C.s,r=C.e+t.e,f=k.length,h=R.length,f=0;){for(e=0,i=f+n;i>n;)a=o[i]+R[n]*k[i-n-1]+e,o[i--]=a%J|0,e=a/J|0;o[i]=(o[i]+e)%J|0}for(;!o[--s];)o.pop();return e?++r:o.shift(),t.d=o,t.e=r,q?L(t,A.precision):t};S.toDecimalPlaces=S.todp=function(t,e){var r=this,n=r.constructor;return r=new n(r),t===void 0?r:(ce(t,0,Le),e===void 0?e=n.rounding:ce(e,0,8),L(r,t+j(r)+1,e))};S.toExponential=function(t,e){var r,n=this,i=n.constructor;return t===void 0?r=ke(n,!0):(ce(t,0,Le),e===void 0?e=i.rounding:ce(e,0,8),n=L(new i(n),t+1,e),r=ke(n,!0,t+1)),r};S.toFixed=function(t,e){var r,n,i=this,o=i.constructor;return t===void 0?ke(i):(ce(t,0,Le),e===void 0?e=o.rounding:ce(e,0,8),n=L(new o(i),t+j(i)+1,e),r=ke(n.abs(),!1,t+j(n)+1),i.isneg()&&!i.isZero()?"-"+r:r)};S.toInteger=S.toint=function(){var t=this,e=t.constructor;return L(new e(t),j(t)+1,e.rounding)};S.toNumber=function(){return+this};S.toPower=S.pow=function(t){var e,r,n,i,o,s,a=this,f=a.constructor,h=12,C=+(t=new f(t));if(!t.s)return new f(te);if(a=new f(a),!a.s){if(t.s<1)throw Error(oe+"Infinity");return a}if(a.eq(te))return a;if(n=f.precision,t.eq(te))return L(a,n);if(e=t.e,r=t.d.length-1,s=e>=r,o=a.s,s){if((r=C<0?-C:C)<=bn){for(i=new f(te),e=Math.ceil(n/N+4),q=!1;r%2&&(i=i.times(a),hn(i.d,e)),r=Fe(r/2),r!==0;)a=a.times(a),hn(a.d,e);return q=!0,t.s<0?new f(te).div(i):L(i,n)}}else if(o<0)throw Error(oe+"NaN");return o=o<0&&t.d[Math.max(e,r)]&1?-1:1,a.s=1,q=!1,i=t.times(nt(a,n+h)),q=!0,i=xn(i),i.s=o,i};S.toPrecision=function(t,e){var r,n,i=this,o=i.constructor;return t===void 0?(r=j(i),n=ke(i,r<=o.toExpNeg||r>=o.toExpPos)):(ce(t,1,Le),e===void 0?e=o.rounding:ce(e,0,8),i=L(new o(i),t,e),r=j(i),n=ke(i,t<=r||r<=o.toExpNeg,t)),n};S.toSignificantDigits=S.tosd=function(t,e){var r=this,n=r.constructor;return t===void 0?(t=n.precision,e=n.rounding):(ce(t,1,Le),e===void 0?e=n.rounding:ce(e,0,8)),L(new n(r),t,e)};S.toString=S.valueOf=S.val=S.toJSON=S[Symbol.for("nodejs.util.inspect.custom")]=function(){var t=this,e=j(t),r=t.constructor;return ke(t,e<=r.toExpNeg||e>=r.toExpPos)};he=function(){function t(n,i){var o,s=0,a=n.length;for(n=n.slice();a--;)o=n[a]*i+s,n[a]=o%J|0,s=o/J|0;return s&&n.unshift(s),n}function e(n,i,o,s){var a,f;if(o!=s)f=o>s?1:-1;else for(a=f=0;ai[a]?1:-1;break}return f}function r(n,i,o){for(var s=0;o--;)n[o]-=s,s=n[o]1;)n.shift()}return function(n,i,o,s){var a,f,h,C,A,k,R,_,O,D,ye,z,F,Y,Re,wr,se,At,Rt=n.constructor,Ho=n.s==i.s?1:-1,le=n.d,B=i.d;if(!n.s)return new Rt(n);if(!i.s)throw Error(oe+"Division by zero");for(f=n.e-i.e,se=B.length,Re=le.length,R=new Rt(Ho),_=R.d=[],h=0;B[h]==(le[h]||0);)++h;if(B[h]>(le[h]||0)&&--f,o==null?z=o=Rt.precision:s?z=o+(j(n)-j(i))+1:z=o,z<0)return new Rt(0);if(z=z/N+2|0,h=0,se==1)for(C=0,B=B[0],z++;(h1&&(B=t(B,C),le=t(le,C),se=B.length,Re=le.length),Y=se,O=le.slice(0,se),D=O.length;D=J/2&&++wr;do C=0,a=e(B,O,se,D),a<0?(ye=O[0],se!=D&&(ye=ye*J+(O[1]||0)),C=ye/wr|0,C>1?(C>=J&&(C=J-1),A=t(B,C),k=A.length,D=O.length,a=e(A,O,k,D),a==1&&(C--,r(A,se{"use strict";vn();v=class extends Mt{static isDecimal(e){return e instanceof Mt}static random(e=20){{let n=globalThis.crypto.getRandomValues(new Uint8Array(e)).reduce((i,o)=>i+o,"");return new Mt(`0.${n.slice(0,e)}`)}}},be=v});function bs(){return!1}function Or(){return{dev:0,ino:0,mode:0,nlink:0,uid:0,gid:0,rdev:0,size:0,blksize:0,blocks:0,atimeMs:0,mtimeMs:0,ctimeMs:0,birthtimeMs:0,atime:new Date,mtime:new Date,ctime:new Date,birthtime:new Date}}function ws(){return Or()}function xs(){return[]}function Es(t){t(null,[])}function Ps(){return""}function vs(){return""}function Ts(){}function Cs(){}function As(){}function Rs(){}function Ss(){}function Os(){}function ks(){}function Ds(){}function Is(){return{close:()=>{},on:()=>{},removeAllListeners:()=>{}}}function Ms(t,e){e(null,Or())}var _s,Ls,Bn,Vn=ie(()=>{"use strict";u();c();m();p();d();l();_s={},Ls={existsSync:bs,lstatSync:Or,stat:Ms,statSync:ws,readdirSync:xs,readdir:Es,readlinkSync:Ps,realpathSync:vs,chmodSync:Ts,renameSync:Cs,mkdirSync:As,rmdirSync:Rs,rmSync:Ss,unlinkSync:Os,watchFile:ks,unwatchFile:Ds,watch:Is,promises:_s},Bn=Ls});var jn=Ot((Zc,Fs)=>{Fs.exports={name:"@prisma/internals",version:"6.19.1",description:"This package is intended for Prisma's internal use",main:"dist/index.js",types:"dist/index.d.ts",repository:{type:"git",url:"https://github.com/prisma/prisma.git",directory:"packages/internals"},homepage:"https://www.prisma.io",author:"Tim Suchanek ",bugs:"https://github.com/prisma/prisma/issues",license:"Apache-2.0",scripts:{dev:"DEV=true tsx helpers/build.ts",build:"tsx helpers/build.ts",test:"dotenv -e ../../.db.env -- jest --silent",prepublishOnly:"pnpm run build"},files:["README.md","dist","!**/libquery_engine*","!dist/get-generators/engines/*","scripts"],devDependencies:{"@babel/helper-validator-identifier":"7.25.9","@opentelemetry/api":"1.9.0","@swc/core":"1.11.5","@swc/jest":"0.2.37","@types/babel__helper-validator-identifier":"7.15.2","@types/jest":"29.5.14","@types/node":"18.19.76","@types/resolve":"1.20.6",archiver:"6.0.2","checkpoint-client":"1.1.33","cli-truncate":"4.0.0",dotenv:"16.5.0",empathic:"2.0.0","escape-string-regexp":"5.0.0",execa:"8.0.1","fast-glob":"3.3.3","find-up":"7.0.0","fp-ts":"2.16.9","fs-extra":"11.3.0","global-directory":"4.0.0",globby:"11.1.0","identifier-regex":"1.0.0","indent-string":"4.0.0","is-windows":"1.0.2","is-wsl":"3.1.0",jest:"29.7.0","jest-junit":"16.0.0",kleur:"4.1.5","mock-stdin":"1.0.0","new-github-issue-url":"0.2.1","node-fetch":"3.3.2","npm-packlist":"5.1.3",open:"7.4.2","p-map":"4.0.0",resolve:"1.22.10","string-width":"7.2.0","strip-indent":"4.0.0","temp-dir":"2.0.0",tempy:"1.0.1","terminal-link":"4.0.0",tmp:"0.2.3","ts-pattern":"5.6.2","ts-toolbelt":"9.6.0",typescript:"5.4.5",yarn:"1.22.22"},dependencies:{"@prisma/config":"workspace:*","@prisma/debug":"workspace:*","@prisma/dmmf":"workspace:*","@prisma/driver-adapter-utils":"workspace:*","@prisma/engines":"workspace:*","@prisma/fetch-engine":"workspace:*","@prisma/generator":"workspace:*","@prisma/generator-helper":"workspace:*","@prisma/get-platform":"workspace:*","@prisma/prisma-schema-wasm":"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7","@prisma/schema-engine-wasm":"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7","@prisma/schema-files-loader":"workspace:*",arg:"5.0.2",prompts:"2.4.2"},peerDependencies:{typescript:">=5.1.0"},peerDependenciesMeta:{typescript:{optional:!0}},sideEffects:!1}});function Ns(...t){return t.join("/")}function qs(...t){return t.join("/")}function Bs(t){let e=$n(t),r=Qn(t),[n,i]=e.split(".");return{root:"/",dir:r,base:e,ext:i,name:n}}function $n(t){let e=t.split("/");return e[e.length-1]}function Qn(t){return t.split("/").slice(0,-1).join("/")}function js(t){let e=t.split("/").filter(i=>i!==""&&i!=="."),r=[];for(let i of e)i===".."?r.pop():r.push(i);let n=r.join("/");return t.startsWith("/")?"/"+n:n}var Jn,Vs,$s,Qs,Ut,Gn=ie(()=>{"use strict";u();c();m();p();d();l();Jn="/",Vs=":";$s={sep:Jn},Qs={basename:$n,delimiter:Vs,dirname:Qn,join:qs,normalize:js,parse:Bs,posix:$s,resolve:Ns,sep:Jn},Ut=Qs});var Yn=Ot((bp,zn)=>{"use strict";u();c();m();p();d();l();zn.exports=(t,e=1,r)=>{if(r={indent:" ",includeEmptyLines:!1,...r},typeof t!="string")throw new TypeError(`Expected \`input\` to be a \`string\`, got \`${typeof t}\``);if(typeof e!="number")throw new TypeError(`Expected \`count\` to be a \`number\`, got \`${typeof e}\``);if(typeof r.indent!="string")throw new TypeError(`Expected \`options.indent\` to be a \`string\`, got \`${typeof r.indent}\``);if(e===0)return t;let n=r.includeEmptyLines?/^/gm:/^(?!\s*$)/gm;return t.replace(n,r.indent.repeat(e))}});var Vr=Ot((Hy,ni)=>{"use strict";u();c();m();p();d();l();ni.exports=function(){function t(e,r,n,i,o){return en?n+1:e+1:i===o?r:r+1}return function(e,r){if(e===r)return 0;if(e.length>r.length){var n=e;e=r,r=n}for(var i=e.length,o=r.length;i>0&&e.charCodeAt(i-1)===r.charCodeAt(o-1);)i--,o--;for(var s=0;s{"use strict";u();c();m();p();d();l()});var ui=ie(()=>{"use strict";u();c();m();p();d();l()});var Mi=Ot((zP,Qa)=>{Qa.exports={name:"@prisma/engines-version",version:"7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7",main:"index.js",types:"index.d.ts",license:"Apache-2.0",author:"Tim Suchanek ",prisma:{enginesVersion:"c2990dca591cba766e3b7ef5d9e8a84796e47ab7"},repository:{type:"git",url:"https://github.com/prisma/engines-wrapper.git",directory:"packages/engines-version"},devDependencies:{"@types/node":"18.19.76",typescript:"4.9.5"},files:["index.js","index.d.ts"],scripts:{build:"tsc -d"}}});var sr,_i=ie(()=>{"use strict";u();c();m();p();d();l();sr=class{events={};on(e,r){return this.events[e]||(this.events[e]=[]),this.events[e].push(r),this}emit(e,...r){return this.events[e]?(this.events[e].forEach(n=>{n(...r)}),!0):!1}}});var Xl={};rt(Xl,{DMMF:()=>ct,Debug:()=>G,Decimal:()=>be,Extensions:()=>Cr,MetricsClient:()=>He,PrismaClientInitializationError:()=>I,PrismaClientKnownRequestError:()=>Z,PrismaClientRustPanicError:()=>xe,PrismaClientUnknownRequestError:()=>Q,PrismaClientValidationError:()=>K,Public:()=>Ar,Sql:()=>ee,createParam:()=>Ci,defineDmmfProperty:()=>Di,deserializeJsonResponse:()=>Xe,deserializeRawResult:()=>hr,dmmfToRuntimeDataModel:()=>ri,empty:()=>Fi,getPrismaClient:()=>Go,getRuntime:()=>Ze,join:()=>Li,makeStrictEnum:()=>Wo,makeTypedQueryFactory:()=>Ii,objectEnumValues:()=>zt,raw:()=>zr,serializeJsonQuery:()=>nr,skip:()=>rr,sqltag:()=>Yr,warnEnvConflicts:()=>void 0,warnOnce:()=>at});module.exports=ts(Xl);u();c();m();p();d();l();var Cr={};rt(Cr,{defineExtension:()=>Tn,getExtensionContext:()=>Cn});u();c();m();p();d();l();u();c();m();p();d();l();function Tn(t){return typeof t=="function"?t:e=>e.$extends(t)}u();c();m();p();d();l();function Cn(t){return t}var Ar={};rt(Ar,{validator:()=>An});u();c();m();p();d();l();u();c();m();p();d();l();function An(...t){return e=>e}u();c();m();p();d();l();u();c();m();p();d();l();u();c();m();p();d();l();var Rr,Rn,Sn,On,kn=!0;typeof g<"u"&&({FORCE_COLOR:Rr,NODE_DISABLE_COLORS:Rn,NO_COLOR:Sn,TERM:On}=g.env||{},kn=g.stdout&&g.stdout.isTTY);var ds={enabled:!Rn&&Sn==null&&On!=="dumb"&&(Rr!=null&&Rr!=="0"||kn)};function U(t,e){let r=new RegExp(`\\x1b\\[${e}m`,"g"),n=`\x1B[${t}m`,i=`\x1B[${e}m`;return function(o){return!ds.enabled||o==null?o:n+(~(""+o).indexOf(i)?o.replace(r,i+n):o)+i}}var zu=U(0,0),_t=U(1,22),Lt=U(2,22),Yu=U(3,23),Dn=U(4,24),Xu=U(7,27),Zu=U(8,28),ec=U(9,29),tc=U(30,39),Ue=U(31,39),In=U(32,39),Mn=U(33,39),_n=U(34,39),rc=U(35,39),Ln=U(36,39),nc=U(37,39),Fn=U(90,39),ic=U(90,39),oc=U(40,49),sc=U(41,49),ac=U(42,49),lc=U(43,49),uc=U(44,49),cc=U(45,49),mc=U(46,49),pc=U(47,49);u();c();m();p();d();l();var fs=100,Un=["green","yellow","blue","magenta","cyan","red"],Ft=[],Nn=Date.now(),gs=0,Sr=typeof g<"u"?g.env:{};globalThis.DEBUG??=Sr.DEBUG??"";globalThis.DEBUG_COLORS??=Sr.DEBUG_COLORS?Sr.DEBUG_COLORS==="true":!0;var it={enable(t){typeof t=="string"&&(globalThis.DEBUG=t)},disable(){let t=globalThis.DEBUG;return globalThis.DEBUG="",t},enabled(t){let e=globalThis.DEBUG.split(",").map(i=>i.replace(/[.+?^${}()|[\]\\]/g,"\\$&")),r=e.some(i=>i===""||i[0]==="-"?!1:t.match(RegExp(i.split("*").join(".*")+"$"))),n=e.some(i=>i===""||i[0]!=="-"?!1:t.match(RegExp(i.slice(1).split("*").join(".*")+"$")));return r&&!n},log:(...t)=>{let[e,r,...n]=t;(console.warn??console.log)(`${e} ${r}`,...n)},formatters:{}};function ys(t){let e={color:Un[gs++%Un.length],enabled:it.enabled(t),namespace:t,log:it.log,extend:()=>{}},r=(...n)=>{let{enabled:i,namespace:o,color:s,log:a}=e;if(n.length!==0&&Ft.push([o,...n]),Ft.length>fs&&Ft.shift(),it.enabled(o)||i){let f=n.map(C=>typeof C=="string"?C:hs(C)),h=`+${Date.now()-Nn}ms`;Nn=Date.now(),a(o,...f,h)}};return new Proxy(r,{get:(n,i)=>e[i],set:(n,i,o)=>e[i]=o})}var G=new Proxy(ys,{get:(t,e)=>it[e],set:(t,e,r)=>it[e]=r});function hs(t,e=2){let r=new Set;return JSON.stringify(t,(n,i)=>{if(typeof i=="object"&&i!==null){if(r.has(i))return"[Circular *]";r.add(i)}else if(typeof i=="bigint")return i.toString();return i},e)}function qn(){Ft.length=0}u();c();m();p();d();l();u();c();m();p();d();l();var kr=["darwin","darwin-arm64","debian-openssl-1.0.x","debian-openssl-1.1.x","debian-openssl-3.0.x","rhel-openssl-1.0.x","rhel-openssl-1.1.x","rhel-openssl-3.0.x","linux-arm64-openssl-1.1.x","linux-arm64-openssl-1.0.x","linux-arm64-openssl-3.0.x","linux-arm-openssl-1.1.x","linux-arm-openssl-1.0.x","linux-arm-openssl-3.0.x","linux-musl","linux-musl-openssl-3.0.x","linux-musl-arm64-openssl-1.1.x","linux-musl-arm64-openssl-3.0.x","linux-nixos","linux-static-x64","linux-static-arm64","windows","freebsd11","freebsd12","freebsd13","freebsd14","freebsd15","openbsd","netbsd","arm"];u();c();m();p();d();l();var Us=jn(),Dr=Us.version;u();c();m();p();d();l();function Ne(t){let e=Js();return e||(t?.config.engineType==="library"?"library":t?.config.engineType==="binary"?"binary":t?.config.engineType==="client"?"client":Gs())}function Js(){let t=g.env.PRISMA_CLIENT_ENGINE_TYPE;return t==="library"?"library":t==="binary"?"binary":t==="client"?"client":void 0}function Gs(){return"library"}u();c();m();p();d();l();u();c();m();p();d();l();u();c();m();p();d();l();u();c();m();p();d();l();function Ir(t){return t.name==="DriverAdapterError"&&typeof t.cause=="object"}u();c();m();p();d();l();function Nt(t){return{ok:!0,value:t,map(e){return Nt(e(t))},flatMap(e){return e(t)}}}function De(t){return{ok:!1,error:t,map(){return De(t)},flatMap(){return De(t)}}}var Wn=G("driver-adapter-utils"),Mr=class{registeredErrors=[];consumeError(e){return this.registeredErrors[e]}registerNewError(e){let r=0;for(;this.registeredErrors[r]!==void 0;)r++;return this.registeredErrors[r]={error:e},r}};var qt=(t,e=new Mr)=>{let r={adapterName:t.adapterName,errorRegistry:e,queryRaw:we(e,t.queryRaw.bind(t)),executeRaw:we(e,t.executeRaw.bind(t)),executeScript:we(e,t.executeScript.bind(t)),dispose:we(e,t.dispose.bind(t)),provider:t.provider,startTransaction:async(...n)=>(await we(e,t.startTransaction.bind(t))(...n)).map(o=>Ws(e,o))};return t.getConnectionInfo&&(r.getConnectionInfo=Ks(e,t.getConnectionInfo.bind(t))),r},Ws=(t,e)=>({adapterName:e.adapterName,provider:e.provider,options:e.options,queryRaw:we(t,e.queryRaw.bind(e)),executeRaw:we(t,e.executeRaw.bind(e)),commit:we(t,e.commit.bind(e)),rollback:we(t,e.rollback.bind(e))});function we(t,e){return async(...r)=>{try{return Nt(await e(...r))}catch(n){if(Wn("[error@wrapAsync]",n),Ir(n))return De(n.cause);let i=t.registerNewError(n);return De({kind:"GenericJs",id:i})}}}function Ks(t,e){return(...r)=>{try{return Nt(e(...r))}catch(n){if(Wn("[error@wrapSync]",n),Ir(n))return De(n.cause);let i=t.registerNewError(n);return De({kind:"GenericJs",id:i})}}}u();c();m();p();d();l();var Kn="prisma+postgres",Hn=`${Kn}:`;function _r(t){return t?.toString().startsWith(`${Hn}//`)??!1}var st={};rt(st,{error:()=>Ys,info:()=>zs,log:()=>Hs,query:()=>Xs,should:()=>Xn,tags:()=>ot,warn:()=>Lr});u();c();m();p();d();l();var ot={error:Ue("prisma:error"),warn:Mn("prisma:warn"),info:Ln("prisma:info"),query:_n("prisma:query")},Xn={warn:()=>!g.env.PRISMA_DISABLE_WARNINGS};function Hs(...t){console.log(...t)}function Lr(t,...e){Xn.warn()&&console.warn(`${ot.warn} ${t}`,...e)}function zs(t,...e){console.info(`${ot.info} ${t}`,...e)}function Ys(t,...e){console.error(`${ot.error} ${t}`,...e)}function Xs(t,...e){console.log(`${ot.query} ${t}`,...e)}u();c();m();p();d();l();function Bt(t,e){if(!t)throw new Error(`${e}. This should never happen. If you see this error, please, open an issue at https://pris.ly/prisma-prisma-bug-report`)}u();c();m();p();d();l();function Ie(t,e){throw new Error(e)}u();c();m();p();d();l();u();c();m();p();d();l();function Fr({onlyFirst:t=!1}={}){let r=["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?(?:\\u0007|\\u001B\\u005C|\\u009C))","(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"].join("|");return new RegExp(r,t?void 0:"g")}var Zs=Fr();function Ur(t){if(typeof t!="string")throw new TypeError(`Expected a \`string\`, got \`${typeof t}\``);return t.replace(Zs,"")}u();c();m();p();d();l();function Nr(t,e){return Object.prototype.hasOwnProperty.call(t,e)}u();c();m();p();d();l();function Vt(t,e){let r={};for(let n of Object.keys(t))r[n]=e(t[n],n);return r}u();c();m();p();d();l();function qr(t,e){if(t.length===0)return;let r=t[0];for(let n=1;n{Zn.has(t)||(Zn.add(t),Lr(e,...r))};var I=class t extends Error{clientVersion;errorCode;retryable;constructor(e,r,n){super(e),this.name="PrismaClientInitializationError",this.clientVersion=r,this.errorCode=n,Error.captureStackTrace(t)}get[Symbol.toStringTag](){return"PrismaClientInitializationError"}};re(I,"PrismaClientInitializationError");u();c();m();p();d();l();var Z=class extends Error{code;meta;clientVersion;batchRequestIdx;constructor(e,{code:r,clientVersion:n,meta:i,batchRequestIdx:o}){super(e),this.name="PrismaClientKnownRequestError",this.code=r,this.clientVersion=n,this.meta=i,Object.defineProperty(this,"batchRequestIdx",{value:o,enumerable:!1,writable:!0})}get[Symbol.toStringTag](){return"PrismaClientKnownRequestError"}};re(Z,"PrismaClientKnownRequestError");u();c();m();p();d();l();var xe=class extends Error{clientVersion;constructor(e,r){super(e),this.name="PrismaClientRustPanicError",this.clientVersion=r}get[Symbol.toStringTag](){return"PrismaClientRustPanicError"}};re(xe,"PrismaClientRustPanicError");u();c();m();p();d();l();var Q=class extends Error{clientVersion;batchRequestIdx;constructor(e,{clientVersion:r,batchRequestIdx:n}){super(e),this.name="PrismaClientUnknownRequestError",this.clientVersion=r,Object.defineProperty(this,"batchRequestIdx",{value:n,writable:!0,enumerable:!1})}get[Symbol.toStringTag](){return"PrismaClientUnknownRequestError"}};re(Q,"PrismaClientUnknownRequestError");u();c();m();p();d();l();var K=class extends Error{name="PrismaClientValidationError";clientVersion;constructor(e,{clientVersion:r}){super(e),this.clientVersion=r}get[Symbol.toStringTag](){return"PrismaClientValidationError"}};re(K,"PrismaClientValidationError");u();c();m();p();d();l();u();c();m();p();d();l();u();c();m();p();d();l();var me=class{_map=new Map;get(e){return this._map.get(e)?.value}set(e,r){this._map.set(e,{value:r})}getOrCreate(e,r){let n=this._map.get(e);if(n)return n.value;let i=r();return this.set(e,i),i}};u();c();m();p();d();l();function ve(t){return t.substring(0,1).toLowerCase()+t.substring(1)}u();c();m();p();d();l();function ti(t,e){let r={};for(let n of t){let i=n[e];r[i]=n}return r}u();c();m();p();d();l();function lt(t){let e;return{get(){return e||(e={value:t()}),e.value}}}u();c();m();p();d();l();function ri(t){return{models:Br(t.models),enums:Br(t.enums),types:Br(t.types)}}function Br(t){let e={};for(let{name:r,...n}of t)e[r]=n;return e}u();c();m();p();d();l();function qe(t){return t instanceof Date||Object.prototype.toString.call(t)==="[object Date]"}function jt(t){return t.toString()!=="Invalid Date"}u();c();m();p();d();l();l();function Be(t){return v.isDecimal(t)?!0:t!==null&&typeof t=="object"&&typeof t.s=="number"&&typeof t.e=="number"&&typeof t.toFixed=="function"&&Array.isArray(t.d)}u();c();m();p();d();l();u();c();m();p();d();l();var ct={};rt(ct,{ModelAction:()=>ut,datamodelEnumToSchemaEnum:()=>ea});u();c();m();p();d();l();u();c();m();p();d();l();function ea(t){return{name:t.name,values:t.values.map(e=>e.name)}}u();c();m();p();d();l();var ut=(F=>(F.findUnique="findUnique",F.findUniqueOrThrow="findUniqueOrThrow",F.findFirst="findFirst",F.findFirstOrThrow="findFirstOrThrow",F.findMany="findMany",F.create="create",F.createMany="createMany",F.createManyAndReturn="createManyAndReturn",F.update="update",F.updateMany="updateMany",F.updateManyAndReturn="updateManyAndReturn",F.upsert="upsert",F.delete="delete",F.deleteMany="deleteMany",F.groupBy="groupBy",F.count="count",F.aggregate="aggregate",F.findRaw="findRaw",F.aggregateRaw="aggregateRaw",F))(ut||{});var ta=kt(Yn());var ra={red:Ue,gray:Fn,dim:Lt,bold:_t,underline:Dn,highlightSource:t=>t.highlight()},na={red:t=>t,gray:t=>t,dim:t=>t,bold:t=>t,underline:t=>t,highlightSource:t=>t};function ia({message:t,originalMethod:e,isPanic:r,callArguments:n}){return{functionName:`prisma.${e}()`,message:t,isPanic:r??!1,callArguments:n}}function oa({functionName:t,location:e,message:r,isPanic:n,contextLines:i,callArguments:o},s){let a=[""],f=e?" in":":";if(n?(a.push(s.red(`Oops, an unknown error occurred! This is ${s.bold("on us")}, you did nothing wrong.`)),a.push(s.red(`It occurred in the ${s.bold(`\`${t}\``)} invocation${f}`))):a.push(s.red(`Invalid ${s.bold(`\`${t}\``)} invocation${f}`)),e&&a.push(s.underline(sa(e))),i){a.push("");let h=[i.toString()];o&&(h.push(o),h.push(s.dim(")"))),a.push(h.join("")),o&&a.push("")}else a.push(""),o&&a.push(o),a.push("");return a.push(r),a.join(` -`)}function sa(t){let e=[t.fileName];return t.lineNumber&&e.push(String(t.lineNumber)),t.columnNumber&&e.push(String(t.columnNumber)),e.join(":")}function $t(t){let e=t.showColors?ra:na,r;return typeof $getTemplateParameters<"u"?r=$getTemplateParameters(t,e):r=ia(t),oa(r,e)}u();c();m();p();d();l();var mi=kt(Vr());u();c();m();p();d();l();function si(t,e,r){let n=ai(t),i=aa(n),o=ua(i);o?Qt(o,e,r):e.addErrorMessage(()=>"Unknown error")}function ai(t){return t.errors.flatMap(e=>e.kind==="Union"?ai(e):[e])}function aa(t){let e=new Map,r=[];for(let n of t){if(n.kind!=="InvalidArgumentType"){r.push(n);continue}let i=`${n.selectionPath.join(".")}:${n.argumentPath.join(".")}`,o=e.get(i);o?e.set(i,{...n,argument:{...n.argument,typeNames:la(o.argument.typeNames,n.argument.typeNames)}}):e.set(i,n)}return r.push(...e.values()),r}function la(t,e){return[...new Set(t.concat(e))]}function ua(t){return qr(t,(e,r)=>{let n=ii(e),i=ii(r);return n!==i?n-i:oi(e)-oi(r)})}function ii(t){let e=0;return Array.isArray(t.selectionPath)&&(e+=t.selectionPath.length),Array.isArray(t.argumentPath)&&(e+=t.argumentPath.length),e}function oi(t){switch(t.kind){case"InvalidArgumentValue":case"ValueTooLarge":return 20;case"InvalidArgumentType":return 10;case"RequiredArgumentMissing":return-10;default:return 0}}u();c();m();p();d();l();var ne=class{constructor(e,r){this.name=e;this.value=r}isRequired=!1;makeRequired(){return this.isRequired=!0,this}write(e){let{colors:{green:r}}=e.context;e.addMarginSymbol(r(this.isRequired?"+":"?")),e.write(r(this.name)),this.isRequired||e.write(r("?")),e.write(r(": ")),typeof this.value=="string"?e.write(r(this.value)):e.write(this.value)}};u();c();m();p();d();l();u();c();m();p();d();l();ui();u();c();m();p();d();l();var Ve=class{constructor(e=0,r){this.context=r;this.currentIndent=e}lines=[];currentLine="";currentIndent=0;marginSymbol;afterNextNewLineCallback;write(e){return typeof e=="string"?this.currentLine+=e:e.write(this),this}writeJoined(e,r,n=(i,o)=>o.write(i)){let i=r.length-1;for(let o=0;o0&&this.currentIndent--,this}addMarginSymbol(e){return this.marginSymbol=e,this}toString(){return this.lines.concat(this.indentedCurrentLine()).join(` -`)}getCurrentLineLength(){return this.currentLine.length}indentedCurrentLine(){let e=this.currentLine.padStart(this.currentLine.length+2*this.currentIndent);return this.marginSymbol?this.marginSymbol+e.slice(1):e}};li();u();c();m();p();d();l();u();c();m();p();d();l();var Jt=class{constructor(e){this.value=e}write(e){e.write(this.value)}markAsError(){this.value.markAsError()}};u();c();m();p();d();l();var Gt=t=>t,Wt={bold:Gt,red:Gt,green:Gt,dim:Gt,enabled:!1},ci={bold:_t,red:Ue,green:In,dim:Lt,enabled:!0},je={write(t){t.writeLine(",")}};u();c();m();p();d();l();var pe=class{constructor(e){this.contents=e}isUnderlined=!1;color=e=>e;underline(){return this.isUnderlined=!0,this}setColor(e){return this.color=e,this}write(e){let r=e.getCurrentLineLength();e.write(this.color(this.contents)),this.isUnderlined&&e.afterNextNewline(()=>{e.write(" ".repeat(r)).writeLine(this.color("~".repeat(this.contents.length)))})}};u();c();m();p();d();l();var Te=class{hasError=!1;markAsError(){return this.hasError=!0,this}};var $e=class extends Te{items=[];addItem(e){return this.items.push(new Jt(e)),this}getField(e){return this.items[e]}getPrintWidth(){return this.items.length===0?2:Math.max(...this.items.map(r=>r.value.getPrintWidth()))+2}write(e){if(this.items.length===0){this.writeEmpty(e);return}this.writeWithItems(e)}writeEmpty(e){let r=new pe("[]");this.hasError&&r.setColor(e.context.colors.red).underline(),e.write(r)}writeWithItems(e){let{colors:r}=e.context;e.writeLine("[").withIndent(()=>e.writeJoined(je,this.items).newLine()).write("]"),this.hasError&&e.afterNextNewline(()=>{e.writeLine(r.red("~".repeat(this.getPrintWidth())))})}asObject(){}};var Qe=class t extends Te{fields={};suggestions=[];addField(e){this.fields[e.name]=e}addSuggestion(e){this.suggestions.push(e)}getField(e){return this.fields[e]}getDeepField(e){let[r,...n]=e,i=this.getField(r);if(!i)return;let o=i;for(let s of n){let a;if(o.value instanceof t?a=o.value.getField(s):o.value instanceof $e&&(a=o.value.getField(Number(s))),!a)return;o=a}return o}getDeepFieldValue(e){return e.length===0?this:this.getDeepField(e)?.value}hasField(e){return!!this.getField(e)}removeAllFields(){this.fields={}}removeField(e){delete this.fields[e]}getFields(){return this.fields}isEmpty(){return Object.keys(this.fields).length===0}getFieldValue(e){return this.getField(e)?.value}getDeepSubSelectionValue(e){let r=this;for(let n of e){if(!(r instanceof t))return;let i=r.getSubSelectionValue(n);if(!i)return;r=i}return r}getDeepSelectionParent(e){let r=this.getSelectionParent();if(!r)return;let n=r;for(let i of e){let o=n.value.getFieldValue(i);if(!o||!(o instanceof t))return;let s=o.getSelectionParent();if(!s)return;n=s}return n}getSelectionParent(){let e=this.getField("select")?.value.asObject();if(e)return{kind:"select",value:e};let r=this.getField("include")?.value.asObject();if(r)return{kind:"include",value:r}}getSubSelectionValue(e){return this.getSelectionParent()?.value.fields[e].value}getPrintWidth(){let e=Object.values(this.fields);return e.length==0?2:Math.max(...e.map(n=>n.getPrintWidth()))+2}write(e){let r=Object.values(this.fields);if(r.length===0&&this.suggestions.length===0){this.writeEmpty(e);return}this.writeWithContents(e,r)}asObject(){return this}writeEmpty(e){let r=new pe("{}");this.hasError&&r.setColor(e.context.colors.red).underline(),e.write(r)}writeWithContents(e,r){e.writeLine("{").withIndent(()=>{e.writeJoined(je,[...r,...this.suggestions]).newLine()}),e.write("}"),this.hasError&&e.afterNextNewline(()=>{e.writeLine(e.context.colors.red("~".repeat(this.getPrintWidth())))})}};u();c();m();p();d();l();var W=class extends Te{constructor(r){super();this.text=r}getPrintWidth(){return this.text.length}write(r){let n=new pe(this.text);this.hasError&&n.underline().setColor(r.context.colors.red),r.write(n)}asObject(){}};u();c();m();p();d();l();var mt=class{fields=[];addField(e,r){return this.fields.push({write(n){let{green:i,dim:o}=n.context.colors;n.write(i(o(`${e}: ${r}`))).addMarginSymbol(i(o("+")))}}),this}write(e){let{colors:{green:r}}=e.context;e.writeLine(r("{")).withIndent(()=>{e.writeJoined(je,this.fields).newLine()}).write(r("}")).addMarginSymbol(r("+"))}};function Qt(t,e,r){switch(t.kind){case"MutuallyExclusiveFields":ca(t,e);break;case"IncludeOnScalar":ma(t,e);break;case"EmptySelection":pa(t,e,r);break;case"UnknownSelectionField":ya(t,e);break;case"InvalidSelectionValue":ha(t,e);break;case"UnknownArgument":ba(t,e);break;case"UnknownInputField":wa(t,e);break;case"RequiredArgumentMissing":xa(t,e);break;case"InvalidArgumentType":Ea(t,e);break;case"InvalidArgumentValue":Pa(t,e);break;case"ValueTooLarge":va(t,e);break;case"SomeFieldsMissing":Ta(t,e);break;case"TooManyFieldsGiven":Ca(t,e);break;case"Union":si(t,e,r);break;default:throw new Error("not implemented: "+t.kind)}}function ca(t,e){let r=e.arguments.getDeepSubSelectionValue(t.selectionPath)?.asObject();r&&(r.getField(t.firstField)?.markAsError(),r.getField(t.secondField)?.markAsError()),e.addErrorMessage(n=>`Please ${n.bold("either")} use ${n.green(`\`${t.firstField}\``)} or ${n.green(`\`${t.secondField}\``)}, but ${n.red("not both")} at the same time.`)}function ma(t,e){let[r,n]=Je(t.selectionPath),i=t.outputType,o=e.arguments.getDeepSelectionParent(r)?.value;if(o&&(o.getField(n)?.markAsError(),i))for(let s of i.fields)s.isRelation&&o.addSuggestion(new ne(s.name,"true"));e.addErrorMessage(s=>{let a=`Invalid scalar field ${s.red(`\`${n}\``)} for ${s.bold("include")} statement`;return i?a+=` on model ${s.bold(i.name)}. ${pt(s)}`:a+=".",a+=` -Note that ${s.bold("include")} statements only accept relation fields.`,a})}function pa(t,e,r){let n=e.arguments.getDeepSubSelectionValue(t.selectionPath)?.asObject();if(n){let i=n.getField("omit")?.value.asObject();if(i){da(t,e,i);return}if(n.hasField("select")){fa(t,e);return}}if(r?.[ve(t.outputType.name)]){ga(t,e);return}e.addErrorMessage(()=>`Unknown field at "${t.selectionPath.join(".")} selection"`)}function da(t,e,r){r.removeAllFields();for(let n of t.outputType.fields)r.addSuggestion(new ne(n.name,"false"));e.addErrorMessage(n=>`The ${n.red("omit")} statement includes every field of the model ${n.bold(t.outputType.name)}. At least one field must be included in the result`)}function fa(t,e){let r=t.outputType,n=e.arguments.getDeepSelectionParent(t.selectionPath)?.value,i=n?.isEmpty()??!1;n&&(n.removeAllFields(),fi(n,r)),e.addErrorMessage(o=>i?`The ${o.red("`select`")} statement for type ${o.bold(r.name)} must not be empty. ${pt(o)}`:`The ${o.red("`select`")} statement for type ${o.bold(r.name)} needs ${o.bold("at least one truthy value")}.`)}function ga(t,e){let r=new mt;for(let i of t.outputType.fields)i.isRelation||r.addField(i.name,"false");let n=new ne("omit",r).makeRequired();if(t.selectionPath.length===0)e.arguments.addSuggestion(n);else{let[i,o]=Je(t.selectionPath),a=e.arguments.getDeepSelectionParent(i)?.value.asObject()?.getField(o);if(a){let f=a?.value.asObject()??new Qe;f.addSuggestion(n),a.value=f}}e.addErrorMessage(i=>`The global ${i.red("omit")} configuration excludes every field of the model ${i.bold(t.outputType.name)}. At least one field must be included in the result`)}function ya(t,e){let r=gi(t.selectionPath,e);if(r.parentKind!=="unknown"){r.field.markAsError();let n=r.parent;switch(r.parentKind){case"select":fi(n,t.outputType);break;case"include":Aa(n,t.outputType);break;case"omit":Ra(n,t.outputType);break}}e.addErrorMessage(n=>{let i=[`Unknown field ${n.red(`\`${r.fieldName}\``)}`];return r.parentKind!=="unknown"&&i.push(`for ${n.bold(r.parentKind)} statement`),i.push(`on model ${n.bold(`\`${t.outputType.name}\``)}.`),i.push(pt(n)),i.join(" ")})}function ha(t,e){let r=gi(t.selectionPath,e);r.parentKind!=="unknown"&&r.field.value.markAsError(),e.addErrorMessage(n=>`Invalid value for selection field \`${n.red(r.fieldName)}\`: ${t.underlyingError}`)}function ba(t,e){let r=t.argumentPath[0],n=e.arguments.getDeepSubSelectionValue(t.selectionPath)?.asObject();n&&(n.getField(r)?.markAsError(),Sa(n,t.arguments)),e.addErrorMessage(i=>pi(i,r,t.arguments.map(o=>o.name)))}function wa(t,e){let[r,n]=Je(t.argumentPath),i=e.arguments.getDeepSubSelectionValue(t.selectionPath)?.asObject();if(i){i.getDeepField(t.argumentPath)?.markAsError();let o=i.getDeepFieldValue(r)?.asObject();o&&yi(o,t.inputType)}e.addErrorMessage(o=>pi(o,n,t.inputType.fields.map(s=>s.name)))}function pi(t,e,r){let n=[`Unknown argument \`${t.red(e)}\`.`],i=ka(e,r);return i&&n.push(`Did you mean \`${t.green(i)}\`?`),r.length>0&&n.push(pt(t)),n.join(" ")}function xa(t,e){let r;e.addErrorMessage(f=>r?.value instanceof W&&r.value.text==="null"?`Argument \`${f.green(o)}\` must not be ${f.red("null")}.`:`Argument \`${f.green(o)}\` is missing.`);let n=e.arguments.getDeepSubSelectionValue(t.selectionPath)?.asObject();if(!n)return;let[i,o]=Je(t.argumentPath),s=new mt,a=n.getDeepFieldValue(i)?.asObject();if(a){if(r=a.getField(o),r&&a.removeField(o),t.inputTypes.length===1&&t.inputTypes[0].kind==="object"){for(let f of t.inputTypes[0].fields)s.addField(f.name,f.typeNames.join(" | "));a.addSuggestion(new ne(o,s).makeRequired())}else{let f=t.inputTypes.map(di).join(" | ");a.addSuggestion(new ne(o,f).makeRequired())}if(t.dependentArgumentPath){n.getDeepField(t.dependentArgumentPath)?.markAsError();let[,f]=Je(t.dependentArgumentPath);e.addErrorMessage(h=>`Argument \`${h.green(o)}\` is required because argument \`${h.green(f)}\` was provided.`)}}}function di(t){return t.kind==="list"?`${di(t.elementType)}[]`:t.name}function Ea(t,e){let r=t.argument.name,n=e.arguments.getDeepSubSelectionValue(t.selectionPath)?.asObject();n&&n.getDeepFieldValue(t.argumentPath)?.markAsError(),e.addErrorMessage(i=>{let o=Kt("or",t.argument.typeNames.map(s=>i.green(s)));return`Argument \`${i.bold(r)}\`: Invalid value provided. Expected ${o}, provided ${i.red(t.inferredType)}.`})}function Pa(t,e){let r=t.argument.name,n=e.arguments.getDeepSubSelectionValue(t.selectionPath)?.asObject();n&&n.getDeepFieldValue(t.argumentPath)?.markAsError(),e.addErrorMessage(i=>{let o=[`Invalid value for argument \`${i.bold(r)}\``];if(t.underlyingError&&o.push(`: ${t.underlyingError}`),o.push("."),t.argument.typeNames.length>0){let s=Kt("or",t.argument.typeNames.map(a=>i.green(a)));o.push(` Expected ${s}.`)}return o.join("")})}function va(t,e){let r=t.argument.name,n=e.arguments.getDeepSubSelectionValue(t.selectionPath)?.asObject(),i;if(n){let s=n.getDeepField(t.argumentPath)?.value;s?.markAsError(),s instanceof W&&(i=s.text)}e.addErrorMessage(o=>{let s=["Unable to fit value"];return i&&s.push(o.red(i)),s.push(`into a 64-bit signed integer for field \`${o.bold(r)}\``),s.join(" ")})}function Ta(t,e){let r=t.argumentPath[t.argumentPath.length-1],n=e.arguments.getDeepSubSelectionValue(t.selectionPath)?.asObject();if(n){let i=n.getDeepFieldValue(t.argumentPath)?.asObject();i&&yi(i,t.inputType)}e.addErrorMessage(i=>{let o=[`Argument \`${i.bold(r)}\` of type ${i.bold(t.inputType.name)} needs`];return t.constraints.minFieldCount===1?t.constraints.requiredFields?o.push(`${i.green("at least one of")} ${Kt("or",t.constraints.requiredFields.map(s=>`\`${i.bold(s)}\``))} arguments.`):o.push(`${i.green("at least one")} argument.`):o.push(`${i.green(`at least ${t.constraints.minFieldCount}`)} arguments.`),o.push(pt(i)),o.join(" ")})}function Ca(t,e){let r=t.argumentPath[t.argumentPath.length-1],n=e.arguments.getDeepSubSelectionValue(t.selectionPath)?.asObject(),i=[];if(n){let o=n.getDeepFieldValue(t.argumentPath)?.asObject();o&&(o.markAsError(),i=Object.keys(o.getFields()))}e.addErrorMessage(o=>{let s=[`Argument \`${o.bold(r)}\` of type ${o.bold(t.inputType.name)} needs`];return t.constraints.minFieldCount===1&&t.constraints.maxFieldCount==1?s.push(`${o.green("exactly one")} argument,`):t.constraints.maxFieldCount==1?s.push(`${o.green("at most one")} argument,`):s.push(`${o.green(`at most ${t.constraints.maxFieldCount}`)} arguments,`),s.push(`but you provided ${Kt("and",i.map(a=>o.red(a)))}. Please choose`),t.constraints.maxFieldCount===1?s.push("one."):s.push(`${t.constraints.maxFieldCount}.`),s.join(" ")})}function fi(t,e){for(let r of e.fields)t.hasField(r.name)||t.addSuggestion(new ne(r.name,"true"))}function Aa(t,e){for(let r of e.fields)r.isRelation&&!t.hasField(r.name)&&t.addSuggestion(new ne(r.name,"true"))}function Ra(t,e){for(let r of e.fields)!t.hasField(r.name)&&!r.isRelation&&t.addSuggestion(new ne(r.name,"true"))}function Sa(t,e){for(let r of e)t.hasField(r.name)||t.addSuggestion(new ne(r.name,r.typeNames.join(" | ")))}function gi(t,e){let[r,n]=Je(t),i=e.arguments.getDeepSubSelectionValue(r)?.asObject();if(!i)return{parentKind:"unknown",fieldName:n};let o=i.getFieldValue("select")?.asObject(),s=i.getFieldValue("include")?.asObject(),a=i.getFieldValue("omit")?.asObject(),f=o?.getField(n);return o&&f?{parentKind:"select",parent:o,field:f,fieldName:n}:(f=s?.getField(n),s&&f?{parentKind:"include",field:f,parent:s,fieldName:n}:(f=a?.getField(n),a&&f?{parentKind:"omit",field:f,parent:a,fieldName:n}:{parentKind:"unknown",fieldName:n}))}function yi(t,e){if(e.kind==="object")for(let r of e.fields)t.hasField(r.name)||t.addSuggestion(new ne(r.name,r.typeNames.join(" | ")))}function Je(t){let e=[...t],r=e.pop();if(!r)throw new Error("unexpected empty path");return[e,r]}function pt({green:t,enabled:e}){return"Available options are "+(e?`listed in ${t("green")}`:"marked with ?")+"."}function Kt(t,e){if(e.length===1)return e[0];let r=[...e],n=r.pop();return`${r.join(", ")} ${t} ${n}`}var Oa=3;function ka(t,e){let r=1/0,n;for(let i of e){let o=(0,mi.default)(t,i);o>Oa||o`}};function Ge(t){return t instanceof dt}u();c();m();p();d();l();var Ht=Symbol(),$r=new WeakMap,Ee=class{constructor(e){e===Ht?$r.set(this,`Prisma.${this._getName()}`):$r.set(this,`new Prisma.${this._getNamespace()}.${this._getName()}()`)}_getName(){return this.constructor.name}toString(){return $r.get(this)}},ft=class extends Ee{_getNamespace(){return"NullTypes"}},gt=class extends ft{#e};Qr(gt,"DbNull");var yt=class extends ft{#e};Qr(yt,"JsonNull");var ht=class extends ft{#e};Qr(ht,"AnyNull");var zt={classes:{DbNull:gt,JsonNull:yt,AnyNull:ht},instances:{DbNull:new gt(Ht),JsonNull:new yt(Ht),AnyNull:new ht(Ht)}};function Qr(t,e){Object.defineProperty(t,"name",{value:e,configurable:!0})}u();c();m();p();d();l();var hi=": ",Yt=class{constructor(e,r){this.name=e;this.value=r}hasError=!1;markAsError(){this.hasError=!0}getPrintWidth(){return this.name.length+this.value.getPrintWidth()+hi.length}write(e){let r=new pe(this.name);this.hasError&&r.underline().setColor(e.context.colors.red),e.write(r).write(hi).write(this.value)}};var Jr=class{arguments;errorMessages=[];constructor(e){this.arguments=e}write(e){e.write(this.arguments)}addErrorMessage(e){this.errorMessages.push(e)}renderAllMessages(e){return this.errorMessages.map(r=>r(e)).join(` -`)}};function We(t){return new Jr(bi(t))}function bi(t){let e=new Qe;for(let[r,n]of Object.entries(t)){let i=new Yt(r,wi(n));e.addField(i)}return e}function wi(t){if(typeof t=="string")return new W(JSON.stringify(t));if(typeof t=="number"||typeof t=="boolean")return new W(String(t));if(typeof t=="bigint")return new W(`${t}n`);if(t===null)return new W("null");if(t===void 0)return new W("undefined");if(Be(t))return new W(`new Prisma.Decimal("${t.toFixed()}")`);if(t instanceof Uint8Array)return b.isBuffer(t)?new W(`Buffer.alloc(${t.byteLength})`):new W(`new Uint8Array(${t.byteLength})`);if(t instanceof Date){let e=jt(t)?t.toISOString():"Invalid Date";return new W(`new Date("${e}")`)}return t instanceof Ee?new W(`Prisma.${t._getName()}`):Ge(t)?new W(`prisma.${ve(t.modelName)}.$fields.${t.name}`):Array.isArray(t)?Da(t):typeof t=="object"?bi(t):new W(Object.prototype.toString.call(t))}function Da(t){let e=new $e;for(let r of t)e.addItem(wi(r));return e}function Xt(t,e){let r=e==="pretty"?ci:Wt,n=t.renderAllMessages(r),i=new Ve(0,{colors:r}).write(t).toString();return{message:n,args:i}}function Zt({args:t,errors:e,errorFormat:r,callsite:n,originalMethod:i,clientVersion:o,globalOmit:s}){let a=We(t);for(let A of e)Qt(A,a,s);let{message:f,args:h}=Xt(a,r),C=$t({message:f,callsite:n,originalMethod:i,showColors:r==="pretty",callArguments:h});throw new K(C,{clientVersion:o})}u();c();m();p();d();l();u();c();m();p();d();l();function de(t){return t.replace(/^./,e=>e.toLowerCase())}u();c();m();p();d();l();function Ei(t,e,r){let n=de(r);return!e.result||!(e.result.$allModels||e.result[n])?t:Ia({...t,...xi(e.name,t,e.result.$allModels),...xi(e.name,t,e.result[n])})}function Ia(t){let e=new me,r=(n,i)=>e.getOrCreate(n,()=>i.has(n)?[n]:(i.add(n),t[n]?t[n].needs.flatMap(o=>r(o,i)):[n]));return Vt(t,n=>({...n,needs:r(n.name,new Set)}))}function xi(t,e,r){return r?Vt(r,({needs:n,compute:i},o)=>({name:o,needs:n?Object.keys(n).filter(s=>n[s]):[],compute:Ma(e,o,i)})):{}}function Ma(t,e,r){let n=t?.[e]?.compute;return n?i=>r({...i,[e]:n(i)}):r}function Pi(t,e){if(!e)return t;let r={...t};for(let n of Object.values(e))if(t[n.name])for(let i of n.needs)r[i]=!0;return r}function vi(t,e){if(!e)return t;let r={...t};for(let n of Object.values(e))if(!t[n.name])for(let i of n.needs)delete r[i];return r}var er=class{constructor(e,r){this.extension=e;this.previous=r}computedFieldsCache=new me;modelExtensionsCache=new me;queryCallbacksCache=new me;clientExtensions=lt(()=>this.extension.client?{...this.previous?.getAllClientExtensions(),...this.extension.client}:this.previous?.getAllClientExtensions());batchCallbacks=lt(()=>{let e=this.previous?.getAllBatchQueryCallbacks()??[],r=this.extension.query?.$__internalBatch;return r?e.concat(r):e});getAllComputedFields(e){return this.computedFieldsCache.getOrCreate(e,()=>Ei(this.previous?.getAllComputedFields(e),this.extension,e))}getAllClientExtensions(){return this.clientExtensions.get()}getAllModelExtensions(e){return this.modelExtensionsCache.getOrCreate(e,()=>{let r=de(e);return!this.extension.model||!(this.extension.model[r]||this.extension.model.$allModels)?this.previous?.getAllModelExtensions(e):{...this.previous?.getAllModelExtensions(e),...this.extension.model.$allModels,...this.extension.model[r]}})}getAllQueryCallbacks(e,r){return this.queryCallbacksCache.getOrCreate(`${e}:${r}`,()=>{let n=this.previous?.getAllQueryCallbacks(e,r)??[],i=[],o=this.extension.query;return!o||!(o[e]||o.$allModels||o[r]||o.$allOperations)?n:(o[e]!==void 0&&(o[e][r]!==void 0&&i.push(o[e][r]),o[e].$allOperations!==void 0&&i.push(o[e].$allOperations)),e!=="$none"&&o.$allModels!==void 0&&(o.$allModels[r]!==void 0&&i.push(o.$allModels[r]),o.$allModels.$allOperations!==void 0&&i.push(o.$allModels.$allOperations)),o[r]!==void 0&&i.push(o[r]),o.$allOperations!==void 0&&i.push(o.$allOperations),n.concat(i))})}getAllBatchQueryCallbacks(){return this.batchCallbacks.get()}},Ke=class t{constructor(e){this.head=e}static empty(){return new t}static single(e){return new t(new er(e))}isEmpty(){return this.head===void 0}append(e){return new t(new er(e,this.head))}getAllComputedFields(e){return this.head?.getAllComputedFields(e)}getAllClientExtensions(){return this.head?.getAllClientExtensions()}getAllModelExtensions(e){return this.head?.getAllModelExtensions(e)}getAllQueryCallbacks(e,r){return this.head?.getAllQueryCallbacks(e,r)??[]}getAllBatchQueryCallbacks(){return this.head?.getAllBatchQueryCallbacks()??[]}};u();c();m();p();d();l();var tr=class{constructor(e){this.name=e}};function Ti(t){return t instanceof tr}function Ci(t){return new tr(t)}u();c();m();p();d();l();u();c();m();p();d();l();var Ai=Symbol(),bt=class{constructor(e){if(e!==Ai)throw new Error("Skip instance can not be constructed directly")}ifUndefined(e){return e===void 0?rr:e}},rr=new bt(Ai);function fe(t){return t instanceof bt}var _a={findUnique:"findUnique",findUniqueOrThrow:"findUniqueOrThrow",findFirst:"findFirst",findFirstOrThrow:"findFirstOrThrow",findMany:"findMany",count:"aggregate",create:"createOne",createMany:"createMany",createManyAndReturn:"createManyAndReturn",update:"updateOne",updateMany:"updateMany",updateManyAndReturn:"updateManyAndReturn",upsert:"upsertOne",delete:"deleteOne",deleteMany:"deleteMany",executeRaw:"executeRaw",queryRaw:"queryRaw",aggregate:"aggregate",groupBy:"groupBy",runCommandRaw:"runCommandRaw",findRaw:"findRaw",aggregateRaw:"aggregateRaw"},Ri="explicitly `undefined` values are not allowed";function nr({modelName:t,action:e,args:r,runtimeDataModel:n,extensions:i=Ke.empty(),callsite:o,clientMethod:s,errorFormat:a,clientVersion:f,previewFeatures:h,globalOmit:C}){let A=new Gr({runtimeDataModel:n,modelName:t,action:e,rootArgs:r,callsite:o,extensions:i,selectionPath:[],argumentPath:[],originalMethod:s,errorFormat:a,clientVersion:f,previewFeatures:h,globalOmit:C});return{modelName:t,action:_a[e],query:wt(r,A)}}function wt({select:t,include:e,...r}={},n){let i=r.omit;return delete r.omit,{arguments:Oi(r,n),selection:La(t,e,i,n)}}function La(t,e,r,n){return t?(e?n.throwValidationError({kind:"MutuallyExclusiveFields",firstField:"include",secondField:"select",selectionPath:n.getSelectionPath()}):r&&n.throwValidationError({kind:"MutuallyExclusiveFields",firstField:"omit",secondField:"select",selectionPath:n.getSelectionPath()}),qa(t,n)):Fa(n,e,r)}function Fa(t,e,r){let n={};return t.modelOrType&&!t.isRawAction()&&(n.$composites=!0,n.$scalars=!0),e&&Ua(n,e,t),Na(n,r,t),n}function Ua(t,e,r){for(let[n,i]of Object.entries(e)){if(fe(i))continue;let o=r.nestSelection(n);if(Wr(i,o),i===!1||i===void 0){t[n]=!1;continue}let s=r.findField(n);if(s&&s.kind!=="object"&&r.throwValidationError({kind:"IncludeOnScalar",selectionPath:r.getSelectionPath().concat(n),outputType:r.getOutputTypeDescription()}),s){t[n]=wt(i===!0?{}:i,o);continue}if(i===!0){t[n]=!0;continue}t[n]=wt(i,o)}}function Na(t,e,r){let n=r.getComputedFields(),i={...r.getGlobalOmit(),...e},o=vi(i,n);for(let[s,a]of Object.entries(o)){if(fe(a))continue;Wr(a,r.nestSelection(s));let f=r.findField(s);n?.[s]&&!f||(t[s]=!a)}}function qa(t,e){let r={},n=e.getComputedFields(),i=Pi(t,n);for(let[o,s]of Object.entries(i)){if(fe(s))continue;let a=e.nestSelection(o);Wr(s,a);let f=e.findField(o);if(!(n?.[o]&&!f)){if(s===!1||s===void 0||fe(s)){r[o]=!1;continue}if(s===!0){f?.kind==="object"?r[o]=wt({},a):r[o]=!0;continue}r[o]=wt(s,a)}}return r}function Si(t,e){if(t===null)return null;if(typeof t=="string"||typeof t=="number"||typeof t=="boolean")return t;if(typeof t=="bigint")return{$type:"BigInt",value:String(t)};if(qe(t)){if(jt(t))return{$type:"DateTime",value:t.toISOString()};e.throwValidationError({kind:"InvalidArgumentValue",selectionPath:e.getSelectionPath(),argumentPath:e.getArgumentPath(),argument:{name:e.getArgumentName(),typeNames:["Date"]},underlyingError:"Provided Date object is invalid"})}if(Ti(t))return{$type:"Param",value:t.name};if(Ge(t))return{$type:"FieldRef",value:{_ref:t.name,_container:t.modelName}};if(Array.isArray(t))return Ba(t,e);if(ArrayBuffer.isView(t)){let{buffer:r,byteOffset:n,byteLength:i}=t;return{$type:"Bytes",value:b.from(r,n,i).toString("base64")}}if(Va(t))return t.values;if(Be(t))return{$type:"Decimal",value:t.toFixed()};if(t instanceof Ee){if(t!==zt.instances[t._getName()])throw new Error("Invalid ObjectEnumValue");return{$type:"Enum",value:t._getName()}}if(ja(t))return t.toJSON();if(typeof t=="object")return Oi(t,e);e.throwValidationError({kind:"InvalidArgumentValue",selectionPath:e.getSelectionPath(),argumentPath:e.getArgumentPath(),argument:{name:e.getArgumentName(),typeNames:[]},underlyingError:`We could not serialize ${Object.prototype.toString.call(t)} value. Serialize the object to JSON or implement a ".toJSON()" method on it`})}function Oi(t,e){if(t.$type)return{$type:"Raw",value:t};let r={};for(let n in t){let i=t[n],o=e.nestArgument(n);fe(i)||(i!==void 0?r[n]=Si(i,o):e.isPreviewFeatureOn("strictUndefinedChecks")&&e.throwValidationError({kind:"InvalidArgumentValue",argumentPath:o.getArgumentPath(),selectionPath:e.getSelectionPath(),argument:{name:e.getArgumentName(),typeNames:[]},underlyingError:Ri}))}return r}function Ba(t,e){let r=[];for(let n=0;n({name:e.name,typeName:"boolean",isRelation:e.kind==="object"}))}}isRawAction(){return["executeRaw","queryRaw","runCommandRaw","findRaw","aggregateRaw"].includes(this.params.action)}isPreviewFeatureOn(e){return this.params.previewFeatures.includes(e)}getComputedFields(){if(this.params.modelName)return this.params.extensions.getAllComputedFields(this.params.modelName)}findField(e){return this.modelOrType?.fields.find(r=>r.name===e)}nestSelection(e){let r=this.findField(e),n=r?.kind==="object"?r.type:void 0;return new t({...this.params,modelName:n,selectionPath:this.params.selectionPath.concat(e)})}getGlobalOmit(){return this.params.modelName&&this.shouldApplyGlobalOmit()?this.params.globalOmit?.[ve(this.params.modelName)]??{}:{}}shouldApplyGlobalOmit(){switch(this.params.action){case"findFirst":case"findFirstOrThrow":case"findUniqueOrThrow":case"findMany":case"upsert":case"findUnique":case"createManyAndReturn":case"create":case"update":case"updateManyAndReturn":case"delete":return!0;case"executeRaw":case"aggregateRaw":case"runCommandRaw":case"findRaw":case"createMany":case"deleteMany":case"groupBy":case"updateMany":case"count":case"aggregate":case"queryRaw":return!1;default:Ie(this.params.action,"Unknown action")}}nestArgument(e){return new t({...this.params,argumentPath:this.params.argumentPath.concat(e)})}};u();c();m();p();d();l();function ki(t){if(!t._hasPreviewFlag("metrics"))throw new K("`metrics` preview feature must be enabled in order to access metrics API",{clientVersion:t._clientVersion})}var He=class{_client;constructor(e){this._client=e}prometheus(e){return ki(this._client),this._client._engine.metrics({format:"prometheus",...e})}json(e){return ki(this._client),this._client._engine.metrics({format:"json",...e})}};u();c();m();p();d();l();function Di(t,e){let r=lt(()=>$a(e));Object.defineProperty(t,"dmmf",{get:()=>r.get()})}function $a(t){throw new Error("Prisma.dmmf is not available when running in edge runtimes.")}function Kr(t){return Object.entries(t).map(([e,r])=>({name:e,...r}))}u();c();m();p();d();l();var Hr=new WeakMap,ir="$$PrismaTypedSql",xt=class{constructor(e,r){Hr.set(this,{sql:e,values:r}),Object.defineProperty(this,ir,{value:ir})}get sql(){return Hr.get(this).sql}get values(){return Hr.get(this).values}};function Ii(t){return(...e)=>new xt(t,e)}function or(t){return t!=null&&t[ir]===ir}u();c();m();p();d();l();var Jo=kt(Mi());u();c();m();p();d();l();_i();Vn();Gn();u();c();m();p();d();l();var ee=class t{constructor(e,r){if(e.length-1!==r.length)throw e.length===0?new TypeError("Expected at least 1 string"):new TypeError(`Expected ${e.length} strings to have ${e.length-1} values`);let n=r.reduce((s,a)=>s+(a instanceof t?a.values.length:1),0);this.values=new Array(n),this.strings=new Array(n+1),this.strings[0]=e[0];let i=0,o=0;for(;it.getPropertyValue(r))},getPropertyDescriptor(r){return t.getPropertyDescriptor?.(r)}}}u();c();m();p();d();l();u();c();m();p();d();l();var ar={enumerable:!0,configurable:!0,writable:!0};function lr(t){let e=new Set(t);return{getPrototypeOf:()=>Object.prototype,getOwnPropertyDescriptor:()=>ar,has:(r,n)=>e.has(n),set:(r,n,i)=>e.add(n)&&Reflect.set(r,n,i),ownKeys:()=>[...e]}}var Ui=Symbol.for("nodejs.util.inspect.custom");function ae(t,e){let r=Ja(e),n=new Set,i=new Proxy(t,{get(o,s){if(n.has(s))return o[s];let a=r.get(s);return a?a.getPropertyValue(s):o[s]},has(o,s){if(n.has(s))return!0;let a=r.get(s);return a?a.has?.(s)??!0:Reflect.has(o,s)},ownKeys(o){let s=Ni(Reflect.ownKeys(o),r),a=Ni(Array.from(r.keys()),r);return[...new Set([...s,...a,...n])]},set(o,s,a){return r.get(s)?.getPropertyDescriptor?.(s)?.writable===!1?!1:(n.add(s),Reflect.set(o,s,a))},getOwnPropertyDescriptor(o,s){let a=Reflect.getOwnPropertyDescriptor(o,s);if(a&&!a.configurable)return a;let f=r.get(s);return f?f.getPropertyDescriptor?{...ar,...f?.getPropertyDescriptor(s)}:ar:a},defineProperty(o,s,a){return n.add(s),Reflect.defineProperty(o,s,a)},getPrototypeOf:()=>Object.prototype});return i[Ui]=function(){let o={...this};return delete o[Ui],o},i}function Ja(t){let e=new Map;for(let r of t){let n=r.getKeys();for(let i of n)e.set(i,r)}return e}function Ni(t,e){return t.filter(r=>e.get(r)?.has?.(r)??!0)}u();c();m();p();d();l();function ze(t){return{getKeys(){return t},has(){return!1},getPropertyValue(){}}}u();c();m();p();d();l();function ur(t,e){return{batch:t,transaction:e?.kind==="batch"?{isolationLevel:e.options.isolationLevel}:void 0}}u();c();m();p();d();l();function qi(t){if(t===void 0)return"";let e=We(t);return new Ve(0,{colors:Wt}).write(e).toString()}u();c();m();p();d();l();var Ga="P2037";function cr({error:t,user_facing_error:e},r,n){return e.error_code?new Z(Wa(e,n),{code:e.error_code,clientVersion:r,meta:e.meta,batchRequestIdx:e.batch_request_idx}):new Q(t,{clientVersion:r,batchRequestIdx:e.batch_request_idx})}function Wa(t,e){let r=t.message;return(e==="postgresql"||e==="postgres"||e==="mysql")&&t.error_code===Ga&&(r+=` -Prisma Accelerate has built-in connection pooling to prevent such errors: https://pris.ly/client/error-accelerate`),r}u();c();m();p();d();l();u();c();m();p();d();l();u();c();m();p();d();l();u();c();m();p();d();l();u();c();m();p();d();l();var Xr=class{getLocation(){return null}};function Ce(t){return typeof $EnabledCallSite=="function"&&t!=="minimal"?new $EnabledCallSite:new Xr}u();c();m();p();d();l();u();c();m();p();d();l();u();c();m();p();d();l();var Bi={_avg:!0,_count:!0,_sum:!0,_min:!0,_max:!0};function Ye(t={}){let e=Ha(t);return Object.entries(e).reduce((n,[i,o])=>(Bi[i]!==void 0?n.select[i]={select:o}:n[i]=o,n),{select:{}})}function Ha(t={}){return typeof t._count=="boolean"?{...t,_count:{_all:t._count}}:t}function mr(t={}){return e=>(typeof t._count=="boolean"&&(e._count=e._count._all),e)}function Vi(t,e){let r=mr(t);return e({action:"aggregate",unpacker:r,argsMapper:Ye})(t)}u();c();m();p();d();l();function za(t={}){let{select:e,...r}=t;return typeof e=="object"?Ye({...r,_count:e}):Ye({...r,_count:{_all:!0}})}function Ya(t={}){return typeof t.select=="object"?e=>mr(t)(e)._count:e=>mr(t)(e)._count._all}function ji(t,e){return e({action:"count",unpacker:Ya(t),argsMapper:za})(t)}u();c();m();p();d();l();function Xa(t={}){let e=Ye(t);if(Array.isArray(e.by))for(let r of e.by)typeof r=="string"&&(e.select[r]=!0);else typeof e.by=="string"&&(e.select[e.by]=!0);return e}function Za(t={}){return e=>(typeof t?._count=="boolean"&&e.forEach(r=>{r._count=r._count._all}),e)}function $i(t,e){return e({action:"groupBy",unpacker:Za(t),argsMapper:Xa})(t)}function Qi(t,e,r){if(e==="aggregate")return n=>Vi(n,r);if(e==="count")return n=>ji(n,r);if(e==="groupBy")return n=>$i(n,r)}u();c();m();p();d();l();function Ji(t,e){let r=e.fields.filter(i=>!i.relationName),n=ti(r,"name");return new Proxy({},{get(i,o){if(o in i||typeof o=="symbol")return i[o];let s=n[o];if(s)return new dt(t,o,s.type,s.isList,s.kind==="enum")},...lr(Object.keys(n))})}u();c();m();p();d();l();u();c();m();p();d();l();var Gi=t=>Array.isArray(t)?t:t.split("."),Zr=(t,e)=>Gi(e).reduce((r,n)=>r&&r[n],t),Wi=(t,e,r)=>Gi(e).reduceRight((n,i,o,s)=>Object.assign({},Zr(t,s.slice(0,o)),{[i]:n}),r);function el(t,e){return t===void 0||e===void 0?[]:[...e,"select",t]}function tl(t,e,r){return e===void 0?t??{}:Wi(e,r,t||!0)}function en(t,e,r,n,i,o){let a=t._runtimeDataModel.models[e].fields.reduce((f,h)=>({...f,[h.name]:h}),{});return f=>{let h=Ce(t._errorFormat),C=el(n,i),A=tl(f,o,C),k=r({dataPath:C,callsite:h})(A),R=rl(t,e);return new Proxy(k,{get(_,O){if(!R.includes(O))return _[O];let ye=[a[O].type,r,O],z=[C,A];return en(t,...ye,...z)},...lr([...R,...Object.getOwnPropertyNames(k)])})}}function rl(t,e){return t._runtimeDataModel.models[e].fields.filter(r=>r.kind==="object").map(r=>r.name)}var nl=["findUnique","findUniqueOrThrow","findFirst","findFirstOrThrow","create","update","upsert","delete"],il=["aggregate","count","groupBy"];function tn(t,e){let r=t._extensions.getAllModelExtensions(e)??{},n=[ol(t,e),al(t,e),Et(r),H("name",()=>e),H("$name",()=>e),H("$parent",()=>t._appliedParent)];return ae({},n)}function ol(t,e){let r=de(e),n=Object.keys(ut).concat("count");return{getKeys(){return n},getPropertyValue(i){let o=i,s=a=>f=>{let h=Ce(t._errorFormat);return t._createPrismaPromise(C=>{let A={args:f,dataPath:[],action:o,model:e,clientMethod:`${r}.${i}`,jsModelName:r,transaction:C,callsite:h};return t._request({...A,...a})},{action:o,args:f,model:e})};return nl.includes(o)?en(t,e,s):sl(i)?Qi(t,i,s):s({})}}}function sl(t){return il.includes(t)}function al(t,e){return Me(H("fields",()=>{let r=t._runtimeDataModel.models[e];return Ji(e,r)}))}u();c();m();p();d();l();function Ki(t){return t.replace(/^./,e=>e.toUpperCase())}var rn=Symbol();function Pt(t){let e=[ll(t),ul(t),H(rn,()=>t),H("$parent",()=>t._appliedParent)],r=t._extensions.getAllClientExtensions();return r&&e.push(Et(r)),ae(t,e)}function ll(t){let e=Object.getPrototypeOf(t._originalClient),r=[...new Set(Object.getOwnPropertyNames(e))];return{getKeys(){return r},getPropertyValue(n){return t[n]}}}function ul(t){let e=Object.keys(t._runtimeDataModel.models),r=e.map(de),n=[...new Set(e.concat(r))];return Me({getKeys(){return n},getPropertyValue(i){let o=Ki(i);if(t._runtimeDataModel.models[o]!==void 0)return tn(t,o);if(t._runtimeDataModel.models[i]!==void 0)return tn(t,i)},getPropertyDescriptor(i){if(!r.includes(i))return{enumerable:!1}}})}function Hi(t){return t[rn]?t[rn]:t}function zi(t){if(typeof t=="function")return t(this);if(t.client?.__AccelerateEngine){let r=t.client.__AccelerateEngine;this._originalClient._engine=new r(this._originalClient._accelerateEngineConfig)}let e=Object.create(this._originalClient,{_extensions:{value:this._extensions.append(t)},_appliedParent:{value:this,configurable:!0},$on:{value:void 0}});return Pt(e)}u();c();m();p();d();l();u();c();m();p();d();l();function Yi({result:t,modelName:e,select:r,omit:n,extensions:i}){let o=i.getAllComputedFields(e);if(!o)return t;let s=[],a=[];for(let f of Object.values(o)){if(n){if(n[f.name])continue;let h=f.needs.filter(C=>n[C]);h.length>0&&a.push(ze(h))}else if(r){if(!r[f.name])continue;let h=f.needs.filter(C=>!r[C]);h.length>0&&a.push(ze(h))}cl(t,f.needs)&&s.push(ml(f,ae(t,s)))}return s.length>0||a.length>0?ae(t,[...s,...a]):t}function cl(t,e){return e.every(r=>Nr(t,r))}function ml(t,e){return Me(H(t.name,()=>t.compute(e)))}u();c();m();p();d();l();function pr({visitor:t,result:e,args:r,runtimeDataModel:n,modelName:i}){if(Array.isArray(e)){for(let s=0;sC.name===o);if(!f||f.kind!=="object"||!f.relationName)continue;let h=typeof s=="object"?s:{};e[o]=pr({visitor:i,result:e[o],args:h,modelName:f.type,runtimeDataModel:n})}}function Zi({result:t,modelName:e,args:r,extensions:n,runtimeDataModel:i,globalOmit:o}){return n.isEmpty()||t==null||typeof t!="object"||!i.models[e]?t:pr({result:t,args:r??{},modelName:e,runtimeDataModel:i,visitor:(a,f,h)=>{let C=de(f);return Yi({result:a,modelName:C,select:h.select,omit:h.select?void 0:{...o?.[C],...h.omit},extensions:n})}})}u();c();m();p();d();l();u();c();m();p();d();l();l();u();c();m();p();d();l();var pl=["$connect","$disconnect","$on","$transaction","$extends"],eo=pl;function to(t){if(t instanceof ee)return dl(t);if(or(t))return fl(t);if(Array.isArray(t)){let r=[t[0]];for(let n=1;n{let o=e.customDataProxyFetch;return"transaction"in e&&i!==void 0&&(e.transaction?.kind==="batch"&&e.transaction.lock.then(),e.transaction=i),n===r.length?t._executeRequest(e):r[n]({model:e.model,operation:e.model?e.action:e.clientMethod,args:to(e.args??{}),__internalParams:e,query:(s,a=e)=>{let f=a.customDataProxyFetch;return a.customDataProxyFetch=ao(o,f),a.args=s,no(t,a,r,n+1)}})})}function io(t,e){let{jsModelName:r,action:n,clientMethod:i}=e,o=r?n:i;if(t._extensions.isEmpty())return t._executeRequest(e);let s=t._extensions.getAllQueryCallbacks(r??"$none",o);return no(t,e,s)}function oo(t){return e=>{let r={requests:e},n=e[0].extensions.getAllBatchQueryCallbacks();return n.length?so(r,n,0,t):t(r)}}function so(t,e,r,n){if(r===e.length)return n(t);let i=t.customDataProxyFetch,o=t.requests[0].transaction;return e[r]({args:{queries:t.requests.map(s=>({model:s.modelName,operation:s.action,args:s.args})),transaction:o?{isolationLevel:o.kind==="batch"?o.isolationLevel:void 0}:void 0},__internalParams:t,query(s,a=t){let f=a.customDataProxyFetch;return a.customDataProxyFetch=ao(i,f),so(a,e,r+1,n)}})}var ro=t=>t;function ao(t=ro,e=ro){return r=>t(e(r))}u();c();m();p();d();l();var lo=G("prisma:client"),uo={Vercel:"vercel","Netlify CI":"netlify"};function co({postinstall:t,ciName:e,clientVersion:r,generator:n}){if(lo("checkPlatformCaching:postinstall",t),lo("checkPlatformCaching:ciName",e),t===!0&&!(n?.output&&typeof(n.output.fromEnvVar??n.output.value)=="string")&&e&&e in uo){let i=`Prisma has detected that this project was built on ${e}, which caches dependencies. This leads to an outdated Prisma Client because Prisma's auto-generation isn't triggered. To fix this, make sure to run the \`prisma generate\` command during the build process. - -Learn how: https://pris.ly/d/${uo[e]}-build`;throw console.error(i),new I(i,r)}}u();c();m();p();d();l();function mo(t,e){return t?t.datasources?t.datasources:t.datasourceUrl?{[e[0]]:{url:t.datasourceUrl}}:{}:{}}u();c();m();p();d();l();u();c();m();p();d();l();u();c();m();p();d();l();u();c();m();p();d();l();l();u();c();m();p();d();l();l();function po(t,e){throw new Error(e)}function gl(t){return t!==null&&typeof t=="object"&&typeof t.$type=="string"}function yl(t,e){let r={};for(let n of Object.keys(t))r[n]=e(t[n],n);return r}function Xe(t){return t===null?t:Array.isArray(t)?t.map(Xe):typeof t=="object"?gl(t)?hl(t):t.constructor!==null&&t.constructor.name!=="Object"?t:yl(t,Xe):t}function hl({$type:t,value:e}){switch(t){case"BigInt":return BigInt(e);case"Bytes":{let{buffer:r,byteOffset:n,byteLength:i}=b.from(e,"base64");return new Uint8Array(r,n,i)}case"DateTime":return new Date(e);case"Decimal":return new v(e);case"Json":return JSON.parse(e);default:po(e,"Unknown tagged value")}}var fo="6.19.1";u();c();m();p();d();l();u();c();m();p();d();l();var wl=()=>globalThis.process?.release?.name==="node",xl=()=>!!globalThis.Bun||!!globalThis.process?.versions?.bun,El=()=>!!globalThis.Deno,Pl=()=>typeof globalThis.Netlify=="object",vl=()=>typeof globalThis.EdgeRuntime=="object",Tl=()=>globalThis.navigator?.userAgent==="Cloudflare-Workers";function Cl(){return[[Pl,"netlify"],[vl,"edge-light"],[Tl,"workerd"],[El,"deno"],[xl,"bun"],[wl,"node"]].flatMap(r=>r[0]()?[r[1]]:[]).at(0)??""}var Al={node:"Node.js",workerd:"Cloudflare Workers",deno:"Deno and Deno Deploy",netlify:"Netlify Edge Functions","edge-light":"Edge Runtime (Vercel Edge Functions, Vercel Edge Middleware, Next.js (Pages Router) Edge API Routes, Next.js (App Router) Edge Route Handlers or Next.js Middleware)"};function Ze(){let t=Cl();return{id:t,prettyName:Al[t]||t,isEdge:["workerd","deno","netlify","edge-light"].includes(t)}}function dr({inlineDatasources:t,overrideDatasources:e,env:r,clientVersion:n}){let i,o=Object.keys(t)[0],s=t[o]?.url,a=e[o]?.url;if(o===void 0?i=void 0:a?i=a:s?.value?i=s.value:s?.fromEnvVar&&(i=r[s.fromEnvVar]),s?.fromEnvVar!==void 0&&i===void 0)throw Ze().id==="workerd"?new I(`error: Environment variable not found: ${s.fromEnvVar}. - -In Cloudflare module Workers, environment variables are available only in the Worker's \`env\` parameter of \`fetch\`. -To solve this, provide the connection string directly: https://pris.ly/d/cloudflare-datasource-url`,n):new I(`error: Environment variable not found: ${s.fromEnvVar}.`,n);if(i===void 0)throw new I("error: Missing URL environment variable, value, or override.",n);return i}u();c();m();p();d();l();u();c();m();p();d();l();function go(t){if(t?.kind==="itx")return t.options.id}u();c();m();p();d();l();var nn,yo={async loadLibrary(t){let{clientVersion:e,adapter:r,engineWasm:n}=t;if(r===void 0)throw new I(`The \`adapter\` option for \`PrismaClient\` is required in this context (${Ze().prettyName})`,e);if(n===void 0)throw new I("WASM engine was unexpectedly `undefined`",e);nn===void 0&&(nn=(async()=>{let o=await n.getRuntime(),s=await n.getQueryEngineWasmModule();if(s==null)throw new I("The loaded wasm module was unexpectedly `undefined` or `null` once loaded",e);let a={"./query_engine_bg.js":o},f=new WebAssembly.Instance(s,a),h=f.exports.__wbindgen_start;return o.__wbg_set_wasm(f.exports),h(),o.QueryEngine})());let i=await nn;return{debugPanic(){return Promise.reject("{}")},dmmf(){return Promise.resolve("{}")},version(){return{commit:"unknown",version:"unknown"}},QueryEngine:i}}};var Rl="P2036",ge=G("prisma:client:libraryEngine");function Sl(t){return t.item_type==="query"&&"query"in t}function Ol(t){return"level"in t?t.level==="error"&&t.message==="PANIC":!1}var oO=[...kr,"native"],kl=0xffffffffffffffffn,on=1n;function Dl(){let t=on++;return on>kl&&(on=1n),t}var Tt=class{name="LibraryEngine";engine;libraryInstantiationPromise;libraryStartingPromise;libraryStoppingPromise;libraryStarted;executingQueryPromise;config;QueryEngineConstructor;libraryLoader;library;logEmitter;libQueryEnginePath;binaryTarget;datasourceOverrides;datamodel;logQueries;logLevel;lastQuery;loggerRustPanic;tracingHelper;adapterPromise;versionInfo;constructor(e,r){this.libraryLoader=r??yo,this.config=e,this.libraryStarted=!1,this.logQueries=e.logQueries??!1,this.logLevel=e.logLevel??"error",this.logEmitter=e.logEmitter,this.datamodel=e.inlineSchema,this.tracingHelper=e.tracingHelper,e.enableDebugLogs&&(this.logLevel="debug");let n=Object.keys(e.overrideDatasources)[0],i=e.overrideDatasources[n]?.url;n!==void 0&&i!==void 0&&(this.datasourceOverrides={[n]:i}),this.libraryInstantiationPromise=this.instantiateLibrary()}wrapEngine(e){return{applyPendingMigrations:e.applyPendingMigrations?.bind(e),commitTransaction:this.withRequestId(e.commitTransaction.bind(e)),connect:this.withRequestId(e.connect.bind(e)),disconnect:this.withRequestId(e.disconnect.bind(e)),metrics:e.metrics?.bind(e),query:this.withRequestId(e.query.bind(e)),rollbackTransaction:this.withRequestId(e.rollbackTransaction.bind(e)),sdlSchema:e.sdlSchema?.bind(e),startTransaction:this.withRequestId(e.startTransaction.bind(e)),trace:e.trace.bind(e),free:e.free?.bind(e)}}withRequestId(e){return async(...r)=>{let n=Dl().toString();try{return await e(...r,n)}finally{if(this.tracingHelper.isEnabled()){let i=await this.engine?.trace(n);if(i){let o=JSON.parse(i);this.tracingHelper.dispatchEngineSpans(o.spans)}}}}}async applyPendingMigrations(){throw new Error("Cannot call this method from this type of engine instance")}async transaction(e,r,n){await this.start();let i=await this.adapterPromise,o=JSON.stringify(r),s;if(e==="start"){let f=JSON.stringify({max_wait:n.maxWait,timeout:n.timeout,isolation_level:n.isolationLevel});s=await this.engine?.startTransaction(f,o)}else e==="commit"?s=await this.engine?.commitTransaction(n.id,o):e==="rollback"&&(s=await this.engine?.rollbackTransaction(n.id,o));let a=this.parseEngineResponse(s);if(Il(a)){let f=this.getExternalAdapterError(a,i?.errorRegistry);throw f?f.error:new Z(a.message,{code:a.error_code,clientVersion:this.config.clientVersion,meta:a.meta})}else if(typeof a.message=="string")throw new Q(a.message,{clientVersion:this.config.clientVersion});return a}async instantiateLibrary(){if(ge("internalSetup"),this.libraryInstantiationPromise)return this.libraryInstantiationPromise;this.binaryTarget=await this.getCurrentBinaryTarget(),await this.tracingHelper.runInChildSpan("load_engine",()=>this.loadEngine()),this.version()}async getCurrentBinaryTarget(){}parseEngineResponse(e){if(!e)throw new Q("Response from the Engine was empty",{clientVersion:this.config.clientVersion});try{return JSON.parse(e)}catch{throw new Q("Unable to JSON.parse response from engine",{clientVersion:this.config.clientVersion})}}async loadEngine(){if(!this.engine){this.QueryEngineConstructor||(this.library=await this.libraryLoader.loadLibrary(this.config),this.QueryEngineConstructor=this.library.QueryEngine);try{let e=new w(this);this.adapterPromise||(this.adapterPromise=this.config.adapter?.connect()?.then(qt));let r=await this.adapterPromise;r&&ge("Using driver adapter: %O",r),this.engine=this.wrapEngine(new this.QueryEngineConstructor({datamodel:this.datamodel,env:g.env,logQueries:this.config.logQueries??!1,ignoreEnvVarErrors:!0,datasourceOverrides:this.datasourceOverrides??{},logLevel:this.logLevel,configDir:this.config.cwd,engineProtocol:"json",enableTracing:this.tracingHelper.isEnabled()},n=>{e.deref()?.logger(n)},r))}catch(e){let r=e,n=this.parseInitError(r.message);throw typeof n=="string"?r:new I(n.message,this.config.clientVersion,n.error_code)}}}logger(e){let r=this.parseEngineResponse(e);r&&(r.level=r?.level.toLowerCase()??"unknown",Sl(r)?this.logEmitter.emit("query",{timestamp:new Date,query:r.query,params:r.params,duration:Number(r.duration_ms),target:r.module_path}):(Ol(r),this.logEmitter.emit(r.level,{timestamp:new Date,message:r.message,target:r.module_path})))}parseInitError(e){try{return JSON.parse(e)}catch{}return e}parseRequestError(e){try{return JSON.parse(e)}catch{}return e}onBeforeExit(){throw new Error('"beforeExit" hook is not applicable to the library engine since Prisma 5.0.0, it is only relevant and implemented for the binary engine. Please add your event listener to the `process` object directly instead.')}async start(){if(this.libraryInstantiationPromise||(this.libraryInstantiationPromise=this.instantiateLibrary()),await this.libraryInstantiationPromise,await this.libraryStoppingPromise,this.libraryStartingPromise)return ge(`library already starting, this.libraryStarted: ${this.libraryStarted}`),this.libraryStartingPromise;if(this.libraryStarted)return;let e=async()=>{ge("library starting");try{let r={traceparent:this.tracingHelper.getTraceParent()};await this.engine?.connect(JSON.stringify(r)),this.libraryStarted=!0,this.adapterPromise||(this.adapterPromise=this.config.adapter?.connect()?.then(qt)),await this.adapterPromise,ge("library started")}catch(r){let n=this.parseInitError(r.message);throw typeof n=="string"?r:new I(n.message,this.config.clientVersion,n.error_code)}finally{this.libraryStartingPromise=void 0}};return this.libraryStartingPromise=this.tracingHelper.runInChildSpan("connect",e),this.libraryStartingPromise}async stop(){if(await this.libraryInstantiationPromise,await this.libraryStartingPromise,await this.executingQueryPromise,this.libraryStoppingPromise)return ge("library is already stopping"),this.libraryStoppingPromise;if(!this.libraryStarted){await(await this.adapterPromise)?.dispose(),this.adapterPromise=void 0;return}let e=async()=>{await new Promise(n=>setImmediate(n)),ge("library stopping");let r={traceparent:this.tracingHelper.getTraceParent()};await this.engine?.disconnect(JSON.stringify(r)),this.engine?.free&&this.engine.free(),this.engine=void 0,this.libraryStarted=!1,this.libraryStoppingPromise=void 0,this.libraryInstantiationPromise=void 0,await(await this.adapterPromise)?.dispose(),this.adapterPromise=void 0,ge("library stopped")};return this.libraryStoppingPromise=this.tracingHelper.runInChildSpan("disconnect",e),this.libraryStoppingPromise}version(){return this.versionInfo=this.library?.version(),this.versionInfo?.version??"unknown"}debugPanic(e){return this.library?.debugPanic(e)}async request(e,{traceparent:r,interactiveTransaction:n}){ge(`sending request, this.libraryStarted: ${this.libraryStarted}`);let i=JSON.stringify({traceparent:r}),o=JSON.stringify(e);try{await this.start();let s=await this.adapterPromise;this.executingQueryPromise=this.engine?.query(o,i,n?.id),this.lastQuery=o;let a=this.parseEngineResponse(await this.executingQueryPromise);if(a.errors)throw a.errors.length===1?this.buildQueryError(a.errors[0],s?.errorRegistry):new Q(JSON.stringify(a.errors),{clientVersion:this.config.clientVersion});if(this.loggerRustPanic)throw this.loggerRustPanic;return{data:a}}catch(s){if(s instanceof I)throw s;s.code==="GenericFailure"&&s.message?.startsWith("PANIC:");let a=this.parseRequestError(s.message);throw typeof a=="string"?s:new Q(`${a.message} -${a.backtrace}`,{clientVersion:this.config.clientVersion})}}async requestBatch(e,{transaction:r,traceparent:n}){ge("requestBatch");let i=ur(e,r);await this.start();let o=await this.adapterPromise;this.lastQuery=JSON.stringify(i),this.executingQueryPromise=this.engine?.query(this.lastQuery,JSON.stringify({traceparent:n}),go(r));let s=await this.executingQueryPromise,a=this.parseEngineResponse(s);if(a.errors)throw a.errors.length===1?this.buildQueryError(a.errors[0],o?.errorRegistry):new Q(JSON.stringify(a.errors),{clientVersion:this.config.clientVersion});let{batchResult:f,errors:h}=a;if(Array.isArray(f))return f.map(C=>C.errors&&C.errors.length>0?this.loggerRustPanic??this.buildQueryError(C.errors[0],o?.errorRegistry):{data:C});throw h&&h.length===1?new Error(h[0].error):new Error(JSON.stringify(a))}buildQueryError(e,r){e.user_facing_error.is_panic;let n=this.getExternalAdapterError(e.user_facing_error,r);return n?n.error:cr(e,this.config.clientVersion,this.config.activeProvider)}getExternalAdapterError(e,r){if(e.error_code===Rl&&r){let n=e.meta?.id;Bt(typeof n=="number","Malformed external JS error received from the engine");let i=r.consumeError(n);return Bt(i,"External error with reported id was not registered"),i}}async metrics(e){await this.start();let r=await this.engine.metrics(JSON.stringify(e));return e.format==="prometheus"?r:this.parseEngineResponse(r)}};function Il(t){return typeof t=="object"&&t!==null&&t.error_code!==void 0}u();c();m();p();d();l();var Ct="Accelerate has not been setup correctly. Make sure your client is using `.$extends(withAccelerate())`. See https://pris.ly/d/accelerate-getting-started",fr=class{constructor(e){this.config=e;this.resolveDatasourceUrl=this.config.accelerateUtils?.resolveDatasourceUrl,this.getBatchRequestPayload=this.config.accelerateUtils?.getBatchRequestPayload,this.prismaGraphQLToJSError=this.config.accelerateUtils?.prismaGraphQLToJSError,this.PrismaClientUnknownRequestError=this.config.accelerateUtils?.PrismaClientUnknownRequestError,this.PrismaClientInitializationError=this.config.accelerateUtils?.PrismaClientInitializationError,this.PrismaClientKnownRequestError=this.config.accelerateUtils?.PrismaClientKnownRequestError,this.debug=this.config.accelerateUtils?.debug,this.engineVersion=this.config.accelerateUtils?.engineVersion,this.clientVersion=this.config.accelerateUtils?.clientVersion}name="AccelerateEngine";resolveDatasourceUrl;getBatchRequestPayload;prismaGraphQLToJSError;PrismaClientUnknownRequestError;PrismaClientInitializationError;PrismaClientKnownRequestError;debug;engineVersion;clientVersion;onBeforeExit(e){}async start(){}async stop(){}version(e){return"unknown"}transaction(e,r,n){throw new I(Ct,this.config.clientVersion)}metrics(e){throw new I(Ct,this.config.clientVersion)}request(e,r){throw new I(Ct,this.config.clientVersion)}requestBatch(e,r){throw new I(Ct,this.config.clientVersion)}applyPendingMigrations(){throw new I(Ct,this.config.clientVersion)}};u();c();m();p();d();l();function ho({url:t,adapter:e,copyEngine:r,targetBuildType:n}){let i=[],o=[],s=O=>{i.push({_tag:"warning",value:O})},a=O=>{let D=O.join(` -`);o.push({_tag:"error",value:D})},f=!!t?.startsWith("prisma://"),h=_r(t),C=!!e,A=f||h;!C&&r&&A&&n!=="client"&&n!=="wasm-compiler-edge"&&s(["recommend--no-engine","In production, we recommend using `prisma generate --no-engine` (See: `prisma generate --help`)"]);let k=A||!r;C&&(k||n==="edge")&&(n==="edge"?a(["Prisma Client was configured to use the `adapter` option but it was imported via its `/edge` endpoint.","Please either remove the `/edge` endpoint or remove the `adapter` from the Prisma Client constructor."]):A?a(["You've provided both a driver adapter and an Accelerate database URL. Driver adapters currently cannot connect to Accelerate.","Please provide either a driver adapter with a direct database URL or an Accelerate URL and no driver adapter."]):r||a(["Prisma Client was configured to use the `adapter` option but `prisma generate` was run with `--no-engine`.","Please run `prisma generate` without `--no-engine` to be able to use Prisma Client with the adapter."]));let R={accelerate:k,ppg:h,driverAdapters:C};function _(O){return O.length>0}return _(o)?{ok:!1,diagnostics:{warnings:i,errors:o},isUsing:R}:{ok:!0,diagnostics:{warnings:i},isUsing:R}}function bo({copyEngine:t=!0},e){let r;try{r=dr({inlineDatasources:e.inlineDatasources,overrideDatasources:e.overrideDatasources,env:{...e.env,...g.env},clientVersion:e.clientVersion})}catch{}let{ok:n,isUsing:i,diagnostics:o}=ho({url:r,adapter:e.adapter,copyEngine:t,targetBuildType:"wasm-engine-edge"});for(let A of o.warnings)at(...A.value);if(!n){let A=o.errors[0];throw new K(A.value,{clientVersion:e.clientVersion})}let s=Ne(e.generator),a=s==="library",f=s==="binary",h=s==="client",C=(i.accelerate||i.ppg)&&!i.driverAdapters;return i.accelerate,i.driverAdapters?new Tt(e):i.accelerate?new fr(e):new sn({clientVersion:e.clientVersion})}var sn=class{constructor(e){return new Proxy(this,{get(r,n){let i=`In order to run Prisma Client on edge runtime, either: -- Use Prisma Accelerate: https://pris.ly/d/accelerate -- Use Driver Adapters: https://pris.ly/d/driver-adapters`;throw new K(i,e)}})}};u();c();m();p();d();l();function wo({generator:t}){return t?.previewFeatures??[]}u();c();m();p();d();l();var xo=t=>({command:t});u();c();m();p();d();l();u();c();m();p();d();l();var Eo=t=>t.strings.reduce((e,r,n)=>`${e}@P${n}${r}`);u();c();m();p();d();l();l();function et(t){try{return Po(t,"fast")}catch{return Po(t,"slow")}}function Po(t,e){return JSON.stringify(t.map(r=>To(r,e)))}function To(t,e){if(Array.isArray(t))return t.map(r=>To(r,e));if(typeof t=="bigint")return{prisma__type:"bigint",prisma__value:t.toString()};if(qe(t))return{prisma__type:"date",prisma__value:t.toJSON()};if(be.isDecimal(t))return{prisma__type:"decimal",prisma__value:t.toJSON()};if(b.isBuffer(t))return{prisma__type:"bytes",prisma__value:t.toString("base64")};if(Ml(t))return{prisma__type:"bytes",prisma__value:b.from(t).toString("base64")};if(ArrayBuffer.isView(t)){let{buffer:r,byteOffset:n,byteLength:i}=t;return{prisma__type:"bytes",prisma__value:b.from(r,n,i).toString("base64")}}return typeof t=="object"&&e==="slow"?Co(t):t}function Ml(t){return t instanceof ArrayBuffer||t instanceof SharedArrayBuffer?!0:typeof t=="object"&&t!==null?t[Symbol.toStringTag]==="ArrayBuffer"||t[Symbol.toStringTag]==="SharedArrayBuffer":!1}function Co(t){if(typeof t!="object"||t===null)return t;if(typeof t.toJSON=="function")return t.toJSON();if(Array.isArray(t))return t.map(vo);let e={};for(let r of Object.keys(t))e[r]=vo(t[r]);return e}function vo(t){return typeof t=="bigint"?t.toString():Co(t)}var _l=/^(\s*alter\s)/i,Ao=G("prisma:client");function an(t,e,r,n){if(!(t!=="postgresql"&&t!=="cockroachdb")&&r.length>0&&_l.exec(e))throw new Error(`Running ALTER using ${n} is not supported -Using the example below you can still execute your query with Prisma, but please note that it is vulnerable to SQL injection attacks and requires you to take care of input sanitization. - -Example: - await prisma.$executeRawUnsafe(\`ALTER USER prisma WITH PASSWORD '\${password}'\`) - -More Information: https://pris.ly/d/execute-raw -`)}var ln=({clientMethod:t,activeProvider:e})=>r=>{let n="",i;if(or(r))n=r.sql,i={values:et(r.values),__prismaRawParameters__:!0};else if(Array.isArray(r)){let[o,...s]=r;n=o,i={values:et(s||[]),__prismaRawParameters__:!0}}else switch(e){case"sqlite":case"mysql":{n=r.sql,i={values:et(r.values),__prismaRawParameters__:!0};break}case"cockroachdb":case"postgresql":case"postgres":{n=r.text,i={values:et(r.values),__prismaRawParameters__:!0};break}case"sqlserver":{n=Eo(r),i={values:et(r.values),__prismaRawParameters__:!0};break}default:throw new Error(`The ${e} provider does not support ${t}`)}return i?.values?Ao(`prisma.${t}(${n}, ${i.values})`):Ao(`prisma.${t}(${n})`),{query:n,parameters:i}},Ro={requestArgsToMiddlewareArgs(t){return[t.strings,...t.values]},middlewareArgsToRequestArgs(t){let[e,...r]=t;return new ee(e,r)}},So={requestArgsToMiddlewareArgs(t){return[t]},middlewareArgsToRequestArgs(t){return t[0]}};u();c();m();p();d();l();function un(t){return function(r,n){let i,o=(s=t)=>{try{return s===void 0||s?.kind==="itx"?i??=Oo(r(s)):Oo(r(s))}catch(a){return Promise.reject(a)}};return{get spec(){return n},then(s,a){return o().then(s,a)},catch(s){return o().catch(s)},finally(s){return o().finally(s)},requestTransaction(s){let a=o(s);return a.requestTransaction?a.requestTransaction(s):a},[Symbol.toStringTag]:"PrismaPromise"}}}function Oo(t){return typeof t.then=="function"?t:Promise.resolve(t)}u();c();m();p();d();l();var Ll=Dr.split(".")[0],Fl={isEnabled(){return!1},getTraceParent(){return"00-10-10-00"},dispatchEngineSpans(){},getActiveContext(){},runInChildSpan(t,e){return e()}},cn=class{isEnabled(){return this.getGlobalTracingHelper().isEnabled()}getTraceParent(e){return this.getGlobalTracingHelper().getTraceParent(e)}dispatchEngineSpans(e){return this.getGlobalTracingHelper().dispatchEngineSpans(e)}getActiveContext(){return this.getGlobalTracingHelper().getActiveContext()}runInChildSpan(e,r){return this.getGlobalTracingHelper().runInChildSpan(e,r)}getGlobalTracingHelper(){let e=globalThis[`V${Ll}_PRISMA_INSTRUMENTATION`],r=globalThis.PRISMA_INSTRUMENTATION;return e?.helper??r?.helper??Fl}};function ko(){return new cn}u();c();m();p();d();l();function Do(t,e=()=>{}){let r,n=new Promise(i=>r=i);return{then(i){return--t===0&&r(e()),i?.(n)}}}u();c();m();p();d();l();function Io(t){return typeof t=="string"?t:t.reduce((e,r)=>{let n=typeof r=="string"?r:r.level;return n==="query"?e:e&&(r==="info"||e==="info")?"info":n},void 0)}u();c();m();p();d();l();u();c();m();p();d();l();function gr(t){return typeof t.batchRequestIdx=="number"}u();c();m();p();d();l();function Mo(t){if(t.action!=="findUnique"&&t.action!=="findUniqueOrThrow")return;let e=[];return t.modelName&&e.push(t.modelName),t.query.arguments&&e.push(mn(t.query.arguments)),e.push(mn(t.query.selection)),e.join("")}function mn(t){return`(${Object.keys(t).sort().map(r=>{let n=t[r];return typeof n=="object"&&n!==null?`(${r} ${mn(n)})`:r}).join(" ")})`}u();c();m();p();d();l();var Ul={aggregate:!1,aggregateRaw:!1,createMany:!0,createManyAndReturn:!0,createOne:!0,deleteMany:!0,deleteOne:!0,executeRaw:!0,findFirst:!1,findFirstOrThrow:!1,findMany:!1,findRaw:!1,findUnique:!1,findUniqueOrThrow:!1,groupBy:!1,queryRaw:!1,runCommandRaw:!0,updateMany:!0,updateManyAndReturn:!0,updateOne:!0,upsertOne:!0};function pn(t){return Ul[t]}u();c();m();p();d();l();var yr=class{constructor(e){this.options=e;this.batches={}}batches;tickActive=!1;request(e){let r=this.options.batchBy(e);return r?(this.batches[r]||(this.batches[r]=[],this.tickActive||(this.tickActive=!0,g.nextTick(()=>{this.dispatchBatches(),this.tickActive=!1}))),new Promise((n,i)=>{this.batches[r].push({request:e,resolve:n,reject:i})})):this.options.singleLoader(e)}dispatchBatches(){for(let e in this.batches){let r=this.batches[e];delete this.batches[e],r.length===1?this.options.singleLoader(r[0].request).then(n=>{n instanceof Error?r[0].reject(n):r[0].resolve(n)}).catch(n=>{r[0].reject(n)}):(r.sort((n,i)=>this.options.batchOrder(n.request,i.request)),this.options.batchLoader(r.map(n=>n.request)).then(n=>{if(n instanceof Error)for(let i=0;i{for(let i=0;i_e("bigint",r));case"bytes-array":return e.map(r=>_e("bytes",r));case"decimal-array":return e.map(r=>_e("decimal",r));case"datetime-array":return e.map(r=>_e("datetime",r));case"date-array":return e.map(r=>_e("date",r));case"time-array":return e.map(r=>_e("time",r));default:return e}}function hr(t){let e=[],r=Nl(t);for(let n=0;n{let{transaction:o,otelParentCtx:s}=n[0],a=n.map(A=>A.protocolQuery),f=this.client._tracingHelper.getTraceParent(s),h=n.some(A=>pn(A.protocolQuery.action));return(await this.client._engine.requestBatch(a,{traceparent:f,transaction:Bl(o),containsWrite:h,customDataProxyFetch:i})).map((A,k)=>{if(A instanceof Error)return A;try{return this.mapQueryEngineResult(n[k],A)}catch(R){return R}})}),singleLoader:async n=>{let i=n.transaction?.kind==="itx"?_o(n.transaction):void 0,o=await this.client._engine.request(n.protocolQuery,{traceparent:this.client._tracingHelper.getTraceParent(),interactiveTransaction:i,isWrite:pn(n.protocolQuery.action),customDataProxyFetch:n.customDataProxyFetch});return this.mapQueryEngineResult(n,o)},batchBy:n=>n.transaction?.id?`transaction-${n.transaction.id}`:Mo(n.protocolQuery),batchOrder(n,i){return n.transaction?.kind==="batch"&&i.transaction?.kind==="batch"?n.transaction.index-i.transaction.index:0}})}async request(e){try{return await this.dataloader.request(e)}catch(r){let{clientMethod:n,callsite:i,transaction:o,args:s,modelName:a}=e;this.handleAndLogRequestError({error:r,clientMethod:n,callsite:i,transaction:o,args:s,modelName:a,globalOmit:e.globalOmit})}}mapQueryEngineResult({dataPath:e,unpacker:r},n){let i=n?.data,o=this.unpack(i,e,r);return g.env.PRISMA_CLIENT_GET_TIME?{data:o}:o}handleAndLogRequestError(e){try{this.handleRequestError(e)}catch(r){throw this.logEmitter&&this.logEmitter.emit("error",{message:r.message,target:e.clientMethod,timestamp:new Date}),r}}handleRequestError({error:e,clientMethod:r,callsite:n,transaction:i,args:o,modelName:s,globalOmit:a}){if(ql(e),Vl(e,i))throw e;if(e instanceof Z&&jl(e)){let h=Lo(e.meta);Zt({args:o,errors:[h],callsite:n,errorFormat:this.client._errorFormat,originalMethod:r,clientVersion:this.client._clientVersion,globalOmit:a})}let f=e.message;if(n&&(f=$t({callsite:n,originalMethod:r,isPanic:e.isPanic,showColors:this.client._errorFormat==="pretty",message:f})),f=this.sanitizeMessage(f),e.code){let h=s?{modelName:s,...e.meta}:e.meta;throw new Z(f,{code:e.code,clientVersion:this.client._clientVersion,meta:h,batchRequestIdx:e.batchRequestIdx})}else{if(e.isPanic)throw new xe(f,this.client._clientVersion);if(e instanceof Q)throw new Q(f,{clientVersion:this.client._clientVersion,batchRequestIdx:e.batchRequestIdx});if(e instanceof I)throw new I(f,this.client._clientVersion);if(e instanceof xe)throw new xe(f,this.client._clientVersion)}throw e.clientVersion=this.client._clientVersion,e}sanitizeMessage(e){return this.client._errorFormat&&this.client._errorFormat!=="pretty"?Ur(e):e}unpack(e,r,n){if(!e||(e.data&&(e=e.data),!e))return e;let i=Object.keys(e)[0],o=Object.values(e)[0],s=r.filter(h=>h!=="select"&&h!=="include"),a=Zr(o,s),f=i==="queryRaw"?hr(a):Xe(a);return n?n(f):f}get[Symbol.toStringTag](){return"RequestHandler"}};function Bl(t){if(t){if(t.kind==="batch")return{kind:"batch",options:{isolationLevel:t.isolationLevel}};if(t.kind==="itx")return{kind:"itx",options:_o(t)};Ie(t,"Unknown transaction kind")}}function _o(t){return{id:t.id,payload:t.payload}}function Vl(t,e){return gr(t)&&e?.kind==="batch"&&t.batchRequestIdx!==e.index}function jl(t){return t.code==="P2009"||t.code==="P2012"}function Lo(t){if(t.kind==="Union")return{kind:"Union",errors:t.errors.map(Lo)};if(Array.isArray(t.selectionPath)){let[,...e]=t.selectionPath;return{...t,selectionPath:e}}return t}u();c();m();p();d();l();var Fo=fo;u();c();m();p();d();l();var Vo=kt(Vr());u();c();m();p();d();l();var M=class extends Error{constructor(e){super(e+` -Read more at https://pris.ly/d/client-constructor`),this.name="PrismaClientConstructorValidationError"}get[Symbol.toStringTag](){return"PrismaClientConstructorValidationError"}};re(M,"PrismaClientConstructorValidationError");var Uo=["datasources","datasourceUrl","errorFormat","adapter","log","transactionOptions","omit","__internal"],No=["pretty","colorless","minimal"],qo=["info","query","warn","error"],$l={datasources:(t,{datasourceNames:e})=>{if(t){if(typeof t!="object"||Array.isArray(t))throw new M(`Invalid value ${JSON.stringify(t)} for "datasources" provided to PrismaClient constructor`);for(let[r,n]of Object.entries(t)){if(!e.includes(r)){let i=tt(r,e)||` Available datasources: ${e.join(", ")}`;throw new M(`Unknown datasource ${r} provided to PrismaClient constructor.${i}`)}if(typeof n!="object"||Array.isArray(n))throw new M(`Invalid value ${JSON.stringify(t)} for datasource "${r}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`);if(n&&typeof n=="object")for(let[i,o]of Object.entries(n)){if(i!=="url")throw new M(`Invalid value ${JSON.stringify(t)} for datasource "${r}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`);if(typeof o!="string")throw new M(`Invalid value ${JSON.stringify(o)} for datasource "${r}" provided to PrismaClient constructor. -It should have this form: { url: "CONNECTION_STRING" }`)}}}},adapter:(t,e)=>{if(!t&&Ne(e.generator)==="client")throw new M('Using engine type "client" requires a driver adapter to be provided to PrismaClient constructor.');if(t!==null){if(t===void 0)throw new M('"adapter" property must not be undefined, use null to conditionally disable driver adapters.');if(Ne(e.generator)==="binary")throw new M('Cannot use a driver adapter with the "binary" Query Engine. Please use the "library" Query Engine.')}},datasourceUrl:t=>{if(typeof t<"u"&&typeof t!="string")throw new M(`Invalid value ${JSON.stringify(t)} for "datasourceUrl" provided to PrismaClient constructor. -Expected string or undefined.`)},errorFormat:t=>{if(t){if(typeof t!="string")throw new M(`Invalid value ${JSON.stringify(t)} for "errorFormat" provided to PrismaClient constructor.`);if(!No.includes(t)){let e=tt(t,No);throw new M(`Invalid errorFormat ${t} provided to PrismaClient constructor.${e}`)}}},log:t=>{if(!t)return;if(!Array.isArray(t))throw new M(`Invalid value ${JSON.stringify(t)} for "log" provided to PrismaClient constructor.`);function e(r){if(typeof r=="string"&&!qo.includes(r)){let n=tt(r,qo);throw new M(`Invalid log level "${r}" provided to PrismaClient constructor.${n}`)}}for(let r of t){e(r);let n={level:e,emit:i=>{let o=["stdout","event"];if(!o.includes(i)){let s=tt(i,o);throw new M(`Invalid value ${JSON.stringify(i)} for "emit" in logLevel provided to PrismaClient constructor.${s}`)}}};if(r&&typeof r=="object")for(let[i,o]of Object.entries(r))if(n[i])n[i](o);else throw new M(`Invalid property ${i} for "log" provided to PrismaClient constructor`)}},transactionOptions:t=>{if(!t)return;let e=t.maxWait;if(e!=null&&e<=0)throw new M(`Invalid value ${e} for maxWait in "transactionOptions" provided to PrismaClient constructor. maxWait needs to be greater than 0`);let r=t.timeout;if(r!=null&&r<=0)throw new M(`Invalid value ${r} for timeout in "transactionOptions" provided to PrismaClient constructor. timeout needs to be greater than 0`)},omit:(t,e)=>{if(typeof t!="object")throw new M('"omit" option is expected to be an object.');if(t===null)throw new M('"omit" option can not be `null`');let r=[];for(let[n,i]of Object.entries(t)){let o=Jl(n,e.runtimeDataModel);if(!o){r.push({kind:"UnknownModel",modelKey:n});continue}for(let[s,a]of Object.entries(i)){let f=o.fields.find(h=>h.name===s);if(!f){r.push({kind:"UnknownField",modelKey:n,fieldName:s});continue}if(f.relationName){r.push({kind:"RelationInOmit",modelKey:n,fieldName:s});continue}typeof a!="boolean"&&r.push({kind:"InvalidFieldValue",modelKey:n,fieldName:s})}}if(r.length>0)throw new M(Gl(t,r))},__internal:t=>{if(!t)return;let e=["debug","engine","configOverride"];if(typeof t!="object")throw new M(`Invalid value ${JSON.stringify(t)} for "__internal" to PrismaClient constructor`);for(let[r]of Object.entries(t))if(!e.includes(r)){let n=tt(r,e);throw new M(`Invalid property ${JSON.stringify(r)} for "__internal" provided to PrismaClient constructor.${n}`)}}};function jo(t,e){for(let[r,n]of Object.entries(t)){if(!Uo.includes(r)){let i=tt(r,Uo);throw new M(`Unknown property ${r} provided to PrismaClient constructor.${i}`)}$l[r](n,e)}if(t.datasourceUrl&&t.datasources)throw new M('Can not use "datasourceUrl" and "datasources" options at the same time. Pick one of them')}function tt(t,e){if(e.length===0||typeof t!="string")return"";let r=Ql(t,e);return r?` Did you mean "${r}"?`:""}function Ql(t,e){if(e.length===0)return null;let r=e.map(i=>({value:i,distance:(0,Vo.default)(t,i)}));r.sort((i,o)=>i.distanceve(n)===e);if(r)return t[r]}function Gl(t,e){let r=We(t);for(let o of e)switch(o.kind){case"UnknownModel":r.arguments.getField(o.modelKey)?.markAsError(),r.addErrorMessage(()=>`Unknown model name: ${o.modelKey}.`);break;case"UnknownField":r.arguments.getDeepField([o.modelKey,o.fieldName])?.markAsError(),r.addErrorMessage(()=>`Model "${o.modelKey}" does not have a field named "${o.fieldName}".`);break;case"RelationInOmit":r.arguments.getDeepField([o.modelKey,o.fieldName])?.markAsError(),r.addErrorMessage(()=>'Relations are already excluded by default and can not be specified in "omit".');break;case"InvalidFieldValue":r.arguments.getDeepFieldValue([o.modelKey,o.fieldName])?.markAsError(),r.addErrorMessage(()=>"Omit field option value must be a boolean.");break}let{message:n,args:i}=Xt(r,"colorless");return`Error validating "omit" option: - -${i} - -${n}`}u();c();m();p();d();l();function $o(t){return t.length===0?Promise.resolve([]):new Promise((e,r)=>{let n=new Array(t.length),i=null,o=!1,s=0,a=()=>{o||(s++,s===t.length&&(o=!0,i?r(i):e(n)))},f=h=>{o||(o=!0,r(h))};for(let h=0;h{n[h]=C,a()},C=>{if(!gr(C)){f(C);return}C.batchRequestIdx===h?f(C):(i||(i=C),a())})})}var Ae=G("prisma:client");typeof globalThis=="object"&&(globalThis.NODE_CLIENT=!0);var Wl={requestArgsToMiddlewareArgs:t=>t,middlewareArgsToRequestArgs:t=>t},Kl=Symbol.for("prisma.client.transaction.id"),Hl={id:0,nextId(){return++this.id}};function Go(t){class e{_originalClient=this;_runtimeDataModel;_requestHandler;_connectionPromise;_disconnectionPromise;_engineConfig;_accelerateEngineConfig;_clientVersion;_errorFormat;_tracingHelper;_previewFeatures;_activeProvider;_globalOmit;_extensions;_engine;_appliedParent;_createPrismaPromise=un();constructor(n){t=n?.__internal?.configOverride?.(t)??t,co(t),n&&jo(n,t);let i=new sr().on("error",()=>{});this._extensions=Ke.empty(),this._previewFeatures=wo(t),this._clientVersion=t.clientVersion??Fo,this._activeProvider=t.activeProvider,this._globalOmit=n?.omit,this._tracingHelper=ko();let o=t.relativeEnvPaths&&{rootEnvPath:t.relativeEnvPaths.rootEnvPath&&Ut.resolve(t.dirname,t.relativeEnvPaths.rootEnvPath),schemaEnvPath:t.relativeEnvPaths.schemaEnvPath&&Ut.resolve(t.dirname,t.relativeEnvPaths.schemaEnvPath)},s;if(n?.adapter){s=n.adapter;let f=t.activeProvider==="postgresql"||t.activeProvider==="cockroachdb"?"postgres":t.activeProvider;if(s.provider!==f)throw new I(`The Driver Adapter \`${s.adapterName}\`, based on \`${s.provider}\`, is not compatible with the provider \`${f}\` specified in the Prisma schema.`,this._clientVersion);if(n.datasources||n.datasourceUrl!==void 0)throw new I("Custom datasource configuration is not compatible with Prisma Driver Adapters. Please define the database connection string directly in the Driver Adapter configuration.",this._clientVersion)}let a=t.injectableEdgeEnv?.();try{let f=n??{},h=f.__internal??{},C=h.debug===!0;C&&G.enable("prisma:client");let A=Ut.resolve(t.dirname,t.relativePath);Bn.existsSync(A)||(A=t.dirname),Ae("dirname",t.dirname),Ae("relativePath",t.relativePath),Ae("cwd",A);let k=h.engine||{};if(f.errorFormat?this._errorFormat=f.errorFormat:g.env.NODE_ENV==="production"?this._errorFormat="minimal":g.env.NO_COLOR?this._errorFormat="colorless":this._errorFormat="colorless",this._runtimeDataModel=t.runtimeDataModel,this._engineConfig={cwd:A,dirname:t.dirname,enableDebugLogs:C,allowTriggerPanic:k.allowTriggerPanic,prismaPath:k.binaryPath??void 0,engineEndpoint:k.endpoint,generator:t.generator,showColors:this._errorFormat==="pretty",logLevel:f.log&&Io(f.log),logQueries:f.log&&!!(typeof f.log=="string"?f.log==="query":f.log.find(R=>typeof R=="string"?R==="query":R.level==="query")),env:a?.parsed??{},flags:[],engineWasm:t.engineWasm,compilerWasm:t.compilerWasm,clientVersion:t.clientVersion,engineVersion:t.engineVersion,previewFeatures:this._previewFeatures,activeProvider:t.activeProvider,inlineSchema:t.inlineSchema,overrideDatasources:mo(f,t.datasourceNames),inlineDatasources:t.inlineDatasources,inlineSchemaHash:t.inlineSchemaHash,tracingHelper:this._tracingHelper,transactionOptions:{maxWait:f.transactionOptions?.maxWait??2e3,timeout:f.transactionOptions?.timeout??5e3,isolationLevel:f.transactionOptions?.isolationLevel},logEmitter:i,isBundled:t.isBundled,adapter:s},this._accelerateEngineConfig={...this._engineConfig,accelerateUtils:{resolveDatasourceUrl:dr,getBatchRequestPayload:ur,prismaGraphQLToJSError:cr,PrismaClientUnknownRequestError:Q,PrismaClientInitializationError:I,PrismaClientKnownRequestError:Z,debug:G("prisma:client:accelerateEngine"),engineVersion:Jo.version,clientVersion:t.clientVersion}},Ae("clientVersion",t.clientVersion),this._engine=bo(t,this._engineConfig),this._requestHandler=new br(this,i),f.log)for(let R of f.log){let _=typeof R=="string"?R:R.emit==="stdout"?R.level:null;_&&this.$on(_,O=>{st.log(`${st.tags[_]??""}`,O.message||O.query)})}}catch(f){throw f.clientVersion=this._clientVersion,f}return this._appliedParent=Pt(this)}get[Symbol.toStringTag](){return"PrismaClient"}$on(n,i){return n==="beforeExit"?this._engine.onBeforeExit(i):n&&this._engineConfig.logEmitter.on(n,i),this}$connect(){try{return this._engine.start()}catch(n){throw n.clientVersion=this._clientVersion,n}}async $disconnect(){try{await this._engine.stop()}catch(n){throw n.clientVersion=this._clientVersion,n}finally{qn()}}$executeRawInternal(n,i,o,s){let a=this._activeProvider;return this._request({action:"executeRaw",args:o,transaction:n,clientMethod:i,argsMapper:ln({clientMethod:i,activeProvider:a}),callsite:Ce(this._errorFormat),dataPath:[],middlewareArgsMapper:s})}$executeRaw(n,...i){return this._createPrismaPromise(o=>{if(n.raw!==void 0||n.sql!==void 0){let[s,a]=Qo(n,i);return an(this._activeProvider,s.text,s.values,Array.isArray(n)?"prisma.$executeRaw``":"prisma.$executeRaw(sql``)"),this.$executeRawInternal(o,"$executeRaw",s,a)}throw new K("`$executeRaw` is a tag function, please use it like the following:\n```\nconst result = await prisma.$executeRaw`UPDATE User SET cool = ${true} WHERE email = ${'user@email.com'};`\n```\n\nOr read our docs at https://www.prisma.io/docs/concepts/components/prisma-client/raw-database-access#executeraw\n",{clientVersion:this._clientVersion})})}$executeRawUnsafe(n,...i){return this._createPrismaPromise(o=>(an(this._activeProvider,n,i,"prisma.$executeRawUnsafe(, [...values])"),this.$executeRawInternal(o,"$executeRawUnsafe",[n,...i])))}$runCommandRaw(n){if(t.activeProvider!=="mongodb")throw new K(`The ${t.activeProvider} provider does not support $runCommandRaw. Use the mongodb provider.`,{clientVersion:this._clientVersion});return this._createPrismaPromise(i=>this._request({args:n,clientMethod:"$runCommandRaw",dataPath:[],action:"runCommandRaw",argsMapper:xo,callsite:Ce(this._errorFormat),transaction:i}))}async $queryRawInternal(n,i,o,s){let a=this._activeProvider;return this._request({action:"queryRaw",args:o,transaction:n,clientMethod:i,argsMapper:ln({clientMethod:i,activeProvider:a}),callsite:Ce(this._errorFormat),dataPath:[],middlewareArgsMapper:s})}$queryRaw(n,...i){return this._createPrismaPromise(o=>{if(n.raw!==void 0||n.sql!==void 0)return this.$queryRawInternal(o,"$queryRaw",...Qo(n,i));throw new K("`$queryRaw` is a tag function, please use it like the following:\n```\nconst result = await prisma.$queryRaw`SELECT * FROM User WHERE id = ${1} OR email = ${'user@email.com'};`\n```\n\nOr read our docs at https://www.prisma.io/docs/concepts/components/prisma-client/raw-database-access#queryraw\n",{clientVersion:this._clientVersion})})}$queryRawTyped(n){return this._createPrismaPromise(i=>{if(!this._hasPreviewFlag("typedSql"))throw new K("`typedSql` preview feature must be enabled in order to access $queryRawTyped API",{clientVersion:this._clientVersion});return this.$queryRawInternal(i,"$queryRawTyped",n)})}$queryRawUnsafe(n,...i){return this._createPrismaPromise(o=>this.$queryRawInternal(o,"$queryRawUnsafe",[n,...i]))}_transactionWithArray({promises:n,options:i}){let o=Hl.nextId(),s=Do(n.length),a=n.map((f,h)=>{if(f?.[Symbol.toStringTag]!=="PrismaPromise")throw new Error("All elements of the array need to be Prisma Client promises. Hint: Please make sure you are not awaiting the Prisma client calls you intended to pass in the $transaction function.");let C=i?.isolationLevel??this._engineConfig.transactionOptions.isolationLevel,A={kind:"batch",id:o,index:h,isolationLevel:C,lock:s};return f.requestTransaction?.(A)??f});return $o(a)}async _transactionWithCallback({callback:n,options:i}){let o={traceparent:this._tracingHelper.getTraceParent()},s={maxWait:i?.maxWait??this._engineConfig.transactionOptions.maxWait,timeout:i?.timeout??this._engineConfig.transactionOptions.timeout,isolationLevel:i?.isolationLevel??this._engineConfig.transactionOptions.isolationLevel},a=await this._engine.transaction("start",o,s),f;try{let h={kind:"itx",...a};f=await n(this._createItxClient(h)),await this._engine.transaction("commit",o,a)}catch(h){throw await this._engine.transaction("rollback",o,a).catch(()=>{}),h}return f}_createItxClient(n){return ae(Pt(ae(Hi(this),[H("_appliedParent",()=>this._appliedParent._createItxClient(n)),H("_createPrismaPromise",()=>un(n)),H(Kl,()=>n.id)])),[ze(eo)])}$transaction(n,i){let o;typeof n=="function"?this._engineConfig.adapter?.adapterName==="@prisma/adapter-d1"?o=()=>{throw new Error("Cloudflare D1 does not support interactive transactions. We recommend you to refactor your queries with that limitation in mind, and use batch transactions with `prisma.$transactions([])` where applicable.")}:o=()=>this._transactionWithCallback({callback:n,options:i}):o=()=>this._transactionWithArray({promises:n,options:i});let s={name:"transaction",attributes:{method:"$transaction"}};return this._tracingHelper.runInChildSpan(s,o)}_request(n){n.otelParentCtx=this._tracingHelper.getActiveContext();let i=n.middlewareArgsMapper??Wl,o={args:i.requestArgsToMiddlewareArgs(n.args),dataPath:n.dataPath,runInTransaction:!!n.transaction,action:n.action,model:n.model},s={operation:{name:"operation",attributes:{method:o.action,model:o.model,name:o.model?`${o.model}.${o.action}`:o.action}}},a=async f=>{let{runInTransaction:h,args:C,...A}=f,k={...n,...A};C&&(k.args=i.middlewareArgsToRequestArgs(C)),n.transaction!==void 0&&h===!1&&delete k.transaction;let R=await io(this,k);return k.model?Zi({result:R,modelName:k.model,args:k.args,extensions:this._extensions,runtimeDataModel:this._runtimeDataModel,globalOmit:this._globalOmit}):R};return this._tracingHelper.runInChildSpan(s.operation,()=>a(o))}async _executeRequest({args:n,clientMethod:i,dataPath:o,callsite:s,action:a,model:f,argsMapper:h,transaction:C,unpacker:A,otelParentCtx:k,customDataProxyFetch:R}){try{n=h?h(n):n;let _={name:"serialize"},O=this._tracingHelper.runInChildSpan(_,()=>nr({modelName:f,runtimeDataModel:this._runtimeDataModel,action:a,args:n,clientMethod:i,callsite:s,extensions:this._extensions,errorFormat:this._errorFormat,clientVersion:this._clientVersion,previewFeatures:this._previewFeatures,globalOmit:this._globalOmit}));return G.enabled("prisma:client")&&(Ae("Prisma Client call:"),Ae(`prisma.${i}(${qi(n)})`),Ae("Generated request:"),Ae(JSON.stringify(O,null,2)+` -`)),C?.kind==="batch"&&await C.lock,this._requestHandler.request({protocolQuery:O,modelName:f,action:a,clientMethod:i,dataPath:o,callsite:s,args:n,extensions:this._extensions,transaction:C,unpacker:A,otelParentCtx:k,otelChildCtx:this._tracingHelper.getActiveContext(),globalOmit:this._globalOmit,customDataProxyFetch:R})}catch(_){throw _.clientVersion=this._clientVersion,_}}$metrics=new He(this);_hasPreviewFlag(n){return!!this._engineConfig.previewFeatures?.includes(n)}$applyPendingMigrations(){return this._engine.applyPendingMigrations()}$extends=zi}return e}function Qo(t,e){return zl(t)?[new ee(t,e),Ro]:[t,So]}function zl(t){return Array.isArray(t)&&Array.isArray(t.raw)}u();c();m();p();d();l();var Yl=new Set(["toJSON","$$typeof","asymmetricMatch",Symbol.iterator,Symbol.toStringTag,Symbol.isConcatSpreadable,Symbol.toPrimitive]);function Wo(t){return new Proxy(t,{get(e,r){if(r in e)return e[r];if(!Yl.has(r))throw new TypeError(`Invalid enum value: ${String(r)}`)}})}u();c();m();p();d();l();l();0&&(module.exports={DMMF,Debug,Decimal,Extensions,MetricsClient,PrismaClientInitializationError,PrismaClientKnownRequestError,PrismaClientRustPanicError,PrismaClientUnknownRequestError,PrismaClientValidationError,Public,Sql,createParam,defineDmmfProperty,deserializeJsonResponse,deserializeRawResult,dmmfToRuntimeDataModel,empty,getPrismaClient,getRuntime,join,makeStrictEnum,makeTypedQueryFactory,objectEnumValues,raw,serializeJsonQuery,skip,sqltag,warnEnvConflicts,warnOnce}); -//# sourceMappingURL=wasm-engine-edge.js.map diff --git a/frontend/generated/prisma/schema.prisma b/frontend/generated/prisma/schema.prisma deleted file mode 100644 index 774bcc5..0000000 --- a/frontend/generated/prisma/schema.prisma +++ /dev/null @@ -1,21 +0,0 @@ -// This is your Prisma schema file, -// learn more about it in the docs: https://pris.ly/d/prisma-schema - -generator client { - provider = "prisma-client-js" - output = "../generated/prisma" -} - -datasource db { - provider = "sqlite" - url = env("DATABASE_URL") -} - -model Post { - id Int @id @default(autoincrement()) - name String - createdAt DateTime @default(now()) - updatedAt DateTime @updatedAt - - @@index([name]) -} diff --git a/frontend/generated/prisma/wasm-edge-light-loader.mjs b/frontend/generated/prisma/wasm-edge-light-loader.mjs deleted file mode 100644 index dcf01f0..0000000 --- a/frontend/generated/prisma/wasm-edge-light-loader.mjs +++ /dev/null @@ -1,5 +0,0 @@ - -/* !!! This is code generated by Prisma. Do not edit directly. !!! -/* eslint-disable */ -// biome-ignore-all lint: generated file -export default import('./query_engine_bg.wasm?module') \ No newline at end of file diff --git a/frontend/generated/prisma/wasm-worker-loader.mjs b/frontend/generated/prisma/wasm-worker-loader.mjs deleted file mode 100644 index e60a3fa..0000000 --- a/frontend/generated/prisma/wasm-worker-loader.mjs +++ /dev/null @@ -1,5 +0,0 @@ - -/* !!! This is code generated by Prisma. Do not edit directly. !!! -/* eslint-disable */ -// biome-ignore-all lint: generated file -export default import('./query_engine_bg.wasm') \ No newline at end of file diff --git a/frontend/generated/prisma/wasm.d.ts b/frontend/generated/prisma/wasm.d.ts deleted file mode 100644 index 274b8fa..0000000 --- a/frontend/generated/prisma/wasm.d.ts +++ /dev/null @@ -1 +0,0 @@ -export * from "./default" \ No newline at end of file diff --git a/frontend/generated/prisma/wasm.js b/frontend/generated/prisma/wasm.js deleted file mode 100644 index 7c5f366..0000000 --- a/frontend/generated/prisma/wasm.js +++ /dev/null @@ -1,188 +0,0 @@ - -/* !!! This is code generated by Prisma. Do not edit directly. !!! -/* eslint-disable */ -// biome-ignore-all lint: generated file - -Object.defineProperty(exports, "__esModule", { value: true }); - -const { - PrismaClientKnownRequestError, - PrismaClientUnknownRequestError, - PrismaClientRustPanicError, - PrismaClientInitializationError, - PrismaClientValidationError, - getPrismaClient, - sqltag, - empty, - join, - raw, - skip, - Decimal, - Debug, - objectEnumValues, - makeStrictEnum, - Extensions, - warnOnce, - defineDmmfProperty, - Public, - getRuntime, - createParam, -} = require('./runtime/wasm-engine-edge.js') - - -const Prisma = {} - -exports.Prisma = Prisma -exports.$Enums = {} - -/** - * Prisma Client JS version: 6.19.1 - * Query Engine version: c2990dca591cba766e3b7ef5d9e8a84796e47ab7 - */ -Prisma.prismaVersion = { - client: "6.19.1", - engine: "c2990dca591cba766e3b7ef5d9e8a84796e47ab7" -} - -Prisma.PrismaClientKnownRequestError = PrismaClientKnownRequestError; -Prisma.PrismaClientUnknownRequestError = PrismaClientUnknownRequestError -Prisma.PrismaClientRustPanicError = PrismaClientRustPanicError -Prisma.PrismaClientInitializationError = PrismaClientInitializationError -Prisma.PrismaClientValidationError = PrismaClientValidationError -Prisma.Decimal = Decimal - -/** - * Re-export of sql-template-tag - */ -Prisma.sql = sqltag -Prisma.empty = empty -Prisma.join = join -Prisma.raw = raw -Prisma.validator = Public.validator - -/** -* Extensions -*/ -Prisma.getExtensionContext = Extensions.getExtensionContext -Prisma.defineExtension = Extensions.defineExtension - -/** - * Shorthand utilities for JSON filtering - */ -Prisma.DbNull = objectEnumValues.instances.DbNull -Prisma.JsonNull = objectEnumValues.instances.JsonNull -Prisma.AnyNull = objectEnumValues.instances.AnyNull - -Prisma.NullTypes = { - DbNull: objectEnumValues.classes.DbNull, - JsonNull: objectEnumValues.classes.JsonNull, - AnyNull: objectEnumValues.classes.AnyNull -} - - - - - -/** - * Enums - */ -exports.Prisma.TransactionIsolationLevel = makeStrictEnum({ - Serializable: 'Serializable' -}); - -exports.Prisma.PostScalarFieldEnum = { - id: 'id', - name: 'name', - createdAt: 'createdAt', - updatedAt: 'updatedAt' -}; - -exports.Prisma.SortOrder = { - asc: 'asc', - desc: 'desc' -}; - - -exports.Prisma.ModelName = { - Post: 'Post' -}; -/** - * Create the Client - */ -const config = { - "generator": { - "name": "client", - "provider": { - "fromEnvVar": null, - "value": "prisma-client-js" - }, - "output": { - "value": "/Users/pavelsoukup/DEV/opencode-os/frontend/generated/prisma", - "fromEnvVar": null - }, - "config": { - "engineType": "library" - }, - "binaryTargets": [ - { - "fromEnvVar": null, - "value": "darwin-arm64", - "native": true - } - ], - "previewFeatures": [], - "sourceFilePath": "/Users/pavelsoukup/DEV/opencode-os/frontend/prisma/schema.prisma", - "isCustomOutput": true - }, - "relativeEnvPaths": { - "rootEnvPath": null, - "schemaEnvPath": "../../.env" - }, - "relativePath": "../../prisma", - "clientVersion": "6.19.1", - "engineVersion": "c2990dca591cba766e3b7ef5d9e8a84796e47ab7", - "datasourceNames": [ - "db" - ], - "activeProvider": "sqlite", - "postinstall": false, - "inlineDatasources": { - "db": { - "url": { - "fromEnvVar": "DATABASE_URL", - "value": null - } - } - }, - "inlineSchema": "// This is your Prisma schema file,\n// learn more about it in the docs: https://pris.ly/d/prisma-schema\n\ngenerator client {\n provider = \"prisma-client-js\"\n output = \"../generated/prisma\"\n}\n\ndatasource db {\n provider = \"sqlite\"\n url = env(\"DATABASE_URL\")\n}\n\nmodel Post {\n id Int @id @default(autoincrement())\n name String\n createdAt DateTime @default(now())\n updatedAt DateTime @updatedAt\n\n @@index([name])\n}\n", - "inlineSchemaHash": "6173f79f1f1e8cae300b91aa9403ded205a6c79085b2f8c48fed8dd26c8c16cc", - "copyEngine": true -} -config.dirname = '/' - -config.runtimeDataModel = JSON.parse("{\"models\":{\"Post\":{\"fields\":[{\"name\":\"id\",\"kind\":\"scalar\",\"type\":\"Int\"},{\"name\":\"name\",\"kind\":\"scalar\",\"type\":\"String\"},{\"name\":\"createdAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"},{\"name\":\"updatedAt\",\"kind\":\"scalar\",\"type\":\"DateTime\"}],\"dbName\":null}},\"enums\":{},\"types\":{}}") -defineDmmfProperty(exports.Prisma, config.runtimeDataModel) -config.engineWasm = { - getRuntime: async () => require('./query_engine_bg.js'), - getQueryEngineWasmModule: async () => { - const loader = (await import('#wasm-engine-loader')).default - const engine = (await loader).default - return engine - } -} -config.compilerWasm = undefined - -config.injectableEdgeEnv = () => ({ - parsed: { - DATABASE_URL: typeof globalThis !== 'undefined' && globalThis['DATABASE_URL'] || typeof process !== 'undefined' && process.env && process.env.DATABASE_URL || undefined - } -}) - -if (typeof globalThis !== 'undefined' && globalThis['DEBUG'] || typeof process !== 'undefined' && process.env && process.env.DEBUG || undefined) { - Debug.enable(typeof globalThis !== 'undefined' && globalThis['DEBUG'] || typeof process !== 'undefined' && process.env && process.env.DEBUG || undefined) -} - -const PrismaClient = getPrismaClient(config) -exports.PrismaClient = PrismaClient -Object.assign(exports, Prisma) - diff --git a/frontend/index.html b/frontend/index.html new file mode 100644 index 0000000..f71aa89 --- /dev/null +++ b/frontend/index.html @@ -0,0 +1,13 @@ + + + + + + + OpenCode Studio + + +

+ + + diff --git a/frontend/next.config.js b/frontend/next.config.js deleted file mode 100644 index 121c4f4..0000000 --- a/frontend/next.config.js +++ /dev/null @@ -1,10 +0,0 @@ -/** - * Run `build` or `dev` with `SKIP_ENV_VALIDATION` to skip env validation. This is especially useful - * for Docker builds. - */ -import "./src/env.js"; - -/** @type {import("next").NextConfig} */ -const config = {}; - -export default config; diff --git a/frontend/orval.config.ts b/frontend/orval.config.ts index 33ce3f6..fa90299 100644 --- a/frontend/orval.config.ts +++ b/frontend/orval.config.ts @@ -7,14 +7,15 @@ export default defineConfig({ }, output: { mode: "tags-split", - target: "src/api/generated", - schemas: "src/api/generated/model", + target: "./src/api/generated", + schemas: "./src/api/generated/model", client: "react-query", - clean: true, + httpClient: "fetch", + baseUrl: "", override: { mutator: { - path: "src/api/mutator/custom-instance.ts", - name: "customInstance", + path: "./src/lib/api-fetcher.ts", + name: "customFetch", }, query: { useQuery: true, diff --git a/frontend/package.json b/frontend/package.json index db4503c..b3ca448 100644 --- a/frontend/package.json +++ b/frontend/package.json @@ -1,78 +1,49 @@ { - "name": "my-v0-project", - "version": "0.1.0", - "private": true, - "scripts": { - "dev": "next dev", - "build": "next build", - "start": "next start", - "lint": "eslint ." - }, - "dependencies": { - "@hookform/resolvers": "^3.10.0", - "@radix-ui/react-accordion": "1.2.2", - "@radix-ui/react-alert-dialog": "1.1.4", - "@radix-ui/react-aspect-ratio": "1.1.1", - "@radix-ui/react-avatar": "1.1.2", - "@radix-ui/react-checkbox": "1.1.3", - "@radix-ui/react-collapsible": "1.1.2", - "@radix-ui/react-context-menu": "2.2.4", - "@radix-ui/react-dialog": "1.1.4", - "@radix-ui/react-dropdown-menu": "2.1.4", - "@radix-ui/react-hover-card": "1.1.4", - "@radix-ui/react-label": "2.1.1", - "@radix-ui/react-menubar": "1.1.4", - "@radix-ui/react-navigation-menu": "1.2.3", - "@radix-ui/react-popover": "1.1.4", - "@radix-ui/react-progress": "1.1.1", - "@radix-ui/react-radio-group": "1.2.2", - "@radix-ui/react-scroll-area": "1.2.2", - "@radix-ui/react-select": "2.1.4", - "@radix-ui/react-separator": "1.1.1", - "@radix-ui/react-slider": "1.2.2", - "@radix-ui/react-slot": "1.1.1", - "@radix-ui/react-switch": "1.1.2", - "@radix-ui/react-tabs": "1.1.2", - "@radix-ui/react-toast": "1.2.4", - "@radix-ui/react-toggle": "1.1.1", - "@radix-ui/react-toggle-group": "1.1.1", - "@radix-ui/react-tooltip": "1.1.6", - "@vercel/analytics": "1.3.1", - "autoprefixer": "^10.4.20", - "class-variance-authority": "^0.7.1", - "clsx": "^2.1.1", - "cmdk": "1.0.4", - "date-fns": "4.1.0", - "embla-carousel-react": "8.5.1", - "input-otp": "1.4.1", - "lucide-react": "^0.454.0", - "next": "16.0.10", - "next-themes": "^0.4.6", - "react": "19.2.0", - "react-day-picker": "9.8.0", - "react-dom": "19.2.0", - "react-hook-form": "^7.60.0", - "react-resizable-panels": "^2.1.7", - "recharts": "2.15.4", - "sonner": "^1.7.4", - "tailwind-merge": "^3.3.1", - "tailwindcss-animate": "^1.0.7", - "vaul": "^1.1.2", - "zod": "3.25.76", - "radix-ui": "1.4.3", - "@hugeicons/react": "1.1.4", - "@hugeicons/core-free-icons": "3.1.1", - "@base-ui/react": "1.0.0", - "shadcn": "3.6.2" - }, - "devDependencies": { - "@tailwindcss/postcss": "^4.1.9", - "@types/node": "^22", - "@types/react": "^19", - "@types/react-dom": "^19", - "postcss": "^8.5", - "tailwindcss": "^4.1.9", - "tw-animate-css": "1.3.3", - "typescript": "^5" - } + "name": "opencode-studio", + "private": true, + "version": "0.1.0", + "type": "module", + "scripts": { + "dev": "vite", + "build": "tsc && vite build", + "check": "tsc --noEmit", + "preview": "vite preview", + "lint": "biome check src", + "lint:fix": "biome check src --write", + "generate:types": "cd .. && cargo run --package server --bin generate-types --features typescript", + "generate:api": "orval" + }, + "dependencies": { + "@ebay/nice-modal-react": "^1.2.13", + "@radix-ui/react-dialog": "^1.1.4", + "@radix-ui/react-dropdown-menu": "^2.1.15", + "@radix-ui/react-label": "^2.1.7", + "@radix-ui/react-select": "^2.2.5", + "@radix-ui/react-slot": "^1.2.3", + "@radix-ui/react-switch": "^1.0.3", + "@radix-ui/react-tabs": "^1.1.2", + "@radix-ui/react-tooltip": "^1.2.7", + "@tanstack/react-query": "^5.85.5", + "class-variance-authority": "^0.7.0", + "clsx": "^2.0.0", + "lucide-react": "^0.539.0", + "react": "^18.2.0", + "react-dom": "^18.2.0", + "react-resizable-panels": "^3.0.6", + "react-router-dom": "^6.8.1", + "tailwind-merge": "^2.2.0", + "tailwindcss-animate": "^1.0.7", + "zustand": "^4.5.4" + }, + "devDependencies": { + "@types/react": "^18.2.43", + "@types/react-dom": "^18.2.17", + "@vitejs/plugin-react": "^4.2.1", + "autoprefixer": "^10.4.16", + "orval": "^7.17.2", + "postcss": "^8.4.32", + "tailwindcss": "^3.4.0", + "typescript": "^5.9.2", + "vite": "^5.0.8" + } } diff --git a/frontend/postcss.config.js b/frontend/postcss.config.js index 017b34b..7b75c83 100644 --- a/frontend/postcss.config.js +++ b/frontend/postcss.config.js @@ -1,5 +1,6 @@ export default { plugins: { - "@tailwindcss/postcss": {}, + tailwindcss: {}, + autoprefixer: {}, }, }; diff --git a/frontend/prisma/schema.prisma b/frontend/prisma/schema.prisma deleted file mode 100644 index 7b1a4dd..0000000 --- a/frontend/prisma/schema.prisma +++ /dev/null @@ -1,21 +0,0 @@ -// This is your Prisma schema file, -// learn more about it in the docs: https://pris.ly/d/prisma-schema - -generator client { - provider = "prisma-client-js" - output = "../generated/prisma" -} - -datasource db { - provider = "sqlite" - url = env("DATABASE_URL") -} - -model Post { - id Int @id @default(autoincrement()) - name String - createdAt DateTime @default(now()) - updatedAt DateTime @updatedAt - - @@index([name]) -} diff --git a/frontend/public/favicon.ico b/frontend/public/favicon.ico deleted file mode 100644 index 60c702a..0000000 Binary files a/frontend/public/favicon.ico and /dev/null differ diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx new file mode 100644 index 0000000..f7c77de --- /dev/null +++ b/frontend/src/App.tsx @@ -0,0 +1,257 @@ +import { useEffect, useState } from "react"; +import type { Task } from "@/api/generated/model"; +import { useGetCurrentProject } from "@/api/generated/projects/projects"; +import { CreateTaskDialog } from "@/components/dialogs/CreateTaskDialog"; +import { ProjectPickerDialog } from "@/components/dialogs/ProjectPickerDialog"; +import { KanbanView } from "@/components/kanban/KanbanView"; +import { SessionsList } from "@/components/sessions/SessionsList"; +import { TaskDetailPanel } from "@/components/task-detail/TaskDetailPanel"; +import { Badge } from "@/components/ui/badge"; +import { Loader } from "@/components/ui/loader"; +import { ToastContainer } from "@/components/ui/toast"; +import { useEventStream } from "@/hooks/useEventStream"; +import { useProjectStore } from "@/stores/useProjectStore"; +import { useSidebarStore } from "@/stores/useSidebarStore"; + +// Navigation icons +const icons = { + kanban: ( + + + + + + ), + sessions: ( + + + + + ), + settings: ( + + + + + ), + folder: ( + + + + ), + chevronLeft: ( + + + + ), + chevronRight: ( + + + + ), +}; + +export default function App() { + const { activeView, setActiveView, collapsed, toggleCollapsed } = useSidebarStore(); + const { + currentProject, + isLoading: isProjectLoading, + setCurrentProject, + setLoading, + openDialog, + } = useProjectStore(); + const [selectedTask, setSelectedTask] = useState(null); + const { isConnected } = useEventStream({ + taskId: selectedTask?.id, + }); + + const { data: currentProjectResponse, isLoading: isFetchingProject } = useGetCurrentProject({ + query: { + retry: false, + }, + }); + + useEffect(() => { + if (!isFetchingProject) { + const project = currentProjectResponse?.data.project ?? null; + setCurrentProject(project); + setLoading(false); + + if (!project) { + void ProjectPickerDialog.show({ allowClose: false }); + } + } + }, [isFetchingProject, currentProjectResponse, setCurrentProject, setLoading]); + + const handleSelectTask = (task: Task) => { + setSelectedTask(task); + }; + + const handleClosePanel = () => { + setSelectedTask(null); + }; + + const handleAddTask = () => { + void CreateTaskDialog.show({}); + }; + + const handleSwitchProject = () => { + openDialog(); + void ProjectPickerDialog.show({ allowClose: true }); + }; + + if (isProjectLoading || isFetchingProject) { + return ( +
+
+ + Loading project... +
+
+ ); + } + + return ( +
+ + + +
+ {activeView === "kanban" && ( + <> +
+ +
+ + {selectedTask && ( +
+ +
+ )} + + )} + + {activeView === "sessions" && ( +
+
+

Sessions

+

View active and past AI sessions.

+
+ +
+
+
+ )} + + {activeView === "settings" && ( +
+
+

Settings

+

Configure your preferences.

+ +
+
+

Connection Status

+
+ + {isConnected ? "Connected" : "Disconnected"} + + + WebSocket connection to backend + +
+
+
+
+
+ )} +
+
+ ); +} diff --git a/frontend/src/api/generated/events/events.ts b/frontend/src/api/generated/events/events.ts new file mode 100644 index 0000000..3faa20b --- /dev/null +++ b/frontend/src/api/generated/events/events.ts @@ -0,0 +1,146 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import { + useQuery +} from '@tanstack/react-query'; +import type { + DataTag, + DefinedInitialDataOptions, + DefinedUseQueryResult, + QueryClient, + QueryFunction, + QueryKey, + UndefinedInitialDataOptions, + UseQueryOptions, + UseQueryResult +} from '@tanstack/react-query'; + +import type { + EventsStreamParams +} from '.././model'; + +import { customFetch } from '../../../lib/api-fetcher'; + + +type SecondParameter unknown> = Parameters[1]; + + + +export type eventsStreamResponse200 = { + data: void + status: 200 +} + +export type eventsStreamResponseSuccess = (eventsStreamResponse200) & { + headers: Headers; +}; +; + +export type eventsStreamResponse = (eventsStreamResponseSuccess) + +export const getEventsStreamUrl = (params?: EventsStreamParams,) => { + const normalizedParams = new URLSearchParams(); + + Object.entries(params || {}).forEach(([key, value]) => { + + if (value !== undefined) { + normalizedParams.append(key, value === null ? 'null' : value.toString()) + } + }); + + const stringifiedParams = normalizedParams.toString(); + + return stringifiedParams.length > 0 ? `/api/events?${stringifiedParams}` : `/api/events` +} + +export const eventsStream = async (params?: EventsStreamParams, options?: RequestInit): Promise => { + + return customFetch(getEventsStreamUrl(params), + { + ...options, + method: 'GET' + + + } +);} + + + + + +export const getEventsStreamQueryKey = (params?: EventsStreamParams,) => { + return [ + `/api/events`, ...(params ? [params]: []) + ] as const; + } + + +export const getEventsStreamQueryOptions = >, TError = unknown>(params?: EventsStreamParams, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} +) => { + +const {query: queryOptions, request: requestOptions} = options ?? {}; + + const queryKey = queryOptions?.queryKey ?? getEventsStreamQueryKey(params); + + + + const queryFn: QueryFunction>> = ({ signal }) => eventsStream(params, { signal, ...requestOptions }); + + + + + + return { queryKey, queryFn, ...queryOptions} as UseQueryOptions>, TError, TData> & { queryKey: DataTag } +} + +export type EventsStreamQueryResult = NonNullable>> +export type EventsStreamQueryError = unknown + + +export function useEventsStream>, TError = unknown>( + params: undefined | EventsStreamParams, options: { query:Partial>, TError, TData>> & Pick< + DefinedInitialDataOptions< + Awaited>, + TError, + Awaited> + > , 'initialData' + >, request?: SecondParameter} + , queryClient?: QueryClient + ): DefinedUseQueryResult & { queryKey: DataTag } +export function useEventsStream>, TError = unknown>( + params?: EventsStreamParams, options?: { query?:Partial>, TError, TData>> & Pick< + UndefinedInitialDataOptions< + Awaited>, + TError, + Awaited> + > , 'initialData' + >, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } +export function useEventsStream>, TError = unknown>( + params?: EventsStreamParams, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } + +export function useEventsStream>, TError = unknown>( + params?: EventsStreamParams, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } { + + const queryOptions = getEventsStreamQueryOptions(params,options) + + const query = useQuery(queryOptions, queryClient) as UseQueryResult & { queryKey: DataTag }; + + query.queryKey = queryOptions.queryKey ; + + return query; +} + + + + diff --git a/frontend/src/api/generated/filesystem/filesystem.ts b/frontend/src/api/generated/filesystem/filesystem.ts new file mode 100644 index 0000000..d12bc5c --- /dev/null +++ b/frontend/src/api/generated/filesystem/filesystem.ts @@ -0,0 +1,154 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import { + useQuery +} from '@tanstack/react-query'; +import type { + DataTag, + DefinedInitialDataOptions, + DefinedUseQueryResult, + QueryClient, + QueryFunction, + QueryKey, + UndefinedInitialDataOptions, + UseQueryOptions, + UseQueryResult +} from '@tanstack/react-query'; + +import type { + BrowseDirectoryParams, + BrowseResponse +} from '.././model'; + +import { customFetch } from '../../../lib/api-fetcher'; + + +type SecondParameter unknown> = Parameters[1]; + + + +export type browseDirectoryResponse200 = { + data: BrowseResponse + status: 200 +} + +export type browseDirectoryResponse400 = { + data: void + status: 400 +} + +export type browseDirectoryResponseSuccess = (browseDirectoryResponse200) & { + headers: Headers; +}; +export type browseDirectoryResponseError = (browseDirectoryResponse400) & { + headers: Headers; +}; + +export type browseDirectoryResponse = (browseDirectoryResponseSuccess | browseDirectoryResponseError) + +export const getBrowseDirectoryUrl = (params?: BrowseDirectoryParams,) => { + const normalizedParams = new URLSearchParams(); + + Object.entries(params || {}).forEach(([key, value]) => { + + if (value !== undefined) { + normalizedParams.append(key, value === null ? 'null' : value.toString()) + } + }); + + const stringifiedParams = normalizedParams.toString(); + + return stringifiedParams.length > 0 ? `/api/filesystem/browse?${stringifiedParams}` : `/api/filesystem/browse` +} + +export const browseDirectory = async (params?: BrowseDirectoryParams, options?: RequestInit): Promise => { + + return customFetch(getBrowseDirectoryUrl(params), + { + ...options, + method: 'GET' + + + } +);} + + + + + +export const getBrowseDirectoryQueryKey = (params?: BrowseDirectoryParams,) => { + return [ + `/api/filesystem/browse`, ...(params ? [params]: []) + ] as const; + } + + +export const getBrowseDirectoryQueryOptions = >, TError = void>(params?: BrowseDirectoryParams, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} +) => { + +const {query: queryOptions, request: requestOptions} = options ?? {}; + + const queryKey = queryOptions?.queryKey ?? getBrowseDirectoryQueryKey(params); + + + + const queryFn: QueryFunction>> = ({ signal }) => browseDirectory(params, { signal, ...requestOptions }); + + + + + + return { queryKey, queryFn, ...queryOptions} as UseQueryOptions>, TError, TData> & { queryKey: DataTag } +} + +export type BrowseDirectoryQueryResult = NonNullable>> +export type BrowseDirectoryQueryError = void + + +export function useBrowseDirectory>, TError = void>( + params: undefined | BrowseDirectoryParams, options: { query:Partial>, TError, TData>> & Pick< + DefinedInitialDataOptions< + Awaited>, + TError, + Awaited> + > , 'initialData' + >, request?: SecondParameter} + , queryClient?: QueryClient + ): DefinedUseQueryResult & { queryKey: DataTag } +export function useBrowseDirectory>, TError = void>( + params?: BrowseDirectoryParams, options?: { query?:Partial>, TError, TData>> & Pick< + UndefinedInitialDataOptions< + Awaited>, + TError, + Awaited> + > , 'initialData' + >, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } +export function useBrowseDirectory>, TError = void>( + params?: BrowseDirectoryParams, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } + +export function useBrowseDirectory>, TError = void>( + params?: BrowseDirectoryParams, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } { + + const queryOptions = getBrowseDirectoryQueryOptions(params,options) + + const query = useQuery(queryOptions, queryClient) as UseQueryResult & { queryKey: DataTag }; + + query.queryKey = queryOptions.queryKey ; + + return query; +} + + + + diff --git a/frontend/src/api/generated/health/health.ts b/frontend/src/api/generated/health/health.ts index 7c48eb2..badf638 100644 --- a/frontend/src/api/generated/health/health.ts +++ b/frontend/src/api/generated/health/health.ts @@ -24,23 +24,45 @@ import type { HealthResponse } from '.././model'; -import { customInstance } from '../../mutator/custom-instance'; +import { customFetch } from '../../../lib/api-fetcher'; +type SecondParameter unknown> = Parameters[1]; -export const healthCheck = ( + +export type healthCheckResponse200 = { + data: HealthResponse + status: 200 +} - signal?: AbortSignal -) => { - - - return customInstance( - {url: `/health`, method: 'GET', signal - }, - ); - } +export type healthCheckResponseSuccess = (healthCheckResponse200) & { + headers: Headers; +}; +; + +export type healthCheckResponse = (healthCheckResponseSuccess) + +export const getHealthCheckUrl = () => { + + + + + return `/health` +} + +export const healthCheck = async ( options?: RequestInit): Promise => { + return customFetch(getHealthCheckUrl(), + { + ...options, + method: 'GET' + + + } +);} + + @@ -51,16 +73,16 @@ export const getHealthCheckQueryKey = () => { } -export const getHealthCheckQueryOptions = >, TError = unknown>( options?: { query?:Partial>, TError, TData>>, } +export const getHealthCheckQueryOptions = >, TError = unknown>( options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} ) => { -const {query: queryOptions} = options ?? {}; +const {query: queryOptions, request: requestOptions} = options ?? {}; const queryKey = queryOptions?.queryKey ?? getHealthCheckQueryKey(); - const queryFn: QueryFunction>> = ({ signal }) => healthCheck(signal); + const queryFn: QueryFunction>> = ({ signal }) => healthCheck({ signal, ...requestOptions }); @@ -80,7 +102,7 @@ export function useHealthCheck>, TError, Awaited> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): DefinedUseQueryResult & { queryKey: DataTag } export function useHealthCheck>, TError = unknown>( @@ -90,16 +112,16 @@ export function useHealthCheck>, TError, Awaited> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useHealthCheck>, TError = unknown>( - options?: { query?:Partial>, TError, TData>>, } + options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useHealthCheck>, TError = unknown>( - options?: { query?:Partial>, TError, TData>>, } + options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } { diff --git a/frontend/src/api/generated/model/browseDirectoryParams.ts b/frontend/src/api/generated/model/browseDirectoryParams.ts new file mode 100644 index 0000000..483d7d8 --- /dev/null +++ b/frontend/src/api/generated/model/browseDirectoryParams.ts @@ -0,0 +1,14 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export type BrowseDirectoryParams = { +/** + * Directory path to browse + */ +path?: string; +}; diff --git a/frontend/src/api/generated/model/browseQuery.ts b/frontend/src/api/generated/model/browseQuery.ts new file mode 100644 index 0000000..9a34d7b --- /dev/null +++ b/frontend/src/api/generated/model/browseQuery.ts @@ -0,0 +1,11 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export interface BrowseQuery { + path?: string; +} diff --git a/frontend/src/api/generated/model/browseResponse.ts b/frontend/src/api/generated/model/browseResponse.ts new file mode 100644 index 0000000..4d3f3c3 --- /dev/null +++ b/frontend/src/api/generated/model/browseResponse.ts @@ -0,0 +1,18 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import type { DirectoryEntry } from './directoryEntry'; +import type { BrowseResponseParentPath } from './browseResponseParentPath'; +import type { BrowseResponseVcs } from './browseResponseVcs'; + +export interface BrowseResponse { + current_path: string; + entries: DirectoryEntry[]; + is_vcs_root: boolean; + parent_path?: BrowseResponseParentPath; + vcs?: BrowseResponseVcs; +} diff --git a/frontend/src/api/generated/model/browseResponseParentPath.ts b/frontend/src/api/generated/model/browseResponseParentPath.ts new file mode 100644 index 0000000..b87d56c --- /dev/null +++ b/frontend/src/api/generated/model/browseResponseParentPath.ts @@ -0,0 +1,9 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export type BrowseResponseParentPath = string | null; diff --git a/frontend/src/api/generated/model/browseResponseVcs.ts b/frontend/src/api/generated/model/browseResponseVcs.ts new file mode 100644 index 0000000..afff339 --- /dev/null +++ b/frontend/src/api/generated/model/browseResponseVcs.ts @@ -0,0 +1,9 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export type BrowseResponseVcs = string | null; diff --git a/frontend/src/api/generated/model/clearRecentResponse.ts b/frontend/src/api/generated/model/clearRecentResponse.ts new file mode 100644 index 0000000..8171e58 --- /dev/null +++ b/frontend/src/api/generated/model/clearRecentResponse.ts @@ -0,0 +1,11 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export interface ClearRecentResponse { + success: boolean; +} diff --git a/frontend/src/api/generated/model/currentProjectResponse.ts b/frontend/src/api/generated/model/currentProjectResponse.ts new file mode 100644 index 0000000..f0efc59 --- /dev/null +++ b/frontend/src/api/generated/model/currentProjectResponse.ts @@ -0,0 +1,12 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import type { CurrentProjectResponseProject } from './currentProjectResponseProject'; + +export interface CurrentProjectResponse { + project?: CurrentProjectResponseProject; +} diff --git a/frontend/src/api/generated/model/currentProjectResponseProject.ts b/frontend/src/api/generated/model/currentProjectResponseProject.ts new file mode 100644 index 0000000..62d46a7 --- /dev/null +++ b/frontend/src/api/generated/model/currentProjectResponseProject.ts @@ -0,0 +1,10 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import type { ProjectInfo } from './projectInfo'; + +export type CurrentProjectResponseProject = null | ProjectInfo; diff --git a/frontend/src/api/generated/model/directoryEntry.ts b/frontend/src/api/generated/model/directoryEntry.ts new file mode 100644 index 0000000..0cf14f6 --- /dev/null +++ b/frontend/src/api/generated/model/directoryEntry.ts @@ -0,0 +1,16 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import type { DirectoryEntryVcs } from './directoryEntryVcs'; + +export interface DirectoryEntry { + is_dir: boolean; + is_vcs_root: boolean; + name: string; + path: string; + vcs?: DirectoryEntryVcs; +} diff --git a/frontend/src/api/generated/model/directoryEntryVcs.ts b/frontend/src/api/generated/model/directoryEntryVcs.ts new file mode 100644 index 0000000..8883ea0 --- /dev/null +++ b/frontend/src/api/generated/model/directoryEntryVcs.ts @@ -0,0 +1,9 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export type DirectoryEntryVcs = string | null; diff --git a/frontend/src/api/generated/model/eventsStreamParams.ts b/frontend/src/api/generated/model/eventsStreamParams.ts new file mode 100644 index 0000000..21bb727 --- /dev/null +++ b/frontend/src/api/generated/model/eventsStreamParams.ts @@ -0,0 +1,14 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export type EventsStreamParams = { +/** + * Comma-separated task IDs to filter events + */ +task_ids?: string; +}; diff --git a/frontend/src/api/generated/model/executeAsyncResponse.ts b/frontend/src/api/generated/model/executeAsyncResponse.ts new file mode 100644 index 0000000..fc6b0be --- /dev/null +++ b/frontend/src/api/generated/model/executeAsyncResponse.ts @@ -0,0 +1,15 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import type { Task } from './task'; + +export interface ExecuteAsyncResponse { + opencode_session_id: string; + phase: string; + session_id: string; + task: Task; +} diff --git a/frontend/src/api/generated/model/executeResponse.ts b/frontend/src/api/generated/model/executeResponse.ts index 6f0fa94..07f927c 100644 --- a/frontend/src/api/generated/model/executeResponse.ts +++ b/frontend/src/api/generated/model/executeResponse.ts @@ -5,10 +5,11 @@ * API for OpenCode Studio - AI-powered development platform * OpenAPI spec version: 0.1.0 */ -import type { PhaseResultDto } from './phaseResultDto'; import type { Task } from './task'; export interface ExecuteResponse { - result: PhaseResultDto; + opencode_session_id: string; + phase: string; + session_id: string; task: Task; } diff --git a/frontend/src/api/generated/model/index.ts b/frontend/src/api/generated/model/index.ts index 77b373c..f4a0f6d 100644 --- a/frontend/src/api/generated/model/index.ts +++ b/frontend/src/api/generated/model/index.ts @@ -6,17 +6,37 @@ * OpenAPI spec version: 0.1.0 */ +export * from './browseDirectoryParams'; +export * from './browseQuery'; +export * from './browseResponse'; +export * from './browseResponseParentPath'; +export * from './browseResponseVcs'; +export * from './clearRecentResponse'; export * from './createTaskRequest'; export * from './createTaskRequestRoadmapItemId'; +export * from './currentProjectResponse'; +export * from './currentProjectResponseProject'; export * from './diffResponse'; +export * from './directoryEntry'; +export * from './directoryEntryVcs'; +export * from './eventsStreamParams'; +export * from './executeAsyncResponse'; export * from './executeResponse'; export * from './healthResponse'; +export * from './initProjectRequest'; +export * from './initProjectResponse'; +export * from './initProjectResponseError'; +export * from './initProjectResponseProject'; export * from './mergeRequest'; export * from './mergeResponse'; export * from './mergeResponseOneOf'; export * from './mergeResponseOneOfResult'; export * from './mergeResponseOneOfThree'; export * from './mergeResponseOneOfThreeResult'; +export * from './openProjectRequest'; +export * from './openProjectResponse'; +export * from './openProjectResponseError'; +export * from './openProjectResponseProject'; export * from './phaseResultDto'; export * from './phaseResultDtoOneOf'; export * from './phaseResultDtoOneOfFive'; @@ -32,6 +52,13 @@ export * from './phaseResultDtoOneOfSevenType'; export * from './phaseResultDtoOneOfThree'; export * from './phaseResultDtoOneOfThreeType'; export * from './phaseResultDtoOneOfType'; +export * from './planResponse'; +export * from './projectErrorResponse'; +export * from './projectInfo'; +export * from './recentProject'; +export * from './recentProjectsResponse'; +export * from './removeRecentRequest'; +export * from './removeRecentResponse'; export * from './session'; export * from './sessionCompletedAt'; export * from './sessionOpencodeSessionId'; @@ -49,5 +76,10 @@ export * from './updateTaskRequestDescription'; export * from './updateTaskRequestStatus'; export * from './updateTaskRequestTitle'; export * from './updateTaskRequestWorkspacePath'; +export * from './validatePathRequest'; +export * from './validatePathResponse'; +export * from './validatePathResponseError'; +export * from './validatePathResponseName'; +export * from './validatePathResponseVcs'; export * from './workspaceResponse'; export * from './workspaceStatusResponse'; \ No newline at end of file diff --git a/frontend/src/api/generated/model/initProjectRequest.ts b/frontend/src/api/generated/model/initProjectRequest.ts new file mode 100644 index 0000000..c02b615 --- /dev/null +++ b/frontend/src/api/generated/model/initProjectRequest.ts @@ -0,0 +1,12 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export interface InitProjectRequest { + force?: boolean; + path: string; +} diff --git a/frontend/src/api/generated/model/initProjectResponse.ts b/frontend/src/api/generated/model/initProjectResponse.ts new file mode 100644 index 0000000..fa03a3a --- /dev/null +++ b/frontend/src/api/generated/model/initProjectResponse.ts @@ -0,0 +1,16 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import type { InitProjectResponseError } from './initProjectResponseError'; +import type { InitProjectResponseProject } from './initProjectResponseProject'; + +export interface InitProjectResponse { + already_initialized: boolean; + error?: InitProjectResponseError; + project?: InitProjectResponseProject; + success: boolean; +} diff --git a/frontend/src/api/generated/model/initProjectResponseError.ts b/frontend/src/api/generated/model/initProjectResponseError.ts new file mode 100644 index 0000000..52659eb --- /dev/null +++ b/frontend/src/api/generated/model/initProjectResponseError.ts @@ -0,0 +1,10 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import type { ProjectErrorResponse } from './projectErrorResponse'; + +export type InitProjectResponseError = null | ProjectErrorResponse; diff --git a/frontend/src/api/generated/model/initProjectResponseProject.ts b/frontend/src/api/generated/model/initProjectResponseProject.ts new file mode 100644 index 0000000..5531938 --- /dev/null +++ b/frontend/src/api/generated/model/initProjectResponseProject.ts @@ -0,0 +1,10 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import type { ProjectInfo } from './projectInfo'; + +export type InitProjectResponseProject = null | ProjectInfo; diff --git a/frontend/src/api/generated/model/openProjectRequest.ts b/frontend/src/api/generated/model/openProjectRequest.ts new file mode 100644 index 0000000..b20b4b7 --- /dev/null +++ b/frontend/src/api/generated/model/openProjectRequest.ts @@ -0,0 +1,11 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export interface OpenProjectRequest { + path: string; +} diff --git a/frontend/src/api/generated/model/openProjectResponse.ts b/frontend/src/api/generated/model/openProjectResponse.ts new file mode 100644 index 0000000..86b32de --- /dev/null +++ b/frontend/src/api/generated/model/openProjectResponse.ts @@ -0,0 +1,16 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import type { OpenProjectResponseError } from './openProjectResponseError'; +import type { OpenProjectResponseProject } from './openProjectResponseProject'; + +export interface OpenProjectResponse { + error?: OpenProjectResponseError; + project?: OpenProjectResponseProject; + success: boolean; + was_initialized: boolean; +} diff --git a/frontend/src/api/generated/model/openProjectResponseError.ts b/frontend/src/api/generated/model/openProjectResponseError.ts new file mode 100644 index 0000000..5a3e7d2 --- /dev/null +++ b/frontend/src/api/generated/model/openProjectResponseError.ts @@ -0,0 +1,10 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import type { ProjectErrorResponse } from './projectErrorResponse'; + +export type OpenProjectResponseError = null | ProjectErrorResponse; diff --git a/frontend/src/api/generated/model/openProjectResponseProject.ts b/frontend/src/api/generated/model/openProjectResponseProject.ts new file mode 100644 index 0000000..5388f2c --- /dev/null +++ b/frontend/src/api/generated/model/openProjectResponseProject.ts @@ -0,0 +1,10 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import type { ProjectInfo } from './projectInfo'; + +export type OpenProjectResponseProject = null | ProjectInfo; diff --git a/frontend/src/api/generated/model/planResponse.ts b/frontend/src/api/generated/model/planResponse.ts new file mode 100644 index 0000000..ad9da35 --- /dev/null +++ b/frontend/src/api/generated/model/planResponse.ts @@ -0,0 +1,12 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export interface PlanResponse { + content: string; + exists: boolean; +} diff --git a/frontend/src/api/generated/model/projectErrorResponse.ts b/frontend/src/api/generated/model/projectErrorResponse.ts new file mode 100644 index 0000000..5735964 --- /dev/null +++ b/frontend/src/api/generated/model/projectErrorResponse.ts @@ -0,0 +1,12 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export interface ProjectErrorResponse { + code: string; + message: string; +} diff --git a/frontend/src/api/generated/model/projectInfo.ts b/frontend/src/api/generated/model/projectInfo.ts new file mode 100644 index 0000000..ed6bdc5 --- /dev/null +++ b/frontend/src/api/generated/model/projectInfo.ts @@ -0,0 +1,15 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export interface ProjectInfo { + initialized: boolean; + name: string; + path: string; + tasks_count: number; + vcs: string; +} diff --git a/frontend/src/api/generated/model/recentProject.ts b/frontend/src/api/generated/model/recentProject.ts new file mode 100644 index 0000000..4848701 --- /dev/null +++ b/frontend/src/api/generated/model/recentProject.ts @@ -0,0 +1,14 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export interface RecentProject { + exists: boolean; + name: string; + path: string; + vcs: string; +} diff --git a/frontend/src/api/generated/model/recentProjectsResponse.ts b/frontend/src/api/generated/model/recentProjectsResponse.ts new file mode 100644 index 0000000..2f98a76 --- /dev/null +++ b/frontend/src/api/generated/model/recentProjectsResponse.ts @@ -0,0 +1,12 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import type { RecentProject } from './recentProject'; + +export interface RecentProjectsResponse { + projects: RecentProject[]; +} diff --git a/frontend/src/api/generated/model/removeRecentRequest.ts b/frontend/src/api/generated/model/removeRecentRequest.ts new file mode 100644 index 0000000..f725284 --- /dev/null +++ b/frontend/src/api/generated/model/removeRecentRequest.ts @@ -0,0 +1,11 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export interface RemoveRecentRequest { + path: string; +} diff --git a/frontend/src/api/generated/model/removeRecentResponse.ts b/frontend/src/api/generated/model/removeRecentResponse.ts new file mode 100644 index 0000000..eb3e8eb --- /dev/null +++ b/frontend/src/api/generated/model/removeRecentResponse.ts @@ -0,0 +1,11 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export interface RemoveRecentResponse { + success: boolean; +} diff --git a/frontend/src/api/generated/model/validatePathRequest.ts b/frontend/src/api/generated/model/validatePathRequest.ts new file mode 100644 index 0000000..0452d60 --- /dev/null +++ b/frontend/src/api/generated/model/validatePathRequest.ts @@ -0,0 +1,11 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export interface ValidatePathRequest { + path: string; +} diff --git a/frontend/src/api/generated/model/validatePathResponse.ts b/frontend/src/api/generated/model/validatePathResponse.ts new file mode 100644 index 0000000..a770214 --- /dev/null +++ b/frontend/src/api/generated/model/validatePathResponse.ts @@ -0,0 +1,19 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import type { ValidatePathResponseError } from './validatePathResponseError'; +import type { ValidatePathResponseName } from './validatePathResponseName'; +import type { ValidatePathResponseVcs } from './validatePathResponseVcs'; + +export interface ValidatePathResponse { + error?: ValidatePathResponseError; + exists: boolean; + is_vcs_repo: boolean; + name?: ValidatePathResponseName; + valid: boolean; + vcs?: ValidatePathResponseVcs; +} diff --git a/frontend/src/api/generated/model/validatePathResponseError.ts b/frontend/src/api/generated/model/validatePathResponseError.ts new file mode 100644 index 0000000..63805a9 --- /dev/null +++ b/frontend/src/api/generated/model/validatePathResponseError.ts @@ -0,0 +1,9 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export type ValidatePathResponseError = string | null; diff --git a/frontend/src/api/generated/model/validatePathResponseName.ts b/frontend/src/api/generated/model/validatePathResponseName.ts new file mode 100644 index 0000000..53ee544 --- /dev/null +++ b/frontend/src/api/generated/model/validatePathResponseName.ts @@ -0,0 +1,9 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export type ValidatePathResponseName = string | null; diff --git a/frontend/src/api/generated/model/validatePathResponseVcs.ts b/frontend/src/api/generated/model/validatePathResponseVcs.ts new file mode 100644 index 0000000..cad4069 --- /dev/null +++ b/frontend/src/api/generated/model/validatePathResponseVcs.ts @@ -0,0 +1,9 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ + +export type ValidatePathResponseVcs = string | null; diff --git a/frontend/src/api/generated/project/project.ts b/frontend/src/api/generated/project/project.ts new file mode 100644 index 0000000..3c16702 --- /dev/null +++ b/frontend/src/api/generated/project/project.ts @@ -0,0 +1,139 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import { + useQuery +} from '@tanstack/react-query'; +import type { + DataTag, + DefinedInitialDataOptions, + DefinedUseQueryResult, + QueryClient, + QueryFunction, + QueryKey, + UndefinedInitialDataOptions, + UseQueryOptions, + UseQueryResult +} from '@tanstack/react-query'; + +import type { + CurrentProjectResponse +} from '.././model'; + +import { customFetch } from '../../../lib/api-fetcher'; + + +type SecondParameter unknown> = Parameters[1]; + + + +export type getProjectInfoResponse200 = { + data: CurrentProjectResponse + status: 200 +} + +export type getProjectInfoResponseSuccess = (getProjectInfoResponse200) & { + headers: Headers; +}; +; + +export type getProjectInfoResponse = (getProjectInfoResponseSuccess) + +export const getGetProjectInfoUrl = () => { + + + + + return `/api/project` +} + +export const getProjectInfo = async ( options?: RequestInit): Promise => { + + return customFetch(getGetProjectInfoUrl(), + { + ...options, + method: 'GET' + + + } +);} + + + + + +export const getGetProjectInfoQueryKey = () => { + return [ + `/api/project` + ] as const; + } + + +export const getGetProjectInfoQueryOptions = >, TError = unknown>( options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} +) => { + +const {query: queryOptions, request: requestOptions} = options ?? {}; + + const queryKey = queryOptions?.queryKey ?? getGetProjectInfoQueryKey(); + + + + const queryFn: QueryFunction>> = ({ signal }) => getProjectInfo({ signal, ...requestOptions }); + + + + + + return { queryKey, queryFn, ...queryOptions} as UseQueryOptions>, TError, TData> & { queryKey: DataTag } +} + +export type GetProjectInfoQueryResult = NonNullable>> +export type GetProjectInfoQueryError = unknown + + +export function useGetProjectInfo>, TError = unknown>( + options: { query:Partial>, TError, TData>> & Pick< + DefinedInitialDataOptions< + Awaited>, + TError, + Awaited> + > , 'initialData' + >, request?: SecondParameter} + , queryClient?: QueryClient + ): DefinedUseQueryResult & { queryKey: DataTag } +export function useGetProjectInfo>, TError = unknown>( + options?: { query?:Partial>, TError, TData>> & Pick< + UndefinedInitialDataOptions< + Awaited>, + TError, + Awaited> + > , 'initialData' + >, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } +export function useGetProjectInfo>, TError = unknown>( + options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } + +export function useGetProjectInfo>, TError = unknown>( + options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } { + + const queryOptions = getGetProjectInfoQueryOptions(options) + + const query = useQuery(queryOptions, queryClient) as UseQueryResult & { queryKey: DataTag }; + + query.queryKey = queryOptions.queryKey ; + + return query; +} + + + + diff --git a/frontend/src/api/generated/projects/projects.ts b/frontend/src/api/generated/projects/projects.ts new file mode 100644 index 0000000..4c174b2 --- /dev/null +++ b/frontend/src/api/generated/projects/projects.ts @@ -0,0 +1,658 @@ +/** + * Generated by orval v7.17.2 🍺 + * Do not edit manually. + * OpenCode Studio API + * API for OpenCode Studio - AI-powered development platform + * OpenAPI spec version: 0.1.0 + */ +import { + useMutation, + useQuery +} from '@tanstack/react-query'; +import type { + DataTag, + DefinedInitialDataOptions, + DefinedUseQueryResult, + MutationFunction, + QueryClient, + QueryFunction, + QueryKey, + UndefinedInitialDataOptions, + UseMutationOptions, + UseMutationResult, + UseQueryOptions, + UseQueryResult +} from '@tanstack/react-query'; + +import type { + ClearRecentResponse, + CurrentProjectResponse, + InitProjectRequest, + InitProjectResponse, + OpenProjectRequest, + OpenProjectResponse, + RecentProjectsResponse, + RemoveRecentRequest, + RemoveRecentResponse, + ValidatePathRequest, + ValidatePathResponse +} from '.././model'; + +import { customFetch } from '../../../lib/api-fetcher'; + + +type SecondParameter unknown> = Parameters[1]; + + + +export type getCurrentProjectResponse200 = { + data: CurrentProjectResponse + status: 200 +} + +export type getCurrentProjectResponseSuccess = (getCurrentProjectResponse200) & { + headers: Headers; +}; +; + +export type getCurrentProjectResponse = (getCurrentProjectResponseSuccess) + +export const getGetCurrentProjectUrl = () => { + + + + + return `/api/projects/current` +} + +export const getCurrentProject = async ( options?: RequestInit): Promise => { + + return customFetch(getGetCurrentProjectUrl(), + { + ...options, + method: 'GET' + + + } +);} + + + + + +export const getGetCurrentProjectQueryKey = () => { + return [ + `/api/projects/current` + ] as const; + } + + +export const getGetCurrentProjectQueryOptions = >, TError = unknown>( options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} +) => { + +const {query: queryOptions, request: requestOptions} = options ?? {}; + + const queryKey = queryOptions?.queryKey ?? getGetCurrentProjectQueryKey(); + + + + const queryFn: QueryFunction>> = ({ signal }) => getCurrentProject({ signal, ...requestOptions }); + + + + + + return { queryKey, queryFn, ...queryOptions} as UseQueryOptions>, TError, TData> & { queryKey: DataTag } +} + +export type GetCurrentProjectQueryResult = NonNullable>> +export type GetCurrentProjectQueryError = unknown + + +export function useGetCurrentProject>, TError = unknown>( + options: { query:Partial>, TError, TData>> & Pick< + DefinedInitialDataOptions< + Awaited>, + TError, + Awaited> + > , 'initialData' + >, request?: SecondParameter} + , queryClient?: QueryClient + ): DefinedUseQueryResult & { queryKey: DataTag } +export function useGetCurrentProject>, TError = unknown>( + options?: { query?:Partial>, TError, TData>> & Pick< + UndefinedInitialDataOptions< + Awaited>, + TError, + Awaited> + > , 'initialData' + >, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } +export function useGetCurrentProject>, TError = unknown>( + options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } + +export function useGetCurrentProject>, TError = unknown>( + options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } { + + const queryOptions = getGetCurrentProjectQueryOptions(options) + + const query = useQuery(queryOptions, queryClient) as UseQueryResult & { queryKey: DataTag }; + + query.queryKey = queryOptions.queryKey ; + + return query; +} + + + + +export type initProjectResponse200 = { + data: InitProjectResponse + status: 200 +} + +export type initProjectResponse400 = { + data: InitProjectResponse + status: 400 +} + +export type initProjectResponseSuccess = (initProjectResponse200) & { + headers: Headers; +}; +export type initProjectResponseError = (initProjectResponse400) & { + headers: Headers; +}; + +export type initProjectResponse = (initProjectResponseSuccess | initProjectResponseError) + +export const getInitProjectUrl = () => { + + + + + return `/api/projects/init` +} + +export const initProject = async (initProjectRequest: InitProjectRequest, options?: RequestInit): Promise => { + + return customFetch(getInitProjectUrl(), + { + ...options, + method: 'POST', + headers: { 'Content-Type': 'application/json', ...options?.headers }, + body: JSON.stringify( + initProjectRequest,) + } +);} + + + + +export const getInitProjectMutationOptions = (options?: { mutation?:UseMutationOptions>, TError,{data: InitProjectRequest}, TContext>, request?: SecondParameter} +): UseMutationOptions>, TError,{data: InitProjectRequest}, TContext> => { + +const mutationKey = ['initProject']; +const {mutation: mutationOptions, request: requestOptions} = options ? + options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ? + options + : {...options, mutation: {...options.mutation, mutationKey}} + : {mutation: { mutationKey, }, request: undefined}; + + + + + const mutationFn: MutationFunction>, {data: InitProjectRequest}> = (props) => { + const {data} = props ?? {}; + + return initProject(data,requestOptions) + } + + + + + return { mutationFn, ...mutationOptions }} + + export type InitProjectMutationResult = NonNullable>> + export type InitProjectMutationBody = InitProjectRequest + export type InitProjectMutationError = InitProjectResponse + + export const useInitProject = (options?: { mutation?:UseMutationOptions>, TError,{data: InitProjectRequest}, TContext>, request?: SecondParameter} + , queryClient?: QueryClient): UseMutationResult< + Awaited>, + TError, + {data: InitProjectRequest}, + TContext + > => { + + const mutationOptions = getInitProjectMutationOptions(options); + + return useMutation(mutationOptions, queryClient); + } + export type openProjectResponse200 = { + data: OpenProjectResponse + status: 200 +} + +export type openProjectResponse400 = { + data: OpenProjectResponse + status: 400 +} + +export type openProjectResponseSuccess = (openProjectResponse200) & { + headers: Headers; +}; +export type openProjectResponseError = (openProjectResponse400) & { + headers: Headers; +}; + +export type openProjectResponse = (openProjectResponseSuccess | openProjectResponseError) + +export const getOpenProjectUrl = () => { + + + + + return `/api/projects/open` +} + +export const openProject = async (openProjectRequest: OpenProjectRequest, options?: RequestInit): Promise => { + + return customFetch(getOpenProjectUrl(), + { + ...options, + method: 'POST', + headers: { 'Content-Type': 'application/json', ...options?.headers }, + body: JSON.stringify( + openProjectRequest,) + } +);} + + + + +export const getOpenProjectMutationOptions = (options?: { mutation?:UseMutationOptions>, TError,{data: OpenProjectRequest}, TContext>, request?: SecondParameter} +): UseMutationOptions>, TError,{data: OpenProjectRequest}, TContext> => { + +const mutationKey = ['openProject']; +const {mutation: mutationOptions, request: requestOptions} = options ? + options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ? + options + : {...options, mutation: {...options.mutation, mutationKey}} + : {mutation: { mutationKey, }, request: undefined}; + + + + + const mutationFn: MutationFunction>, {data: OpenProjectRequest}> = (props) => { + const {data} = props ?? {}; + + return openProject(data,requestOptions) + } + + + + + return { mutationFn, ...mutationOptions }} + + export type OpenProjectMutationResult = NonNullable>> + export type OpenProjectMutationBody = OpenProjectRequest + export type OpenProjectMutationError = OpenProjectResponse + + export const useOpenProject = (options?: { mutation?:UseMutationOptions>, TError,{data: OpenProjectRequest}, TContext>, request?: SecondParameter} + , queryClient?: QueryClient): UseMutationResult< + Awaited>, + TError, + {data: OpenProjectRequest}, + TContext + > => { + + const mutationOptions = getOpenProjectMutationOptions(options); + + return useMutation(mutationOptions, queryClient); + } + export type getRecentProjectsResponse200 = { + data: RecentProjectsResponse + status: 200 +} + +export type getRecentProjectsResponseSuccess = (getRecentProjectsResponse200) & { + headers: Headers; +}; +; + +export type getRecentProjectsResponse = (getRecentProjectsResponseSuccess) + +export const getGetRecentProjectsUrl = () => { + + + + + return `/api/projects/recent` +} + +export const getRecentProjects = async ( options?: RequestInit): Promise => { + + return customFetch(getGetRecentProjectsUrl(), + { + ...options, + method: 'GET' + + + } +);} + + + + + +export const getGetRecentProjectsQueryKey = () => { + return [ + `/api/projects/recent` + ] as const; + } + + +export const getGetRecentProjectsQueryOptions = >, TError = unknown>( options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} +) => { + +const {query: queryOptions, request: requestOptions} = options ?? {}; + + const queryKey = queryOptions?.queryKey ?? getGetRecentProjectsQueryKey(); + + + + const queryFn: QueryFunction>> = ({ signal }) => getRecentProjects({ signal, ...requestOptions }); + + + + + + return { queryKey, queryFn, ...queryOptions} as UseQueryOptions>, TError, TData> & { queryKey: DataTag } +} + +export type GetRecentProjectsQueryResult = NonNullable>> +export type GetRecentProjectsQueryError = unknown + + +export function useGetRecentProjects>, TError = unknown>( + options: { query:Partial>, TError, TData>> & Pick< + DefinedInitialDataOptions< + Awaited>, + TError, + Awaited> + > , 'initialData' + >, request?: SecondParameter} + , queryClient?: QueryClient + ): DefinedUseQueryResult & { queryKey: DataTag } +export function useGetRecentProjects>, TError = unknown>( + options?: { query?:Partial>, TError, TData>> & Pick< + UndefinedInitialDataOptions< + Awaited>, + TError, + Awaited> + > , 'initialData' + >, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } +export function useGetRecentProjects>, TError = unknown>( + options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } + +export function useGetRecentProjects>, TError = unknown>( + options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } { + + const queryOptions = getGetRecentProjectsQueryOptions(options) + + const query = useQuery(queryOptions, queryClient) as UseQueryResult & { queryKey: DataTag }; + + query.queryKey = queryOptions.queryKey ; + + return query; +} + + + + +export type clearRecentProjectsResponse200 = { + data: ClearRecentResponse + status: 200 +} + +export type clearRecentProjectsResponseSuccess = (clearRecentProjectsResponse200) & { + headers: Headers; +}; +; + +export type clearRecentProjectsResponse = (clearRecentProjectsResponseSuccess) + +export const getClearRecentProjectsUrl = () => { + + + + + return `/api/projects/recent/clear` +} + +export const clearRecentProjects = async ( options?: RequestInit): Promise => { + + return customFetch(getClearRecentProjectsUrl(), + { + ...options, + method: 'POST' + + + } +);} + + + + +export const getClearRecentProjectsMutationOptions = (options?: { mutation?:UseMutationOptions>, TError,void, TContext>, request?: SecondParameter} +): UseMutationOptions>, TError,void, TContext> => { + +const mutationKey = ['clearRecentProjects']; +const {mutation: mutationOptions, request: requestOptions} = options ? + options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ? + options + : {...options, mutation: {...options.mutation, mutationKey}} + : {mutation: { mutationKey, }, request: undefined}; + + + + + const mutationFn: MutationFunction>, void> = () => { + + + return clearRecentProjects(requestOptions) + } + + + + + return { mutationFn, ...mutationOptions }} + + export type ClearRecentProjectsMutationResult = NonNullable>> + + export type ClearRecentProjectsMutationError = unknown + + export const useClearRecentProjects = (options?: { mutation?:UseMutationOptions>, TError,void, TContext>, request?: SecondParameter} + , queryClient?: QueryClient): UseMutationResult< + Awaited>, + TError, + void, + TContext + > => { + + const mutationOptions = getClearRecentProjectsMutationOptions(options); + + return useMutation(mutationOptions, queryClient); + } + export type removeRecentProjectResponse200 = { + data: RemoveRecentResponse + status: 200 +} + +export type removeRecentProjectResponseSuccess = (removeRecentProjectResponse200) & { + headers: Headers; +}; +; + +export type removeRecentProjectResponse = (removeRecentProjectResponseSuccess) + +export const getRemoveRecentProjectUrl = () => { + + + + + return `/api/projects/recent/remove` +} + +export const removeRecentProject = async (removeRecentRequest: RemoveRecentRequest, options?: RequestInit): Promise => { + + return customFetch(getRemoveRecentProjectUrl(), + { + ...options, + method: 'POST', + headers: { 'Content-Type': 'application/json', ...options?.headers }, + body: JSON.stringify( + removeRecentRequest,) + } +);} + + + + +export const getRemoveRecentProjectMutationOptions = (options?: { mutation?:UseMutationOptions>, TError,{data: RemoveRecentRequest}, TContext>, request?: SecondParameter} +): UseMutationOptions>, TError,{data: RemoveRecentRequest}, TContext> => { + +const mutationKey = ['removeRecentProject']; +const {mutation: mutationOptions, request: requestOptions} = options ? + options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ? + options + : {...options, mutation: {...options.mutation, mutationKey}} + : {mutation: { mutationKey, }, request: undefined}; + + + + + const mutationFn: MutationFunction>, {data: RemoveRecentRequest}> = (props) => { + const {data} = props ?? {}; + + return removeRecentProject(data,requestOptions) + } + + + + + return { mutationFn, ...mutationOptions }} + + export type RemoveRecentProjectMutationResult = NonNullable>> + export type RemoveRecentProjectMutationBody = RemoveRecentRequest + export type RemoveRecentProjectMutationError = unknown + + export const useRemoveRecentProject = (options?: { mutation?:UseMutationOptions>, TError,{data: RemoveRecentRequest}, TContext>, request?: SecondParameter} + , queryClient?: QueryClient): UseMutationResult< + Awaited>, + TError, + {data: RemoveRecentRequest}, + TContext + > => { + + const mutationOptions = getRemoveRecentProjectMutationOptions(options); + + return useMutation(mutationOptions, queryClient); + } + export type validateProjectPathResponse200 = { + data: ValidatePathResponse + status: 200 +} + +export type validateProjectPathResponseSuccess = (validateProjectPathResponse200) & { + headers: Headers; +}; +; + +export type validateProjectPathResponse = (validateProjectPathResponseSuccess) + +export const getValidateProjectPathUrl = () => { + + + + + return `/api/projects/validate` +} + +export const validateProjectPath = async (validatePathRequest: ValidatePathRequest, options?: RequestInit): Promise => { + + return customFetch(getValidateProjectPathUrl(), + { + ...options, + method: 'POST', + headers: { 'Content-Type': 'application/json', ...options?.headers }, + body: JSON.stringify( + validatePathRequest,) + } +);} + + + + +export const getValidateProjectPathMutationOptions = (options?: { mutation?:UseMutationOptions>, TError,{data: ValidatePathRequest}, TContext>, request?: SecondParameter} +): UseMutationOptions>, TError,{data: ValidatePathRequest}, TContext> => { + +const mutationKey = ['validateProjectPath']; +const {mutation: mutationOptions, request: requestOptions} = options ? + options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ? + options + : {...options, mutation: {...options.mutation, mutationKey}} + : {mutation: { mutationKey, }, request: undefined}; + + + + + const mutationFn: MutationFunction>, {data: ValidatePathRequest}> = (props) => { + const {data} = props ?? {}; + + return validateProjectPath(data,requestOptions) + } + + + + + return { mutationFn, ...mutationOptions }} + + export type ValidateProjectPathMutationResult = NonNullable>> + export type ValidateProjectPathMutationBody = ValidatePathRequest + export type ValidateProjectPathMutationError = unknown + + export const useValidateProjectPath = (options?: { mutation?:UseMutationOptions>, TError,{data: ValidatePathRequest}, TContext>, request?: SecondParameter} + , queryClient?: QueryClient): UseMutationResult< + Awaited>, + TError, + {data: ValidatePathRequest}, + TContext + > => { + + const mutationOptions = getValidateProjectPathMutationOptions(options); + + return useMutation(mutationOptions, queryClient); + } + \ No newline at end of file diff --git a/frontend/src/api/generated/sessions/sessions.ts b/frontend/src/api/generated/sessions/sessions.ts index 9db2bf0..4605dc0 100644 --- a/frontend/src/api/generated/sessions/sessions.ts +++ b/frontend/src/api/generated/sessions/sessions.ts @@ -28,23 +28,45 @@ import type { Session } from '.././model'; -import { customInstance } from '../../mutator/custom-instance'; +import { customFetch } from '../../../lib/api-fetcher'; +type SecondParameter unknown> = Parameters[1]; -export const listSessions = ( + +export type listSessionsResponse200 = { + data: Session[] + status: 200 +} - signal?: AbortSignal -) => { - - - return customInstance( - {url: `/api/sessions`, method: 'GET', signal - }, - ); - } +export type listSessionsResponseSuccess = (listSessionsResponse200) & { + headers: Headers; +}; +; + +export type listSessionsResponse = (listSessionsResponseSuccess) + +export const getListSessionsUrl = () => { + + + + + return `/api/sessions` +} + +export const listSessions = async ( options?: RequestInit): Promise => { + return customFetch(getListSessionsUrl(), + { + ...options, + method: 'GET' + + + } +);} + + @@ -55,16 +77,16 @@ export const getListSessionsQueryKey = () => { } -export const getListSessionsQueryOptions = >, TError = unknown>( options?: { query?:Partial>, TError, TData>>, } +export const getListSessionsQueryOptions = >, TError = unknown>( options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} ) => { -const {query: queryOptions} = options ?? {}; +const {query: queryOptions, request: requestOptions} = options ?? {}; const queryKey = queryOptions?.queryKey ?? getListSessionsQueryKey(); - const queryFn: QueryFunction>> = ({ signal }) => listSessions(signal); + const queryFn: QueryFunction>> = ({ signal }) => listSessions({ signal, ...requestOptions }); @@ -84,7 +106,7 @@ export function useListSessions> TError, Awaited> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): DefinedUseQueryResult & { queryKey: DataTag } export function useListSessions>, TError = unknown>( @@ -94,16 +116,16 @@ export function useListSessions> TError, Awaited> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useListSessions>, TError = unknown>( - options?: { query?:Partial>, TError, TData>>, } + options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useListSessions>, TError = unknown>( - options?: { query?:Partial>, TError, TData>>, } + options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } { @@ -119,18 +141,45 @@ export function useListSessions> -export const getSession = ( - id: string, - signal?: AbortSignal -) => { - - - return customInstance( - {url: `/api/sessions/${id}`, method: 'GET', signal - }, - ); - } +export type getSessionResponse200 = { + data: Session + status: 200 +} + +export type getSessionResponse404 = { + data: void + status: 404 +} + +export type getSessionResponseSuccess = (getSessionResponse200) & { + headers: Headers; +}; +export type getSessionResponseError = (getSessionResponse404) & { + headers: Headers; +}; + +export type getSessionResponse = (getSessionResponseSuccess | getSessionResponseError) + +export const getGetSessionUrl = (id: string,) => { + + + + + return `/api/sessions/${id}` +} + +export const getSession = async (id: string, options?: RequestInit): Promise => { + return customFetch(getGetSessionUrl(id), + { + ...options, + method: 'GET' + + + } +);} + + @@ -141,16 +190,16 @@ export const getGetSessionQueryKey = (id?: string,) => { } -export const getGetSessionQueryOptions = >, TError = void>(id: string, options?: { query?:Partial>, TError, TData>>, } +export const getGetSessionQueryOptions = >, TError = void>(id: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} ) => { -const {query: queryOptions} = options ?? {}; +const {query: queryOptions, request: requestOptions} = options ?? {}; const queryKey = queryOptions?.queryKey ?? getGetSessionQueryKey(id); - const queryFn: QueryFunction>> = ({ signal }) => getSession(id, signal); + const queryFn: QueryFunction>> = ({ signal }) => getSession(id, { signal, ...requestOptions }); @@ -170,7 +219,7 @@ export function useGetSession>, TE TError, Awaited> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): DefinedUseQueryResult & { queryKey: DataTag } export function useGetSession>, TError = void>( @@ -180,16 +229,16 @@ export function useGetSession>, TE TError, Awaited> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useGetSession>, TError = void>( - id: string, options?: { query?:Partial>, TError, TData>>, } + id: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useGetSession>, TError = void>( - id: string, options?: { query?:Partial>, TError, TData>>, } + id: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } { @@ -205,29 +254,57 @@ export function useGetSession>, TE -export const deleteSession = ( - id: string, - ) => { - - - return customInstance( - {url: `/api/sessions/${id}`, method: 'DELETE' - }, - ); - } +export type deleteSessionResponse204 = { + data: void + status: 204 +} + +export type deleteSessionResponse404 = { + data: void + status: 404 +} + +export type deleteSessionResponseSuccess = (deleteSessionResponse204) & { + headers: Headers; +}; +export type deleteSessionResponseError = (deleteSessionResponse404) & { + headers: Headers; +}; + +export type deleteSessionResponse = (deleteSessionResponseSuccess | deleteSessionResponseError) + +export const getDeleteSessionUrl = (id: string,) => { + + + + + return `/api/sessions/${id}` +} + +export const deleteSession = async (id: string, options?: RequestInit): Promise => { + return customFetch(getDeleteSessionUrl(id), + { + ...options, + method: 'DELETE' + + + } +);} + + export const getDeleteSessionMutationOptions = (options?: { mutation?:UseMutationOptions>, TError,{id: string}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{id: string}, TContext>, request?: SecondParameter} ): UseMutationOptions>, TError,{id: string}, TContext> => { const mutationKey = ['deleteSession']; -const {mutation: mutationOptions} = options ? +const {mutation: mutationOptions, request: requestOptions} = options ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ? options : {...options, mutation: {...options.mutation, mutationKey}} - : {mutation: { mutationKey, }}; + : {mutation: { mutationKey, }, request: undefined}; @@ -235,7 +312,7 @@ const {mutation: mutationOptions} = options ? const mutationFn: MutationFunction>, {id: string}> = (props) => { const {id} = props ?? {}; - return deleteSession(id,) + return deleteSession(id,requestOptions) } @@ -248,7 +325,7 @@ const {mutation: mutationOptions} = options ? export type DeleteSessionMutationError = void export const useDeleteSession = (options?: { mutation?:UseMutationOptions>, TError,{id: string}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{id: string}, TContext>, request?: SecondParameter} , queryClient?: QueryClient): UseMutationResult< Awaited>, TError, @@ -260,19 +337,152 @@ const {mutation: mutationOptions} = options ? return useMutation(mutationOptions, queryClient); } - export const listSessionsForTask = ( - taskId: string, - signal?: AbortSignal + export type sessionActivityStreamResponse200 = { + data: void + status: 200 +} + +export type sessionActivityStreamResponse404 = { + data: void + status: 404 +} + +export type sessionActivityStreamResponseSuccess = (sessionActivityStreamResponse200) & { + headers: Headers; +}; +export type sessionActivityStreamResponseError = (sessionActivityStreamResponse404) & { + headers: Headers; +}; + +export type sessionActivityStreamResponse = (sessionActivityStreamResponseSuccess | sessionActivityStreamResponseError) + +export const getSessionActivityStreamUrl = (id: string,) => { + + + + + return `/api/sessions/${id}/activity` +} + +export const sessionActivityStream = async (id: string, options?: RequestInit): Promise => { + + return customFetch(getSessionActivityStreamUrl(id), + { + ...options, + method: 'GET' + + + } +);} + + + + + +export const getSessionActivityStreamQueryKey = (id?: string,) => { + return [ + `/api/sessions/${id}/activity` + ] as const; + } + + +export const getSessionActivityStreamQueryOptions = >, TError = void>(id: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} ) => { + +const {query: queryOptions, request: requestOptions} = options ?? {}; + + const queryKey = queryOptions?.queryKey ?? getSessionActivityStreamQueryKey(id); + + + + const queryFn: QueryFunction>> = ({ signal }) => sessionActivityStream(id, { signal, ...requestOptions }); + + - return customInstance( - {url: `/api/tasks/${taskId}/sessions`, method: 'GET', signal - }, - ); - } + + return { queryKey, queryFn, enabled: !!(id), ...queryOptions} as UseQueryOptions>, TError, TData> & { queryKey: DataTag } +} + +export type SessionActivityStreamQueryResult = NonNullable>> +export type SessionActivityStreamQueryError = void + + +export function useSessionActivityStream>, TError = void>( + id: string, options: { query:Partial>, TError, TData>> & Pick< + DefinedInitialDataOptions< + Awaited>, + TError, + Awaited> + > , 'initialData' + >, request?: SecondParameter} + , queryClient?: QueryClient + ): DefinedUseQueryResult & { queryKey: DataTag } +export function useSessionActivityStream>, TError = void>( + id: string, options?: { query?:Partial>, TError, TData>> & Pick< + UndefinedInitialDataOptions< + Awaited>, + TError, + Awaited> + > , 'initialData' + >, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } +export function useSessionActivityStream>, TError = void>( + id: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } + +export function useSessionActivityStream>, TError = void>( + id: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } { + + const queryOptions = getSessionActivityStreamQueryOptions(id,options) + + const query = useQuery(queryOptions, queryClient) as UseQueryResult & { queryKey: DataTag }; + + query.queryKey = queryOptions.queryKey ; + + return query; +} + + + + +export type listSessionsForTaskResponse200 = { + data: Session[] + status: 200 +} + +export type listSessionsForTaskResponseSuccess = (listSessionsForTaskResponse200) & { + headers: Headers; +}; +; + +export type listSessionsForTaskResponse = (listSessionsForTaskResponseSuccess) + +export const getListSessionsForTaskUrl = (taskId: string,) => { + + + return `/api/tasks/${taskId}/sessions` +} + +export const listSessionsForTask = async (taskId: string, options?: RequestInit): Promise => { + + return customFetch(getListSessionsForTaskUrl(taskId), + { + ...options, + method: 'GET' + + + } +);} + + + export const getListSessionsForTaskQueryKey = (taskId?: string,) => { @@ -282,16 +492,16 @@ export const getListSessionsForTaskQueryKey = (taskId?: string,) => { } -export const getListSessionsForTaskQueryOptions = >, TError = unknown>(taskId: string, options?: { query?:Partial>, TError, TData>>, } +export const getListSessionsForTaskQueryOptions = >, TError = unknown>(taskId: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} ) => { -const {query: queryOptions} = options ?? {}; +const {query: queryOptions, request: requestOptions} = options ?? {}; const queryKey = queryOptions?.queryKey ?? getListSessionsForTaskQueryKey(taskId); - const queryFn: QueryFunction>> = ({ signal }) => listSessionsForTask(taskId, signal); + const queryFn: QueryFunction>> = ({ signal }) => listSessionsForTask(taskId, { signal, ...requestOptions }); @@ -311,7 +521,7 @@ export function useListSessionsForTask> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): DefinedUseQueryResult & { queryKey: DataTag } export function useListSessionsForTask>, TError = unknown>( @@ -321,16 +531,16 @@ export function useListSessionsForTask> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useListSessionsForTask>, TError = unknown>( - taskId: string, options?: { query?:Partial>, TError, TData>>, } + taskId: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useListSessionsForTask>, TError = unknown>( - taskId: string, options?: { query?:Partial>, TError, TData>>, } + taskId: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } { diff --git a/frontend/src/api/generated/tasks/tasks.ts b/frontend/src/api/generated/tasks/tasks.ts index aa8e8e5..5f53c9b 100644 --- a/frontend/src/api/generated/tasks/tasks.ts +++ b/frontend/src/api/generated/tasks/tasks.ts @@ -27,30 +27,53 @@ import type { import type { CreateTaskRequest, ExecuteResponse, + PlanResponse, Task, TransitionRequest, TransitionResponse, UpdateTaskRequest } from '.././model'; -import { customInstance } from '../../mutator/custom-instance'; +import { customFetch } from '../../../lib/api-fetcher'; +type SecondParameter unknown> = Parameters[1]; -export const listTasks = ( + +export type listTasksResponse200 = { + data: Task[] + status: 200 +} - signal?: AbortSignal -) => { - - - return customInstance( - {url: `/api/tasks`, method: 'GET', signal - }, - ); - } +export type listTasksResponseSuccess = (listTasksResponse200) & { + headers: Headers; +}; +; + +export type listTasksResponse = (listTasksResponseSuccess) + +export const getListTasksUrl = () => { + + + return `/api/tasks` +} + +export const listTasks = async ( options?: RequestInit): Promise => { + + return customFetch(getListTasksUrl(), + { + ...options, + method: 'GET' + + + } +);} + + + export const getListTasksQueryKey = () => { @@ -60,16 +83,16 @@ export const getListTasksQueryKey = () => { } -export const getListTasksQueryOptions = >, TError = unknown>( options?: { query?:Partial>, TError, TData>>, } +export const getListTasksQueryOptions = >, TError = unknown>( options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} ) => { -const {query: queryOptions} = options ?? {}; +const {query: queryOptions, request: requestOptions} = options ?? {}; const queryKey = queryOptions?.queryKey ?? getListTasksQueryKey(); - const queryFn: QueryFunction>> = ({ signal }) => listTasks(signal); + const queryFn: QueryFunction>> = ({ signal }) => listTasks({ signal, ...requestOptions }); @@ -89,7 +112,7 @@ export function useListTasks>, TErr TError, Awaited> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): DefinedUseQueryResult & { queryKey: DataTag } export function useListTasks>, TError = unknown>( @@ -99,16 +122,16 @@ export function useListTasks>, TErr TError, Awaited> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useListTasks>, TError = unknown>( - options?: { query?:Partial>, TError, TData>>, } + options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useListTasks>, TError = unknown>( - options?: { query?:Partial>, TError, TData>>, } + options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } { @@ -124,32 +147,58 @@ export function useListTasks>, TErr -export const createTask = ( - createTaskRequest: CreateTaskRequest, - signal?: AbortSignal -) => { - - - return customInstance( - {url: `/api/tasks`, method: 'POST', - headers: {'Content-Type': 'application/json', }, - data: createTaskRequest, signal - }, - ); - } +export type createTaskResponse201 = { + data: Task + status: 201 +} + +export type createTaskResponse400 = { + data: void + status: 400 +} + +export type createTaskResponseSuccess = (createTaskResponse201) & { + headers: Headers; +}; +export type createTaskResponseError = (createTaskResponse400) & { + headers: Headers; +}; + +export type createTaskResponse = (createTaskResponseSuccess | createTaskResponseError) + +export const getCreateTaskUrl = () => { + + + + + return `/api/tasks` +} + +export const createTask = async (createTaskRequest: CreateTaskRequest, options?: RequestInit): Promise => { + return customFetch(getCreateTaskUrl(), + { + ...options, + method: 'POST', + headers: { 'Content-Type': 'application/json', ...options?.headers }, + body: JSON.stringify( + createTaskRequest,) + } +);} + + export const getCreateTaskMutationOptions = (options?: { mutation?:UseMutationOptions>, TError,{data: CreateTaskRequest}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{data: CreateTaskRequest}, TContext>, request?: SecondParameter} ): UseMutationOptions>, TError,{data: CreateTaskRequest}, TContext> => { const mutationKey = ['createTask']; -const {mutation: mutationOptions} = options ? +const {mutation: mutationOptions, request: requestOptions} = options ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ? options : {...options, mutation: {...options.mutation, mutationKey}} - : {mutation: { mutationKey, }}; + : {mutation: { mutationKey, }, request: undefined}; @@ -157,7 +206,7 @@ const {mutation: mutationOptions} = options ? const mutationFn: MutationFunction>, {data: CreateTaskRequest}> = (props) => { const {data} = props ?? {}; - return createTask(data,) + return createTask(data,requestOptions) } @@ -170,7 +219,7 @@ const {mutation: mutationOptions} = options ? export type CreateTaskMutationError = void export const useCreateTask = (options?: { mutation?:UseMutationOptions>, TError,{data: CreateTaskRequest}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{data: CreateTaskRequest}, TContext>, request?: SecondParameter} , queryClient?: QueryClient): UseMutationResult< Awaited>, TError, @@ -182,18 +231,45 @@ const {mutation: mutationOptions} = options ? return useMutation(mutationOptions, queryClient); } - export const getTask = ( - id: string, - signal?: AbortSignal -) => { - - - return customInstance( - {url: `/api/tasks/${id}`, method: 'GET', signal - }, - ); - } + export type getTaskResponse200 = { + data: Task + status: 200 +} + +export type getTaskResponse404 = { + data: void + status: 404 +} + +export type getTaskResponseSuccess = (getTaskResponse200) & { + headers: Headers; +}; +export type getTaskResponseError = (getTaskResponse404) & { + headers: Headers; +}; + +export type getTaskResponse = (getTaskResponseSuccess | getTaskResponseError) + +export const getGetTaskUrl = (id: string,) => { + + + + + return `/api/tasks/${id}` +} + +export const getTask = async (id: string, options?: RequestInit): Promise => { + return customFetch(getGetTaskUrl(id), + { + ...options, + method: 'GET' + + + } +);} + + @@ -204,16 +280,16 @@ export const getGetTaskQueryKey = (id?: string,) => { } -export const getGetTaskQueryOptions = >, TError = void>(id: string, options?: { query?:Partial>, TError, TData>>, } +export const getGetTaskQueryOptions = >, TError = void>(id: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} ) => { -const {query: queryOptions} = options ?? {}; +const {query: queryOptions, request: requestOptions} = options ?? {}; const queryKey = queryOptions?.queryKey ?? getGetTaskQueryKey(id); - const queryFn: QueryFunction>> = ({ signal }) => getTask(id, signal); + const queryFn: QueryFunction>> = ({ signal }) => getTask(id, { signal, ...requestOptions }); @@ -233,7 +309,7 @@ export function useGetTask>, TError = TError, Awaited> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): DefinedUseQueryResult & { queryKey: DataTag } export function useGetTask>, TError = void>( @@ -243,16 +319,16 @@ export function useGetTask>, TError = TError, Awaited> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useGetTask>, TError = void>( - id: string, options?: { query?:Partial>, TError, TData>>, } + id: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useGetTask>, TError = void>( - id: string, options?: { query?:Partial>, TError, TData>>, } + id: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } { @@ -268,29 +344,57 @@ export function useGetTask>, TError = -export const deleteTask = ( - id: string, - ) => { - - - return customInstance( - {url: `/api/tasks/${id}`, method: 'DELETE' - }, - ); - } +export type deleteTaskResponse204 = { + data: void + status: 204 +} + +export type deleteTaskResponse404 = { + data: void + status: 404 +} + +export type deleteTaskResponseSuccess = (deleteTaskResponse204) & { + headers: Headers; +}; +export type deleteTaskResponseError = (deleteTaskResponse404) & { + headers: Headers; +}; + +export type deleteTaskResponse = (deleteTaskResponseSuccess | deleteTaskResponseError) + +export const getDeleteTaskUrl = (id: string,) => { + + + + + return `/api/tasks/${id}` +} + +export const deleteTask = async (id: string, options?: RequestInit): Promise => { + return customFetch(getDeleteTaskUrl(id), + { + ...options, + method: 'DELETE' + + + } +);} + + export const getDeleteTaskMutationOptions = (options?: { mutation?:UseMutationOptions>, TError,{id: string}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{id: string}, TContext>, request?: SecondParameter} ): UseMutationOptions>, TError,{id: string}, TContext> => { const mutationKey = ['deleteTask']; -const {mutation: mutationOptions} = options ? +const {mutation: mutationOptions, request: requestOptions} = options ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ? options : {...options, mutation: {...options.mutation, mutationKey}} - : {mutation: { mutationKey, }}; + : {mutation: { mutationKey, }, request: undefined}; @@ -298,7 +402,7 @@ const {mutation: mutationOptions} = options ? const mutationFn: MutationFunction>, {id: string}> = (props) => { const {id} = props ?? {}; - return deleteTask(id,) + return deleteTask(id,requestOptions) } @@ -311,7 +415,7 @@ const {mutation: mutationOptions} = options ? export type DeleteTaskMutationError = void export const useDeleteTask = (options?: { mutation?:UseMutationOptions>, TError,{id: string}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{id: string}, TContext>, request?: SecondParameter} , queryClient?: QueryClient): UseMutationResult< Awaited>, TError, @@ -323,32 +427,59 @@ const {mutation: mutationOptions} = options ? return useMutation(mutationOptions, queryClient); } - export const updateTask = ( - id: string, - updateTaskRequest: UpdateTaskRequest, - ) => { - - - return customInstance( - {url: `/api/tasks/${id}`, method: 'PATCH', - headers: {'Content-Type': 'application/json', }, - data: updateTaskRequest - }, - ); - } + export type updateTaskResponse200 = { + data: Task + status: 200 +} + +export type updateTaskResponse404 = { + data: void + status: 404 +} + +export type updateTaskResponseSuccess = (updateTaskResponse200) & { + headers: Headers; +}; +export type updateTaskResponseError = (updateTaskResponse404) & { + headers: Headers; +}; + +export type updateTaskResponse = (updateTaskResponseSuccess | updateTaskResponseError) + +export const getUpdateTaskUrl = (id: string,) => { + + + return `/api/tasks/${id}` +} + +export const updateTask = async (id: string, + updateTaskRequest: UpdateTaskRequest, options?: RequestInit): Promise => { + + return customFetch(getUpdateTaskUrl(id), + { + ...options, + method: 'PATCH', + headers: { 'Content-Type': 'application/json', ...options?.headers }, + body: JSON.stringify( + updateTaskRequest,) + } +);} + + + export const getUpdateTaskMutationOptions = (options?: { mutation?:UseMutationOptions>, TError,{id: string;data: UpdateTaskRequest}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{id: string;data: UpdateTaskRequest}, TContext>, request?: SecondParameter} ): UseMutationOptions>, TError,{id: string;data: UpdateTaskRequest}, TContext> => { const mutationKey = ['updateTask']; -const {mutation: mutationOptions} = options ? +const {mutation: mutationOptions, request: requestOptions} = options ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ? options : {...options, mutation: {...options.mutation, mutationKey}} - : {mutation: { mutationKey, }}; + : {mutation: { mutationKey, }, request: undefined}; @@ -356,7 +487,7 @@ const {mutation: mutationOptions} = options ? const mutationFn: MutationFunction>, {id: string;data: UpdateTaskRequest}> = (props) => { const {id,data} = props ?? {}; - return updateTask(id,data,) + return updateTask(id,data,requestOptions) } @@ -369,7 +500,7 @@ const {mutation: mutationOptions} = options ? export type UpdateTaskMutationError = void export const useUpdateTask = (options?: { mutation?:UseMutationOptions>, TError,{id: string;data: UpdateTaskRequest}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{id: string;data: UpdateTaskRequest}, TContext>, request?: SecondParameter} , queryClient?: QueryClient): UseMutationResult< Awaited>, TError, @@ -381,30 +512,62 @@ const {mutation: mutationOptions} = options ? return useMutation(mutationOptions, queryClient); } - export const executeTask = ( - id: string, - signal?: AbortSignal -) => { - - - return customInstance( - {url: `/api/tasks/${id}/execute`, method: 'POST', signal - }, - ); - } + export type executeTaskResponse202 = { + data: ExecuteResponse + status: 202 +} + +export type executeTaskResponse404 = { + data: void + status: 404 +} + +export type executeTaskResponse500 = { + data: void + status: 500 +} + +export type executeTaskResponseSuccess = (executeTaskResponse202) & { + headers: Headers; +}; +export type executeTaskResponseError = (executeTaskResponse404 | executeTaskResponse500) & { + headers: Headers; +}; + +export type executeTaskResponse = (executeTaskResponseSuccess | executeTaskResponseError) + +export const getExecuteTaskUrl = (id: string,) => { + + + return `/api/tasks/${id}/execute` +} + +export const executeTask = async (id: string, options?: RequestInit): Promise => { + + return customFetch(getExecuteTaskUrl(id), + { + ...options, + method: 'POST' + + + } +);} + + + export const getExecuteTaskMutationOptions = (options?: { mutation?:UseMutationOptions>, TError,{id: string}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{id: string}, TContext>, request?: SecondParameter} ): UseMutationOptions>, TError,{id: string}, TContext> => { const mutationKey = ['executeTask']; -const {mutation: mutationOptions} = options ? +const {mutation: mutationOptions, request: requestOptions} = options ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ? options : {...options, mutation: {...options.mutation, mutationKey}} - : {mutation: { mutationKey, }}; + : {mutation: { mutationKey, }, request: undefined}; @@ -412,7 +575,7 @@ const {mutation: mutationOptions} = options ? const mutationFn: MutationFunction>, {id: string}> = (props) => { const {id} = props ?? {}; - return executeTask(id,) + return executeTask(id,requestOptions) } @@ -425,7 +588,7 @@ const {mutation: mutationOptions} = options ? export type ExecuteTaskMutationError = void export const useExecuteTask = (options?: { mutation?:UseMutationOptions>, TError,{id: string}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{id: string}, TContext>, request?: SecondParameter} , queryClient?: QueryClient): UseMutationResult< Awaited>, TError, @@ -437,33 +600,177 @@ const {mutation: mutationOptions} = options ? return useMutation(mutationOptions, queryClient); } - export const transitionTask = ( - id: string, - transitionRequest: TransitionRequest, - signal?: AbortSignal + export type getTaskPlanResponse200 = { + data: PlanResponse + status: 200 +} + +export type getTaskPlanResponse404 = { + data: void + status: 404 +} + +export type getTaskPlanResponseSuccess = (getTaskPlanResponse200) & { + headers: Headers; +}; +export type getTaskPlanResponseError = (getTaskPlanResponse404) & { + headers: Headers; +}; + +export type getTaskPlanResponse = (getTaskPlanResponseSuccess | getTaskPlanResponseError) + +export const getGetTaskPlanUrl = (id: string,) => { + + + + + return `/api/tasks/${id}/plan` +} + +export const getTaskPlan = async (id: string, options?: RequestInit): Promise => { + + return customFetch(getGetTaskPlanUrl(id), + { + ...options, + method: 'GET' + + + } +);} + + + + + +export const getGetTaskPlanQueryKey = (id?: string,) => { + return [ + `/api/tasks/${id}/plan` + ] as const; + } + + +export const getGetTaskPlanQueryOptions = >, TError = void>(id: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} ) => { + +const {query: queryOptions, request: requestOptions} = options ?? {}; + + const queryKey = queryOptions?.queryKey ?? getGetTaskPlanQueryKey(id); + + + + const queryFn: QueryFunction>> = ({ signal }) => getTaskPlan(id, { signal, ...requestOptions }); + + - return customInstance( - {url: `/api/tasks/${id}/transition`, method: 'POST', - headers: {'Content-Type': 'application/json', }, - data: transitionRequest, signal - }, - ); - } + + return { queryKey, queryFn, enabled: !!(id), ...queryOptions} as UseQueryOptions>, TError, TData> & { queryKey: DataTag } +} + +export type GetTaskPlanQueryResult = NonNullable>> +export type GetTaskPlanQueryError = void + + +export function useGetTaskPlan>, TError = void>( + id: string, options: { query:Partial>, TError, TData>> & Pick< + DefinedInitialDataOptions< + Awaited>, + TError, + Awaited> + > , 'initialData' + >, request?: SecondParameter} + , queryClient?: QueryClient + ): DefinedUseQueryResult & { queryKey: DataTag } +export function useGetTaskPlan>, TError = void>( + id: string, options?: { query?:Partial>, TError, TData>> & Pick< + UndefinedInitialDataOptions< + Awaited>, + TError, + Awaited> + > , 'initialData' + >, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } +export function useGetTaskPlan>, TError = void>( + id: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } + +export function useGetTaskPlan>, TError = void>( + id: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} + , queryClient?: QueryClient + ): UseQueryResult & { queryKey: DataTag } { + + const queryOptions = getGetTaskPlanQueryOptions(id,options) + + const query = useQuery(queryOptions, queryClient) as UseQueryResult & { queryKey: DataTag }; + + query.queryKey = queryOptions.queryKey ; + + return query; +} + + + + +export type transitionTaskResponse200 = { + data: TransitionResponse + status: 200 +} + +export type transitionTaskResponse400 = { + data: void + status: 400 +} + +export type transitionTaskResponse404 = { + data: void + status: 404 +} + +export type transitionTaskResponseSuccess = (transitionTaskResponse200) & { + headers: Headers; +}; +export type transitionTaskResponseError = (transitionTaskResponse400 | transitionTaskResponse404) & { + headers: Headers; +}; + +export type transitionTaskResponse = (transitionTaskResponseSuccess | transitionTaskResponseError) + +export const getTransitionTaskUrl = (id: string,) => { + + + return `/api/tasks/${id}/transition` +} + +export const transitionTask = async (id: string, + transitionRequest: TransitionRequest, options?: RequestInit): Promise => { + + return customFetch(getTransitionTaskUrl(id), + { + ...options, + method: 'POST', + headers: { 'Content-Type': 'application/json', ...options?.headers }, + body: JSON.stringify( + transitionRequest,) + } +);} + + + export const getTransitionTaskMutationOptions = (options?: { mutation?:UseMutationOptions>, TError,{id: string;data: TransitionRequest}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{id: string;data: TransitionRequest}, TContext>, request?: SecondParameter} ): UseMutationOptions>, TError,{id: string;data: TransitionRequest}, TContext> => { const mutationKey = ['transitionTask']; -const {mutation: mutationOptions} = options ? +const {mutation: mutationOptions, request: requestOptions} = options ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ? options : {...options, mutation: {...options.mutation, mutationKey}} - : {mutation: { mutationKey, }}; + : {mutation: { mutationKey, }, request: undefined}; @@ -471,7 +778,7 @@ const {mutation: mutationOptions} = options ? const mutationFn: MutationFunction>, {id: string;data: TransitionRequest}> = (props) => { const {id,data} = props ?? {}; - return transitionTask(id,data,) + return transitionTask(id,data,requestOptions) } @@ -484,7 +791,7 @@ const {mutation: mutationOptions} = options ? export type TransitionTaskMutationError = void export const useTransitionTask = (options?: { mutation?:UseMutationOptions>, TError,{id: string;data: TransitionRequest}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{id: string;data: TransitionRequest}, TContext>, request?: SecondParameter} , queryClient?: QueryClient): UseMutationResult< Awaited>, TError, diff --git a/frontend/src/api/generated/workspaces/workspaces.ts b/frontend/src/api/generated/workspaces/workspaces.ts index 18dfef3..a21e439 100644 --- a/frontend/src/api/generated/workspaces/workspaces.ts +++ b/frontend/src/api/generated/workspaces/workspaces.ts @@ -32,35 +32,64 @@ import type { WorkspaceStatusResponse } from '.././model'; -import { customInstance } from '../../mutator/custom-instance'; +import { customFetch } from '../../../lib/api-fetcher'; +type SecondParameter unknown> = Parameters[1]; + + + +export type createWorkspaceForTaskResponse201 = { + data: WorkspaceResponse + status: 201 +} + +export type createWorkspaceForTaskResponse404 = { + data: void + status: 404 +} + +export type createWorkspaceForTaskResponseSuccess = (createWorkspaceForTaskResponse201) & { + headers: Headers; +}; +export type createWorkspaceForTaskResponseError = (createWorkspaceForTaskResponse404) & { + headers: Headers; +}; + +export type createWorkspaceForTaskResponse = (createWorkspaceForTaskResponseSuccess | createWorkspaceForTaskResponseError) + +export const getCreateWorkspaceForTaskUrl = (taskId: string,) => { -export const createWorkspaceForTask = ( - taskId: string, - signal?: AbortSignal -) => { - - - return customInstance( - {url: `/api/tasks/${taskId}/workspace`, method: 'POST', signal - }, - ); - } + return `/api/tasks/${taskId}/workspace` +} + +export const createWorkspaceForTask = async (taskId: string, options?: RequestInit): Promise => { + + return customFetch(getCreateWorkspaceForTaskUrl(taskId), + { + ...options, + method: 'POST' + + + } +);} + + + export const getCreateWorkspaceForTaskMutationOptions = (options?: { mutation?:UseMutationOptions>, TError,{taskId: string}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{taskId: string}, TContext>, request?: SecondParameter} ): UseMutationOptions>, TError,{taskId: string}, TContext> => { const mutationKey = ['createWorkspaceForTask']; -const {mutation: mutationOptions} = options ? +const {mutation: mutationOptions, request: requestOptions} = options ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ? options : {...options, mutation: {...options.mutation, mutationKey}} - : {mutation: { mutationKey, }}; + : {mutation: { mutationKey, }, request: undefined}; @@ -68,7 +97,7 @@ const {mutation: mutationOptions} = options ? const mutationFn: MutationFunction>, {taskId: string}> = (props) => { const {taskId} = props ?? {}; - return createWorkspaceForTask(taskId,) + return createWorkspaceForTask(taskId,requestOptions) } @@ -81,7 +110,7 @@ const {mutation: mutationOptions} = options ? export type CreateWorkspaceForTaskMutationError = void export const useCreateWorkspaceForTask = (options?: { mutation?:UseMutationOptions>, TError,{taskId: string}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{taskId: string}, TContext>, request?: SecondParameter} , queryClient?: QueryClient): UseMutationResult< Awaited>, TError, @@ -93,18 +122,38 @@ const {mutation: mutationOptions} = options ? return useMutation(mutationOptions, queryClient); } - export const listWorkspaces = ( + export type listWorkspacesResponse200 = { + data: WorkspaceResponse[] + status: 200 +} - signal?: AbortSignal -) => { - - - return customInstance( - {url: `/api/workspaces`, method: 'GET', signal - }, - ); - } +export type listWorkspacesResponseSuccess = (listWorkspacesResponse200) & { + headers: Headers; +}; +; + +export type listWorkspacesResponse = (listWorkspacesResponseSuccess) + +export const getListWorkspacesUrl = () => { + + + + + return `/api/workspaces` +} + +export const listWorkspaces = async ( options?: RequestInit): Promise => { + return customFetch(getListWorkspacesUrl(), + { + ...options, + method: 'GET' + + + } +);} + + @@ -115,16 +164,16 @@ export const getListWorkspacesQueryKey = () => { } -export const getListWorkspacesQueryOptions = >, TError = unknown>( options?: { query?:Partial>, TError, TData>>, } +export const getListWorkspacesQueryOptions = >, TError = unknown>( options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} ) => { -const {query: queryOptions} = options ?? {}; +const {query: queryOptions, request: requestOptions} = options ?? {}; const queryKey = queryOptions?.queryKey ?? getListWorkspacesQueryKey(); - const queryFn: QueryFunction>> = ({ signal }) => listWorkspaces(signal); + const queryFn: QueryFunction>> = ({ signal }) => listWorkspaces({ signal, ...requestOptions }); @@ -144,7 +193,7 @@ export function useListWorkspaces> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): DefinedUseQueryResult & { queryKey: DataTag } export function useListWorkspaces>, TError = unknown>( @@ -154,16 +203,16 @@ export function useListWorkspaces> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useListWorkspaces>, TError = unknown>( - options?: { query?:Partial>, TError, TData>>, } + options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useListWorkspaces>, TError = unknown>( - options?: { query?:Partial>, TError, TData>>, } + options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } { @@ -179,18 +228,45 @@ export function useListWorkspaces { - - - return customInstance( - {url: `/api/workspaces/${taskId}`, method: 'GET', signal - }, - ); - } +export type getWorkspaceStatusResponse200 = { + data: WorkspaceStatusResponse + status: 200 +} + +export type getWorkspaceStatusResponse404 = { + data: void + status: 404 +} + +export type getWorkspaceStatusResponseSuccess = (getWorkspaceStatusResponse200) & { + headers: Headers; +}; +export type getWorkspaceStatusResponseError = (getWorkspaceStatusResponse404) & { + headers: Headers; +}; + +export type getWorkspaceStatusResponse = (getWorkspaceStatusResponseSuccess | getWorkspaceStatusResponseError) + +export const getGetWorkspaceStatusUrl = (taskId: string,) => { + + + + + return `/api/workspaces/${taskId}` +} + +export const getWorkspaceStatus = async (taskId: string, options?: RequestInit): Promise => { + return customFetch(getGetWorkspaceStatusUrl(taskId), + { + ...options, + method: 'GET' + + + } +);} + + @@ -201,16 +277,16 @@ export const getGetWorkspaceStatusQueryKey = (taskId?: string,) => { } -export const getGetWorkspaceStatusQueryOptions = >, TError = void>(taskId: string, options?: { query?:Partial>, TError, TData>>, } +export const getGetWorkspaceStatusQueryOptions = >, TError = void>(taskId: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} ) => { -const {query: queryOptions} = options ?? {}; +const {query: queryOptions, request: requestOptions} = options ?? {}; const queryKey = queryOptions?.queryKey ?? getGetWorkspaceStatusQueryKey(taskId); - const queryFn: QueryFunction>> = ({ signal }) => getWorkspaceStatus(taskId, signal); + const queryFn: QueryFunction>> = ({ signal }) => getWorkspaceStatus(taskId, { signal, ...requestOptions }); @@ -230,7 +306,7 @@ export function useGetWorkspaceStatus> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): DefinedUseQueryResult & { queryKey: DataTag } export function useGetWorkspaceStatus>, TError = void>( @@ -240,16 +316,16 @@ export function useGetWorkspaceStatus> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useGetWorkspaceStatus>, TError = void>( - taskId: string, options?: { query?:Partial>, TError, TData>>, } + taskId: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useGetWorkspaceStatus>, TError = void>( - taskId: string, options?: { query?:Partial>, TError, TData>>, } + taskId: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } { @@ -265,29 +341,57 @@ export function useGetWorkspaceStatus { - - - return customInstance( - {url: `/api/workspaces/${taskId}`, method: 'DELETE' - }, - ); - } +export type deleteWorkspaceResponse204 = { + data: void + status: 204 +} + +export type deleteWorkspaceResponse404 = { + data: void + status: 404 +} + +export type deleteWorkspaceResponseSuccess = (deleteWorkspaceResponse204) & { + headers: Headers; +}; +export type deleteWorkspaceResponseError = (deleteWorkspaceResponse404) & { + headers: Headers; +}; + +export type deleteWorkspaceResponse = (deleteWorkspaceResponseSuccess | deleteWorkspaceResponseError) + +export const getDeleteWorkspaceUrl = (taskId: string,) => { + + + return `/api/workspaces/${taskId}` +} + +export const deleteWorkspace = async (taskId: string, options?: RequestInit): Promise => { + + return customFetch(getDeleteWorkspaceUrl(taskId), + { + ...options, + method: 'DELETE' + + + } +);} + + + export const getDeleteWorkspaceMutationOptions = (options?: { mutation?:UseMutationOptions>, TError,{taskId: string}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{taskId: string}, TContext>, request?: SecondParameter} ): UseMutationOptions>, TError,{taskId: string}, TContext> => { const mutationKey = ['deleteWorkspace']; -const {mutation: mutationOptions} = options ? +const {mutation: mutationOptions, request: requestOptions} = options ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ? options : {...options, mutation: {...options.mutation, mutationKey}} - : {mutation: { mutationKey, }}; + : {mutation: { mutationKey, }, request: undefined}; @@ -295,7 +399,7 @@ const {mutation: mutationOptions} = options ? const mutationFn: MutationFunction>, {taskId: string}> = (props) => { const {taskId} = props ?? {}; - return deleteWorkspace(taskId,) + return deleteWorkspace(taskId,requestOptions) } @@ -308,7 +412,7 @@ const {mutation: mutationOptions} = options ? export type DeleteWorkspaceMutationError = void export const useDeleteWorkspace = (options?: { mutation?:UseMutationOptions>, TError,{taskId: string}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{taskId: string}, TContext>, request?: SecondParameter} , queryClient?: QueryClient): UseMutationResult< Awaited>, TError, @@ -320,19 +424,46 @@ const {mutation: mutationOptions} = options ? return useMutation(mutationOptions, queryClient); } - export const getWorkspaceDiff = ( - taskId: string, - signal?: AbortSignal -) => { - - - return customInstance( - {url: `/api/workspaces/${taskId}/diff`, method: 'GET', signal - }, - ); - } + export type getWorkspaceDiffResponse200 = { + data: DiffResponse + status: 200 +} + +export type getWorkspaceDiffResponse404 = { + data: void + status: 404 +} + +export type getWorkspaceDiffResponseSuccess = (getWorkspaceDiffResponse200) & { + headers: Headers; +}; +export type getWorkspaceDiffResponseError = (getWorkspaceDiffResponse404) & { + headers: Headers; +}; + +export type getWorkspaceDiffResponse = (getWorkspaceDiffResponseSuccess | getWorkspaceDiffResponseError) + +export const getGetWorkspaceDiffUrl = (taskId: string,) => { + + + return `/api/workspaces/${taskId}/diff` +} + +export const getWorkspaceDiff = async (taskId: string, options?: RequestInit): Promise => { + + return customFetch(getGetWorkspaceDiffUrl(taskId), + { + ...options, + method: 'GET' + + + } +);} + + + export const getGetWorkspaceDiffQueryKey = (taskId?: string,) => { @@ -342,16 +473,16 @@ export const getGetWorkspaceDiffQueryKey = (taskId?: string,) => { } -export const getGetWorkspaceDiffQueryOptions = >, TError = void>(taskId: string, options?: { query?:Partial>, TError, TData>>, } +export const getGetWorkspaceDiffQueryOptions = >, TError = void>(taskId: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} ) => { -const {query: queryOptions} = options ?? {}; +const {query: queryOptions, request: requestOptions} = options ?? {}; const queryKey = queryOptions?.queryKey ?? getGetWorkspaceDiffQueryKey(taskId); - const queryFn: QueryFunction>> = ({ signal }) => getWorkspaceDiff(taskId, signal); + const queryFn: QueryFunction>> = ({ signal }) => getWorkspaceDiff(taskId, { signal, ...requestOptions }); @@ -371,7 +502,7 @@ export function useGetWorkspaceDiff> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): DefinedUseQueryResult & { queryKey: DataTag } export function useGetWorkspaceDiff>, TError = void>( @@ -381,16 +512,16 @@ export function useGetWorkspaceDiff> > , 'initialData' - >, } + >, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useGetWorkspaceDiff>, TError = void>( - taskId: string, options?: { query?:Partial>, TError, TData>>, } + taskId: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } export function useGetWorkspaceDiff>, TError = void>( - taskId: string, options?: { query?:Partial>, TError, TData>>, } + taskId: string, options?: { query?:Partial>, TError, TData>>, request?: SecondParameter} , queryClient?: QueryClient ): UseQueryResult & { queryKey: DataTag } { @@ -406,33 +537,59 @@ export function useGetWorkspaceDiff { - - - return customInstance( - {url: `/api/workspaces/${taskId}/merge`, method: 'POST', - headers: {'Content-Type': 'application/json', }, - data: mergeRequest, signal - }, - ); - } +export type mergeWorkspaceResponse200 = { + data: MergeResponse + status: 200 +} + +export type mergeWorkspaceResponse404 = { + data: void + status: 404 +} + +export type mergeWorkspaceResponseSuccess = (mergeWorkspaceResponse200) & { + headers: Headers; +}; +export type mergeWorkspaceResponseError = (mergeWorkspaceResponse404) & { + headers: Headers; +}; + +export type mergeWorkspaceResponse = (mergeWorkspaceResponseSuccess | mergeWorkspaceResponseError) + +export const getMergeWorkspaceUrl = (taskId: string,) => { + + + return `/api/workspaces/${taskId}/merge` +} + +export const mergeWorkspace = async (taskId: string, + mergeRequest: MergeRequest, options?: RequestInit): Promise => { + + return customFetch(getMergeWorkspaceUrl(taskId), + { + ...options, + method: 'POST', + headers: { 'Content-Type': 'application/json', ...options?.headers }, + body: JSON.stringify( + mergeRequest,) + } +);} + + + export const getMergeWorkspaceMutationOptions = (options?: { mutation?:UseMutationOptions>, TError,{taskId: string;data: MergeRequest}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{taskId: string;data: MergeRequest}, TContext>, request?: SecondParameter} ): UseMutationOptions>, TError,{taskId: string;data: MergeRequest}, TContext> => { const mutationKey = ['mergeWorkspace']; -const {mutation: mutationOptions} = options ? +const {mutation: mutationOptions, request: requestOptions} = options ? options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ? options : {...options, mutation: {...options.mutation, mutationKey}} - : {mutation: { mutationKey, }}; + : {mutation: { mutationKey, }, request: undefined}; @@ -440,7 +597,7 @@ const {mutation: mutationOptions} = options ? const mutationFn: MutationFunction>, {taskId: string;data: MergeRequest}> = (props) => { const {taskId,data} = props ?? {}; - return mergeWorkspace(taskId,data,) + return mergeWorkspace(taskId,data,requestOptions) } @@ -453,7 +610,7 @@ const {mutation: mutationOptions} = options ? export type MergeWorkspaceMutationError = void export const useMergeWorkspace = (options?: { mutation?:UseMutationOptions>, TError,{taskId: string;data: MergeRequest}, TContext>, } + TContext = unknown>(options?: { mutation?:UseMutationOptions>, TError,{taskId: string;data: MergeRequest}, TContext>, request?: SecondParameter} , queryClient?: QueryClient): UseMutationResult< Awaited>, TError, diff --git a/frontend/src/api/mutator/custom-instance.ts b/frontend/src/api/mutator/custom-instance.ts deleted file mode 100644 index afc4f58..0000000 --- a/frontend/src/api/mutator/custom-instance.ts +++ /dev/null @@ -1,51 +0,0 @@ -/** - * Custom Axios-like instance for Orval generated API client. - * Uses native fetch with configurable base URL. - */ - -const BASE_URL = process.env.NEXT_PUBLIC_API_URL ?? "http://localhost:3001"; - -export type CustomInstanceParams = { - url: string; - method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH"; - params?: Record; - headers?: Record; - data?: T; - signal?: AbortSignal; -}; - -export const customInstance = async ({ - url, - method, - params, - headers, - data, - signal, -}: CustomInstanceParams): Promise => { - const searchParams = params ? `?${new URLSearchParams(params).toString()}` : ""; - - const response = await fetch(`${BASE_URL}${url}${searchParams}`, { - method, - headers: { - "Content-Type": "application/json", - ...headers, - }, - body: data ? JSON.stringify(data) : undefined, - signal, - }); - - if (!response.ok) { - const error = await response.text(); - throw new Error(error || `HTTP ${response.status}`); - } - - // Handle empty responses (204 No Content) - const contentType = response.headers.get("content-type"); - if (response.status === 204 || !contentType?.includes("application/json")) { - return undefined as T; - } - - return response.json() as Promise; -}; - -export default customInstance; diff --git a/frontend/src/app/_components/post.tsx b/frontend/src/app/_components/post.tsx deleted file mode 100644 index d3314f0..0000000 --- a/frontend/src/app/_components/post.tsx +++ /dev/null @@ -1,50 +0,0 @@ -"use client"; - -import { useState } from "react"; - -import { api } from "~/trpc/react"; - -export function LatestPost() { - const [latestPost] = api.post.getLatest.useSuspenseQuery(); - - const utils = api.useUtils(); - const [name, setName] = useState(""); - const createPost = api.post.create.useMutation({ - onSuccess: async () => { - await utils.post.invalidate(); - setName(""); - }, - }); - - return ( -
- {latestPost ? ( -

Your most recent post: {latestPost.name}

- ) : ( -

You have no posts yet.

- )} -
{ - e.preventDefault(); - createPost.mutate({ name }); - }} - className="flex flex-col gap-2" - > - setName(e.target.value)} - className="w-full rounded-full bg-white/10 px-4 py-2 text-white" - /> - -
-
- ); -} diff --git a/frontend/src/app/api/trpc/[trpc]/route.ts b/frontend/src/app/api/trpc/[trpc]/route.ts deleted file mode 100644 index 3ff17fe..0000000 --- a/frontend/src/app/api/trpc/[trpc]/route.ts +++ /dev/null @@ -1,31 +0,0 @@ -import { fetchRequestHandler } from "@trpc/server/adapters/fetch"; -import type { NextRequest } from "next/server"; - -import { env } from "~/env"; -import { appRouter } from "~/server/api/root"; -import { createTRPCContext } from "~/server/api/trpc"; - -/** - * This wraps the `createTRPCContext` helper and provides the required context for the tRPC API when - * handling a HTTP request (e.g. when you make requests from Client Components). - */ -const createContext = async (req: NextRequest) => - createTRPCContext({ - headers: req.headers, - }); - -const handler = (req: NextRequest) => - fetchRequestHandler({ - endpoint: "/api/trpc", - req, - router: appRouter, - createContext: () => createContext(req), - onError: - env.NODE_ENV === "development" - ? ({ path, error }) => { - console.error(`❌ tRPC failed on ${path ?? ""}: ${error.message}`); - } - : undefined, - }); - -export { handler as GET, handler as POST }; diff --git a/frontend/src/app/layout.tsx b/frontend/src/app/layout.tsx deleted file mode 100644 index 01d2571..0000000 --- a/frontend/src/app/layout.tsx +++ /dev/null @@ -1,24 +0,0 @@ -import type React from "react" -import type { Metadata } from "next" -import { Inter, JetBrains_Mono } from "next/font/google" -import "./globals.css" - -const fontSans = Inter({ subsets: ["latin"], variable: "--font-sans" }) -const fontMono = JetBrains_Mono({ subsets: ["latin"], variable: "--font-mono" }) - -export const metadata: Metadata = { - title: "OpenCode Studio", - description: "AI-powered autonomous development platform", -} - -export default function RootLayout({ - children, -}: Readonly<{ - children: React.ReactNode -}>) { - return ( - - {children} - - ) -} diff --git a/frontend/src/app/page.tsx b/frontend/src/app/page.tsx deleted file mode 100644 index ac1c886..0000000 --- a/frontend/src/app/page.tsx +++ /dev/null @@ -1,5 +0,0 @@ -import { AppShell } from "~/components/app-shell" - -export default function Page() { - return -} diff --git a/frontend/src/components/ErrorBoundary.tsx b/frontend/src/components/ErrorBoundary.tsx new file mode 100644 index 0000000..17d43b5 --- /dev/null +++ b/frontend/src/components/ErrorBoundary.tsx @@ -0,0 +1,54 @@ +import type { ErrorInfo, ReactNode } from "react"; +import { Component } from "react"; +import { Button } from "@/components/ui/button"; + +interface ErrorBoundaryProps { + children: ReactNode; + fallback?: ReactNode; +} + +interface ErrorBoundaryState { + hasError: boolean; + error: Error | null; +} + +export class ErrorBoundary extends Component { + constructor(props: ErrorBoundaryProps) { + super(props); + this.state = { hasError: false, error: null }; + } + + static getDerivedStateFromError(error: Error): ErrorBoundaryState { + return { hasError: true, error }; + } + + componentDidCatch(_error: Error, _errorInfo: ErrorInfo) {} + + handleReset = () => { + this.setState({ hasError: false, error: null }); + }; + + render() { + if (this.state.hasError) { + if (this.props.fallback) { + return this.props.fallback; + } + + return ( +
+
+

Something went wrong

+

+ {this.state.error?.message ?? "An unexpected error occurred"} +

+
+ +
+ ); + } + + return this.props.children; + } +} diff --git a/frontend/src/components/activity/ActivityFeed.tsx b/frontend/src/components/activity/ActivityFeed.tsx new file mode 100644 index 0000000..1403e00 --- /dev/null +++ b/frontend/src/components/activity/ActivityFeed.tsx @@ -0,0 +1,117 @@ +import { useCallback, useEffect, useRef, useState } from "react"; +import { Button } from "@/components/ui/button"; +import { ScrollArea } from "@/components/ui/scroll-area"; +import { cn } from "@/lib/utils"; +import type { SessionActivityMsg } from "@/types/generated/SessionActivityMsg"; +import { ActivityItem } from "./ActivityItem"; + +interface ActivityFeedProps { + activities: SessionActivityMsg[]; + isConnected: boolean; + isFinished: boolean; + error: string | null; + className?: string; +} + +export function ActivityFeed({ + activities, + isConnected, + isFinished, + error, + className, +}: ActivityFeedProps) { + const scrollRef = useRef(null); + const [autoScroll, setAutoScroll] = useState(true); + const [isNearBottom, setIsNearBottom] = useState(true); + + const scrollToBottom = useCallback(() => { + if (scrollRef.current) { + scrollRef.current.scrollTop = scrollRef.current.scrollHeight; + } + }, []); + + const handleScroll = useCallback(() => { + if (!scrollRef.current) { + return; + } + + const { scrollTop, scrollHeight, clientHeight } = scrollRef.current; + const distanceFromBottom = scrollHeight - scrollTop - clientHeight; + const nearBottom = distanceFromBottom < 100; + + setIsNearBottom(nearBottom); + + if (nearBottom && !autoScroll) { + setAutoScroll(true); + } else if (!nearBottom && autoScroll) { + setAutoScroll(false); + } + }, [autoScroll]); + + useEffect(() => { + if (autoScroll && activities.length > 0) { + scrollToBottom(); + } + }, [activities, autoScroll, scrollToBottom]); + + const handleResumeAutoScroll = () => { + setAutoScroll(true); + scrollToBottom(); + }; + + const showLiveIndicator = isConnected && !isFinished; + + return ( +
+
+
+ Activity + {showLiveIndicator && ( + + + Live + + )} + {isFinished && Completed} + {error && {error}} +
+ {activities.length} events +
+ + +
+ {activities.length === 0 ? ( +
+ {isConnected ? ( + <> +
+

Waiting for activity...

+ + ) : ( +

No activity recorded

+ )} +
+ ) : ( + activities.map((activity, index) => { + const key = "id" in activity ? activity.id : `activity-${index}`; + return ; + }) + )} +
+ + + {!isNearBottom && ( +
+ +
+ )} +
+ ); +} diff --git a/frontend/src/components/activity/ActivityItem.tsx b/frontend/src/components/activity/ActivityItem.tsx new file mode 100644 index 0000000..691898a --- /dev/null +++ b/frontend/src/components/activity/ActivityItem.tsx @@ -0,0 +1,422 @@ +import { useState } from "react"; +import { cn } from "@/lib/utils"; +import type { SessionActivityMsg } from "@/types/generated/SessionActivityMsg"; +import { Icon, getToolIcon, getToolStatus } from "@/components/ui/icon"; +import { Markdown } from "@/components/ui/markdown"; +import { Collapsible } from "@/components/ui/collapsible"; + +interface ActivityItemProps { + activity: SessionActivityMsg; +} + +function formatTime(timestamp: string): string { + return new Date(timestamp).toLocaleTimeString([], { + hour: "2-digit", + minute: "2-digit", + second: "2-digit", + }); +} + +function truncateString(str: string, maxLen: number): string { + if (str.length <= maxLen) { + return str; + } + return `${str.slice(0, maxLen)}...`; +} + +function getFilename(path: string | undefined): string { + if (!path) return ""; + const parts = path.split("/"); + return parts[parts.length - 1] || path; +} + + +function formatToolArgs( + args: Record | null, +): { summary: string; full: string } | null { + if (!args || Object.keys(args).length === 0) return null; + + const entries = Object.entries(args); + const summary = entries + .slice(0, 2) + .map(([k, v]) => { + const val = typeof v === "string" ? v : JSON.stringify(v); + return `${k}: ${truncateString(val, 30)}`; + }) + .join(", "); + + return { + summary: + entries.length > 2 ? `${summary} (+${entries.length - 2} more)` : summary, + full: JSON.stringify(args, null, 2), + }; +} + +function getToolSubtitle( + toolName: string, + args: Record | null, +): string | undefined { + if (!args) return undefined; + + const tool = toolName.toLowerCase(); + + if (tool === "read" || tool === "edit" || tool === "write") { + const path = args.filePath as string | undefined; + return path ? getFilename(path) : undefined; + } + + if (tool === "bash" || tool === "shell") { + return ( + (args.description as string) || + truncateString((args.command as string) || "", 50) + ); + } + + if (tool === "glob" || tool === "grep") { + return (args.pattern as string) || (args.path as string); + } + + if (tool === "webfetch" || tool === "web_fetch") { + const url = args.url as string; + return url ? truncateString(url, 40) : undefined; + } + + if (tool === "task") { + return (args.description as string) || (args.subagent_type as string); + } + + return undefined; +} + +function ToolCallItem({ + activity, +}: { + activity: Extract; +}) { + const [isExpanded, setIsExpanded] = useState(false); + const argsFormatted = formatToolArgs(activity.args); + const subtitle = getToolSubtitle(activity.tool_name, activity.args); + const statusText = getToolStatus(activity.tool_name); + + return ( + +
+ +
+
+ +
+ +
+ + {activity.tool_name} + + {subtitle && ( + + {subtitle} + + )} +
+ +
+ {statusText} + + {formatTime(activity.timestamp)} + + {argsFormatted && } +
+
+ + + {argsFormatted && ( + +
+ 
+								{argsFormatted.full}
+
+
+ + )} +
+ + ); +} + +function ToolResultItem({ + activity, +}: { + activity: Extract; +}) { + const [isExpanded, setIsExpanded] = useState(false); + const hasResult = activity.result && activity.result.length > 0; + const hasLongResult = activity.result && activity.result.length > 150; + const subtitle = getToolSubtitle(activity.tool_name, activity.args); + const iconName = getToolIcon(activity.tool_name); + + return ( + +
+ +
+
+ +
+ +
+ + + {activity.tool_name} + + {subtitle && ( + + {subtitle} + + )} +
+ +
+ + {activity.success ? "done" : "failed"} + + + {formatTime(activity.timestamp)} + + {hasResult && } +
+
+ + + {hasResult && ( + +
+ 
+								{activity.result}
+
+
+ + )} +
+ + ); +} + +function AgentMessageItem({ + activity, +}: { + activity: Extract; +}) { + return ( +
+
+
+ +
+
+
+ + Assistant + + {activity.is_partial && ( + + + typing + + )} + + {formatTime(activity.timestamp)} + +
+ +
+
+
+ ); +} + +function ReasoningItem({ + activity, +}: { + activity: Extract; +}) { + const [isExpanded, setIsExpanded] = useState(false); + const isLong = activity.content.length > 200; + + // Extract first bold section as title if present + const match = activity.content.trimStart().match(/^\*\*(.+?)\*\*/); + const title = match ? match[1].trim() : null; + + return ( + +
+ +
+
+ +
+ +
+ + Thinking + {title && ( + + {" "} + · {title} + + )} + +
+ +
+ + {formatTime(activity.timestamp)} + + {isLong && } +
+
+ + + +
+

+ {activity.content} +

+
+ + + {!isLong && !isExpanded && ( +
+

+ {activity.content} +

+
+ )} +
+ + ); +} + +function StepStartItem({ + activity, +}: { + activity: Extract; +}) { + return ( +
+
+
+ + + {activity.step_name ?? "Step"} + +
+ + {formatTime(activity.timestamp)} + +
+
+ ); +} + +function FinishedItem({ + activity, +}: { + activity: Extract; +}) { + return ( +
+
+ +
+
+ + Session {activity.success ? "completed" : "failed"} + + {activity.error && ( +

{activity.error}

+ )} +
+ + {formatTime(activity.timestamp)} + +
+ ); +} + +export function ActivityItem({ activity }: ActivityItemProps) { + switch (activity.type) { + case "tool_call": + return ; + case "tool_result": + return ; + case "agent_message": + return ; + case "reasoning": + return ; + case "step_start": + return ; + case "finished": + return ; + case "json_patch": + return null; + default: + return null; + } +} diff --git a/frontend/src/components/activity/BasicTool.tsx b/frontend/src/components/activity/BasicTool.tsx new file mode 100644 index 0000000..5100a85 --- /dev/null +++ b/frontend/src/components/activity/BasicTool.tsx @@ -0,0 +1,143 @@ +import { type ReactNode, useState, useEffect } from "react"; +import { cn } from "@/lib/utils"; +import { Collapsible } from "@/components/ui/collapsible"; +import { Icon, type IconName } from "@/components/ui/icon"; + +export interface TriggerTitle { + title: string; + subtitle?: string; + args?: string[]; + action?: ReactNode; +} + +interface BasicToolProps { + icon: IconName; + trigger: TriggerTitle | ReactNode; + children?: ReactNode; + status?: "pending" | "running" | "completed" | "error"; + hideDetails?: boolean; + defaultOpen?: boolean; + forceOpen?: boolean; + className?: string; +} + +function isTriggerTitle(val: unknown): val is TriggerTitle { + return ( + typeof val === "object" && + val !== null && + "title" in val && + typeof (val as TriggerTitle).title === "string" + ); +} + +export function BasicTool({ + icon, + trigger, + children, + status = "completed", + hideDetails, + defaultOpen = false, + forceOpen, + className, +}: BasicToolProps) { + const [open, setOpen] = useState(defaultOpen); + + useEffect(() => { + if (forceOpen) { + setOpen(true); + } + }, [forceOpen]); + + const isRunning = status === "running"; + const hasError = status === "error"; + + return ( + + +
+
+
+ {isRunning ? ( + + ) : ( + + )} +
+ +
+ {isTriggerTitle(trigger) ? ( +
+ + {trigger.title} + + {trigger.subtitle && ( + + {trigger.subtitle} + + )} + {trigger.args && trigger.args.length > 0 && ( +
+ {trigger.args.map((arg, i) => ( + + {arg} + + ))} +
+ )} + {trigger.action && ( +
{trigger.action}
+ )} +
+ ) : ( + trigger + )} +
+
+ + {children && !hideDetails && ( + + )} +
+ + + {children && !hideDetails && ( + + {children} + + )} + + ); +} + +export function GenericTool({ + tool, + status, +}: { tool: string; status?: "pending" | "running" | "completed" | "error" }) { + return ( + + ); +} diff --git a/frontend/src/components/activity/ToolRegistry.tsx b/frontend/src/components/activity/ToolRegistry.tsx new file mode 100644 index 0000000..e5fc86e --- /dev/null +++ b/frontend/src/components/activity/ToolRegistry.tsx @@ -0,0 +1,313 @@ +import type { ReactNode } from "react"; +import { BasicTool } from "./BasicTool"; +import { cn } from "@/lib/utils"; + +export interface ToolRenderProps { + tool: string; + input: Record; + output?: string; + error?: string; + status: "pending" | "running" | "completed" | "error"; + metadata?: Record; +} + +type ToolRenderer = (props: ToolRenderProps) => ReactNode; + +const toolRenderers: Record = {}; + +export function registerTool(name: string, renderer: ToolRenderer) { + toolRenderers[name] = renderer; +} + +export function getToolRenderer(name: string): ToolRenderer | undefined { + return toolRenderers[name]; +} + +function getFilename(path: string | undefined): string { + if (!path) return ""; + const parts = path.split("/"); + return parts[parts.length - 1] || path; +} + +function getDirectory(path: string | undefined): string { + if (!path) return ""; + const parts = path.split("/"); + parts.pop(); + return parts.join("/"); +} + +// Tool output wrapper +function ToolOutput({ + children, + scrollable = true, + className, +}: { children: ReactNode; scrollable?: boolean; className?: string }) { + return ( +
+ 
{children}
+
+ ); +} + +// Read tool +registerTool("read", (props) => { + const filePath = props.input.filePath as string | undefined; + const args: string[] = []; + if (props.input.offset) args.push(`offset=${props.input.offset}`); + if (props.input.limit) args.push(`limit=${props.input.limit}`); + + return ( + 0 ? args : undefined, + }} + /> + ); +}); + +// Edit tool +registerTool("edit", (props) => { + const filePath = props.input.filePath as string | undefined; + const directory = getDirectory(filePath); + const filename = getFilename(filePath); + + return ( + + + Edit + + {directory && ( + + {directory}/ + + )} + {filename} +
+ } + > + {props.output && {props.output}} + + ); +}); + +// Write tool +registerTool("write", (props) => { + const filePath = props.input.filePath as string | undefined; + const directory = getDirectory(filePath); + const filename = getFilename(filePath); + + return ( + + + Write + + {directory && ( + + {directory}/ + + )} + {filename} +
+ } + > + {props.output && {props.output}} + + ); +}); + +// Bash/Shell tool +registerTool("bash", (props) => { + const command = (props.input.command as string) || ""; + const description = props.input.description as string | undefined; + + return ( + + + $ + {command} + {props.output && ( + <> + {"\n\n"} + {props.output} + + )} + + + ); +}); + +// Glob tool +registerTool("glob", (props) => { + const pattern = props.input.pattern as string | undefined; + const path = props.input.path as string | undefined; + + return ( + + {props.output && {props.output}} + + ); +}); + +// Grep tool +registerTool("grep", (props) => { + const pattern = props.input.pattern as string | undefined; + const path = props.input.path as string | undefined; + + return ( + + {props.output && {props.output}} + + ); +}); + +// WebFetch tool +registerTool("webfetch", (props) => { + const url = props.input.url as string | undefined; + + return ( + + {props.output && {props.output}} + + ); +}); + +// Task/Agent tool +registerTool("task", (props) => { + const description = props.input.description as string | undefined; + const agentType = props.input.subagent_type as string | undefined; + + return ( + + {props.output && {props.output}} + + ); +}); + +// TodoWrite tool +registerTool("todowrite", (props) => { + const todos = props.input.todos as + | Array<{ content: string; status: string }> + | undefined; + const completed = todos?.filter((t) => t.status === "completed").length || 0; + const total = todos?.length || 0; + + return ( + 0 ? `${completed}/${total}` : undefined, + }} + defaultOpen + > + {todos && todos.length > 0 && ( +
+ {todos.map((todo, i) => ( +
+ + {todo.status === "completed" ? "✓" : "○"} + + + {todo.content} + +
+ ))} +
+ )} + + ); +}); + +// Default/fallback renderer +export function renderTool(props: ToolRenderProps): ReactNode { + const renderer = getToolRenderer(props.tool); + + if (renderer) { + return renderer(props); + } + + // Fallback for unknown tools + return ( + + {props.output && {props.output}} + + ); +} + +// Export all for convenience +export { BasicTool, ToolOutput }; diff --git a/frontend/src/components/app-shell.tsx b/frontend/src/components/app-shell.tsx deleted file mode 100644 index 894e1fc..0000000 --- a/frontend/src/components/app-shell.tsx +++ /dev/null @@ -1,83 +0,0 @@ -"use client"; - -import { useState } from "react"; -import { Sidebar } from "./sidebar"; -import { Header } from "./header"; -import { KanbanView } from "./kanban/kanban-view"; -import { RoadmapView } from "./roadmap/roadmap-view"; -import { SessionsView } from "./sessions/sessions-view"; -import { SettingsView } from "./settings/settings-view"; -import { TaskDetailPanel } from "./task-detail/task-detail-panel"; -import { mockTasks, mockProjects, type Task, type Project } from "~/lib/mock-data"; - -export type View = "kanban" | "roadmap" | "sessions" | "settings"; - -export function AppShell() { - const [activeView, setActiveView] = useState("kanban"); - const [selectedTask, setSelectedTask] = useState(null); - const [tasks, setTasks] = useState(mockTasks); - const [selectedProject, setSelectedProject] = useState(() => mockProjects[0]!); - const [sidebarCollapsed, setSidebarCollapsed] = useState(false); - - const handleTaskSelect = (task: Task) => { - setSelectedTask(task); - }; - - const handleCloseTaskDetail = () => { - setSelectedTask(null); - }; - - const handleTaskStatusChange = (taskId: string, newStatus: Task["status"]) => { - setTasks((prev) => - prev.map((t) => - t.id === taskId ? { ...t, status: newStatus, updatedAt: new Date().toISOString() } : t, - ), - ); - if (selectedTask?.id === taskId) { - setSelectedTask((prev) => (prev ? { ...prev, status: newStatus } : null)); - } - }; - - const handleProjectChange = (project: Project) => { - setSelectedProject(project); - setSelectedTask(null); // Close any open task detail when switching projects - }; - - return ( -
- -
-
-
-
- {activeView === "kanban" && ( - - )} - {activeView === "roadmap" && } - {activeView === "sessions" && } - {activeView === "settings" && } -
- {selectedTask && ( - - )} -
-
-
- ); -} diff --git a/frontend/src/components/dialogs/CreateTaskDialog.tsx b/frontend/src/components/dialogs/CreateTaskDialog.tsx new file mode 100644 index 0000000..3b8dabb --- /dev/null +++ b/frontend/src/components/dialogs/CreateTaskDialog.tsx @@ -0,0 +1,103 @@ +import NiceModal, { useModal } from "@ebay/nice-modal-react"; +import { useQueryClient } from "@tanstack/react-query"; +import { useState } from "react"; +import { getListTasksQueryKey, useCreateTask } from "@/api/generated/tasks/tasks"; +import { Button } from "@/components/ui/button"; +import { + Dialog, + DialogContent, + DialogDescription, + DialogFooter, + DialogHeader, + DialogTitle, +} from "@/components/ui/dialog"; +import { Input } from "@/components/ui/input"; +import { Textarea } from "@/components/ui/textarea"; +import { defineModal } from "@/lib/modals"; + +interface CreateTaskDialogProps { + initialTitle?: string; +} + +const CreateTaskDialogComponent = NiceModal.create(({ initialTitle }) => { + const modal = useModal(); + const queryClient = useQueryClient(); + const [title, setTitle] = useState(initialTitle ?? ""); + const [description, setDescription] = useState(""); + + const createTask = useCreateTask({ + mutation: { + onSuccess: () => { + void queryClient.invalidateQueries({ queryKey: getListTasksQueryKey() }); + modal.resolve(); + void modal.hide(); + }, + }, + }); + + const handleSubmit = (e: React.FormEvent) => { + e.preventDefault(); + if (!title.trim()) { + return; + } + + createTask.mutate({ + data: { + title: title.trim(), + description: description.trim(), + }, + }); + }; + + return ( + !open && modal.hide()}> + + + Create New Task + + Add a new task to your kanban board. It will start in the Todo column. + + + +
+
+ + setTitle(e.target.value)} + placeholder="What needs to be done?" + autoFocus + /> +
+ +
+ +