@plyaz/types 1.7.16 → 1.7.18

package/dist/api/events/types.d.ts

@@ -0,0 +1,795 @@
+/**
+ * Event Type Definitions for API Package
+ * All event interfaces and type definitions from the events system
+ */
+import type { HEADER_EVENTS, NETWORK_EVENTS, ERROR_EVENTS, DEBUG_EVENTS, CONFIG_EVENTS, PERFORMANCE_EVENTS, CACHE_EVENTS } from '@plyaz/config';
+import type { EventHandler } from '../../events';
+/**
+ * Type for core event scopes
+ */
+export type EventScope = 'global' | 'config' | 'client' | 'request';
+/**
+ * Type for event scopes including 'temporary'
+ */
+export type EventScopeWithTemporary = EventScope | 'temporary';
+/**
+ * Configuration source type
+ */
+export type ConfigSource = 'global' | 'createApiClient' | 'updateConfig' | 'manual' | 'environment' | 'preset' | 'networkAware' | 'adaptive';
+/**
+ * Configuration update strategy - controls WHERE configuration is applied
+ * - 'merge': Merges with existing config at CLIENT scope
+ * - 'replace': Replaces existing config at CLIENT scope
+ * - 'temporary': Applies at REQUEST/TEMPORARY scope (highest priority)
+ */
+export type ConfigUpdateStrategy = 'merge' | 'replace' | 'temporary';
+/**
+ * Handler strategy - controls how handlers are registered and merged
+ * - 'merge': Merge handlers with existing ones (chain them)
+ * - 'replace': Replace existing handlers entirely
+ * - 'prepend': Add new handlers before existing ones
+ * - 'append': Add new handlers after existing ones
+ * - 'temporary': Apply as temporary handlers (highest priority, can be reverted)
+ */
+export type HandlerStrategy = 'merge' | 'replace' | 'append' | 'prepend' | 'temporary';
+/**
+ * Options for adding event handlers
+ */
+export interface HandlerOptions {
+    /** Strategy for handling multiple handlers */
+    strategy?: HandlerStrategy;
+}
+/**
+ * Base structure for all events
+ */
+export interface BaseEvent {
+    /** Event type/name */
+    type: string;
+    /** Timestamp when event was created (milliseconds since epoch) */
+    timestamp: number;
+    /** Optional event source identifier */
+    source?: string;
+}
+/**
+ * Options for event creation
+ */
+export interface EventOptions {
+    /** Whether to emit immediately after creation */
+    emit?: boolean;
+    /** Additional metadata to attach */
+    metadata?: Record<string, unknown>;
+    /** Event source identifier */
+    source?: string;
+}
+/**
+ * Base structure for header events
+ */
+export interface HeaderEvent extends BaseEvent {
+    type: string;
+    data: Record<string, unknown>;
+}
+/**
+ * Headers changed event
+ */
+export interface HeadersChangedEvent extends HeaderEvent {
+    type: typeof HEADER_EVENTS.CHANGED;
+    data: {
+        previous: Record<string, string>;
+        current: Record<string, string>;
+        changes: {
+            added: Record<string, string>;
+            modified: Record<string, string>;
+            removed: string[];
+        };
+        source: ConfigSource;
+        reason?: string;
+    };
+}
+/**
+ * Headers enriched event
+ */
+export interface HeadersEnrichedEvent extends HeaderEvent {
+    type: typeof HEADER_EVENTS.ENRICHED;
+    data: {
+        original: Record<string, string>;
+        enriched: Record<string, string>;
+        addedHeaders: string[];
+        source: 'client-hints' | 'device-detection' | 'user-agent' | 'custom';
+        metadata?: {
+            deviceType?: string;
+            browserName?: string;
+            osName?: string;
+            [key: string]: unknown;
+        };
+    };
+}
+/**
+ * Headers conflict event
+ */
+export interface HeadersConflictEvent extends HeaderEvent {
+    type: typeof HEADER_EVENTS.CONFLICT;
+    data: {
+        header: string;
+        conflicts: Array<{
+            source: ConfigSource;
+            value: string;
+            priority: number;
+        }>;
+        resolution: {
+            source: ConfigSource;
+            value: string;
+            reason: string;
+        };
+        strategy: 'override' | 'merge' | 'preserve';
+    };
+}
+/**
+ * Headers override event
+ */
+export interface HeadersOverrideEvent extends HeaderEvent {
+    type: typeof HEADER_EVENTS.OVERRIDE;
+    data: {
+        header: string;
+        previousValue: string | undefined;
+        newValue: string;
+        source: ConfigSource;
+        reason: string;
+        temporary?: boolean;
+    };
+}
+/**
+ * Headers merged event
+ */
+export interface HeadersMergedEvent extends HeaderEvent {
+    type: typeof HEADER_EVENTS.MERGED;
+    data: {
+        sources: Array<Record<string, string>>;
+        result: Record<string, string>;
+        strategy: 'shallow' | 'deep' | 'concat';
+        conflictsResolved: number;
+    };
+}
+/**
+ * Headers filtered event
+ */
+export interface HeadersFilteredEvent extends HeaderEvent {
+    type: typeof HEADER_EVENTS.FILTERED;
+    data: {
+        original: Record<string, string>;
+        filtered: Record<string, string>;
+        removedHeaders: string[];
+        reason: string;
+        source?: ConfigSource;
+    };
+}
+/**
+ * Headers validated event
+ */
+export interface HeadersValidatedEvent extends HeaderEvent {
+    type: typeof HEADER_EVENTS.VALIDATED;
+    data: {
+        headers: Record<string, string>;
+        valid: boolean;
+        errors?: Array<{
+            header: string;
+            reason: string;
+        }>;
+        warnings?: Array<{
+            header: string;
+            message: string;
+        }>;
+    };
+}
+/**
+ * Headers cached event
+ */
+export interface HeadersCachedEvent extends HeaderEvent {
+    type: typeof HEADER_EVENTS.CACHED;
+    data: {
+        key: string;
+        headers: Record<string, string>;
+        ttl?: number;
+        strategy?: 'memory' | 'session' | 'persistent';
+    };
+}
+/**
+ * Union type for all header event types
+ */
+export type HeaderEventData = HeadersChangedEvent | HeadersEnrichedEvent | HeadersConflictEvent | HeadersOverrideEvent | HeadersMergedEvent | HeadersValidatedEvent | HeadersCachedEvent;
+/**
+ * Base structure for network events
+ */
+export interface NetworkEvent extends BaseEvent {
+    type: string;
+    data: Record<string, unknown>;
+}
+/**
+ * Network quality event
+ */
+export interface NetworkQualityEvent extends NetworkEvent {
+    type: typeof NETWORK_EVENTS.QUALITY_CHANGE;
+    data: {
+        previous: string;
+        current: string;
+        rtt?: number;
+        downlink?: number;
+        effectiveType?: string;
+        saveData?: boolean;
+    };
+}
+/**
+ * Network info event
+ */
+export interface NetworkInfoEvent extends NetworkEvent {
+    type: typeof NETWORK_EVENTS.INFO_UPDATE;
+    data: {
+        type?: string;
+        effectiveType?: string;
+        downlink?: number;
+        downlinkMax?: number;
+        rtt?: number;
+        saveData?: boolean;
+    };
+}
+/**
+ * Network config override event
+ */
+export interface NetworkConfigOverrideEvent extends NetworkEvent {
+    type: typeof NETWORK_EVENTS.CONFIG_OVERRIDE;
+    data: {
+        reason: string;
+        override: Record<string, unknown>;
+        original: Record<string, unknown>;
+    };
+}
+/**
+ * Network preset event
+ */
+export interface NetworkPresetEvent extends NetworkEvent {
+    type: typeof NETWORK_EVENTS.PRESET_APPLIED;
+    data: {
+        preset: string;
+        config: Record<string, unknown>;
+    };
+}
+/**
+ * Network client hints event
+ */
+export interface NetworkClientHintsEvent extends NetworkEvent {
+    type: typeof NETWORK_EVENTS.HINTS_UPDATED;
+    data: {
+        hints: Record<string, unknown>;
+    };
+}
+/**
+ * Network auto detection event
+ */
+export interface NetworkAutoDetectionEvent extends NetworkEvent {
+    type: typeof NETWORK_EVENTS.AUTO_DETECTION;
+    data: {
+        detected: Record<string, unknown>;
+        confidence: number;
+    };
+}
+/**
+ * Network manual update event
+ */
+export interface NetworkManualUpdateEvent extends NetworkEvent {
+    type: typeof NETWORK_EVENTS.MANUAL_UPDATE;
+    data: {
+        updates: Record<string, unknown>;
+    };
+}
+/**
+ * Union type for all network event types
+ */
+export type NetworkEventData = NetworkQualityEvent | NetworkInfoEvent | NetworkConfigOverrideEvent | NetworkPresetEvent | NetworkClientHintsEvent | NetworkAutoDetectionEvent | NetworkManualUpdateEvent;
+/**
+ * Base structure for error events
+ */
+export interface ErrorEvent extends BaseEvent {
+    type: string;
+    data: Record<string, unknown>;
+}
+/**
+ * Generic error event
+ */
+export interface GenericErrorEvent extends ErrorEvent {
+    type: typeof ERROR_EVENTS.GENERIC_ERROR;
+    data: {
+        error: unknown;
+        message: string;
+        code?: string;
+        statusCode?: number;
+    };
+}
+/**
+ * Network error event
+ */
+export interface NetworkErrorEvent extends ErrorEvent {
+    type: typeof ERROR_EVENTS.NETWORK_ERROR;
+    data: {
+        error: unknown;
+        message: string;
+        url?: string;
+        method?: string;
+    };
+}
+/**
+ * Validation error event
+ */
+export interface ValidationErrorEvent extends ErrorEvent {
+    type: typeof ERROR_EVENTS.VALIDATION_ERROR;
+    data: {
+        error: unknown;
+        message: string;
+        field?: string;
+        value?: unknown;
+    };
+}
+/**
+ * Authentication error event
+ */
+export interface AuthenticationErrorEvent extends ErrorEvent {
+    type: typeof ERROR_EVENTS.AUTHENTICATION_ERROR;
+    data: {
+        error: unknown;
+        message: string;
+        scheme?: string;
+    };
+}
+/**
+ * Rate limit error event
+ */
+export interface RateLimitErrorEvent extends ErrorEvent {
+    type: typeof ERROR_EVENTS.RATE_LIMIT_ERROR;
+    data: {
+        error: unknown;
+        message: string;
+        limit?: number;
+        remaining?: number;
+        reset?: number;
+    };
+}
+/**
+ * Server error event
+ */
+export interface ServerErrorEvent extends ErrorEvent {
+    type: typeof ERROR_EVENTS.SERVER_ERROR;
+    data: {
+        error: unknown;
+        message: string;
+        statusCode?: number;
+    };
+}
+/**
+ * Timeout error event
+ */
+export interface TimeoutErrorEvent extends ErrorEvent {
+    type: typeof ERROR_EVENTS.TIMEOUT_ERROR;
+    data: {
+        error: unknown;
+        message: string;
+        timeout?: number;
+    };
+}
+/**
+ * Union type for all error event types
+ */
+export type ErrorEventData = GenericErrorEvent | NetworkErrorEvent | ValidationErrorEvent | AuthenticationErrorEvent | RateLimitErrorEvent | ServerErrorEvent | TimeoutErrorEvent;
+/**
+ * Base structure for debug events
+ */
+export interface DebugEvent extends BaseEvent {
+    type: string;
+    data: Record<string, unknown>;
+}
+/**
+ * Config conflict event
+ */
+export interface ConfigConflictEvent extends DebugEvent {
+    type: typeof DEBUG_EVENTS.CONFIG_CONFLICT;
+    data: {
+        property: string;
+        values: Array<{
+            source: string;
+            value: unknown;
+        }>;
+        resolution: {
+            source: string;
+            value: unknown;
+        };
+    };
+}
+/**
+ * Config change event
+ */
+export interface ConfigChangeEvent extends DebugEvent {
+    type: typeof DEBUG_EVENTS.CONFIG_CHANGE;
+    data: {
+        property: string;
+        previous: unknown;
+        current: unknown;
+        source: ConfigSource;
+    };
+}
+/**
+ * Headers tracked event
+ */
+export interface HeadersTrackedEvent extends DebugEvent {
+    type: typeof DEBUG_EVENTS.HEADERS_TRACKED;
+    data: {
+        headers: Record<string, string>;
+        timestamp: number;
+    };
+}
+/**
+ * Network override event
+ */
+export interface NetworkOverrideEvent extends DebugEvent {
+    type: typeof DEBUG_EVENTS.NETWORK_OVERRIDE;
+    data: {
+        reason: string;
+        override: Record<string, unknown>;
+    };
+}
+/**
+ * Debug info update event
+ */
+export interface DebugInfoUpdateEvent extends DebugEvent {
+    type: typeof DEBUG_EVENTS.DEBUG_INFO;
+    data: {
+        info: Record<string, unknown>;
+    };
+}
+/**
+ * Performance impact event
+ */
+export interface PerformanceImpactEvent extends DebugEvent {
+    type: typeof DEBUG_EVENTS.PERFORMANCE_IMPACT;
+    data: {
+        operation: string;
+        duration: number;
+        impact: 'low' | 'medium' | 'high';
+    };
+}
+/**
+ * Monitoring alert event
+ */
+export interface MonitoringAlertEvent extends DebugEvent {
+    type: typeof DEBUG_EVENTS.MONITORING_ALERT;
+    data: {
+        severity: 'info' | 'warning' | 'error';
+        message: string;
+        metadata?: Record<string, unknown>;
+    };
+}
+/**
+ * Config tracking event
+ */
+export interface ConfigTrackingEvent extends DebugEvent {
+    type: typeof DEBUG_EVENTS.CONFIG_TRACKED;
+    data: {
+        config: Record<string, unknown>;
+        source: ConfigSource;
+    };
+}
+/**
+ * Union type for all debug event types
+ */
+export type DebugEventData = ConfigConflictEvent | ConfigChangeEvent | HeadersTrackedEvent | NetworkOverrideEvent | DebugInfoUpdateEvent | PerformanceImpactEvent | MonitoringAlertEvent | ConfigTrackingEvent;
+/**
+ * Config global updated event
+ */
+export interface ConfigGlobalUpdatedEvent extends BaseEvent {
+    type: typeof CONFIG_EVENTS.GLOBAL_UPDATED;
+    data: {
+        config: Record<string, unknown>;
+        previous?: Record<string, unknown>;
+    };
+}
+/**
+ * Config global reset event
+ */
+export interface ConfigGlobalResetEvent extends BaseEvent {
+    type: typeof CONFIG_EVENTS.GLOBAL_RESET;
+    data: {
+        previous: Record<string, unknown>;
+    };
+}
+/**
+ * Config environment event
+ */
+export interface ConfigEnvironmentEvent extends BaseEvent {
+    type: typeof CONFIG_EVENTS.ENVIRONMENT_CONFIGURED;
+    data: {
+        environment: string;
+        config: Record<string, unknown>;
+    };
+}
+/**
+ * Config preset applied event
+ */
+export interface ConfigPresetAppliedEvent extends BaseEvent {
+    type: typeof CONFIG_EVENTS.PRESET_APPLIED;
+    data: {
+        preset: string;
+        config: Record<string, unknown>;
+    };
+}
+/**
+ * Union type for all config event types
+ */
+export type ConfigEventData = ConfigGlobalUpdatedEvent | ConfigGlobalResetEvent | ConfigEnvironmentEvent | ConfigPresetAppliedEvent;
+/**
+ * Performance request start event
+ */
+export interface PerformanceRequestStartEvent extends BaseEvent {
+    type: typeof PERFORMANCE_EVENTS.REQUEST_START;
+    data: {
+        requestId: string;
+        url: string;
+        method: string;
+    };
+}
+/**
+ * Performance request complete event
+ */
+export interface PerformanceRequestCompleteEvent extends BaseEvent {
+    type: typeof PERFORMANCE_EVENTS.REQUEST_COMPLETE;
+    data: {
+        requestId: string;
+        url: string;
+        method: string;
+        duration: number;
+        status?: number;
+    };
+}
+/**
+ * Performance retry event
+ */
+export interface PerformanceRetryEvent extends BaseEvent {
+    type: typeof PERFORMANCE_EVENTS.RETRY;
+    data: {
+        requestId: string;
+        attempt: number;
+        reason: string;
+    };
+}
+/**
+ * Performance threshold exceeded event
+ */
+export interface PerformanceThresholdExceededEvent extends BaseEvent {
+    type: typeof PERFORMANCE_EVENTS.THRESHOLD_EXCEEDED;
+    data: {
+        type: string;
+        threshold: number;
+        actual: number;
+    };
+}
+/**
+ * Performance optimization applied event
+ */
+export interface PerformanceOptimizationAppliedEvent extends BaseEvent {
+    type: typeof PERFORMANCE_EVENTS.OPTIMIZATION_APPLIED;
+    data: {
+        type: string;
+        description: string;
+    };
+}
+/**
+ * Performance metric recorded event
+ */
+export interface PerformanceMetricRecordedEvent extends BaseEvent {
+    type: typeof PERFORMANCE_EVENTS.METRIC_RECORDED;
+    data: {
+        metric: string;
+        value: number;
+        unit: string;
+    };
+}
+/**
+ * Union type for all performance event types
+ */
+export type PerformanceEventData = PerformanceRequestStartEvent | PerformanceRequestCompleteEvent | PerformanceRetryEvent | PerformanceThresholdExceededEvent | PerformanceOptimizationAppliedEvent | PerformanceMetricRecordedEvent;
+/**
+ * Cache hit event
+ */
+export interface CacheHitEvent extends BaseEvent {
+    type: typeof CACHE_EVENTS.HIT;
+    data: {
+        key: string;
+        ttl?: number;
+    };
+}
+/**
+ * Cache miss event
+ */
+export interface CacheMissEvent extends BaseEvent {
+    type: typeof CACHE_EVENTS.MISS;
+    data: {
+        key: string;
+    };
+}
+/**
+ * Cache invalidate event
+ */
+export interface CacheInvalidateEvent extends BaseEvent {
+    type: typeof CACHE_EVENTS.INVALIDATE;
+    data: {
+        pattern?: string;
+        keys?: string[];
+    };
+}
+/**
+ * Union type for all cache event types
+ */
+export type CacheEventData = CacheHitEvent | CacheMissEvent | CacheInvalidateEvent;
+/**
+ * Client conflict event
+ */
+export interface ClientConflictEvent extends BaseEvent {
+    type: string;
+    data: Record<string, unknown>;
+}
+/**
+ * Client debug event
+ */
+export interface ClientDebugEvent extends BaseEvent {
+    type: string;
+    data: Record<string, unknown>;
+}
+/**
+ * Client created event
+ */
+export interface ClientCreatedEvent extends BaseEvent {
+    type: string;
+    data: {
+        clientId: string;
+        config: Record<string, unknown>;
+    };
+}
+/**
+ * Request start event (client-level)
+ */
+export interface RequestStartEvent extends BaseEvent {
+    type: 'request:start';
+    data: {
+        url?: string;
+        method?: string;
+        timestamp: number;
+    };
+}
+/**
+ * Response received event
+ */
+export interface ResponseReceivedEvent extends BaseEvent {
+    type: 'response:received';
+    data: {
+        url?: string;
+        status?: number;
+        statusText?: string;
+        headers?: Record<string, string>;
+        timestamp: number;
+    };
+}
+/**
+ * Retry attempt event
+ */
+export interface RetryAttemptEvent extends BaseEvent {
+    type: 'retry:attempt';
+    data: {
+        error: {
+            message: string;
+            code?: string;
+            status?: number;
+        };
+        attempt: number;
+        maxAttempts: number;
+        delay: number;
+        url?: string;
+        method?: string;
+    };
+}
+/**
+ * Union type for all client event types
+ */
+export type ClientEventType = ClientConflictEvent | ClientDebugEvent | ClientCreatedEvent | RequestStartEvent | ResponseReceivedEvent | RetryAttemptEvent;
+export type AnyHeaderEvent = HeaderEventData;
+export type AnyNetworkEvent = NetworkEventData;
+export type AnyErrorEvent = ErrorEventData;
+export type AnyDebugEvent = DebugEventData;
+export type AnyPerformanceEvent = PerformanceEventData;
+export type AnyConfigEvent = ConfigEventData;
+export type AnyCacheEvent = CacheEventData;
+export type AnyClientEvent = ClientEventType;
+/**
+ * Combined event type
+ */
+export type AnyEvent = AnyHeaderEvent | AnyNetworkEvent | AnyErrorEvent | AnyDebugEvent | AnyPerformanceEvent | AnyConfigEvent | AnyCacheEvent | AnyClientEvent;
+export type HeaderEventHandler = EventHandler<HeaderEventData>;
+export type NetworkEventHandler = EventHandler<NetworkEventData>;
+export type ErrorEventHandler = EventHandler<ErrorEventData>;
+export type DebugEventHandler = EventHandler<DebugEventData>;
+export type PerformanceEventHandler = EventHandler<PerformanceEventData>;
+export type ConfigEventHandler = EventHandler<ConfigEventData>;
+export type CacheEventHandler = EventHandler<CacheEventData>;
+export type AnyHeaderEventHandler = EventHandler<AnyHeaderEvent>;
+export type AnyNetworkEventHandler = EventHandler<AnyNetworkEvent>;
+export type AnyErrorEventHandler = EventHandler<AnyErrorEvent>;
+export type AnyDebugEventHandler = EventHandler<AnyDebugEvent>;
+export type AnyPerformanceEventHandler = EventHandler<AnyPerformanceEvent>;
+export type AnyConfigEventHandler = EventHandler<AnyConfigEvent>;
+export type AnyCacheEventHandler = EventHandler<AnyCacheEvent>;
+export type AnyClientEventHandler = EventHandler<AnyClientEvent>;
+export type UniversalEventHandler = EventHandler<AnyEvent>;
+/**
+ * Header event handlers interface
+ */
+export interface HeaderEventHandlers {
+    onHeadersChanged?: (event: HeadersChangedEvent) => void;
+    onHeadersEnriched?: (event: HeadersEnrichedEvent) => void;
+    onHeadersConflict?: (event: HeadersConflictEvent) => void;
+    onHeadersOverride?: (event: HeadersOverrideEvent) => void;
+    onHeadersMerged?: (event: HeadersMergedEvent) => void;
+    onHeadersFiltered?: (event: HeadersFilteredEvent) => void;
+    onHeadersValidated?: (event: HeadersValidatedEvent) => void;
+    onHeadersCached?: (event: HeadersCachedEvent) => void;
+    onAnyHeaderEvent?: (event: HeaderEventData) => void;
+}
+/**
+ * Network event handlers interface
+ */
+export interface NetworkEventHandlers {
+    onNetworkQualityChange?: (event: NetworkQualityEvent) => void;
+    onNetworkInfoUpdate?: (event: NetworkInfoEvent) => void;
+    onNetworkConfigOverride?: (event: NetworkConfigOverrideEvent) => void;
+    onNetworkPresetApplied?: (event: NetworkPresetEvent) => void;
+    onClientHintsUpdated?: (event: NetworkClientHintsEvent) => void;
+    onAutoDetection?: (event: NetworkAutoDetectionEvent) => void;
+    onManualUpdate?: (event: NetworkManualUpdateEvent) => void;
+    onAnyNetworkEvent?: (event: NetworkEventData) => void;
+}
+/**
+ * Configuration event handlers interface
+ */
+export interface ConfigEventHandlers {
+    onGlobalUpdated?: (event: ConfigGlobalUpdatedEvent) => void;
+    onGlobalReset?: (event: ConfigGlobalResetEvent) => void;
+    onEnvironmentConfigured?: (event: ConfigEnvironmentEvent) => void;
+    onPresetApplied?: (event: ConfigPresetAppliedEvent) => void;
+    onAnyConfigEvent?: (event: ConfigEventData) => void;
+}
+/**
+ * Performance event handlers interface
+ */
+export interface PerformanceEventHandlers {
+    onRequestStart?: (event: PerformanceRequestStartEvent) => void;
+    onRequestComplete?: (event: PerformanceRequestCompleteEvent) => void;
+    onRetry?: (event: PerformanceRetryEvent) => void;
+    onMetricRecorded?: (event: PerformanceMetricRecordedEvent) => void;
+    onThresholdExceeded?: (event: PerformanceThresholdExceededEvent) => void;
+    onOptimizationApplied?: (event: PerformanceOptimizationAppliedEvent) => void;
+    onAnyPerformanceEvent?: (event: PerformanceEventData) => void;
+}
+/**
+ * Cache event handlers interface
+ */
+export interface CacheEventHandlers {
+    onCacheHit?: (event: CacheHitEvent) => void;
+    onCacheMiss?: (event: CacheMissEvent) => void;
+    onCacheInvalidate?: (event: CacheInvalidateEvent) => void;
+    onAnyCacheEvent?: (event: CacheEventData) => void;
+}
+/**
+ * Client event handlers interface
+ */
+export interface ClientEventHandlers {
+    onClientConflict?: (event: ClientConflictEvent) => void;
+    onClientDebug?: (event: ClientDebugEvent) => void;
+    onClientCreated?: (event: ClientCreatedEvent) => void;
+    onRequestStart?: (event: RequestStartEvent) => void;
+    onResponseReceived?: (event: ResponseReceivedEvent) => void;
+    onRetryAttempt?: (event: RetryAttemptEvent) => void;
+    onAnyClientEvent?: (event: ClientEventType) => void;
+}