http-request-manager 18.15.32 → 18.15.34

package/src/docs/COMPLETE_API_REFERENCE.md

@@ -0,0 +1,1037 @@
+# HTTP Request Manager - Complete API Reference
+
+A comprehensive guide to all services, methods, and features available in the HTTP Request Manager library.
+
+## Table of Contents
+
+1. [HTTP Services](#http-services)
+2. [State Management Services](#state-management-services)
+3. [WebSocket Services](#websocket-services)
+4. [Storage Services](#storage-services)
+5. [Database Services](#database-services)
+6. [Utility Services](#utility-services)
+7. [Interceptors](#interceptors)
+8. [Models & Configuration](#models--configuration)
+
+---
+
+## HTTP Services
+
+### HTTPManagerService
+
+**Location:** `services/request-manager-services/http-manager.service.ts`
+
+**Description:** Core HTTP client service with Observable-based state management.
+
+**Features:**
+- HTTP CRUD operations (GET, POST, PUT, DELETE)
+- Loading states (`isPending$`, `error$`, `data$`, `countdown$`)
+- Configurable retry logic
+- Polling with countdown timers
+- Data adapters and mappers
+- Streaming response support (NDJSON, SSE)
+- File download with progress tracking
+
+**Observable Properties:**
+```typescript
+data$: Observable<any>              // Response data
+isPending$: Observable<boolean>     // Loading state
+error$: Observable<any>             // Error state
+countdown$: Observable<number>      // Polling countdown
+```
+
+**Methods:**
+
+#### HTTP Request Methods
+
+```typescript
+getRequest<T>(options?: ApiRequest, params?: any[]): Observable<T>
+postRequest<T>(data: T, options: ApiRequest, params?: any[]): Observable<T>
+putRequest<T>(data: T, options: ApiRequest, params?: any[]): Observable<T>
+deleteRequest<T>(options: ApiRequest, params?: any[]): Observable<T>
+downloadRequest<T>(options: ApiRequest, params?: any[], saveAs?: string): Observable<T>
+uploadRequest<T>(files: File | File[], options: ApiRequest, params?: any[]): Observable<T>
+```
+
+#### WebSocket Methods (delegated to WebSocketManagerService)
+
+```typescript
+connect(options: WSOptions, jwtToken: string): void
+disconnect(): void
+subscribeToChannel(channel: string, userData?: any): void
+subscribeToChannels(channels: string[], userData?: any): void
+unsubscribeFromChannel(channel: string): void
+getSubscribedChannels(): Set<string>
+sendBroadcast(content: any): void
+sendMessageInChannel(channel: string, content: any): void
+sendChannelMessage(channel: string, content: any): void
+sendChannelMessageToChannels(channels: string[], content: any): void
+sendMessageToUser(user: string, content: any): void
+getAllChannels(): void
+createChannel(channel: string): void
+deleteChannel(channel: string): void
+```
+
+**Usage Example:**
+```typescript
+import { HTTPManagerService, ApiRequest } from 'http-request-manager';
+
+@Component({})
+export class UsersComponent {
+  httpManager = inject(HTTPManagerService);
+  data$ = this.httpManager.data$;
+  isLoading$ = this.httpManager.isPending$;
+
+  ngOnInit() {
+    this.httpManager.getRequest(
+      ApiRequest.adapt({ 
+        path: ['users'],
+        retry: { times: 3, delay: 1 }
+      })
+    ).subscribe();
+  }
+}
+```
+
+---
+
+### HTTPManagerSignalsService
+
+**Location:** `services/request-manager-services/http-manager-signals.service.ts`
+
+**Description:** Signal-based HTTP service with the same features as HTTPManagerService.
+
+**Signal Properties:**
+```typescript
+data: Signal<any>              // Response data
+isPending: Signal<boolean>     // Loading state
+error: Signal<any>             // Error state
+countdown: Signal<number>      // Polling countdown
+```
+
+**Methods:** Same as HTTPManagerService
+
+**Usage Example:**
+```typescript
+import { HTTPManagerSignalsService, ApiRequest } from 'http-request-manager';
+
+@Component({
+  template: `
+    <div *ngIf="isLoading()">Loading...</div>
+    <div *ngFor="let user of data()">{{ user.name }}</div>
+  `
+})
+export class UsersComponent {
+  httpManager = inject(HTTPManagerSignalsService);
+  data = this.httpManager.data;
+  isLoading = this.httpManager.isPending;
+
+  ngOnInit() {
+    this.httpManager.getRequest(
+      ApiRequest.adapt({ path: ['users'] })
+    ).subscribe();
+  }
+}
+```
+
+---
+
+## State Management Services
+
+### HTTPManagerStateService
+
+**Location:** `services/request-manager-state-service/http-manager-state.store.ts`
+
+**Description:** Comprehensive state management service combining HTTP requests, WebSocket real-time updates, and IndexedDB persistence. Extends NgRx ComponentStore.
+
+**Extends:** `ComponentStore<APIStateManagerData<T>>`
+
+**Features:**
+- All HTTPManagerService features
+- ComponentStore-based state management
+- Automatic CRUD state updates
+- WebSocket integration with channel prefixes
+- IndexedDB caching with expiration
+- Pagination support
+- Real-time synchronization
+- Database flush capability
+
+**Observable Properties:**
+```typescript
+// From ComponentStore
+data$: Observable<T[]>                    // Array data
+page$: Observable<number>                 // Current page
+totalPages$: Observable<number>           // Total pages
+percentage$: Observable<number>           // Download percentage
+
+// WebSocket
+messages$: Observable<any>                // All WS messages
+userListByChannel$: Observable<Map<string, any[]>>
+userList$: Observable<any[]>              // Unique users
+user$: Observable<WSUser|null>            // Current user
+channels$: Observable<string[]|null>      // Subscribed channels
+
+// Notifications
+notificationChannels$: Observable<string[]>        // In-memory channels
+todaysNotificationChannels$: Observable<string[]>  // DB channels
+notificationMessages$: Observable<any[]>           // Notification list
+latestNotification$: Observable<any>               // Latest notification
+
+// Communication
+communicationMessages$: Observable<any[]>          // Channel messages
+latestCommunicationMessages$: Observable<any|null>
+userAction$: Observable<any|null>                  // WS-triggered actions
+
+// Connection
+connectionStatus$: Observable<boolean>             // WS connection
+wsRetryAttempts$: Observable<number>               // Retry count
+wsNextRetry$: Observable<number>                   // Next retry countdown
+```
+
+**Methods:**
+
+#### State Management
+
+```typescript
+initializeState(data: any): void
+clearRecords(): void
+```
+
+#### CRUD Operations
+
+```typescript
+fetchRecords(options?: RequestOptions): Effect
+fetchRecord(options: RequestOptions, method: string): Effect
+createRecord(data: any|null, options?: RequestOptions): Effect
+updateRecord(data: any|null, options?: RequestOptions): Effect
+deleteRecord(options?: RequestOptions): Effect
+```
+
+**RequestOptions for fetchRecords/fetchStream:**
+
+| Property | Type | Default | Description |
+|----------|------|---------|-------------|
+| `path` | `any[]` | `[]` | URL path segments |
+| `headers` | `any` | `{}` | Custom HTTP headers |
+| `forceRefresh` | `boolean` | `undefined` | Bypass query tracking and always make the API request |
+| `ignoreQueryParams` | `string[]` | `[]` | Query parameter keys to exclude from request-change tracking |
+| `queryParamsExpiresIn` | `string \| number` | `undefined` | Expiry duration for tracked query values (e.g., `'10s'`, `'5mn'`, `'1h'`) |
+| `watchParams` | `string[]` | `undefined` | Specific query keys to watch for change detection (variation mode) |
+| `watchExpiresAt` | `number` | `undefined` | Epoch timestamp when tracked values expire |
+
+**Scope and behavior:**
+- Database enabled (`DatabaseStorage` configured): tracker is active and can prevent repeated identical API calls until expiry resets tracked values.
+- Database disabled: tracker is not enabled; requests go straight to API.
+- `forceRefresh: true` bypasses tracking and always makes the API request.
+
+#### Streaming
+
+```typescript
+createStream(data: any|null, options?: RequestOptions): Effect
+fetchStream(options?: RequestOptions): Effect
+```
+
+#### Database Operations
+
+```typescript
+clearDatabase(): void
+```
+
+**Clear Database Example:**
+```typescript
+// Simple call - subscription handled internally
+myStateService.clearDatabase();
+
+// This will:
+// 1. Clear all records from IndexedDB table
+// 2. Clear in-memory state (set to empty array/object)
+// 3. Log success/error to console
+// 4. NOT re-fetch from API
+// 5. NOT clear localStorage metadata
+```
+
+#### WebSocket Communication
+
+```typescript
+wsCommunication(method: string, path?: string|number[]): void
+wsMessaging(message: ChannelMessage, channels?: string[]): void
+```
+
+#### Channel Management
+
+```typescript
+subscribeToChannel(channel: string): void
+subscribeToChannels(channels: string[]): void
+unsubscribeFromChannel(channel: string): void
+getSubscribedChannels(): Set<string>
+createChannel(channel: string): void
+deleteChannel(channel: string): void
+getAllChannels(): void
+getUsersInChannel(channel: string): void
+```
+
+#### Message Channels (PUB- prefix)
+
+```typescript
+subscribeToMessageChannel(channel: string): void
+unsubscribeFromMessageChannel(channel: string): void
+```
+
+#### Notification Channels (MES- prefix)
+
+```typescript
+createNotificationChannel(channel: string): void
+getNotificationChannels(): void
+getTodaysNotificationChannels(): void
+subscribeToNotificationChannel(channel: string, options?: { startEpoch?: number; endEpoch?: number }, user?: any): void
+unsubscribeFromNotificationChannel(channel: string): void
+sendNotification(channel: string, content: any): void
+```
+
+**Usage Example:**
+```typescript
+import { HTTPManagerStateService, ApiRequest, DataType, DatabaseStorage } from 'http-request-manager';
+
+@Injectable()
+export class UsersStateService extends HTTPManagerStateService<User> {
+  constructor() {
+    super(
+      ApiRequest.adapt({
+        server: 'https://api.example.com',
+        path: ['users'],
+        adapter: User.adapt
+      }),
+      DataType.ARRAY,
+      DatabaseStorage.adapt({
+        table: 'users',
+        expiresIn: '1h'
+      })
+    );
+  }
+}
+
+// Component
+@Component({})
+export class UsersComponent {
+  usersStore = inject(UsersStateService);
+  data$ = this.usersStore.data$;
+  
+  ngOnInit() {
+    this.usersStore.fetchRecords();
+  }
+  
+  onClearCache() {
+    this.usersStore.clearDatabase();
+  }
+}
+```
+
+---
+
+### StoreStateManagerService
+
+**Location:** `services/store-state-manager-service/store-state-manager.service.ts`
+
+**Description:** LocalStorage persistence with ComponentStore integration.
+
+**Extends:** `ComponentStore<T>`
+
+**Features:**
+- Automatic state synchronization with LocalStorage
+- Configurable model-based state
+- Reactive updates via localStorage changes
+
+**Methods:**
+```typescript
+init(options?: StateStorageOptions): void
+restoreState(): Subscription
+updateState(state: any): void
+```
+
+**Usage Example:**
+```typescript
+import { StoreStateManagerService, StateStorageOptions } from 'http-request-manager';
+
+@Injectable()
+export class AppStore extends StoreStateManagerService<AppState> {
+  constructor() {
+    super(StateStorageOptions.adapt({
+      store: 'app-state',
+      model: () => ({
+        theme: 'light',
+        language: 'en',
+        notifications: true
+      }),
+      options: SettingOptions.adapt({
+        storage: StorageType.GLOBAL,
+        encrypted: false,
+        expiresIn: '30d'
+      })
+    }));
+  }
+}
+```
+
+---
+
+## WebSocket Services
+
+### WebSocketManagerService
+
+**Location:** `services/ws-manager-service/websocket-service/websocket-manager.service.ts`
+
+**Description:** Singleton WebSocket connection manager ensuring only ONE connection across ALL instances.
+
+**Features:**
+- Single static connection (shared across all instances)
+- Connection lifecycle management
+- Channel subscription tracking
+- Session ID management (UUID per browser session)
+- JWT authentication support
+- Automatic reconnection handling
+- Message replay support (lastSeenId)
+
+**Static Properties:**
+```typescript
+private static socket: WebSocket | null
+private static isConnecting: boolean
+private static connectionInitialized: boolean
+private static lastOptions: WSOptions | null
+```
+
+**Observable Properties:**
+```typescript
+messages$: Observable<any>              // All messages
+connectionStatus$: Observable<boolean>  // Connection state
+subscribedChannels$: Observable<Set<string>>
+onReconnect$: Observable<void>          // Reconnect events
+```
+
+**Methods:**
+
+#### Connection Management
+
+```typescript
+connect(options: WSOptions, jwtToken: string): void
+disconnect(): void
+```
+
+#### Subscription Management
+
+```typescript
+subscribeToChannel(channelName: string): void
+subscribeToChannels(channelNames: string[]): void
+unsubscribeFromChannel(channelName: string): void
+getSubscribedChannels(): Set<string>
+addSubscribedChannel(channelName: string): void
+sendSubscribe(channelName: string, user: any): void
+sendSubscribeWithLastSeen(channelName: string, user: any, lastSeenId: number): void
+```
+
+#### Messaging
+
+```typescript
+sendBroadcast(content: any): void
+sendMessageInChannel(channel: string, content: any): void
+sendChannelMessage(channel: string, content: any): void
+sendChannelMessageToChannels(channels: string[], content: any): void
+sendMessageToUser(user: string, content: any): void
+```
+
+#### Channel Management
+
+```typescript
+createChannel(channel: string): void
+deleteChannel(channel: string): void
+getAllChannels(): void
+getUsersInChannel(channel: string): void
+```
+
+**Usage Example:**
+```typescript
+import { WebSocketManagerService, WSOptions } from 'http-request-manager';
+
+@Component({})
+export class ChatComponent {
+  wsManager = inject(WebSocketManagerService);
+  
+  ngOnInit() {
+    // Connection is singleton - only first call connects
+    this.wsManager.connect(
+      WSOptions.adapt({
+        wsServer: 'wss://ws.example.com',
+        id: 'chat-room',
+        user: { id: 'user123', name: 'John' }
+      }),
+      'jwt-token'
+    );
+    
+    // Listen to messages
+    this.wsManager.messages$.subscribe(message => {
+      console.log('Received:', message);
+    });
+    
+    // Subscribe to channel
+    this.wsManager.subscribeToChannel('chat-room');
+  }
+  
+  sendMessage(content: any) {
+    this.wsManager.sendChannelMessage('chat-room', content);
+  }
+}
+```
+
+---
+
+### MessageTrackerService
+
+**Location:** `services/ws-manager-service/message-tracker.service.ts`
+
+**Description:** Message history tracking and re-subscription management.
+
+**Features:**
+- Message history with persistence
+- Last-seen message ID tracking
+- Automatic re-subscription on reconnect
+- Notification channel management
+- Historical message retrieval
+
+**Methods:**
+```typescript
+subscribeToChannel(channel: string, userData?: any): void
+getNotificationChannels(): void
+getTodaysNotificationChannels(): void
+subscribeToNotificationChannel(channel: string, options?: any, user?: any): void
+unsubscribeFromNotificationChannel(channel: string): void
+sendNotification(channel: string, content: any): void
+createNotificationChannel(channel: string): void
+```
+
+---
+
+## Storage Services
+
+### LocalStorageManagerService
+
+**Location:** `services/local-storage-manager-service/local-storage-manager.service.ts`
+
+**Description:** LocalStorage and SessionStorage management with encryption and expiration.
+
+**Extends:** `ComponentStore<State>`
+
+**Features:**
+- LocalStorage (GLOBAL) and SessionStorage (SESSION) support
+- AES encryption for sensitive data
+- Automatic expiration cleanup
+- Reactive store$ observables
+- Metadata tracking (settings, expires)
+
+**Observable Properties:**
+```typescript
+stores$: Observable<StorageOption[]>      // All store metadata
+store$(name: string): Observable<any>     // Store data observable
+setting$(name: string): Observable<any>   // Store settings observable
+```
+
+**Signal Methods:**
+```typescript
+signal<T>(key: string, defaultValue: T): WritableSignal<T>
+```
+
+**Methods:**
+
+#### Store Management
+
+```typescript
+createStore(options: StoreOptions): void
+updateStore(options: StoreOptions): void
+deleteStore(options: { name: string }): void
+resetStore(): void
+```
+
+#### Item Operations
+
+```typescript
+setItem(key: string, value: any, options?: SettingOptions): void
+getItem(key: string): any
+removeItem(key: string): void
+```
+
+#### Observable Methods
+
+```typescript
+store$(name: string): Observable<any>
+setting$(name: string): Observable<any>
+stores$: Observable<StorageOption[]>
+```
+
+**Usage Example:**
+```typescript
+import { LocalStorageManagerService, SettingOptions, StorageType } from 'http-request-manager';
+
+@Component({})
+export class SettingsComponent {
+  storage = inject(LocalStorageManagerService);
+  
+  // Signal-based access
+  theme = this.storage.signal('theme', 'light');
+  language = this.storage.signal('language', 'en');
+  
+  // Observable-based access
+  settings$ = this.storage.store$('user-preferences');
+  
+  // Manual operations
+  saveSettings() {
+    this.storage.setItem('user-preferences', {
+      theme: this.theme(),
+      language: this.language()
+    }, SettingOptions.adapt({
+      storage: StorageType.GLOBAL,
+      encrypted: false,
+      expiresIn: '30d'
+    }));
+  }
+}
+```
+
+---
+
+### LocalStorageSignalsManagerService
+
+**Location:** `services/local-storage-manager-service/local-storage-signals-manager.service.ts`
+
+**Description:** Signal-optimized version of LocalStorageManagerService.
+
+**Features:** Same as LocalStorageManagerService but with Signal-first API
+
+---
+
+## Database Services
+
+### DatabaseManagerService
+
+**Location:** `services/database-manager-service/database.manager.service.ts`
+
+**Description:** IndexedDB wrapper using Dexie.js with Observable API.
+
+**Extends:** `DbService` (Dexie.js wrapper)
+
+**Features:**
+- IndexedDB table management
+- Observable-based CRUD operations
+- Bulk operations
+- Query support with filtering
+- Schema inspection
+
+**Methods:**
+
+#### Table Management
+
+```typescript
+getDatabaseTables(): Observable<string[]>
+databaseExists(): Observable<boolean>
+hasDatabaseTable(tableName: string): Observable<boolean>
+getDatabaseTable(tableName: string): Observable<any>
+getDatabaseTableSchema(tableName: string): Observable<string[]>
+createDatabaseTable(tableDef: TableSchemaDef): Observable<void>
+updateDatabaseTableSchema(tableDef: TableSchemaDef): Observable<any>
+```
+
+#### CRUD Operations
+
+```typescript
+// Read
+getTableRecords(table: string): Observable<any[]>
+getTableRecord(table: string, id: number): Observable<any>
+findTableRecords(table: string, column: string, value: any): Observable<any[]>
+findTableRecord(table: string, column: string, value: any): Observable<any>
+
+// Create
+createTableRecord(table: string, record: any): Observable<any>
+createTableRecords(table: string, records: any[]): Observable<any[]>
+
+// Update
+updateTableRecord(table: string, record: any): Observable<any>
+updateTableRecords(table: string, records: any[]): Observable<any[]>
+
+// Delete
+deleteTableRecord(table: string, id: number): Observable<void>
+deleteTableRecords(table: string, ids: number[]): Observable<void>
+deleteTableRecordByColumn(table: string, column: string, value: any): Observable<void>
+
+// Clear
+clearTable(table: string): Observable<any>
+```
+
+**Clear Table Example:**
+```typescript
+import { DatabaseManagerService, TableSchemaDef } from 'http-request-manager';
+
+@Component({})
+export class DatabaseComponent {
+  dbManager = inject(DatabaseManagerService);
+  
+  initializeTable() {
+    const tableDef = TableSchemaDef.adapt({
+      table: 'users',
+      schema: '++id, name, email, age, createdAt'
+    });
+    
+    this.dbManager.createDatabaseTable(tableDef).subscribe();
+  }
+  
+  addSampleData() {
+    const users = [
+      { name: 'John', email: 'john@example.com', age: 30 },
+      { name: 'Jane', email: 'jane@example.com', age: 25 }
+    ];
+    
+    this.dbManager.createTableRecords('users', users).subscribe();
+  }
+  
+  loadData() {
+    this.dbManager.getTableRecords('users').subscribe(users => {
+      console.log('Users:', users);
+    });
+  }
+  
+  clearData() {
+    this.dbManager.clearTable('users').subscribe(() => {
+      console.log('Table cleared');
+    });
+  }
+}
+```
+
+---
+
+## Utility Services
+
+### UtilsService
+
+**Location:** `services/utils/utils.service.ts`
+
+**Description:** Collection of utility functions for common tasks.
+
+**Methods:**
+
+#### JSON Handling
+
+```typescript
+stringToJSON(str: string): any
+JSONToString(obj: any): string
+```
+
+#### Type Checking
+
+```typescript
+isString(value: any): boolean
+isObject(value: any): boolean
+isJson(str: string): boolean
+```
+
+#### Expiration Management
+
+```typescript
+expires(duration: string): number          // Convert '1h', '30mn' to epoch
+hasExpired(epoch: number): boolean         // Check if timestamp expired
+timeRemaining(epoch: number): string       // Time until expiration
+```
+
+#### Conversions
+
+```typescript
+base32ToHex(base32: string): string
+binaryToHex(binary: string): string
+```
+
+#### Object Operations
+
+```typescript
+deepCompare(obj1: any, obj2: any): boolean
+getProperty(obj: any, path: string): any
+```
+
+**Usage Example:**
+```typescript
+import { UtilsService } from 'http-request-manager';
+
+utils = inject(UtilsService);
+
+// Expiration
+const expires = this.utils.expires('1h');  // Epoch timestamp
+const hasExpired = this.utils.hasExpired(expires);
+
+// JSON
+const obj = this.utils.stringToJSON('{"name": "John"}');
+const str = this.utils.JSONToString({ name: 'John' });
+
+// Type checking
+if (this.utils.isString(value)) { ... }
+```
+
+---
+
+### ObjectMergerService
+
+**Location:** `services/utils/object-merger.service.ts`
+
+**Description:** Deep merge utility for objects.
+
+**Methods:**
+```typescript
+merge(target: any, source: any): any
+```
+
+---
+
+### SymmetricalEncryptionService
+
+**Location:** `services/utils/encryption/symmetrical-encryption.service.ts`
+
+**Description:** AES encryption/decryption utility.
+
+**Methods:**
+```typescript
+encrypt(data: any, key: string): string
+decrypt(encryptedData: string, key: string): any
+```
+
+---
+
+## Interceptors
+
+### RequestErrorInterceptor
+
+**Description:** Handles HTTP error responses with toast notifications.
+
+**Features:**
+- 4xx errors → Warning toast
+- 5xx errors → Error toast
+- Detailed console logging
+
+**Installation:**
+```typescript
+providers: [
+  { provide: HTTP_INTERCEPTORS, useClass: RequestErrorInterceptor, multi: true }
+]
+```
+
+---
+
+### RequestHeadersInterceptor
+
+**Description:** Automatically adds common headers to requests.
+
+**Headers Added:**
+- `Content-Type: application/json`
+- `Accept-Language: {locale}-CA`
+- `Current-Date: YYYY-MM-DD`
+
+**Installation:**
+```typescript
+providers: [
+  { provide: HTTP_INTERCEPTORS, useClass: RequestHeadersInterceptor, multi: true }
+]
+```
+
+---
+
+### CredentialsInterceptor
+
+**Description:** Adds `withCredentials: true` to all requests.
+
+**Installation:**
+```typescript
+providers: [
+  { provide: HTTP_INTERCEPTORS, useClass: CredentialsInterceptor, multi: true }
+]
+```
+
+---
+
+### ProxyDebuggerInterceptor
+
+**Description:** Logs request/response details for debugging.
+
+**Installation:**
+```typescript
+providers: [
+  { provide: HTTP_INTERCEPTORS, useClass: ProxyDebuggerInterceptor, multi: true }
+]
+```
+
+---
+
+## Models & Configuration
+
+### ApiRequest
+
+Configuration for HTTP requests.
+
+```typescript
+interface ApiRequest {
+  server: string;                    // Base URL
+  path: any[];                       // Path segments
+  headers: any;                      // Custom headers
+  adapter: Function;                 // Response transformer
+  mapper: Function;                  // Request transformer
+  polling: number;                   // Polling interval (seconds)
+  retry: RetryOptions;               // Retry config
+  stream: boolean;                   // Enable streaming
+  displayError: boolean;             // Show error toast
+  saveAs: string;                    // Download filename
+  ws: WSOptions;                     // WebSocket config
+}
+```
+
+### DatabaseStorage
+
+Configuration for IndexedDB caching.
+
+```typescript
+interface DatabaseStorage {
+  table: string;                     // Table name
+  expiresIn: string;                 // '1h', '30mn', '5mn'
+}
+```
+
+### WSOptions
+
+WebSocket connection configuration.
+
+```typescript
+interface WSOptions {
+  wsServer: string;                  // WebSocket server URL
+  id: string;                        // Channel ID
+  user: any;                         // User info
+  channels?: string[];               // Additional channels
+  jwtToken?: string;                 // JWT token
+  retry?: { times: number; delay: number };
+}
+```
+
+### SettingOptions
+
+LocalStorage configuration.
+
+```typescript
+interface SettingOptions {
+  storage: StorageType;              // GLOBAL or SESSION
+  encrypted: boolean;                // Enable encryption
+  expiresIn?: string;                // Expiration duration
+}
+```
+
+### TableSchemaDef
+
+IndexedDB table schema definition.
+
+```typescript
+interface TableSchemaDef {
+  table: string;                     // Table name
+  schema: string;                    // Dexie schema (e.g., '++id, name, email')
+}
+```
+
+### DataType
+
+Enum for data structure type.
+
+```typescript
+enum DataType {
+  ARRAY = 'array',                   // List data
+  OBJECT = 'object'                  // Single object
+}
+```
+
+### StorageType
+
+Enum for storage location.
+
+```typescript
+enum StorageType {
+  GLOBAL = 'global',                 // LocalStorage
+  SESSION = 'session'                // SessionStorage
+}
+```
+
+---
+
+## Quick Reference
+
+### Service Injection
+
+```typescript
+// HTTP (Observable)
+httpManager = inject(HTTPManagerService);
+
+// HTTP (Signals)
+httpManager = inject(HTTPManagerSignalsService);
+
+// State Management
+stateStore = inject(HTTPManagerStateService);
+
+// WebSocket
+wsManager = inject(WebSocketManagerService);
+
+// LocalStorage
+localStorage = inject(LocalStorageManagerService);
+
+// IndexedDB
+dbManager = inject(DatabaseManagerService);
+
+// Utilities
+utils = inject(UtilsService);
+```
+
+### Common Patterns
+
+#### Fetch and Display
+
+```typescript
+// Observable
+data$ = this.httpManager.data$;
+httpManager.getRequest(ApiRequest.adapt({ path: ['users'] })).subscribe();
+
+// Signal
+data = this.httpManager.data;
+httpManager.getRequest(ApiRequest.adapt({ path: ['users'] })).subscribe();
+```
+
+#### Create Record
+
+```typescript
+// State Service
+stateStore.createRecord(newData, { path: ['users'] });
+
+// HTTP Service
+httpManager.postRequest(newData, ApiRequest.adapt({ path: ['users'] })).subscribe();
+```
+
+#### Clear Cache
+
+```typescript
+// Clear IndexedDB
+stateStore.clearDatabase();
+
+// Clear specific table
+dbManager.clearTable('users').subscribe();
+```
+
+#### WebSocket Messaging
+
+```typescript
+// Connect (singleton)
+wsManager.connect(options, jwtToken);
+
+// Subscribe
+wsManager.subscribeToChannel('chat-room');
+
+// Send
+wsManager.sendChannelMessage('chat-room', { text: 'Hello' });
+```
+
+---
+
+This API reference provides comprehensive documentation for all services in the HTTP Request Manager library. For more detailed examples and use cases, refer to the individual README files in the `docs/` folder.