@plyaz/types 1.7.18 → 1.7.20

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

@@ -0,0 +1,628 @@
+/**
+ * Debug Event Types
+ * Type definitions for all debug-related events and data structures
+ */
+import type { ConfigChangeEvent, HeadersTrackedEvent, NetworkConfigOverrideEvent, NetworkOverrideEvent, NetworkQualityEvent } from '../events';
+import type { DebuggerConfigSource } from '..';
+import type { ApiConfig } from '../config';
+import type { EventTrackingAnalysis } from './factories';
+import type { NETWORK_QUALITY, NetworkClientHints, NetworkInfo } from '../network';
+import type { HEADER_STAGES, HISTORY_TYPES } from './enums';
+export type HistoryType = (typeof HISTORY_TYPES)[keyof typeof HISTORY_TYPES];
+export type HeaderStage = (typeof HEADER_STAGES)[keyof typeof HEADER_STAGES];
+/**
+ * Configuration that can be tracked
+ */
+export type TrackableConfig = Partial<ApiConfig> | Record<string, unknown>;
+/**
+ * Configuration conflict details
+ */
+export interface ConfigConflict {
+    /** Property that has a conflict */
+    property: string;
+    /** Previous value before conflict */
+    previousValue: unknown;
+    /** New value after conflict */
+    newValue: unknown;
+    /** Source of the previous value */
+    previousSource: string;
+    /** Source of the new value */
+    newSource: string;
+    /** Reason for precedence */
+    precedenceReason?: string;
+    /** Timestamp of conflict detection */
+    timestamp?: number;
+    /** Which source won the conflict resolution */
+    resolution?: string;
+    /** Severity of the conflict */
+    severity?: 'high' | 'medium' | 'low';
+    /** Description of the conflict */
+    description?: string;
+}
+/**
+ * Performance impact metrics
+ */
+export interface PerformanceImpact {
+    /** User experience score (0-100) */
+    uxScore: number;
+    /** Bandwidth score (0-100) */
+    bandwidthScore: number;
+    /** Latency score (0-100) */
+    latencyScore: number;
+    /** Overall impact level */
+    level: 'NONE' | 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+    /** Number of requests tracked */
+    requestCount?: number;
+    /** Latency impact in milliseconds */
+    latencyImpact?: number;
+    /** Bandwidth impact as percentage */
+    bandwidthImpact?: number;
+    /** Detailed metrics */
+    metrics: {
+        avgLatency?: number;
+        avgBandwidth?: number;
+        errorRate?: number;
+        successRate?: number;
+    };
+    /** Performance recommendations */
+    recommendations?: string[];
+    /** Cache efficiency impact */
+    cacheEfficiencyImpact?: number;
+}
+/**
+ * Active override information
+ */
+export interface ActiveOverride {
+    /** Property being overridden */
+    property: string;
+    /** Original value */
+    originalValue: unknown;
+    /** Override value */
+    overrideValue: unknown;
+    /** Source of override */
+    source: string;
+    /** Reason for override */
+    reason: string;
+    /** When override was applied */
+    appliedAt: number;
+}
+/**
+ * Configuration history entry
+ */
+export interface ConfigHistoryEntry {
+    timestamp: number;
+    changeType: 'override' | 'restore' | 'preset_change' | 'user_preference' | 'auto_optimization';
+    changes?: Array<{
+        property: string;
+        previousValue: unknown;
+        newValue: unknown;
+        source: DebuggerConfigSource;
+    }>;
+    networkConditions?: {
+        quality: NETWORK_QUALITY;
+        info: NetworkInfo;
+    };
+    trigger?: string;
+}
+/**
+ * Debug information structure
+ */
+export interface DebugInfo {
+    /** Current timestamp */
+    timestamp: number;
+    /** Network information */
+    networkInfo: NetworkInfo;
+    /** Network quality assessment */
+    networkQuality: NETWORK_QUALITY;
+    /** Active configuration overrides */
+    activeOverrides: ActiveOverride[];
+    /** Recent configuration conflicts */
+    recentConflicts: ConfigConflict[];
+    /** Performance impact assessment */
+    performanceImpact: PerformanceImpact;
+    /** Configuration change history */
+    configHistory?: ConfigHistoryEntry[];
+    /** Client hints data */
+    clientHints?: NetworkClientHints;
+    /** Additional context data */
+    context: {
+        userAgent?: string;
+        platform?: string;
+        environment?: string;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Debug event listener types
+ */
+export type ConflictHandler = (conflict: ConfigConflict) => void;
+export type ConflictsHandler = (conflicts: ConfigConflict[]) => void;
+export type DebugInfoHandler = (debugInfo: DebugInfo) => void;
+export type ConfigOverrideHandler = (event: NetworkConfigOverrideEvent) => void;
+export type NetworkQualityHandler = (event: NetworkQualityEvent) => void;
+/**
+ * Additional handler type definitions for debug events
+ */
+export type ConfigChangeHandler = (event: ConfigChangeEvent) => void;
+export type HeadersTrackedHandler = (event: HeadersTrackedEvent) => void;
+export type NetworkOverrideHandler = (event: NetworkOverrideEvent) => void;
+export type PerformanceImpactHandler = (impact: PerformanceImpact) => void;
+export type MonitoringAlertHandler = (alert: MonitoringAlert) => void;
+export type NetworkStateChangedHandler = (state: {
+    online: boolean;
+    quality?: string;
+}) => void;
+export type NetworkDataClearedHandler = () => void;
+/**
+ * Debug events configuration
+ */
+export interface DebugEventsConfig {
+    /** Handler for individual conflicts */
+    onConflict?: ConflictHandler | ConflictHandler[];
+    /** Handler for batch conflict checks */
+    onConflictsCheck?: ConflictsHandler | ConflictsHandler[];
+    /** Handler for debug info updates */
+    onDebugInfo?: DebugInfoHandler | DebugInfoHandler[];
+    /** Handler for configuration overrides */
+    onConfigOverride?: ConfigOverrideHandler;
+    /** Handler for network quality changes */
+    onNetworkQualityChange?: NetworkQualityHandler;
+    /** Handler for configuration changes */
+    onConfigChange?: ConfigChangeHandler | ConfigChangeHandler[];
+    /** Handler for headers being tracked */
+    onHeadersTracked?: HeadersTrackedHandler | HeadersTrackedHandler[];
+    /** Handler for network overrides */
+    onNetworkOverride?: NetworkOverrideHandler | NetworkOverrideHandler[];
+    /** Handler for performance impact events */
+    onPerformanceImpact?: PerformanceImpactHandler | PerformanceImpactHandler[];
+    /** Handler for monitoring alerts */
+    onMonitoringAlert?: MonitoringAlertHandler | MonitoringAlertHandler[];
+    /** Handler for network state changes */
+    onNetworkStateChanged?: NetworkStateChangedHandler | NetworkStateChangedHandler[];
+    /** Handler for network data being cleared */
+    onNetworkDataCleared?: NetworkDataClearedHandler | NetworkDataClearedHandler[];
+    /** Enable automatic conflict checking */
+    autoCheckConflicts?: boolean;
+    /** Interval for automatic conflict checks (ms) */
+    autoCheckInterval?: number;
+    /** Enable automatic debug info generation */
+    autoGenerateDebugInfo?: boolean;
+    /** Interval for debug info generation (ms) */
+    debugInfoInterval?: number;
+}
+/**
+ * Alert types for monitoring
+ */
+export interface MonitoringAlert {
+    /** Alert type */
+    type: 'conflict' | 'performance' | 'network';
+    /** Alert message */
+    message: string;
+    /** Alert severity */
+    severity?: 'info' | 'warning' | 'error' | 'critical';
+    /** Additional alert data */
+    data?: ConfigConflict | PerformanceImpact | NetworkQualityEvent['data'];
+    /** Alert timestamp */
+    timestamp: number;
+}
+/**
+ * Factory operation types for type safety
+ */
+export type FactoryOperationType = 'factory_created' | 'factory_accessed' | 'factory_initialized' | 'factories_reset' | 'factory_register' | 'handler_registered' | 'handler_unregistered' | 'scope_listeners_cleared';
+/**
+ * Event operation types for pubsub and event system
+ */
+export type EventOperationType = 'on' | 'once' | 'off' | 'emit' | 'emit_across_scopes' | 'removeAllListeners' | 'once_executed' | 'config_update' | 'config_update_failed' | 'global_config_update' | 'global_config_reset' | 'scope_change' | 'factory_create' | 'factory_coordination' | 'handler_strategy' | 'handler_strategy_applied';
+/**
+ * Combined operation types for unified tracking
+ */
+export type UnifiedOperationType = FactoryOperationType | EventOperationType;
+export interface TrackedValue {
+    value: unknown;
+    source: DebuggerConfigSource;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Header changes detected between transformations
+ */
+export interface HeaderChanges {
+    added?: string[];
+    modified?: string[];
+    removed?: string[];
+}
+export interface HeaderTransformation {
+    stage: HeaderStage;
+    headers: Record<string, string>;
+    source: DebuggerConfigSource;
+    timestamp: number;
+    changes?: HeaderChanges;
+    metadata?: Record<string, unknown>;
+}
+export interface NetworkOverride extends NetworkOverrideParams {
+    appliedAt: number;
+    active: boolean;
+    impact?: number;
+}
+export interface NetworkOverrideParams {
+    property: string;
+    originalValue: unknown;
+    overrideValue: unknown;
+    source: DebuggerConfigSource;
+    reason: string;
+    networkInfo?: NetworkInfo;
+    networkQuality?: NETWORK_QUALITY;
+    temporary?: boolean;
+    duration?: number;
+    trigger?: string;
+}
+export interface DebugHistoryEntry {
+    type: 'config' | 'header' | 'network' | 'performance' | 'event' | 'event_operation';
+    timestamp: number;
+    source: DebuggerConfigSource;
+    changes?: Array<{
+        property: string;
+        oldValue: unknown;
+        newValue: unknown;
+        source: DebuggerConfigSource;
+        timestamp: number;
+    }>;
+    conflicts?: ConfigConflict[];
+    stage?: HeaderStage;
+    headers?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+}
+export interface TrackingResult {
+    changes: Array<{
+        property: string;
+        oldValue: unknown;
+        newValue: unknown;
+        source: DebuggerConfigSource;
+        timestamp: number;
+    }>;
+    conflicts: ConfigConflict[];
+}
+export interface TrackingOptions {
+    phase?: 'initialization' | 'runtime' | 'update';
+    reason?: string;
+    metadata?: Record<string, unknown>;
+    trigger?: string;
+    preset?: string;
+    changeType?: 'override' | 'restore' | 'preset_change' | 'user_preference' | 'auto_optimization';
+    skipHistory?: boolean;
+}
+export interface ComplianceReport {
+    totalEvents: number;
+    configChanges: number;
+    headerChanges: number;
+    conflicts: number;
+    overrides: number;
+    compliance: {
+        tracking: boolean;
+        historyMaintained: boolean;
+        conflictsDetected: boolean;
+    };
+    violations: string[];
+    timestamp: number;
+}
+export interface DebugReport {
+    activeConfigs: Record<string, TrackedValue>;
+    activeOverrides: Record<string, NetworkOverride>;
+    headerPipeline: HeaderTransformation[];
+    stats: {
+        totalChanges: number;
+        conflicts: number;
+        networkOverrides: number;
+        headerTransformations: number;
+    };
+    recentHistory: DebugHistoryEntry[];
+    recentConflicts: ConfigConflict[];
+    performanceAnalysis: {
+        summary: string;
+        score: number;
+        issues: string[];
+    };
+    complianceReport: ComplianceReport;
+    recommendations: string[];
+}
+export interface DebuggerConfigUpdateStrategy {
+    strategy?: 'merge' | 'replace' | 'temporary';
+    preserveFields?: string[];
+    trackUpdate?: boolean;
+}
+/**
+ * Issue priority levels for debugging reports
+ */
+export type IssuePriority = 'critical' | 'high' | 'medium' | 'low';
+/**
+ * Detailed issue information with priority and context
+ */
+export interface DetailedIssue {
+    id: string;
+    title: string;
+    description: string;
+    priority: IssuePriority;
+    category: 'performance' | 'security' | 'compliance' | 'configuration' | 'network';
+    impact: string;
+    recommendation: string;
+    metadata?: Record<string, unknown>;
+    timestamp: number;
+}
+/**
+ * Issue breakdown by scope with detailed analysis
+ */
+export interface IssueBreakdown {
+    scope: string;
+    issues: DetailedIssue[];
+    summary: {
+        total: number;
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+    };
+}
+/**
+ * Enhanced compliance report with detailed issues
+ */
+export interface EnhancedComplianceReport extends ComplianceReport {
+    networkCompliance: {
+        status: 'compliant' | 'needs-review' | 'non-compliant';
+        issues: DetailedIssue[];
+    };
+    dataCompliance: {
+        status: 'compliant' | 'needs-review' | 'non-compliant';
+        issues: DetailedIssue[];
+    };
+    securityHeaders: {
+        status: 'compliant' | 'needs-review' | 'non-compliant';
+        issues: DetailedIssue[];
+    };
+}
+/**
+ * Security analysis for headers
+ */
+export interface HeaderSecurityAnalysis {
+    hasAuthHeaders: boolean;
+    hasSensitiveData: boolean;
+    hasCSPHeaders: boolean;
+    hasSecurityHeaders: boolean;
+    vulnerabilities: string[];
+    recommendations: string[];
+    complianceStatus: 'compliant' | 'non-compliant' | 'needs-review';
+}
+/**
+ * Event migration analysis
+ */
+export interface EventMigrationAnalysis {
+    oldSystemEvents: string[];
+    newSystemEvents: string[];
+    migrationStatus: 'complete' | 'in-progress' | 'not-started';
+    unmappedEvents: string[];
+    deprecatedHandlers: string[];
+    recommendations: string[];
+}
+/**
+ * Network adaptation analysis
+ */
+export interface NetworkAdaptationAnalysis {
+    currentQuality: NETWORK_QUALITY;
+    adaptationHistory: Array<{
+        timestamp: number;
+        from: NETWORK_QUALITY;
+        to: NETWORK_QUALITY;
+        reason: string;
+    }>;
+    effectiveness: number;
+    score: number;
+    timeInPoorNetwork: number;
+    timeInGoodNetwork: number;
+    adaptationFrequency: number;
+    recommendations: string[];
+}
+/**
+ * Temporary config lifecycle analysis
+ */
+export interface TemporaryConfigAnalysis {
+    activeTemporaryConfigs: number;
+    averageLifetime: number;
+    orphanedConfigs: string[];
+    leakRisk: 'low' | 'medium' | 'high';
+    cleanupEffectiveness: number;
+    recommendations: string[];
+}
+/**
+ * Fetchff interceptor analysis
+ */
+export interface InterceptorChainAnalysis {
+    requestInterceptors: string[];
+    responseInterceptors: string[];
+    errorInterceptors: string[];
+    executionOrder: string[];
+    averageLatency: number;
+    bottlenecks: Array<{
+        interceptor: string;
+        latency: number;
+        impact: 'low' | 'medium' | 'high';
+    }>;
+    recommendations: string[];
+}
+/**
+ * Event emitter factory analysis
+ */
+export interface EventFactoryAnalysis {
+    name: string;
+    scope: string;
+    listenerCount: number;
+    events: string[];
+    state: 'active' | 'inactive' | 'error';
+    lastActivity?: number;
+    memoryFootprint?: number;
+}
+/**
+ * Event scope analysis
+ */
+export interface EventScopeAnalysis {
+    scope: string;
+    eventCount: number;
+    listenerCount: number;
+    events: Array<{
+        name: string;
+        listeners: number;
+        category: string;
+        lastEmitted?: number;
+        frequency?: number;
+    }>;
+    memoryUsage: number;
+    recommendations: string[];
+}
+/**
+ * Available events analysis by source
+ */
+export interface AvailableEventsAnalysis {
+    sourceType: 'createApiClient' | 'config' | 'updateConfig' | 'manual' | 'pubsub' | 'eventManager' | 'clientEventManager' | 'factory';
+    events: Array<{
+        name: string;
+        category: string;
+        scope: string;
+        initialized: boolean;
+        usage: 'active' | 'passive' | 'inactive' | 'never-used';
+        lastUsed?: number;
+        emitCount?: number;
+        lastEmitted?: number;
+    }>;
+    initializationSource: string;
+    recommendedEvents: string[];
+}
+/**
+ * Event validation report
+ */
+export interface EventValidationReport {
+    validEvents: string[];
+    invalidEvents: Array<{
+        attempted: string;
+        reason: string;
+        suggestions: string[];
+        potentialSources: string[];
+    }>;
+    missingInitializations: Array<{
+        event: string;
+        requiredFor: string[];
+        initializationOptions: string[];
+    }>;
+    recommendations: string[];
+}
+/**
+ * Comprehensive event emitter analysis
+ */
+export interface EventEmitterAnalysis {
+    systemOverview: {
+        totalEvents: number;
+        totalListeners: number;
+        totalFactories: number;
+        memoryUsage: number;
+        healthScore: number;
+    };
+    factoryDetails: EventFactoryAnalysis[];
+    scopeBreakdown: EventScopeAnalysis[];
+    availableEvents: AvailableEventsAnalysis[];
+    validation: EventValidationReport;
+    performanceMetrics: {
+        eventEmissionLatency: number;
+        listenerExecutionTime: number;
+        memoryLeaks: string[];
+        optimizationOpportunities: string[];
+    };
+    recommendations: string[];
+    trackingAnalysis?: EventTrackingAnalysis;
+    isEnabled: boolean;
+}
+export interface AnalyzeConfigImpact {
+    impact: 'positive' | 'negative' | 'neutral';
+    factors: string[];
+    suggestions: string[];
+}
+export interface ConflictPatterns {
+    mostConflictedProperties: Array<{
+        property: string;
+        count: number;
+    }>;
+    conflictingSources: Array<{
+        source: string;
+        count: number;
+    }>;
+    resolutionPatterns: Array<{
+        pattern: string;
+        count: number;
+    }>;
+    recommendations: string[];
+}
+/**
+ * Comprehensive debug report
+ */
+export interface ComprehensiveDebugReport extends DebugReport {
+    headerSecurity: HeaderSecurityAnalysis;
+    complianceAnalysis: {
+        overall: ComplianceReport;
+        networkCompliance: 'compliant' | 'non-compliant' | 'needs-review';
+        dataCompliance: 'compliant' | 'non-compliant' | 'needs-review';
+        autoDetectedIssues: string[];
+    };
+    eventMigration: EventMigrationAnalysis;
+    eventEmitterAnalysis: EventEmitterAnalysis;
+    eventStatistics: {
+        totalEvents: number;
+        eventsPerMinute: number;
+        topEvents: Array<{
+            event: string;
+            count: number;
+        }>;
+        errorEvents: number;
+        droppedEvents: number;
+    };
+    networkAdaptation: NetworkAdaptationAnalysis;
+    performanceBreakdown: {
+        networkLatency: number;
+        processingTime: number;
+        cacheHitRate: number;
+        errorRate: number;
+        p95ResponseTime: number;
+        p99ResponseTime: number;
+    };
+    temporaryConfigs: TemporaryConfigAnalysis;
+    configurationHealth: {
+        conflicts: number;
+        overrides: number;
+        stability: 'stable' | 'unstable' | 'critical';
+        driftFromBaseline: number;
+        impact?: AnalyzeConfigImpact;
+        conflictPatterns?: ConflictPatterns;
+    };
+    interceptorAnalysis: InterceptorChainAnalysis;
+    systemHealth: {
+        score: number;
+        status: 'healthy' | 'degraded' | 'critical';
+        criticalIssues: string[];
+        warnings: string[];
+        recommendations: string[];
+    };
+    trends: {
+        performanceTrend: 'improving' | 'stable' | 'degrading';
+        errorTrend: 'increasing' | 'stable' | 'decreasing';
+        networkQualityTrend: 'improving' | 'stable' | 'degrading';
+        configStabilityTrend: 'improving' | 'stable' | 'degrading';
+    };
+    networkContext: {
+        networkInfo?: NetworkInfo;
+        networkQuality?: NETWORK_QUALITY;
+        clientHints?: unknown;
+    };
+}
+export interface EventEmitterLike {
+    listenerCount(event?: string): number;
+}
+export interface FactoryLike {
+    scope?: string;
+    emit?: <T = unknown>(event: string, data?: T) => void;
+    lastActivity?: number;
+}

package/dist/api/endpoints/campaigns/index.d.ts

@@ -0,0 +1 @@
+export type * from './types';

package/dist/api/endpoints/campaigns/types.d.ts

@@ -0,0 +1,68 @@
+import type { Endpoint, Req } from 'fetchff';
+interface Campaign {
+    id: string;
+    name: string;
+    description: string;
+    status: 'draft' | 'active' | 'paused' | 'completed';
+    startDate: string;
+    endDate: string;
+    athleteIds: string[];
+    createdAt: string;
+    updatedAt: string;
+}
+interface CampaignStats {
+    totalParticipants: number;
+    totalViews: number;
+    engagement: number;
+    performance: Record<string, unknown>;
+}
+interface CampaignListParams {
+    limit?: number;
+    offset?: number;
+    status?: Campaign['status'];
+    athleteId?: string;
+}
+interface CampaignCreateBody {
+    name: string;
+    description: string;
+    startDate: string;
+    endDate: string;
+    athleteIds?: string[];
+}
+interface CampaignUpdateBody {
+    name?: string;
+    description?: string;
+    status?: Campaign['status'];
+    startDate?: string;
+    endDate?: string;
+}
+interface CampaignPathParams {
+    id: string;
+}
+interface JoinCampaignBody {
+    athleteId: string;
+}
+/**
+ * Campaign endpoint types for TypeScript
+ * Using fetchff's Req type to properly define endpoints
+ */
+export interface CampaignEndpointTypes {
+    getCampaign: Endpoint<Req<Campaign, never, never, CampaignPathParams>>;
+    listCampaigns: Endpoint<Req<Campaign[], never, CampaignListParams>>;
+    createCampaign: Endpoint<Req<Campaign, CampaignCreateBody>>;
+    updateCampaign: Endpoint<Req<Campaign, CampaignUpdateBody, never, CampaignPathParams>>;
+    deleteCampaign: Endpoint<Req<{
+        success: boolean;
+    }, never, never, CampaignPathParams>>;
+    getCampaignStats: Endpoint<Req<CampaignStats, never, never, CampaignPathParams>>;
+    getCampaignParticipants: Endpoint<Req<{
+        athleteIds: string[];
+    }, never, never, CampaignPathParams>>;
+    joinCampaign: Endpoint<Req<{
+        success: boolean;
+    }, JoinCampaignBody, never, CampaignPathParams>>;
+    leaveCampaign: Endpoint<Req<{
+        success: boolean;
+    }, JoinCampaignBody, never, CampaignPathParams>>;
+}
+export {};

package/dist/api/endpoints/health/index.d.ts

@@ -0,0 +1 @@
+export type * from './types';