een-api-toolkit 0.3.16 → 0.3.22

package/docs/AI-CONTEXT.md

@@ -1,303 +1,161 @@
 # EEN API Toolkit - AI Reference
 
-> **Version:** 0.3.16
+> **Version:** 0.3.22
 >
-> This file is optimized for AI assistants. It contains all API signatures,
-> types, and usage patterns in a single, parseable document.
+> This documentation is optimized for AI assistants. It provides focused, domain-specific
+> references to help you understand and use the een-api-toolkit efficiently.
 >
-> For the full EEN API documentation, see the
-> [Eagle Eye Networks Developer Portal](https://developer.eagleeyenetworks.com).
-
-> **Working Examples:** The installed package includes complete Vue 3 example applications
-> at `./node_modules/een-api-toolkit/examples/`. These demonstrate OAuth authentication,
-> user management, camera listing, live/recorded media, video feeds, events, and metrics.
-> For Live Main Video streaming, see `vue-feeds/src/views/Feeds.vue`.
-> For Events API with thumbnails, see `vue-events/src/components/EventsModal.vue`.
-> For Event Metrics with Chart.js visualization, see `vue-alerts-metrics/src/components/MetricsChart.vue`.
+> **Split Documentation:** Load only the documents you need to preserve context.
 
 ---
 
-## Prerequisites & Installation (READ FIRST)
-
-> **⚠️ CRITICAL:** This section contains essential setup requirements.
-> Skipping these steps will cause runtime errors.
-
-### Prerequisites
-
-Before using the een-api-toolkit, ensure you have:
-
-| Requirement | Details |
-|-------------|---------|
-| **Vue 3.x** | The toolkit is built for Vue 3 Composition API |
-| **Pinia** | Required peer dependency for state management |
-| **Vite** | Recommended build tool (dev server must run on `127.0.0.1:3333`) |
-| **OAuth Proxy** | Required for secure token management (see [een-oauth-proxy](https://github.com/klaushofrichter/een-oauth-proxy)) |
-
-### Installation
-
-```bash
-npm install een-api-toolkit pinia
-```
-
-### Complete Setup (main.ts)
-
-> **⚠️ CRITICAL:** Pinia MUST be installed on the Vue app BEFORE calling
-> `initEenToolkit()` or using `useAuthStore()`. Failure to do so will cause
-> a runtime error.
-
-```typescript
-// main.ts - Complete Setup Example
-import { createApp } from 'vue'
-import { createPinia } from 'pinia'
-import { initEenToolkit } from 'een-api-toolkit'
-import App from './App.vue'
-import router from './router'
-
-const app = createApp(App)
-const pinia = createPinia()
-
-// Step 1: Install Pinia FIRST (required)
-app.use(pinia)
-
-// Step 2: Install router if using Vue Router
-app.use(router)
-
-// Step 3: Initialize the toolkit (Pinia must already be installed)
-initEenToolkit({
-  proxyUrl: import.meta.env.VITE_PROXY_URL,      // e.g., 'http://localhost:8787'
-  clientId: import.meta.env.VITE_EEN_CLIENT_ID,  // Your EEN OAuth client ID
-  redirectUri: 'http://127.0.0.1:3333',          // Must be exactly this
-  debug: import.meta.env.VITE_DEBUG === 'true'
-})
-
-// Step 4: Mount the app
-app.mount('#app')
-```
-
-### Environment Variables (.env)
-
-```env
-VITE_PROXY_URL=http://localhost:8787
-VITE_EEN_CLIENT_ID=your-een-client-id
-VITE_DEBUG=true
-```
-
-### Common Errors
-
-#### "getActivePinia() was called but there was no active Pinia"
-
-**Cause:** Pinia was not installed before `initEenToolkit()` was called or before using `useAuthStore()`.
-
-**Solution:** Ensure your `main.ts` calls `app.use(pinia)` BEFORE `initEenToolkit()`:
-
-```typescript
-const app = createApp(App)
-const pinia = createPinia()
-
-app.use(pinia)           // ✅ First - install Pinia
-initEenToolkit({...})    // ✅ Second - initialize toolkit
-app.mount('#app')        // ✅ Last - mount app
-```
-
-#### "Redirect URI mismatch"
-
-**Cause:** OAuth redirect URI doesn't exactly match `http://127.0.0.1:3333`.
-
-**Solution:**
-- Use `127.0.0.1` not `localhost`
-- Use port `3333` exactly
-- No trailing slash (not `http://127.0.0.1:3333/`)
-- No path (not `http://127.0.0.1:3333/callback`)
-- Register this exact URI at [EEN Developer Portal](https://developer.eagleeyenetworks.com/page/my-application)
-
-**Vite config:**
-```typescript
-// vite.config.ts
-server: { host: '127.0.0.1', port: 3333, strictPort: true }
-```
-
-**Router pattern:** Handle OAuth callback on root path, then redirect internally:
-```typescript
-// router/index.ts - root path must catch OAuth params
-{
-  path: '/',
-  beforeEnter: (to, _from, next) => {
-    if (to.query.code && to.query.state) {
-      next({ name: 'callback', query: to.query })
-    } else {
-      next()
-    }
-  }
-}
-```
+## Document Navigation
 
-### Common Pitfalls - Preview Images
+| Task | Document | Tokens |
+|------|----------|--------|
+| Setting up a new Vue 3 app | [AI-SETUP.md](./ai-reference/AI-SETUP.md) | ~2.5K |
+| Implementing OAuth login | [AI-AUTH.md](./ai-reference/AI-AUTH.md) | ~2K |
+| Working with users | [AI-USERS.md](./ai-reference/AI-USERS.md) | ~1.5K |
+| Working with cameras or bridges | [AI-DEVICES.md](./ai-reference/AI-DEVICES.md) | ~3K |
+| Live video, images, HLS playback | [AI-MEDIA.md](./ai-reference/AI-MEDIA.md) | ~4K |
+| Events, alerts, metrics, SSE | [AI-EVENTS.md](./ai-reference/AI-EVENTS.md) | ~3.5K |
 
-Displaying live preview images requires careful attention to authentication. Here are common mistakes:
+## Specialized Agents
 
-#### DON'T: Construct API URLs directly for `<img>` tags
+Specialized agents are available in `.claude/agents/` for domain-specific tasks:
 
-```typescript
-// WRONG - browsers cannot send Authorization headers with <img src>
-const url = `${authStore.baseUrl}/api/v3.0/media/liveImage.jpeg?deviceId=${cameraId}`
-imgElement.src = url  // Results in 401 Unauthorized
-```
+| Agent | Use When |
+|-------|----------|
+| `een-setup-agent` | Creating a new Vue 3 app, fixing Pinia errors, OAuth redirect issues |
+| `een-auth-agent` | Implementing login/logout, auth callbacks, route guards, token refresh |
+| `een-users-agent` | Listing users, user profiles, user management features |
+| `een-devices-agent` | Working with cameras or bridges, filtering by status/tags |
+| `een-media-agent` | Live video, camera previews, HLS playback, recorded images |
+| `een-events-agent` | Events, alerts, metrics, real-time SSE subscriptions |
 
-**Why it fails:** The `<img>` element makes a simple GET request without custom headers. The JWT token cannot be sent, so the request is unauthorized.
+**How to Use Agents:**
 
-#### DON'T: Modify multipartUrl by adding query parameters
+1. **In the toolkit repository:** Agents are automatically discovered in `.claude/agents/`
 
-```typescript
-// WRONG - adding parameters breaks the pre-signed URL
-const feedUrl = feed.multipartUrl
-imgElement.src = `${feedUrl}?timestamp=${Date.now()}`  // Results in 400 Bad Request
-imgElement.src = `${feedUrl}&cache=${Date.now()}`     // Also fails
-```
+2. **In your own project using een-api-toolkit:**
+   ```bash
+   # Install agents to your project (user must run this command)
+   npx een-setup-agents
+   ```
+   This copies agents to `.claude/agents/` where Claude Code discovers them automatically.
 
-**Why it fails:** The `multipartUrl` is a complete, pre-authenticated URL. Any modification (including cache-busting parameters) invalidates it.
+3. **Manual access:** Agents can also be read directly from `node_modules/een-api-toolkit/.claude/agents/`
 
-#### DO: Use `getLiveImage()` for preview thumbnails
+**For AI assistants:**
 
-```typescript
-// CORRECT - returns base64 data URL that works directly in <img src>
-import { getLiveImage } from 'een-api-toolkit'
+> **IMPORTANT:** If specialized agents are not installed in this project's `.claude/agents/` directory,
+> recommend that the user run `npx een-setup-agents` to install them. This enables automatic
+> agent discovery and provides focused, context-efficient assistance for EEN API development.
 
-const { data, error } = await getLiveImage({ deviceId: cameraId })
-if (data?.imageData) {
-  imgElement.src = data.imageData  // "data:image/jpeg;base64,..."
-}
+To use an agent's knowledge without installation, read its definition directly:
 ```
-
-**Why it works:** The toolkit handles authentication internally and returns a base64-encoded data URL that can be used directly without browser restrictions.
-
-### Choosing the Right Preview Method
-
-| Use Case | Method | Notes |
-|----------|--------|-------|
-| Grid of camera thumbnails (20+) | `getLiveImage()` | Best for large grids, handles auth internally |
-| Periodic refresh (e.g., every 3s) | `getLiveImage()` | Call repeatedly in a timer |
-| Camera grid (<20 cameras) | `multipartUrl` | Automatic updates via continuous MJPEG stream. Requires `initMediaSession()` first |
-| One-time snapshot | `getLiveImage()` | Simple and self-contained |
-| Full-quality live video | Live Video SDK | For modal/fullscreen video playback |
-
-**Quick Reference:**
-
-```typescript
-// For thumbnails and grids - USE THIS
-const { data } = await getLiveImage({ deviceId })
-img.src = data.imageData
-
-// For continuous MJPEG stream (grids <20 cameras, auto-updates)
-await initMediaSession()
-const { data: feeds } = await listFeeds({ deviceId, include: ['multipartUrl'] })
-img.src = feeds.results.find(f => f.type === 'preview')?.multipartUrl
-
-// For HD live video - use @een/live-video-web-sdk
-const player = new LivePlayer()
-player.start({ videoElement, cameraId, baseUrl, jwt })
+Read: node_modules/een-api-toolkit/.claude/agents/een-auth-agent.md
 ```
+Then follow the context files and instructions specified within.
 
----
-
-## Quick Reference
-
-### Example Applications
-
-Complete Vue 3 applications demonstrating toolkit features:
+## Example Applications
 
 | Example | Description | Key Files |
 |---------|-------------|-----------|
 | [vue-users](../examples/vue-users/) | User management with pagination | `src/views/Users.vue` |
 | [vue-cameras](../examples/vue-cameras/) | Camera listing with status filters | `src/views/Cameras.vue` |
 | [vue-bridges](../examples/vue-bridges/) | Bridge listing with device info | `src/views/Bridges.vue` |
-| [vue-media](../examples/vue-media/) | Live and recorded image viewing | `src/views/LiveCamera.vue`, `RecordedImage.vue`, `HLS.vue` |
-| [vue-feeds](../examples/vue-feeds/) | Live video streaming (preview and main) | `src/views/Feeds.vue` |
-| [vue-events](../examples/vue-events/) | Events with bounding box overlays | `src/components/EventsModal.vue` |
-| [vue-alerts-metrics](../examples/vue-alerts-metrics/) | Event metrics, alerts, and notifications | `src/components/MetricsChart.vue`, `AlertsList.vue` |
+| [vue-media](../examples/vue-media/) | Live and recorded image viewing | `src/views/LiveCamera.vue` |
+| [vue-feeds](../examples/vue-feeds/) | Live video streaming | `src/views/Feeds.vue` |
+| [vue-events](../examples/vue-events/) | Events with bounding boxes | `src/components/EventsModal.vue` |
+| [vue-alerts-metrics](../examples/vue-alerts-metrics/) | Event metrics and alerts | `src/components/MetricsChart.vue` |
+| [vue-event-subscriptions](../examples/vue-event-subscriptions/) | Real-time SSE streaming | `src/views/LiveEvents.vue` |
 
-### Configuration
+---
 
+## Quick Reference - All Functions
+
+### Configuration
 | Function | Purpose |
 |----------|---------|
 | `initEenToolkit(config)` | Initialize the toolkit with proxy URL and client ID |
 
-### Authentication Functions
-
-| Function | Purpose | Returns |
-|----------|---------|---------|
-| `getAuthUrl()` | Generate OAuth authorization URL | `string` |
-| `handleAuthCallback(code, state)` | Exchange auth code for token | `Result<TokenResponse>` |
-| `refreshToken()` | Refresh the access token | `Result<{accessToken, expiresIn}>` |
-| `revokeToken()` | Revoke token and logout | `Result<void>` |
-
-### User Functions
-
-| Function | Purpose | Returns |
-|----------|---------|---------|
-| `getCurrentUser()` | Get current user profile | `Result<UserProfile>` |
-| `getUsers(params?)` | List all users (paginated) | `Result<PaginatedResult<User>>` |
-| `getUser(userId, params?)` | Get a specific user | `Result<User>` |
-
-### Camera Functions
-
-| Function | Purpose | Returns |
-|----------|---------|---------|
-| `getCameras(params?)` | List all cameras (paginated) | `Result<PaginatedResult<Camera>>` |
-| `getCamera(cameraId, params?)` | Get a specific camera | `Result<Camera>` |
-
-### Bridge Functions
-
-| Function | Purpose | Returns |
-|----------|---------|---------|
-| `getBridges(params?)` | List all bridges (paginated) | `Result<PaginatedResult<Bridge>>` |
-| `getBridge(bridgeId, params?)` | Get a specific bridge | `Result<Bridge>` |
-
-### Media Functions
-
-| Function | Purpose | Returns |
-|----------|---------|---------|
-| `listMedia(params)` | List media intervals for a device | `Result<PaginatedResult<MediaInterval>>` |
-| `listFeeds(params)` | List available feeds for a device | `Result<ListFeedsResult>` |
-| `getLiveImage(params)` | Get live preview image from camera | `Result<LiveImageResult>` |
-| `getRecordedImage(params)` | Get recorded image from history | `Result<RecordedImageResult>` |
-| `getMediaSession()` | Get media session URL for cookies | `Result<MediaSessionResponse>` |
-| `initMediaSession()` | Initialize media session (sets cookie) | `Result<MediaSessionResult>` |
-
-### Events Functions
+### Authentication
+| Function | Purpose |
+|----------|---------|
+| `getAuthUrl()` | Generate OAuth authorization URL |
+| `handleAuthCallback(code, state)` | Exchange auth code for token |
+| `refreshToken()` | Refresh the access token |
+| `revokeToken()` | Revoke token and logout |
 
-| Function | Purpose | Returns |
-|----------|---------|---------|
-| `listEvents(params)` | List events for a device with filters | `Result<PaginatedResult<Event>>` |
-| `getEvent(eventId, params?)` | Get a specific event by ID | `Result<Event>` |
-| `listEventTypes(params?)` | List all available event types | `Result<PaginatedResult<EventType>>` |
-| `listEventFieldValues(params)` | Get available event types for a device | `Result<EventFieldValues>` |
+### Users
+| Function | Purpose |
+|----------|---------|
+| `getCurrentUser()` | Get current user profile |
+| `getUsers(params?)` | List all users (paginated) |
+| `getUser(userId, params?)` | Get a specific user |
 
-### Event Metrics Functions
+### Cameras
+| Function | Purpose |
+|----------|---------|
+| `getCameras(params?)` | List all cameras (paginated) |
+| `getCamera(cameraId, params?)` | Get a specific camera |
 
-| Function | Purpose | Returns |
-|----------|---------|---------|
-| `getEventMetrics(params)` | Get event count metrics over time | `Result<EventMetric[]>` |
+### Bridges
+| Function | Purpose |
+|----------|---------|
+| `getBridges(params?)` | List all bridges (paginated) |
+| `getBridge(bridgeId, params?)` | Get a specific bridge |
 
-### Alerts Functions
+### Media
+| Function | Purpose |
+|----------|---------|
+| `listMedia(params)` | List media intervals for a device |
+| `listFeeds(params)` | List available feeds for a device |
+| `getLiveImage(params)` | Get live preview image from camera |
+| `getRecordedImage(params)` | Get recorded image from history |
+| `getMediaSession()` | Get media session URL for cookies |
+| `initMediaSession()` | Initialize media session (sets cookie) |
+
+### Events
+| Function | Purpose |
+|----------|---------|
+| `listEvents(params)` | List events for a device |
+| `getEvent(eventId, params?)` | Get a specific event |
+| `listEventTypes(params?)` | List all available event types |
+| `listEventFieldValues(params)` | Get event types for a device |
 
-| Function | Purpose | Returns |
-|----------|---------|---------|
-| `listAlerts(params?)` | List alerts with filters | `Result<PaginatedResult<Alert>>` |
-| `getAlert(id, params?)` | Get a specific alert by ID | `Result<Alert>` |
-| `listAlertTypes(params?)` | List all available alert types | `Result<PaginatedResult<AlertType>>` |
+### Event Metrics
+| Function | Purpose |
+|----------|---------|
+| `getEventMetrics(params)` | Get event count metrics over time |
 
-### Notifications Functions
+### Alerts
+| Function | Purpose |
+|----------|---------|
+| `listAlerts(params?)` | List alerts with filters |
+| `getAlert(id, params?)` | Get a specific alert |
+| `listAlertTypes(params?)` | List all available alert types |
 
-| Function | Purpose | Returns |
-|----------|---------|---------|
-| `listNotifications(params?)` | List notifications with filters | `Result<PaginatedResult<Notification>>` |
-| `getNotification(id)` | Get a specific notification by ID | `Result<Notification>` |
+### Notifications
+| Function | Purpose |
+|----------|---------|
+| `listNotifications(params?)` | List notifications |
+| `getNotification(id)` | Get a specific notification |
 
-### Utility Functions
+### Event Subscriptions
+| Function | Purpose |
+|----------|---------|
+| `listEventSubscriptions(params?)` | List all subscriptions |
+| `getEventSubscription(id)` | Get a specific subscription |
+| `createEventSubscription(params)` | Create a new subscription |
+| `deleteEventSubscription(id)` | Delete a subscription |
+| `connectToEventSubscription(sseUrl, options)` | Connect to SSE stream |
 
-| Function | Purpose | Returns |
-|----------|---------|---------|
-| `formatTimestamp(timestamp)` | Convert ISO timestamp from Z to +00:00 format (required by EEN API) | `string` |
+### Utilities
+| Function | Purpose |
+|----------|---------|
+| `formatTimestamp(timestamp)` | Convert Z to +00:00 format |
 
 ---
 
@@ -349,1320 +207,15 @@ interface PaginatedResult<T> {
 }
 ```
 
-### Configuration Type
-
-```typescript
-type StorageStrategy = 'localStorage' | 'sessionStorage' | 'memory'
-
-interface EenToolkitConfig {
-  proxyUrl?: string           // OAuth proxy URL (required for API calls)
-  clientId?: string           // EEN OAuth client ID
-  redirectUri?: string        // OAuth redirect URI (default: http://127.0.0.1:3333)
-  storageStrategy?: StorageStrategy  // Token storage: 'localStorage' (default), 'sessionStorage', or 'memory'
-  debug?: boolean             // Enable debug logging
-}
-```
-
-### Storage Strategy Descriptions
-
-Human-readable descriptions for each storage strategy, useful for displaying in UI components:
-
-```typescript
-import { getStorageStrategy, STORAGE_STRATEGY_DESCRIPTIONS } from 'een-api-toolkit'
-
-// STORAGE_STRATEGY_DESCRIPTIONS is a Record<StorageStrategy, string>:
-// {
-//   localStorage: 'persists across sessions',
-//   sessionStorage: 'per-tab, cleared on tab close',
-//   memory: 'tokens lost on page refresh'
-// }
-
-const strategy = getStorageStrategy()
-const description = STORAGE_STRATEGY_DESCRIPTIONS[strategy]
-console.log(`Using ${strategy}: ${description}`)
-```
-
----
-
-## Entity Types
-
-### User
-
-```typescript
-interface User {
-  id: string
-  email: string
-  firstName: string
-  lastName: string
-  accountId?: string
-  timeZone?: string       // IANA timezone (e.g., "America/Los_Angeles")
-  language?: string       // ISO 639-1 code (e.g., "en")
-  phone?: string
-  mobilePhone?: string
-  permissions?: string[]  // Requires include: ['permissions']
-  lastLogin?: string      // ISO 8601 timestamp
-  isActive?: boolean
-  createdAt?: string
-  updatedAt?: string
-}
-
-interface UserProfile {
-  id: string
-  email: string
-  firstName: string
-  lastName: string
-  accountId?: string
-  timeZone?: string
-  language?: string
-}
-```
-
-### Camera
-
-```typescript
-type CameraStatus =
-  | 'online' | 'offline' | 'deviceOffline' | 'bridgeOffline'
-  | 'invalidCredentials' | 'error' | 'streaming' | 'registered'
-  | 'attaching' | 'initializing'
-
-interface Camera {
-  id: string
-  name: string
-  accountId: string
-  bridgeId?: string | null
-  locationId?: string | null
-  status?: CameraStatus
-  timezone?: string
-  guid?: string
-  ipAddress?: string
-  macAddress?: string
-  tags?: string[]
-  notes?: string
-  multiCameraId?: string
-  recordingModes?: CameraRecordingModes
-  deviceInfo?: CameraDeviceInfo
-  shareDetails?: CameraShareDetails
-  devicePosition?: CameraDevicePosition
-  enabledAnalytics?: string[]
-  packages?: string[]
-  createdAt?: string
-  updatedAt?: string
-}
-
-interface CameraDeviceInfo {
-  make?: string           // Manufacturer (e.g., "Axis", "Hikvision")
-  model?: string          // Model name
-  firmwareVersion?: string
-  directToCloud?: boolean // Direct-to-cloud camera (no bridge)
-  serialNumber?: string
-  resolution?: string
-  type?: string           // Camera type (e.g., "IP", "Analog")
-}
-
-interface CameraShareDetails {
-  shared?: boolean
-  accountId?: string      // Sharing account ID
-  firstResponder?: boolean
-  permissions?: string[]
-}
-
-interface CameraDevicePosition {
-  latitude?: number
-  longitude?: number
-  altitude?: number
-  floor?: number
-  azimuth?: number
-}
-```
-
-### User Parameter Types
-
-```typescript
-interface ListUsersParams {
-  pageSize?: number    // Results per page (default: 100, max: 1000)
-  pageToken?: string   // Pagination token
-  include?: string[]   // Additional fields (e.g., ['permissions'])
-}
-
-interface GetUserParams {
-  include?: string[]   // Additional fields to include
-}
-```
-
-### Camera Parameter Types
-
-```typescript
-interface ListCamerasParams {
-  pageSize?: number           // Results per page
-  pageToken?: string          // Pagination token
-  include?: string[]          // Additional fields to include
-  sort?: string[]             // Sort order
-  status__in?: CameraStatus[] // Filter by status
-  status__ne?: CameraStatus   // Exclude by status
-  tags__contains?: string[]   // Filter by tags (all must match)
-  tags__any?: string[]        // Filter by tags (any match)
-  name?: string               // Exact name match
-  name__contains?: string     // Partial name match
-  name__in?: string[]         // Name in list
-  id__in?: string[]           // ID in list
-  id__notIn?: string[]        // ID not in list
-  bridgeId__in?: string[]     // Bridge ID filter
-  locationId__in?: string[]   // Location ID filter
-  shared?: boolean            // Shared camera filter
-  directToCloud?: boolean     // Direct-to-cloud filter
-  q?: string                  // Full-text search
-  // ... and more filter parameters
-}
-
-interface GetCameraParams {
-  include?: string[]  // Valid values: bridge, account, status, locationSummary,
-                      // deviceAddress, timeZone, notes, tags, devicePosition,
-                      // networkInfo, deviceInfo, effectivePermissions, firmware,
-                      // shareDetails, visibleByBridges, capabilities, analog,
-                      // packages, dewarpConfig, adminCredentials,
-                      // publicSafetySharing, enabledAnalytics
-}
-```
-
-### Bridge
-
-```typescript
-type BridgeStatus =
-  | 'online' | 'offline' | 'error' | 'idle'
-  | 'registered' | 'attaching' | 'initializing'
-
-interface Bridge {
-  id: string
-  name: string
-  accountId: string
-  locationId?: string | null
-  guid?: string
-  timezone?: string
-  status?: BridgeStatus | { connectionStatus?: BridgeStatus }
-  tags?: string[]
-  deviceInfo?: BridgeDeviceInfo
-  networkInfo?: BridgeNetworkInfo
-  devicePosition?: BridgeDevicePosition
-  cameraCount?: number
-  createdAt?: string
-  updatedAt?: string
-}
-
-interface BridgeDeviceInfo {
-  make?: string           // Manufacturer
-  model?: string          // Model name
-  firmwareVersion?: string
-  serialNumber?: string
-  hardwareVersion?: string
-}
-
-interface BridgeNetworkInfo {
-  localIpAddress?: string
-  publicIpAddress?: string
-  macAddress?: string
-  subnetMask?: string
-  gateway?: string
-  dnsServers?: string[]
-}
-
-interface BridgeDevicePosition {
-  latitude?: number
-  longitude?: number
-  altitude?: number
-  floor?: number
-  azimuth?: number
-}
-```
-
-### Bridge Parameter Types
-
-```typescript
-interface ListBridgesParams {
-  pageSize?: number           // Results per page
-  pageToken?: string          // Pagination token
-  include?: string[]          // Additional fields to include
-  sort?: string[]             // Sort order
-  status__in?: BridgeStatus[] // Filter by status
-  status__ne?: BridgeStatus   // Exclude by status
-  tags__contains?: string[]   // Filter by tags (all must match)
-  tags__any?: string[]        // Filter by tags (any match)
-  name?: string               // Exact name match
-  name__contains?: string     // Partial name match
-  name__in?: string[]         // Name in list
-  id__in?: string[]           // ID in list
-  id__notIn?: string[]        // ID not in list
-  locationId__in?: string[]   // Location ID filter
-  q?: string                  // Full-text search
-  qRelevance__gte?: number    // Minimum relevance score
-}
-
-interface GetBridgeParams {
-  include?: string[]  // Valid values: status, deviceInfo, networkInfo,
-                      // devicePosition, tags, effectivePermissions, etc.
-}
-```
-
-### Media Types
-
-```typescript
-type MediaType = 'video' | 'image'
-type MediaStreamType = 'preview' | 'main'
-
-interface MediaInterval {
-  type: MediaStreamType
-  deviceId: string
-  mediaType: MediaType
-  startTimestamp: string  // ISO 8601
-  endTimestamp: string    // ISO 8601
-  flvUrl?: string | null
-  rtspUrl?: string
-  rtspsUrl?: string
-  hlsUrl?: string
-  mp4Url?: string
-  multipartUrl?: string
-  wsLiveUrl?: string
-}
-
-interface ListMediaParams {
-  deviceId: string          // Required - camera ID
-  type: MediaStreamType     // 'preview' or 'main'
-  mediaType: MediaType      // 'video' or 'image'
-  startTimestamp: string    // ISO 8601 start time
-  endTimestamp?: string     // ISO 8601 end time
-  coalesce?: boolean        // Merge adjacent intervals
-  include?: string[]        // e.g., ['flvUrl', 'hlsUrl', 'wsLiveUrl']
-  pageToken?: string
-  pageSize?: number
-}
-
-interface GetLiveImageParams {
-  deviceId: string          // Required - camera ID
-  type?: 'preview'          // Only 'preview' supported for live images
-}
-
-interface LiveImageResult {
-  imageData: string         // Base64 data URL (data:image/jpeg;base64,...)
-  timestamp: string | null  // X-Een-Timestamp header value
-  prevToken: string | null  // X-Een-PrevToken for navigation
-}
-
-interface GetRecordedImageParams {
-  deviceId?: string         // Camera ID (optional if using pageToken)
-  pageToken?: string        // Token for specific image
-  type?: MediaStreamType    // 'preview' or 'main'
-  timestamp__lt?: string    // Before timestamp
-  timestamp__lte?: string   // At or before timestamp
-  timestamp?: string        // Exact timestamp
-  timestamp__gte?: string   // At or after timestamp
-  timestamp__gt?: string    // After timestamp
-  overlayId__in?: string[]  // Overlay filter
-  include?: string[]        // e.g., ['overlayEmbedded', 'overlaySvgHeader']
-  targetWidth?: number      // Resize width
-  targetHeight?: number     // Resize height
-}
-
-interface RecordedImageResult {
-  imageData: string         // Base64 data URL
-  timestamp: string | null  // X-Een-Timestamp header value
-  nextToken: string | null  // X-Een-NextToken for next image
-  prevToken: string | null  // X-Een-PrevToken for previous image
-  overlaySvg: string | null // X-Een-OverlaySvg for overlays
-}
-
-// Media Session types - for setting up cookie-based media access
-interface MediaSessionResponse {
-  url: string               // URL to call to set the session cookie
-}
-
-interface MediaSessionResult {
-  success: boolean          // Whether cookie was set successfully
-  sessionUrl: string        // The URL that was called
-}
-```
-
-### Feed Types
-
-```typescript
-type FeedStreamType = 'main' | 'preview' | 'talkdown'
-type FeedMediaType = 'video' | 'audio' | 'image' | 'halfDuplex' | 'fullDuplex'
-type FeedIncludeOption = 'flvUrl' | 'rtspUrl' | 'rtspsUrl' | 'localRtspUrl' | 'hlsUrl' | 'multipartUrl' | 'webRtcUrl' | 'audioPushHttpsUrl'
-
-interface Feed {
-  id: string                    // Feed identifier (typically deviceId-type)
-  type: FeedStreamType          // Stream type
-  deviceId: string              // Device generating this feed
-  mediaType: FeedMediaType      // Media type
-  flvUrl?: string | null        // Flash Video URL (if requested)
-  rtspUrl?: string | null       // RTSP URL (if requested)
-  rtspsUrl?: string | null      // RTSP over TLS (if requested)
-  localRtspUrl?: string | null  // Local RTSP to bridge (if requested)
-  hlsUrl?: string | null        // HLS URL (if requested)
-  multipartUrl?: string | null  // Multipart URL for raw frames (if requested)
-  webRtcUrl?: string | null     // WebRTC URL (if requested)
-  audioPushHttpsUrl?: string | null  // Audio push for speakers (if requested)
-}
-
-interface ListFeedsParams {
-  deviceId?: string             // Filter by single device ID
-  deviceId__in?: string[]       // Filter by multiple device IDs
-  type?: FeedStreamType         // Filter by stream type
-  include?: FeedIncludeOption[] // URL fields to include in response
-  pageSize?: number
-  pageToken?: string
-}
-
-interface ListFeedsResult {
-  results: Feed[]
-  nextPageToken?: string
-  totalSize?: number
-}
-```
-
-### Event Types
-
-```typescript
-type ActorType = 'bridge' | 'camera' | 'speaker' | 'account' | 'user' | 'layout' | 'job' | 'measurement' | 'sensor' | 'gateway'
-
-interface Event {
-  id: string
-  startTimestamp: string       // ISO 8601
-  endTimestamp?: string | null
-  span: boolean
-  accountId: string
-  actorId: string
-  actorAccountId: string
-  actorType: ActorType
-  creatorId: string
-  type: string                 // e.g., 'een.motionDetectionEvent.v1'
-  dataSchemas: string[]
-  data: EventData[]
-}
-
-interface EventData {
-  type: string
-  creatorId: string
-  [key: string]: unknown       // Event data is polymorphic
-}
-
-interface EventType {
-  type: string                 // e.g., 'een.motionDetectionEvent.v1'
-  name: string                 // Human-readable name
-  description: string
-}
-
-interface EventFieldValues {
-  type: string[]               // Available event types for the actor
-}
-
-interface ListEventsParams {
-  actor: string                     // Required: 'camera:{id}' format
-  type__in: string[]                // Required: event types to fetch
-  startTimestamp__gte: string       // Required: ISO 8601 timestamp
-  endTimestamp__lte?: string        // Optional: filter by end time
-  pageSize?: number
-  pageToken?: string
-  sort?: '+startTimestamp' | '-startTimestamp'
-  include?: string[]                // e.g., ['data.een.fullFrameImageUrl.v1']
-}
-
-interface ListEventFieldValuesParams {
-  actor: string                     // Required: 'camera:{id}' format
-}
-```
-
-### Event Metrics Types
-
-```typescript
-type MetricActorType = 'bridge' | 'camera' | 'speaker' | 'account' | 'user' | 'layout' | 'job'
-
-// Data point: [timestamp_ms, value]
-type MetricDataPoint = [number, number]
-
-interface EventMetric {
-  eventType: string
-  actorId: string
-  actorType: MetricActorType
-  target: string                 // e.g., 'count'
-  dataPoints: MetricDataPoint[]
-  [key: string]: unknown         // Additional properties
-}
-
-interface GetEventMetricsParams {
-  actor: string                  // Required: 'camera:{id}' format
-  eventType: string              // Required: e.g., 'een.motionDetectionEvent.v1'
-  timestamp__gte?: string        // Optional: defaults to 7 days ago
-  timestamp__lte?: string        // Optional: defaults to now
-  aggregateByMinutes?: number    // Optional: default 60, minimum 60
-}
-```
-
-### Alert Types
-
-```typescript
-interface AlertAction {
-  name: string
-  type: string
-  success: boolean
-  timestamp: string
-  status?: 'fired' | 'success' | 'partialSuccess' | 'silenced' | 'failed' | 'internalError'
-}
-
-interface Alert {
-  id: string
-  timestamp: string
-  createTimestamp: string
-  creatorId: string
-  alertType: string
-  alertName?: string
-  category?: string
-  serviceRuleId?: string
-  eventType?: string
-  actorId: string
-  actorType: string
-  actorAccountId: string
-  actorName?: string
-  ruleId?: string
-  eventId?: string
-  locationId?: string
-  locationName?: string
-  priority?: number              // 0-20
-  dataSchemas?: string[]
-  data?: Record<string, unknown>
-  actions?: Record<string, AlertAction>
-  description?: string
-}
-
-interface AlertType {
-  type: string
-  description: string
-}
-
-type AlertInclude = 'data' | 'actions' | 'dataSchemas' | 'description'
-type AlertSort = '+timestamp' | '-timestamp'
-type AlertActionStatus = 'fired' | 'success' | 'partialSuccess' | 'silenced' | 'failed' | 'internalError'
-
-interface ListAlertsParams {
-  pageSize?: number
-  pageToken?: string
-  timestamp__lte?: string
-  timestamp__gte?: string
-  creatorId?: string
-  alertType__in?: string[]
-  actorId__in?: string[]
-  actorType__in?: string[]
-  actorAccountId?: string
-  ruleId?: string
-  ruleId__in?: string[]
-  eventId?: string
-  locationId__in?: string[]
-  priority__gte?: number
-  priority__lte?: number
-  showInvalidAlerts?: boolean
-  alertActionId__in?: string[]
-  alertActionStatus__in?: AlertActionStatus[]
-  include?: AlertInclude[]
-  sort?: AlertSort[]
-  language?: string
-}
-
-interface GetAlertParams {
-  include?: AlertInclude[]
-}
-
-interface ListAlertTypesParams {
-  pageSize?: number
-  pageToken?: string
-}
-```
-
-### Notification Types
-
-```typescript
-type NotificationCategory = 'health' | 'video' | 'operational' | 'audit' | 'job' | 'security' | 'sharing'
-
-type NotificationStatus =
-  | 'pending' | 'bounced' | 'dropped' | 'deferred' | 'delivered' | 'sent'
-  | 'outsideUsersSchedule' | 'notificationsDisabled' | 'noNotificationActions'
-  | 'sendingFailed' | 'throttled' | 'unableToGetSettings'
-
-interface Notification {
-  id: string
-  timestamp: string
-  createTimestamp: string
-  sentTimestamp?: string
-  alertId?: string | null
-  alertType?: string
-  actorId: string
-  actorName?: string
-  actorType: string
-  actorAccountId: string
-  userId: string
-  accountId: string
-  read: boolean
-  status: NotificationStatus
-  category: NotificationCategory
-  description?: string
-  notificationActions: string[]
-  dataSchemas: string[]
-  data: Record<string, unknown>
-}
-
-interface ListNotificationsParams {
-  pageSize?: number
-  pageToken?: string
-  timestamp__lte?: string
-  timestamp__gte?: string
-  alertId?: string
-  alertType?: string
-  actorId?: string
-  actorType?: string
-  actorAccountId?: string
-  category?: NotificationCategory
-  userId?: string
-  read?: boolean
-  status?: NotificationStatus
-  includeV1Notifications?: boolean
-  sort?: ('+timestamp' | '-timestamp')[]
-  language?: string
-}
-```
-
 ---
 
-## API Reference
-
-### initEenToolkit
 
-Initialize the toolkit. Call this before using any API functions.
-
-```typescript
-import { initEenToolkit } from 'een-api-toolkit'
-
-// In main.ts
-initEenToolkit({
-  proxyUrl: import.meta.env.VITE_PROXY_URL,
-  clientId: import.meta.env.VITE_EEN_CLIENT_ID,
-  debug: true // optional
-})
-```
-
-### getAuthUrl
-
-Generate the OAuth authorization URL. Redirect the user here to start login.
-
-```typescript
-import { getAuthUrl } from 'een-api-toolkit'
-
-function login() {
-  window.location.href = getAuthUrl()
-}
-```
-
-### handleAuthCallback
-
-Handle the OAuth callback after user authorizes. Call this when user returns to your redirect URI.
-
-```typescript
-import { handleAuthCallback } from 'een-api-toolkit'
-
-// In your callback route handler
-const url = new URL(window.location.href)
-const code = url.searchParams.get('code')
-const state = url.searchParams.get('state')
-
-if (code && state) {
-  const { data, error } = await handleAuthCallback(code, state)
-
-  if (error) {
-    console.error('Auth failed:', error.message)
-    return
-  }
-
-  // User is now authenticated
-  router.push('/dashboard')
-}
-```
-
-### getCurrentUser
-
-Get the current authenticated user's profile.
-
-```typescript
-import { getCurrentUser } from 'een-api-toolkit'
-
-const { data, error } = await getCurrentUser()
-
-if (error) {
-  if (error.code === 'AUTH_REQUIRED') {
-    router.push('/login')
-  }
-  return
-}
-
-console.log(`Welcome, ${data.firstName} ${data.lastName}`)
-```
-
-### getUsers
-
-List users with optional pagination.
-
-```typescript
-import { getUsers } from 'een-api-toolkit'
-
-// Basic usage
-const { data, error } = await getUsers()
-
-// With pagination
-const { data } = await getUsers({ pageSize: 50 })
-
-// Fetch all users
-let allUsers: User[] = []
-let pageToken: string | undefined
-
-do {
-  const { data, error } = await getUsers({ pageSize: 100, pageToken })
-  if (error) break
-  allUsers.push(...data.results)
-  pageToken = data.nextPageToken
-} while (pageToken)
-```
-
-### getUser
-
-Get a specific user by ID.
-
-```typescript
-import { getUser } from 'een-api-toolkit'
-
-const { data, error } = await getUser('user-id-123')
-
-if (error) {
-  if (error.code === 'NOT_FOUND') {
-    console.log('User not found')
-  }
-  return
-}
-
-// With permissions
-const { data: userWithPerms } = await getUser('user-id-123', {
-  include: ['permissions']
-})
-```
-
-### getCameras
-
-List cameras with optional pagination and filtering.
-
-```typescript
-import { getCameras } from 'een-api-toolkit'
-
-// Basic usage
-const { data, error } = await getCameras()
-
-// With pagination
-const { data } = await getCameras({ pageSize: 50 })
-
-// With status filter
-const { data } = await getCameras({
-  pageSize: 20,
-  status__in: ['online', 'streaming']
-})
-
-// With search
-const { data } = await getCameras({
-  q: 'front door',
-  include: ['deviceInfo', 'status']
-})
-```
-
-### getCamera
-
-Get a specific camera by ID.
-
-```typescript
-import { getCamera } from 'een-api-toolkit'
-
-const { data, error } = await getCamera('camera-id-123')
-
-if (error) {
-  if (error.code === 'NOT_FOUND') {
-    console.log('Camera not found')
-  }
-  return
-}
-
-// With additional fields
-const { data: cameraWithDetails } = await getCamera('camera-id-123', {
-  include: ['deviceInfo', 'status', 'shareDetails']
-})
-```
-
-### getBridges
-
-List bridges with optional pagination and filtering.
-
-```typescript
-import { getBridges } from 'een-api-toolkit'
-
-// Basic usage
-const { data, error } = await getBridges()
-
-// With pagination
-const { data } = await getBridges({ pageSize: 50 })
-
-// With status filter
-const { data } = await getBridges({
-  pageSize: 20,
-  status__in: ['online']
-})
-
-// With search
-const { data } = await getBridges({
-  q: 'office',
-  include: ['deviceInfo', 'status', 'networkInfo']
-})
-```
-
-### getBridge
-
-Get a specific bridge by ID.
-
-```typescript
-import { getBridge } from 'een-api-toolkit'
-
-const { data, error } = await getBridge('bridge-id-123')
-
-if (error) {
-  if (error.code === 'NOT_FOUND') {
-    console.log('Bridge not found')
-  }
-  return
-}
-
-// With additional fields
-const { data: bridgeWithDetails } = await getBridge('bridge-id-123', {
-  include: ['deviceInfo', 'networkInfo', 'status']
-})
-```
-
-### listMedia
-
-List media intervals for a camera. Useful for finding when recordings exist.
-
-```typescript
-import { listMedia } from 'een-api-toolkit'
-
-const { data, error } = await listMedia({
-  deviceId: 'camera-id-123',
-  type: 'preview',
-  mediaType: 'video',
-  startTimestamp: '2024-01-01T00:00:00.000Z',
-  endTimestamp: '2024-01-02T00:00:00.000Z'
-})
-
-if (error) {
-  console.error('Failed to list media:', error.message)
-  return
-}
-
-// Get available recording intervals
-for (const interval of data.results) {
-  console.log(`Recording: ${interval.startTimestamp} - ${interval.endTimestamp}`)
-}
-```
-
-### getLiveImage
-
-Get a live preview image from a camera. Returns base64-encoded image data.
-
-```typescript
-import { getLiveImage } from 'een-api-toolkit'
-
-const { data, error } = await getLiveImage({
-  deviceId: 'camera-id-123'
-})
-
-if (error) {
-  console.error('Failed to get live image:', error.message)
-  return
-}
-
-// Use in an <img> element
-const imgElement = document.querySelector('img')
-imgElement.src = data.imageData  // data:image/jpeg;base64,...
-
-// Timestamp of the image
-console.log('Image timestamp:', data.timestamp)
-```
-
-### getRecordedImage
-
-Get a recorded image from camera history. Supports timestamp-based navigation.
-
-```typescript
-import { getRecordedImage } from 'een-api-toolkit'
-
-// Get image at specific timestamp
-const { data, error } = await getRecordedImage({
-  deviceId: 'camera-id-123',
-  timestamp: '2024-01-15T14:30:00.000Z'
-})
-
-if (error) {
-  console.error('Failed to get recorded image:', error.message)
-  return
-}
-
-// Display the image
-const imgElement = document.querySelector('img')
-if (imgElement) {
-  imgElement.src = data.imageData
-}
-
-// Navigate to next/previous image
-if (data.nextToken) {
-  const { data: nextImage } = await getRecordedImage({
-    pageToken: data.nextToken
-  })
-  // Use nextImage...
-}
-```
-
-### initMediaSession
-
-Initialize media session for cookie-based authentication. Required before using
-multipart URLs directly in HTML elements.
-
-```typescript
-import { initMediaSession, listFeeds } from 'een-api-toolkit'
-
-// Initialize the media session (do this once after login)
-const { data, error } = await initMediaSession()
-
-if (error) {
-  console.error('Failed to init media session:', error.message)
-  return
-}
-
-console.log('Media session initialized:', data.sessionUrl)
-
-// Now multipart URLs can be used directly in <img> elements
-const { data: feeds } = await listFeeds({
-  deviceId: 'camera-123',
-  include: ['multipartUrl']
-})
-
-if (feeds?.results[0]?.multipartUrl) {
-  // This works because the session cookie is set
-  const imgElement = document.querySelector('img')
-  imgElement.src = feeds.results[0].multipartUrl
-}
-```
-
-### getMediaSession
-
-Get the media session URL without setting the cookie. Use `initMediaSession()`
-for most cases.
-
-```typescript
-import { getMediaSession } from 'een-api-toolkit'
-
-// Get the session URL (step 1 of 2)
-const { data, error } = await getMediaSession()
-
-if (error) {
-  console.error('Failed to get media session:', error.message)
-  return
-}
-
-console.log('Session URL:', data.url)
-// Manually call data.url with credentials: 'include' to set the cookie
-```
-
----
-
-## Utilities
-
-### formatTimestamp
-
-Converts ISO 8601 timestamps from `Z` (Zulu/UTC) format to `+00:00` format, as required by the EEN API.
-
-**Why this is needed:** JavaScript's `Date.toISOString()` returns timestamps with a `Z` suffix (e.g., `2025-01-15T22:30:00.000Z`), but the EEN API requires the `+00:00` format (e.g., `2025-01-15T22:30:00.000+00:00`).
-
-```typescript
-import { formatTimestamp } from 'een-api-toolkit'
-
-// Convert Z format to +00:00 format
-formatTimestamp('2025-01-15T22:30:00.000Z')
-// Returns: '2025-01-15T22:30:00.000+00:00'
-
-// Already in +00:00 format - returns unchanged
-formatTimestamp('2025-01-15T22:30:00.000+00:00')
-// Returns: '2025-01-15T22:30:00.000+00:00'
-
-// Common usage with Date objects
-const now = new Date()
-const apiTimestamp = formatTimestamp(now.toISOString())
-// Returns timestamp in EEN API format
-```
-
-**When to use:**
-- When displaying timestamps that match the exact format used in API calls (e.g., for debugging)
-- When making direct API calls outside of the toolkit
-- When building custom timestamp display components
-
-**Note:** The toolkit's API functions (`listAlerts`, `getEventMetrics`, `listNotifications`, `listEvents`, etc.) automatically apply `formatTimestamp` internally, so you don't need to pre-format timestamps when using these functions.
-
----
-
-## Live Video Streaming
-
-The EEN API Toolkit supports two methods for displaying live video from cameras:
-
-### Stream Types Comparison
-
-| Feature | Preview Stream | Main Stream |
-|---------|---------------|-------------|
-| Quality | Lower resolution | Full resolution |
-| Authentication | Session cookie (multipart URL) | JWT token (Live SDK) |
-| Element Type | `<img>` element | `<video>` element |
-| Technology | MJPEG multipart | WebCodecs via SDK |
-| Browser Support | All modern browsers | Chrome 94+, Edge 94+, Opera 80+ (WebCodecs) |
-| Use Case | Thumbnails, quick previews | Full video playback |
-| Setup | `initMediaSession()` | `@een/live-video-web-sdk` |
-
-### Preview Streams (Multipart URL)
-
-Preview streams use cookie-based authentication with multipart URLs. These are ideal
-for thumbnails and quick previews using simple `<img>` elements.
-
-**Step 1: Initialize the media session (once after login)**
-
-```typescript
-import { initMediaSession } from 'een-api-toolkit'
-
-// Call once after authentication
-const { data, error } = await initMediaSession()
-if (error) {
-  console.error('Failed to init media session:', error.message)
-  return
-}
-// Session cookie is now set
-```
-
-**Step 2: Get the feed URL and display it**
-
-```typescript
-import { listFeeds } from 'een-api-toolkit'
-
-const { data: feeds } = await listFeeds({
-  deviceId: cameraId,
-  type: 'preview',
-  include: ['multipartUrl']
-})
-
-// Find a feed with multipartUrl
-const previewFeed = feeds?.results.find(f => f.multipartUrl)
-if (previewFeed?.multipartUrl) {
-  // Can be used directly in an <img> element
-  imgElement.src = previewFeed.multipartUrl
-}
-```
-
-**Complete Vue Example (Preview Stream):**
-
-```vue
-<script setup lang="ts">
-import { ref, onMounted } from 'vue'
-import { initMediaSession, listFeeds, type Feed } from 'een-api-toolkit'
-
-const props = defineProps<{ cameraId: string }>()
-const previewUrl = ref<string | null>(null)
-const loading = ref(true)
-
-onMounted(async () => {
-  // Initialize media session for cookie-based auth
-  const { error: sessionError } = await initMediaSession()
-  if (sessionError) {
-    console.error('Failed to init session:', sessionError.message)
-    loading.value = false
-    return
-  }
-
-  // Get preview feed
-  const { data, error } = await listFeeds({
-    deviceId: props.cameraId,
-    type: 'preview',
-    include: ['multipartUrl']
-  })
-
-  if (error) {
-    console.error('Failed to get feeds:', error.message)
-    loading.value = false
-    return
-  }
-
-  const feed = data.results.find(f => f.multipartUrl)
-  previewUrl.value = feed?.multipartUrl ?? null
-  loading.value = false
-})
-</script>
-
-<template>
-  <div class="preview-container">
-    <div v-if="loading">Loading...</div>
-    <img v-else-if="previewUrl" :src="previewUrl" alt="Camera preview" />
-    <div v-else>No preview available</div>
-  </div>
-</template>
-```
-
-### Main Streams (Live Video SDK)
-
-Main streams provide full-resolution video using the `@een/live-video-web-sdk`.
-This requires JWT authentication and uses WebCodecs for efficient video playback.
-
-**Installation:**
-
-```bash
-npm install @een/live-video-web-sdk
-```
-
-**Complete Vue Example (Main Stream):**
-
-```vue
-<script setup lang="ts">
-import { ref, onMounted, onUnmounted, nextTick } from 'vue'
-import { LivePlayer } from '@een/live-video-web-sdk'
-import { useAuthStore, listFeeds, type Feed } from 'een-api-toolkit'
-
-const props = defineProps<{ cameraId: string }>()
-const authStore = useAuthStore()
-const videoElement = ref<HTMLVideoElement | null>(null)
-const loading = ref(true)
-const statusMessage = ref('')
-
-let livePlayer: LivePlayer | null = null
-
-async function initPlayer() {
-  // Get the main feed to verify it exists
-  const { data, error } = await listFeeds({
-    deviceId: props.cameraId,
-    type: 'main',
-    include: ['multipartUrl']
-  })
-
-  if (error || !data.results.length) {
-    statusMessage.value = 'No main feed available'
-    loading.value = false
-    return
-  }
-
-  // Wait for video element to be mounted
-  await nextTick()
-  if (!videoElement.value) return
-
-  // Ensure auth is valid
-  if (!authStore.baseUrl || !authStore.token) {
-    statusMessage.value = 'Not authenticated'
-    loading.value = false
-    return
-  }
-
-  // Initialize the Live SDK player
-  livePlayer = new LivePlayer()
-
-  // Subscribe to status updates
-  livePlayer.onStatusChange((status) => {
-    statusMessage.value = status
-    if (status === 'playing') {
-      loading.value = false
-    }
-  })
-
-  // Start playback
-  await livePlayer.start({
-    videoElement: videoElement.value,
-    cameraId: props.cameraId,
-    baseUrl: authStore.baseUrl,
-    jwt: authStore.token
-  })
-}
-
-function handleVideoError(event: Event) {
-  const video = event.target as HTMLVideoElement
-  console.error('Video error:', video.error?.message)
-  statusMessage.value = 'Playback error'
-  loading.value = false
-}
-
-function cleanup() {
-  if (livePlayer) {
-    livePlayer.stop()
-    livePlayer = null
-  }
-}
-
-onMounted(() => {
-  initPlayer()
-})
-
-onUnmounted(() => {
-  cleanup()
-})
-</script>
-
-<template>
-  <div class="video-container">
-    <div v-if="loading" class="loading-overlay">
-      <span>{{ statusMessage || 'Connecting...' }}</span>
-    </div>
-    <video
-      ref="videoElement"
-      autoplay
-      muted
-      playsinline
-      @error="handleVideoError"
-    />
-    <div v-if="statusMessage && !loading" class="status">{{ statusMessage }}</div>
-  </div>
-</template>
-
-<style scoped>
-.video-container {
-  position: relative;
-  background: #000;
-}
-video {
-  width: 100%;
-  height: auto;
-}
-.loading-overlay {
-  position: absolute;
-  inset: 0;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  background: rgba(0, 0, 0, 0.7);
-  color: white;
-}
-</style>
-```
-
-### Choosing Between Preview and Main Streams
-
-- **Preview streams** are simpler to implement and work well for:
-  - Camera selection grids
-  - Thumbnail previews
-  - Lower bandwidth scenarios
-  - Simple `<img>` element integration
-
-- **Main streams** are better for:
-  - Full-screen video viewing
-  - High-quality playback
-  - Professional monitoring applications
-  - Integration with video controls
-
----
-
-## HLS Video Playback Troubleshooting
-
-For detailed troubleshooting, see the [HLS Video Troubleshooting Guide](./guides/HLS-VIDEO-TROUBLESHOOTING.md).
-
-### Overview
-
-HLS video playback from the EEN API requires:
-
-1. **Initialize media session** - `initMediaSession()`
-2. **Find recording intervals** - `listMedia()` with `include: ['hlsUrl']`
-3. **Extract HLS URL** - From interval containing target timestamp
-4. **Configure HLS.js with auth** - Bearer token in Authorization header
-
-### Key Requirements
-
-| Requirement | Details |
-|-------------|---------|
-| Feed Type | HLS only available for `main` feeds, not `preview` |
-| Timestamp Format | Use `formatTimestamp()` to convert `Z` to `+00:00` |
-| Authentication | HLS.js requires `xhr.setRequestHeader('Authorization', `Bearer ${token}`)` |
-| Recording Coverage | Target timestamp must fall within a recording interval |
-
-### Common Issues
-
-#### 401 Unauthorized
-
-**Cause:** Using `withCredentials: true` instead of Authorization header.
-
-```typescript
-// WRONG
-const hls = new Hls({
-  xhrSetup: (xhr) => { xhr.withCredentials = true }
-})
-
-// CORRECT
-import { useAuthStore } from 'een-api-toolkit'
-const authStore = useAuthStore()
-
-const hls = new Hls({
-  xhrSetup: (xhr) => {
-    xhr.setRequestHeader('Authorization', `Bearer ${authStore.token}`)
-  }
-})
-```
-
-#### No Video Available for Timestamp
-
-**Cause:** Search range too narrow or using wrong feed type.
-
-```typescript
-import { listMedia, formatTimestamp } from 'een-api-toolkit'
-
-const targetTime = new Date(alertTimestamp)
-const searchStart = new Date(targetTime.getTime() - 60 * 60 * 1000) // 1 hour before
-const searchEnd = new Date(targetTime.getTime() + 60 * 60 * 1000)   // 1 hour after
-
-const result = await listMedia({
-  deviceId: cameraId,
-  type: 'main',              // MUST be 'main' for HLS
-  mediaType: 'video',
-  startTimestamp: formatTimestamp(searchStart.toISOString()),
-  endTimestamp: formatTimestamp(searchEnd.toISOString()),
-  include: ['hlsUrl']        // MUST include 'hlsUrl'
-})
-
-// Find interval containing target timestamp
-const intervals = result.data?.results ?? []
-const targetTimeMs = targetTime.getTime()
-
-const matchingInterval = intervals.find(i => {
-  if (!i.hlsUrl) return false
-  const start = new Date(i.startTimestamp).getTime()
-  const end = new Date(i.endTimestamp).getTime()
-  return targetTimeMs >= start && targetTimeMs <= end
-})
-```
-
-#### Timestamp Format Error
-
-**Cause:** Using `Z` suffix instead of `+00:00`.
-
-```typescript
-// WRONG
-const timestamp = new Date().toISOString()  // "2025-01-15T22:30:00.000Z"
-
-// CORRECT
-import { formatTimestamp } from 'een-api-toolkit'
-const timestamp = formatTimestamp(new Date().toISOString())  // "2025-01-15T22:30:00.000+00:00"
-```
-
----
 
 ## Common Patterns
 
 ### Error Handling
 
 ```typescript
-// All functions return Result<T>, never throw
 const { data, error } = await getUsers()
 
 if (error) {
@@ -1670,12 +223,9 @@ if (error) {
     case 'AUTH_REQUIRED':
       router.push('/login')
       break
-    case 'NETWORK_ERROR':
-      showRetryDialog()
+    case 'NOT_FOUND':
+      showNotFound()
       break
-    case 'RATE_LIMITED':
-      await sleep(1000)
-      return retry()
     default:
       showError(error.message)
   }
@@ -1689,75 +239,23 @@ processUsers(data.results)
 ### Pagination
 
 ```typescript
-// Manual pagination - fetch all
-async function fetchAllUsers(): Promise<User[]> {
-  const allUsers: User[] = []
+async function fetchAll<T>(
+  fetcher: (params: { pageToken?: string }) => Promise<Result<PaginatedResult<T>>>
+): Promise<T[]> {
+  const all: T[] = []
   let pageToken: string | undefined
 
   do {
-    const { data, error } = await getUsers({ pageSize: 100, pageToken })
-    if (error) break // Stop on error, return what we have
-    allUsers.push(...data.results)
+    const { data, error } = await fetcher({ pageToken })
+    if (error) break
+    all.push(...data.results)
     pageToken = data.nextPageToken
   } while (pageToken)
 
-  return allUsers
+  return all
 }
 ```
 
-### Auth Guard (Vue Router)
-
-```typescript
-import { useAuthStore } from 'een-api-toolkit'
-
-router.beforeEach((to, from, next) => {
-  const authStore = useAuthStore()
-
-  if (to.meta.requiresAuth && !authStore.isAuthenticated) {
-    next('/login')
-  } else {
-    next()
-  }
-})
-```
-
-### Vue Component Example
-
-```vue
-<script setup lang="ts">
-import { ref, onMounted } from 'vue'
-import { getCurrentUser, type UserProfile, type EenError } from 'een-api-toolkit'
-
-const user = ref<UserProfile | null>(null)
-const loading = ref(false)
-const error = ref<EenError | null>(null)
-
-async function fetchUser() {
-  loading.value = true
-  const result = await getCurrentUser()
-  loading.value = false
-
-  if (result.error) {
-    error.value = result.error
-    return
-  }
-
-  user.value = result.data
-}
-
-onMounted(() => {
-  fetchUser()
-})
-</script>
-
-<template>
-  <div v-if="loading">Loading...</div>
-  <div v-else-if="error">{{ error.message }}</div>
-  <div v-else-if="user">Welcome, {{ user.firstName }}!</div>
-  <div v-else>Not authenticated or user data not available.</div>
-</template>
-```
-
 ---
 
 ## Anti-Patterns (What NOT to Do)
@@ -1787,7 +285,7 @@ data.results.forEach(...) // TypeError if error occurred!
 // CORRECT
 const { data, error } = await getUsers()
 if (error) return
-data.results.forEach(...) // Safe - TypeScript knows data is not null
+data.results.forEach(...) // Safe
 ```
 
 ### DON'T: Call initEenToolkit multiple times
@@ -1801,28 +299,10 @@ export default {
 }
 
 // CORRECT - call once in main.ts
-// main.ts
 initEenToolkit({ ... })
 app.mount('#app')
 ```
 
-### DON'T: Access data before checking error
-
-```typescript
-// WRONG - unsafe access
-const { data, error } = await getUser(id)
-console.log(data.email) // TypeError if error!
-if (error) { ... }
-
-// CORRECT - check error first
-const { data, error } = await getUser(id)
-if (error) {
-  console.error(error.message)
-  return
-}
-console.log(data.email) // Safe
-```
-
 ---
 
 ## External Resources
@@ -1830,4 +310,4 @@ console.log(data.email) // Safe
 - [Eagle Eye Networks Developer Portal](https://developer.eagleeyenetworks.com)
 - [EEN API v3.0 Reference](https://developer.eagleeyenetworks.com/reference/using-the-api)
 - [GitHub Repository](https://github.com/klaushofrichter/een-api-toolkit)
-- [OAuth Proxy](https://github.com/klaushofrichter/een-oauth-proxy) - Required for secure token management
+- [OAuth Proxy](https://github.com/klaushofrichter/een-oauth-proxy)