@plyaz/types 1.7.18 → 1.7.20

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

@@ -0,0 +1,262 @@
+/**
+ * Event Namespace Constants
+ * Centralized constants for all event namespaces in the API package
+ */
+/**
+ * Main event namespaces for the API package
+ */
+export declare const EVENT_NAMESPACES: {
+    readonly HEADERS: "headers";
+    readonly NETWORK: "network";
+    readonly ERRORS: "errors";
+    readonly DEBUG: "debug";
+    readonly CONFIG: "config";
+    readonly PERFORMANCE: "performance";
+    readonly CLIENT: "client";
+    readonly CACHE: "cache";
+    readonly POLLING: "polling";
+    readonly REQUEST: "request";
+    readonly REVALIDATION: "revalidation";
+    readonly EVENT_MANAGER: "eventManager";
+};
+/**
+ * Header-specific event keys
+ */
+export declare const HEADER_EVENTS: {
+    readonly CHANGED: "headers:changed";
+    readonly ENRICHED: "headers:enriched";
+    readonly CONFLICT: "headers:conflict";
+    readonly OVERRIDE: "headers:override";
+    readonly TRACKED: "headers:tracked";
+    readonly MERGED: "headers:merged";
+    readonly FILTERED: "headers:filtered";
+    readonly VALIDATED: "headers:validated";
+    readonly CACHED: "headers:cached";
+    readonly CACHE_HIT: "headers:cache:hit";
+    readonly CACHE_MISS: "headers:cache:miss";
+    readonly ANY: "headers:*";
+};
+/**
+ * Network-specific event keys
+ */
+export declare const NETWORK_EVENTS: {
+    readonly QUALITY_CHANGE: "network:quality:changed";
+    readonly INFO_UPDATE: "network:info-update";
+    readonly CONFIG_OVERRIDE: "network:config:override";
+    readonly CONFIG_RESTORED: "network:config:restored";
+    readonly OVERRIDE_CHANGE: "network:override-change";
+    readonly PRESET_APPLIED: "network:preset-applied";
+    readonly PRESET_CHANGED: "network:preset:changed";
+    readonly HINTS_UPDATED: "network:hints:updated";
+    readonly AUTO_DETECTION: "network:auto:detection";
+    readonly MANUAL_UPDATE: "network:manual:update";
+    readonly ANY: "network:*";
+};
+/**
+ * Error-specific event keys
+ */
+export declare const ERROR_EVENTS: {
+    readonly NETWORK_ERROR: "errors:network";
+    readonly VALIDATION_ERROR: "errors:validation";
+    readonly AUTHENTICATION_ERROR: "errors:authentication";
+    readonly AUTHORIZATION_ERROR: "errors:authorization";
+    readonly RATE_LIMIT_ERROR: "errors:rate-limit";
+    readonly SERVER_ERROR: "errors:server";
+    readonly CLIENT_ERROR: "errors:client";
+    readonly TIMEOUT_ERROR: "errors:timeout";
+    readonly CONFLICT_ERROR: "errors:conflict";
+    readonly CACHE_ERROR: "errors:cache";
+    readonly HEADERS_ERROR: "errors:headers";
+    readonly RETRY_ERROR: "errors:retry";
+    readonly STRATEGY_ERROR: "errors:strategy";
+    readonly REGIONAL_ERROR: "errors:regional";
+    readonly NOT_FOUND_ERROR: "errors:not-found";
+    readonly EXTERNAL_SERVICE_ERROR: "errors:external-service";
+    readonly UNKNOWN_ERROR: "errors:unknown";
+    readonly GENERIC_ERROR: "errors:generic";
+    readonly ANY: "errors:*";
+};
+/**
+ * Handler scopes for different levels of event handlers
+ * These prefixes are used for registering handlers at different priority levels
+ * Can be used for any type of handler (error, request, response, debug, etc.)
+ *
+ * Priority order (lowest to highest):
+ * 1. GLOBAL - Set via setGlobalErrorHandlers(), persists across all instances
+ * 2. CONFIG - Set via setGlobalConfig({ errorHandlers }), global configuration
+ * 3. CLIENT - Set via createApiClient({ errorHandlers }), instance-specific
+ * 4. REQUEST/TEMPORARY - Set per-request or via updateConfig(), highest priority
+ *
+ * Usage:
+ * - GLOBAL: For app-wide handlers that should always run (e.g., logging)
+ * - CONFIG: For environment-specific handlers (e.g., dev vs prod)
+ * - CLIENT: For instance-specific handlers (e.g., per-service client)
+ * - REQUEST/TEMPORARY: For request-specific or runtime updates
+ *
+ * Note: REQUEST and TEMPORARY are aliases - both use 'request' scope
+ *
+ * Examples of namespaced handlers:
+ * - Error handlers: 'global:error', 'config:error', 'client:error'
+ * - Debug handlers: 'global:debug', 'config:debug', 'client:debug'
+ * - Request handlers: 'global:request', 'config:request', 'client:request'
+ */
+export declare const HANDLER_SCOPES: {
+    readonly GLOBAL: "global";
+    readonly CONFIG: "config";
+    readonly CLIENT: "client";
+    readonly TEMPORARY: "request";
+    readonly REQUEST: "request";
+};
+/**
+ * Core event scopes (excluding aliases)
+ * These are the actual scope values used by the event system
+ */
+export declare const EVENT_SCOPES: readonly ["global", "config", "client", "request"];
+/**
+ * All event scopes including 'temporary' alias
+ * Used in APIs where 'temporary' provides semantic clarity
+ */
+export declare const EVENT_SCOPES_WITH_TEMPORARY: readonly ["global", "config", "client", "request", "temporary"];
+/**
+ * Debug-specific event keys
+ */
+export declare const DEBUG_EVENTS: {
+    readonly CONFIG_CONFLICT: "debug:config-conflict";
+    readonly CONFIG_CHANGE: "debug:config-change";
+    readonly HEADERS_TRACKED: "debug:headers-tracked";
+    readonly NETWORK_OVERRIDE: "debug:network-override";
+    readonly NETWORK_STATE_CHANGED: "debug:network-state-changed";
+    readonly NETWORK_DATA_CLEARED: "debug:network-data-cleared";
+    readonly DEBUG_INFO: "debug:info";
+    readonly PERFORMANCE_IMPACT: "debug:performance-impact";
+    readonly MONITORING_ALERT: "debug:monitoring-alert";
+    readonly CONFIG_TRACKED: "debug:config-tracked";
+    readonly CONFLICTS_BATCH: "debug:conflicts-batch";
+    readonly EVENT_OPERATION: "debug:event-operation";
+    readonly ANY: "debug:*";
+};
+/**
+ * Configuration sources - where config updates originate from
+ */
+export declare const EVENTS_CONFIG_SOURCES: {
+    readonly GLOBAL: "global";
+    readonly CREATE_API_CLIENT: "createApiClient";
+    readonly UPDATE_CONFIG: "updateConfig";
+    readonly MANUAL: "manual";
+    readonly ENVIRONMENT: "environment";
+    readonly PRESET: "preset";
+    readonly NETWORK_AWARE: "networkAware";
+    readonly ADAPTIVE: "adaptive";
+};
+/**
+ * Configuration-specific event keys
+ */
+export declare const CONFIG_EVENTS: {
+    readonly GLOBAL_UPDATED: "config:global-updated";
+    readonly GLOBAL_RESET: "config:global-reset";
+    readonly ENVIRONMENT_CONFIGURED: "config:environment-configured";
+    readonly PRESET_APPLIED: "config:preset-applied";
+    readonly ANY: "config:*";
+};
+/**
+ * Performance-specific event keys
+ */
+export declare const PERFORMANCE_EVENTS: {
+    readonly REQUEST_START: "performance:request-start";
+    readonly REQUEST_COMPLETE: "performance:request-complete";
+    readonly RETRY: "performance:retry";
+    readonly THRESHOLD_EXCEEDED: "performance:threshold-exceeded";
+    readonly OPTIMIZATION_APPLIED: "performance:optimization-applied";
+    readonly METRIC_RECORDED: "performance:metric-recorded";
+    readonly ANY: "performance:*";
+};
+/**
+ * Client-specific event keys
+ */
+export declare const CLIENT_EVENTS: {
+    readonly CONFLICT: "client:conflict";
+    readonly DEBUG: "client:debug";
+    readonly CREATED: "client:created";
+    readonly ANY: "client:*";
+};
+/**
+ * Cache-specific event keys
+ */
+export declare const CACHE_EVENTS: {
+    readonly HIT: "cache:hit";
+    readonly MISS: "cache:miss";
+    readonly INVALIDATE: "cache:invalidate";
+    readonly ANY: "cache:*";
+};
+/**
+ * All event keys combined for easy access
+ */
+export declare const ALL_EVENTS: {
+    readonly HIT: "cache:hit";
+    readonly MISS: "cache:miss";
+    readonly INVALIDATE: "cache:invalidate";
+    readonly ANY: "cache:*";
+    readonly CONFLICT: "client:conflict";
+    readonly DEBUG: "client:debug";
+    readonly CREATED: "client:created";
+    readonly REQUEST_START: "performance:request-start";
+    readonly REQUEST_COMPLETE: "performance:request-complete";
+    readonly RETRY: "performance:retry";
+    readonly THRESHOLD_EXCEEDED: "performance:threshold-exceeded";
+    readonly OPTIMIZATION_APPLIED: "performance:optimization-applied";
+    readonly METRIC_RECORDED: "performance:metric-recorded";
+    readonly GLOBAL_UPDATED: "config:global-updated";
+    readonly GLOBAL_RESET: "config:global-reset";
+    readonly ENVIRONMENT_CONFIGURED: "config:environment-configured";
+    readonly PRESET_APPLIED: "config:preset-applied";
+    readonly CONFIG_CONFLICT: "debug:config-conflict";
+    readonly CONFIG_CHANGE: "debug:config-change";
+    readonly HEADERS_TRACKED: "debug:headers-tracked";
+    readonly NETWORK_OVERRIDE: "debug:network-override";
+    readonly NETWORK_STATE_CHANGED: "debug:network-state-changed";
+    readonly NETWORK_DATA_CLEARED: "debug:network-data-cleared";
+    readonly DEBUG_INFO: "debug:info";
+    readonly PERFORMANCE_IMPACT: "debug:performance-impact";
+    readonly MONITORING_ALERT: "debug:monitoring-alert";
+    readonly CONFIG_TRACKED: "debug:config-tracked";
+    readonly CONFLICTS_BATCH: "debug:conflicts-batch";
+    readonly EVENT_OPERATION: "debug:event-operation";
+    readonly NETWORK_ERROR: "errors:network";
+    readonly VALIDATION_ERROR: "errors:validation";
+    readonly AUTHENTICATION_ERROR: "errors:authentication";
+    readonly AUTHORIZATION_ERROR: "errors:authorization";
+    readonly RATE_LIMIT_ERROR: "errors:rate-limit";
+    readonly SERVER_ERROR: "errors:server";
+    readonly CLIENT_ERROR: "errors:client";
+    readonly TIMEOUT_ERROR: "errors:timeout";
+    readonly CONFLICT_ERROR: "errors:conflict";
+    readonly CACHE_ERROR: "errors:cache";
+    readonly HEADERS_ERROR: "errors:headers";
+    readonly RETRY_ERROR: "errors:retry";
+    readonly STRATEGY_ERROR: "errors:strategy";
+    readonly REGIONAL_ERROR: "errors:regional";
+    readonly NOT_FOUND_ERROR: "errors:not-found";
+    readonly EXTERNAL_SERVICE_ERROR: "errors:external-service";
+    readonly UNKNOWN_ERROR: "errors:unknown";
+    readonly GENERIC_ERROR: "errors:generic";
+    readonly QUALITY_CHANGE: "network:quality:changed";
+    readonly INFO_UPDATE: "network:info-update";
+    readonly CONFIG_OVERRIDE: "network:config:override";
+    readonly CONFIG_RESTORED: "network:config:restored";
+    readonly OVERRIDE_CHANGE: "network:override-change";
+    readonly PRESET_CHANGED: "network:preset:changed";
+    readonly HINTS_UPDATED: "network:hints:updated";
+    readonly AUTO_DETECTION: "network:auto:detection";
+    readonly MANUAL_UPDATE: "network:manual:update";
+    readonly CHANGED: "headers:changed";
+    readonly ENRICHED: "headers:enriched";
+    readonly OVERRIDE: "headers:override";
+    readonly TRACKED: "headers:tracked";
+    readonly MERGED: "headers:merged";
+    readonly FILTERED: "headers:filtered";
+    readonly VALIDATED: "headers:validated";
+    readonly CACHED: "headers:cached";
+    readonly CACHE_HIT: "headers:cache:hit";
+    readonly CACHE_MISS: "headers:cache:miss";
+};
+export type EventsConfigSource = (typeof EVENTS_CONFIG_SOURCES)[keyof typeof EVENTS_CONFIG_SOURCES];

package/dist/api/events/factories/cache/index.d.ts

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

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

@@ -0,0 +1,60 @@
+import type { EventOptions } from '..';
+import type { CACHE_EVENTS } from '../..';
+/**
+ * Cache hit event
+ */
+export interface CacheHitEvent {
+    type: typeof CACHE_EVENTS.HIT;
+    timestamp: number;
+    data: {
+        key: string;
+        value?: unknown;
+        age?: number;
+        ttl?: number;
+    };
+}
+/**
+ * Cache miss event
+ */
+export interface CacheMissEvent {
+    type: typeof CACHE_EVENTS.MISS;
+    timestamp: number;
+    data: {
+        key: string;
+        reason?: 'not_found' | 'expired' | 'disabled';
+    };
+}
+/**
+ * Cache invalidate event
+ */
+export interface CacheInvalidateEvent {
+    type: typeof CACHE_EVENTS.INVALIDATE;
+    timestamp: number;
+    data: {
+        key?: string;
+        pattern?: string;
+        reason?: string;
+        count?: number;
+    };
+}
+/**
+ * All cache event types
+ */
+export type CacheEventData = CacheHitEvent | CacheMissEvent | CacheInvalidateEvent;
+/**
+ * Options for emitHit method
+ */
+export interface EmitHitOptions extends EventOptions {
+    value?: unknown;
+    age?: number;
+    ttl?: number;
+}
+/**
+ * Options for emitInvalidate method
+ */
+export interface EmitInvalidateOptions extends EventOptions {
+    key?: string;
+    pattern?: string;
+    reason?: string;
+    count?: number;
+}

package/dist/api/events/factories/client/index.d.ts

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

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

@@ -0,0 +1,120 @@
+/**
+ * Client Event Factory
+ * Creates and emits client-related events with type safety
+ */
+import { type BaseEvent, type EventOptions } from '..';
+import type { CLIENT_EVENTS } from '../..';
+import type { ConfigConflict, DebugInfo } from '../../../debugger';
+/**
+ * Base structure for client events
+ */
+export interface ClientEvent extends BaseEvent {
+    type: string;
+    data: unknown;
+}
+/**
+ * Client conflict event
+ */
+export interface ClientConflictEvent extends BaseEvent {
+    type: typeof CLIENT_EVENTS.CONFLICT;
+    data: ConfigConflict;
+}
+/**
+ * Client debug event
+ */
+export interface ClientDebugEvent extends BaseEvent {
+    type: typeof CLIENT_EVENTS.DEBUG;
+    data: DebugInfo;
+}
+/**
+ * Client created event
+ */
+export interface ClientCreatedEvent extends BaseEvent {
+    type: typeof CLIENT_EVENTS.CREATED;
+    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;
+    };
+}
+/**
+ * Options for emitResponseReceived method
+ */
+export interface EmitResponseReceivedOptions extends EventOptions {
+    url?: string;
+    status?: number;
+    statusText?: string;
+    headers?: Record<string, string>;
+}
+/**
+ * Options for emitRetryAttempt method
+ */
+export interface EmitRetryAttemptOptions extends EventOptions {
+    error: {
+        message: string;
+        code?: string;
+        status?: number;
+    };
+    attempt: number;
+    maxAttempts: number;
+    delay: number;
+    url?: string;
+    method?: string;
+}
+/**
+ * All client event types union
+ */
+export type ClientEventType = ClientConflictEvent | ClientDebugEvent | ClientCreatedEvent | RequestStartEvent | ResponseReceivedEvent | RetryAttemptEvent;
+/**
+ * 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;
+}

package/dist/api/events/factories/config/index.d.ts

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

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

@@ -0,0 +1,77 @@
+/**
+ * Config Event Factory
+ * Factory for creating and emitting configuration-related events
+ */
+import type { DebuggerConfigSource, CONFIG_EVENTS, EventOptions, ApiConfig } from '../../..';
+/**
+ * Configuration updated event
+ */
+export interface ConfigGlobalUpdatedEvent {
+    type: typeof CONFIG_EVENTS.GLOBAL_UPDATED;
+    timestamp: number;
+    data: {
+        previous: ApiConfig;
+        current: ApiConfig;
+        source: DebuggerConfigSource;
+        changes: string[];
+    };
+}
+/**
+ * Configuration reset event
+ */
+export interface ConfigGlobalResetEvent {
+    type: typeof CONFIG_EVENTS.GLOBAL_RESET;
+    timestamp: number;
+    data: {
+        previous: ApiConfig;
+        defaults: ApiConfig;
+        source: DebuggerConfigSource;
+    };
+}
+/**
+ * Environment configured event
+ */
+export interface ConfigEnvironmentEvent {
+    type: typeof CONFIG_EVENTS.ENVIRONMENT_CONFIGURED;
+    timestamp: number;
+    data: {
+        environment: string;
+        config: ApiConfig;
+        source: DebuggerConfigSource;
+    };
+}
+/**
+ * Preset applied event
+ */
+export interface ConfigPresetAppliedEvent {
+    type: typeof CONFIG_EVENTS.PRESET_APPLIED;
+    timestamp: number;
+    data: {
+        presetName: string;
+        config: ApiConfig;
+        source: DebuggerConfigSource;
+    };
+}
+/**
+ * All config event types
+ */
+export type ConfigEventData = ConfigGlobalUpdatedEvent | ConfigGlobalResetEvent | ConfigEnvironmentEvent | ConfigPresetAppliedEvent;
+/**
+ * Options for emitGlobalUpdated method
+ */
+export interface EmitGlobalUpdatedOptions extends EventOptions {
+    previous: ApiConfig;
+    current: ApiConfig;
+    source: DebuggerConfigSource;
+    changes: string[];
+}
+/**
+ * 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;
+}

package/dist/api/events/factories/debug/index.d.ts

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

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

@@ -0,0 +1,131 @@
+/**
+ * Debug Event Factory
+ * Creates and emits debug-related events with type safety
+ */
+import { type BaseEvent, type EventOptions } from '..';
+import type { DEBUG_EVENTS } from '../..';
+import type { ConfigConflict, DebugInfo, ActiveOverride, PerformanceImpact, MonitoringAlert } from '../../../debugger';
+import type { DebuggerConfigSource } from '../../..';
+/**
+ * Base structure for debug events
+ */
+export interface DebugEvent extends BaseEvent {
+    type: string;
+    data: Record<string, unknown>;
+}
+/**
+ * Config conflict event
+ */
+export interface ConfigConflictEvent extends BaseEvent {
+    type: typeof DEBUG_EVENTS.CONFIG_CONFLICT;
+    data: ConfigConflict;
+}
+/**
+ * Config change event
+ */
+export interface ConfigChangeEvent extends BaseEvent {
+    type: typeof DEBUG_EVENTS.CONFIG_CHANGE;
+    data: {
+        property: string;
+        oldValue: unknown;
+        newValue: unknown;
+        source: DebuggerConfigSource;
+        reason?: string;
+    };
+}
+/**
+ * Headers tracked event
+ */
+export interface HeadersTrackedEvent extends BaseEvent {
+    type: typeof DEBUG_EVENTS.HEADERS_TRACKED;
+    data: {
+        headers: Record<string, string>;
+        source: DebuggerConfigSource;
+        metadata?: {
+            phase: 'config' | 'request' | 'response';
+            reason?: string;
+        };
+    };
+}
+/**
+ * Network override event
+ */
+export interface NetworkOverrideEvent extends BaseEvent {
+    type: typeof DEBUG_EVENTS.NETWORK_OVERRIDE;
+    data: {
+        overrides: ActiveOverride[];
+        reason: string;
+        temporary?: boolean;
+    };
+}
+/**
+ * Debug info update event
+ */
+export interface DebugInfoUpdateEvent extends BaseEvent {
+    type: typeof DEBUG_EVENTS.DEBUG_INFO;
+    data: DebugInfo;
+}
+/**
+ * Performance impact event
+ */
+export interface PerformanceImpactEvent extends BaseEvent {
+    type: typeof DEBUG_EVENTS.PERFORMANCE_IMPACT;
+    data: PerformanceImpact & {
+        source: 'network' | 'config' | 'strategy' | 'adaptive';
+        recommendation?: string;
+        operation?: string;
+        duration?: number;
+        impact?: 'low' | 'medium' | 'high';
+    };
+}
+/**
+ * Monitoring alert event
+ */
+export interface MonitoringAlertEvent extends BaseEvent {
+    type: typeof DEBUG_EVENTS.MONITORING_ALERT;
+    data: MonitoringAlert;
+}
+/**
+ * Config tracking event
+ */
+export interface ConfigTrackingEvent extends BaseEvent {
+    type: typeof DEBUG_EVENTS.CONFIG_TRACKED;
+    data: {
+        config: Record<string, unknown>;
+        source: DebuggerConfigSource;
+        phase: 'initialization' | 'runtime' | 'update';
+        metadata?: Record<string, unknown>;
+    };
+}
+/**
+ * Options for emitConfigChange method
+ */
+export interface EmitConfigChangeOptions extends EventOptions {
+    property: string;
+    oldValue: unknown;
+    newValue: unknown;
+    source: DebuggerConfigSource;
+    reason?: string;
+}
+/**
+ * Options for emitHeadersTracked method
+ */
+export interface EmitHeadersTrackedOptions extends EventOptions {
+    headers: Record<string, string>;
+    source: DebuggerConfigSource;
+    phase?: 'config' | 'request' | 'response';
+    reason?: string;
+}
+/**
+ * Options for emitConfigTracked method
+ */
+export interface EmitConfigTrackedOptions extends EventOptions {
+    config: Record<string, unknown>;
+    source: DebuggerConfigSource;
+    phase?: 'initialization' | 'runtime' | 'update';
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Union type for all debug event types
+ */
+export type DebugEventData = ConfigConflictEvent | ConfigChangeEvent | HeadersTrackedEvent | NetworkOverrideEvent | DebugInfoUpdateEvent | PerformanceImpactEvent | MonitoringAlertEvent | ConfigTrackingEvent;

package/dist/api/events/factories/errors/index.d.ts

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