@plyaz/types 1.7.30 → 1.8.0

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

@@ -158,7 +158,7 @@ export interface TrackConfigUpdateParams {
 export interface ClientEventManagerLike<TEventManager> {
     readonly emitter: TEventManager extends {
         getEmitter(): infer E;
-    } ? E : never;
+    } ? E : unknown;
     addHandler(event: string, handler: Function | Function[], options?: HandlerOptions): () => void;
     updateConfig(updates: Partial<ApiConfig>, options?: UpdateConfigOptions): void;
     clearTemporaryOverrides(): void;
@@ -222,3 +222,42 @@ export type ApiClientWithEvents<TEventManager, EndpointsList = UnknownRecord> =
     clearTemporaryOverrides(): void;
     getConfig(): ApiConfigWithMetadata;
 };
+/**
+ * Configuration for temporary override setup
+ */
+export interface TemporaryOverrideSetupConfig<ApiClientInstance> {
+    client: ApiClientInstance;
+    options: NonNullable<ApiClientOptions['networkAware']>;
+    userConfig: ApiClientOptions['preservedConfig'];
+}
+/**
+ * Parameters for mergeHandlerConfig helper function
+ */
+export interface MergeHandlerConfigParams<T extends object | Function> {
+    handlerStrategy: HandlerStrategy;
+    usePriority: boolean;
+    global: T | undefined;
+    client: T | undefined;
+    request: T | undefined;
+}
+/**
+ * Parameters for merging handler types
+ */
+export interface MergeHandlerTypesParams {
+    merged: Partial<ApiConfig>;
+    handlerStrategy: HandlerStrategy;
+    usePriority: boolean;
+    global?: Partial<ApiConfig>;
+    client?: Partial<ApiConfig>;
+    request?: Partial<ApiConfig>;
+}
+/**
+ * Parameters for setupUnifiedHandlers
+ */
+export interface SetupUnifiedHandlersParams {
+    mergedConfig: ApiConfig;
+    enrichedHeadersConfig?: ApiClientOptions['enrichedHeaders'];
+    globalConfig?: ApiConfig;
+    clientOptions?: ApiClientOptions;
+    clearTemporaryOverrides?: () => void;
+}

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

@@ -2,6 +2,7 @@
  * Debugger Event Namespaces and Constants
  * Centralized definition of all debugger tracking operations and event types
  */
+import type { HistoryType, UnifiedOperationType } from '..';
 /**
  * Factory operation types for tracking
  * Used when tracking factory-related operations
@@ -113,6 +114,56 @@ export declare const UPDATE_STRATEGIES: {
     readonly REPLACE: "replace";
     readonly TEMPORARY: "temporary";
 };
+/**
+ * Config change types
+ * Used to categorize configuration changes
+ */
+export declare const CHANGE_TYPES: {
+    readonly OVERRIDE: "override";
+    readonly RESTORE: "restore";
+    readonly PRESET_CHANGE: "preset_change";
+    readonly USER_PREFERENCE: "user_preference";
+    readonly AUTO_OPTIMIZATION: "auto_optimization";
+};
+/**
+ * Tracking phases
+ * Used to identify when tracking occurs
+ */
+export declare const TRACKING_PHASES: {
+    readonly INITIALIZATION: "initialization";
+    readonly RUNTIME: "runtime";
+    readonly UPDATE: "update";
+};
+/**
+ * Performance impact levels
+ * Used to categorize performance impact
+ */
+export declare const IMPACT_LEVELS: {
+    readonly NONE: "NONE";
+    readonly LOW: "LOW";
+    readonly MEDIUM: "MEDIUM";
+    readonly HIGH: "HIGH";
+    readonly CRITICAL: "CRITICAL";
+};
+/**
+ * Monitoring alert severities
+ * Used to categorize alert severity
+ */
+export declare const ALERT_SEVERITIES: {
+    readonly INFO: "info";
+    readonly WARNING: "warning";
+    readonly ERROR: "error";
+    readonly CRITICAL: "critical";
+};
+/**
+ * Monitoring alert types
+ * Used to categorize monitoring alerts
+ */
+export declare const ALERT_TYPES: {
+    readonly CONFLICT: "conflict";
+    readonly PERFORMANCE: "performance";
+    readonly NETWORK: "network";
+};
 /**
  * Combined operation types for unified tracking
  */
@@ -150,4 +201,18 @@ export declare const UNIFIED_OPERATIONS: {
     readonly HANDLER_UNREGISTERED: "handler_unregistered";
     readonly SCOPE_LISTENERS_CLEARED: "scope_listeners_cleared";
 };
+export type QueueOperationType = (typeof QUEUE_OPERATIONS)[keyof typeof QUEUE_OPERATIONS];
 export type DebuggerConfigSource = (typeof DEBUGGER_CONFIG_SOURCES)[keyof typeof DEBUGGER_CONFIG_SOURCES];
+export type ChangeType = (typeof CHANGE_TYPES)[keyof typeof CHANGE_TYPES];
+/**
+ * Helper to check if a string is a valid operation type
+ */
+export declare function isValidOperation(operation: string): operation is UnifiedOperationType;
+/**
+ * Helper to check if a string is a valid config source
+ */
+export declare function isValidConfigSource(source: string): source is DebuggerConfigSource;
+/**
+ * Helper to check if a string is a valid history type
+ */
+export declare function isValidHistoryType(type: string): type is HistoryType;

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

@@ -42,7 +42,7 @@ export interface EventTrackingMetadata {
         dataSize?: number;
         hasWildcardMatches?: boolean;
         strategy?: HandlerStrategy | 'prioritize';
-        configSource?: keyof typeof DEBUGGER_CONFIG_SOURCES;
+        configSource?: (typeof DEBUGGER_CONFIG_SOURCES)[keyof typeof DEBUGGER_CONFIG_SOURCES];
         previousConfig?: unknown;
         newConfig?: unknown;
         impactedEvents?: string[];

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

@@ -626,3 +626,47 @@ export interface FactoryLike {
     emit?: <T = unknown>(event: string, data?: T) => void;
     lastActivity?: number;
 }
+/**
+ * Event system health data for analysis
+ */
+export interface EventSystemHealthData {
+    totalListeners: number;
+    factoryDetails: EventFactoryAnalysis[];
+    scopeBreakdown: EventScopeAnalysis[];
+    validation: EventValidationReport;
+    performanceMetrics: {
+        eventEmissionLatency?: number;
+        listenerExecutionTime?: number;
+        memoryLeaks?: string[];
+        optimizationOpportunities?: string[];
+    };
+}
+/**
+ * Event system data summary
+ */
+export interface EventSystemData {
+    systemOverview: {
+        totalListeners: number;
+        totalFactories?: number;
+        healthScore: number;
+    };
+    factoryDetails?: EventFactoryAnalysis[];
+    scopeBreakdown?: EventScopeAnalysis[];
+    validation: {
+        missingInitializations: unknown[];
+    };
+    performanceMetrics?: {
+        memoryLeaks?: string[];
+    };
+}
+/**
+ * Parameters for calculating system health
+ */
+export interface CalculateSystemHealthParams {
+    basicReport: DebugReport;
+    headerSecurity: HeaderSecurityAnalysis;
+    eventMigration: EventMigrationAnalysis;
+    networkAdaptation: NetworkAdaptationAnalysis;
+    temporaryConfigs: TemporaryConfigAnalysis;
+    interceptorAnalysis: InterceptorChainAnalysis;
+}

package/dist/api/index.cjs

@@ -1,6 +1,8 @@
 'use strict';
 
 // @plyaz package - Built with tsup
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/api/events/enum.ts
 var EVENT_NAMESPACES = {
@@ -156,7 +158,7 @@ var ALL_EVENTS = {
   ...CACHE_EVENTS
 };
 
-// node_modules/.pnpm/@plyaz+config@1.5.3_next@15.4.7_react-dom@19.2.0_react@19.2.0_typescript@5.9.3_zod@3.25.76/node_modules/@plyaz/config/dist/index.mjs
+// node_modules/.pnpm/@plyaz+config@1.5.5_next@15.4.7_react-dom@19.2.0_react@19.2.0_typescript@5.9.3_zod@3.25.76/node_modules/@plyaz/config/dist/index.mjs
 globalThis.process.env.NODE_ENV === "development";
 globalThis.process.env.NODE_ENV === "production";
 globalThis.process.env.NODE_ENV === "test";
@@ -165,9 +167,9 @@ globalThis.process.env.NODE_ENV === "test";
 ({ isLoggingEnabled: globalThis.process.env.NODE_ENV === "development" });
 ({ api: globalThis.process.env.NEXT_PUBLIC_API_URL });
 ({ FNV_64_PRIME: BigInt("0x100000001b3"), FNV_64_OFFSET: BigInt("0xcbf29ce484222325")});
-var po = { BAD_REQUEST: 400, UNAUTHORIZED: 401, FORBIDDEN: 403, NOT_FOUND: 404, REQUEST_TIMEOUT: 408, CONFLICT: 409, UNPROCESSABLE_ENTITY: 422, TOO_MANY_REQUESTS: 429, INTERNAL_SERVER_ERROR: 500, BAD_GATEWAY: 502, SERVICE_UNAVAILABLE: 503, GATEWAY_TIMEOUT: 504};
-var t = { unauthorized: { status: 401}, internal_server_error: { status: 500}};
-({ InvalidInput: { timestamp: (/* @__PURE__ */ new Date()).toISOString() }, [t.internal_server_error.status]: { timestamp: (/* @__PURE__ */ new Date()).toISOString() }, [t.unauthorized.status]: { timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
+var Bo = { BAD_REQUEST: 400, UNAUTHORIZED: 401, FORBIDDEN: 403, NOT_FOUND: 404, REQUEST_TIMEOUT: 408, CONFLICT: 409, UNPROCESSABLE_ENTITY: 422, TOO_MANY_REQUESTS: 429, INTERNAL_SERVER_ERROR: 500, BAD_GATEWAY: 502, SERVICE_UNAVAILABLE: 503, GATEWAY_TIMEOUT: 504};
+var T = { unauthorized: { status: 401}, internal_server_error: { status: 500}};
+({ InvalidInput: { timestamp: (/* @__PURE__ */ new Date()).toISOString() }, [T.internal_server_error.status]: { timestamp: (/* @__PURE__ */ new Date()).toISOString() }, [T.unauthorized.status]: { timestamp: (/* @__PURE__ */ new Date()).toISOString() } });
 
 // src/errors/enums.ts
 var ERROR_CATEGORY = {
@@ -400,90 +402,90 @@ var ERROR_DEFINITIONS = {
   // Authentication
   [API_ERROR_CODES.AUTH_UNAUTHORIZED]: {
     code: API_ERROR_CODES.AUTH_UNAUTHORIZED,
-    status: po.UNAUTHORIZED,
+    status: Bo.UNAUTHORIZED,
     category: ERROR_CATEGORY.Authentication
   },
   [API_ERROR_CODES.AUTH_FORBIDDEN]: {
     code: API_ERROR_CODES.AUTH_FORBIDDEN,
-    status: po.FORBIDDEN,
+    status: Bo.FORBIDDEN,
     category: ERROR_CATEGORY.Authorization
   },
   [API_ERROR_CODES.AUTH_TOKEN_EXPIRED]: {
     code: API_ERROR_CODES.AUTH_TOKEN_EXPIRED,
-    status: po.UNAUTHORIZED,
+    status: Bo.UNAUTHORIZED,
     category: ERROR_CATEGORY.Authentication
   },
   [API_ERROR_CODES.AUTH_INVALID_CREDENTIALS]: {
     code: API_ERROR_CODES.AUTH_INVALID_CREDENTIALS,
-    status: po.UNAUTHORIZED,
+    status: Bo.UNAUTHORIZED,
     category: ERROR_CATEGORY.Authentication
   },
   // Rate Limiting
   [API_ERROR_CODES.RATE_LIMIT_EXCEEDED]: {
     code: API_ERROR_CODES.RATE_LIMIT_EXCEEDED,
-    status: po.TOO_MANY_REQUESTS,
+    status: Bo.TOO_MANY_REQUESTS,
     category: ERROR_CATEGORY.RateLimit
   },
   // Resource Errors
   [API_ERROR_CODES.RESOURCE_NOT_FOUND]: {
     code: API_ERROR_CODES.RESOURCE_NOT_FOUND,
-    status: po.NOT_FOUND,
+    status: Bo.NOT_FOUND,
     category: ERROR_CATEGORY.NotFound
   },
   // System Errors
   [API_ERROR_CODES.INTERNAL_SERVER_ERROR]: {
     code: API_ERROR_CODES.INTERNAL_SERVER_ERROR,
-    status: po.INTERNAL_SERVER_ERROR,
+    status: Bo.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Server
   },
   [API_ERROR_CODES.SERVICE_UNAVAILABLE]: {
     code: API_ERROR_CODES.SERVICE_UNAVAILABLE,
-    status: po.SERVICE_UNAVAILABLE,
+    status: Bo.SERVICE_UNAVAILABLE,
     category: ERROR_CATEGORY.Server
   },
   [API_ERROR_CODES.EXTERNAL_SERVICE_ERROR]: {
     code: API_ERROR_CODES.EXTERNAL_SERVICE_ERROR,
-    status: po.BAD_GATEWAY,
+    status: Bo.BAD_GATEWAY,
     category: ERROR_CATEGORY.ExternalService
   },
   // Validation
   [API_ERROR_CODES.VALIDATION_ERROR]: {
     code: API_ERROR_CODES.VALIDATION_ERROR,
-    status: po.BAD_REQUEST,
+    status: Bo.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation
   },
   [API_ERROR_CODES.VALIDATION_FAILED]: {
     code: API_ERROR_CODES.VALIDATION_FAILED,
-    status: po.BAD_REQUEST,
+    status: Bo.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation
   },
   [API_ERROR_CODES.REQUIRED_FIELD_MISSING]: {
     code: API_ERROR_CODES.REQUIRED_FIELD_MISSING,
-    status: po.BAD_REQUEST,
+    status: Bo.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     fieldsLeft: ["field"]
   },
   [API_ERROR_CODES.INVALID_FORMAT]: {
     code: API_ERROR_CODES.INVALID_FORMAT,
-    status: po.BAD_REQUEST,
+    status: Bo.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation
   },
   [API_ERROR_CODES.STRING_TOO_SHORT]: {
     code: API_ERROR_CODES.STRING_TOO_SHORT,
-    status: po.BAD_REQUEST,
+    status: Bo.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     fieldsLeft: ["field", "minLength"]
   },
   [API_ERROR_CODES.STRING_TOO_LONG]: {
     code: API_ERROR_CODES.STRING_TOO_LONG,
-    status: po.BAD_REQUEST,
+    status: Bo.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation,
     fieldsLeft: ["field", "maxLength"]
   },
   // Request Errors
   [API_ERROR_CODES.REQUEST_TIMEOUT]: {
     code: API_ERROR_CODES.REQUEST_TIMEOUT,
-    status: po.REQUEST_TIMEOUT,
+    status: Bo.REQUEST_TIMEOUT,
     category: ERROR_CATEGORY.Timeout
   },
   [API_ERROR_CODES.REQUEST_ABORTED]: {
@@ -494,34 +496,34 @@ var ERROR_DEFINITIONS = {
   },
   [API_ERROR_CODES.REQUEST_INVALID_PARAMS]: {
     code: API_ERROR_CODES.REQUEST_INVALID_PARAMS,
-    status: po.BAD_REQUEST,
+    status: Bo.BAD_REQUEST,
     category: ERROR_CATEGORY.Client
   },
   [API_ERROR_CODES.REQUEST_PREPARATION_FAILED]: {
     code: API_ERROR_CODES.REQUEST_PREPARATION_FAILED,
-    status: po.BAD_REQUEST,
+    status: Bo.BAD_REQUEST,
     category: ERROR_CATEGORY.Client
   },
   // Response Errors
   [API_ERROR_CODES.RESPONSE_INVALID_FORMAT]: {
     code: API_ERROR_CODES.RESPONSE_INVALID_FORMAT,
-    status: po.UNPROCESSABLE_ENTITY,
+    status: Bo.UNPROCESSABLE_ENTITY,
     category: ERROR_CATEGORY.Client
   },
   [API_ERROR_CODES.RESPONSE_PARSING_FAILED]: {
     code: API_ERROR_CODES.RESPONSE_PARSING_FAILED,
-    status: po.UNPROCESSABLE_ENTITY,
+    status: Bo.UNPROCESSABLE_ENTITY,
     category: ERROR_CATEGORY.Client
   },
   // Network
   [API_ERROR_CODES.NETWORK_ERROR]: {
     code: API_ERROR_CODES.NETWORK_ERROR,
-    status: po.BAD_GATEWAY,
+    status: Bo.BAD_GATEWAY,
     category: ERROR_CATEGORY.Network
   },
   [API_ERROR_CODES.NETWORK_TIMEOUT]: {
     code: API_ERROR_CODES.NETWORK_TIMEOUT,
-    status: po.GATEWAY_TIMEOUT,
+    status: Bo.GATEWAY_TIMEOUT,
     category: ERROR_CATEGORY.Timeout
   },
   [API_ERROR_CODES.NETWORK_CONNECTION_FAILED]: {
@@ -545,13 +547,13 @@ var ERROR_DEFINITIONS = {
   // Server
   [API_ERROR_CODES.SERVER_ERROR]: {
     code: API_ERROR_CODES.SERVER_ERROR,
-    status: po.INTERNAL_SERVER_ERROR,
+    status: Bo.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Server
   },
   // Client
   [API_ERROR_CODES.CLIENT_ERROR]: {
     code: API_ERROR_CODES.CLIENT_ERROR,
-    status: po.BAD_REQUEST,
+    status: Bo.BAD_REQUEST,
     category: ERROR_CATEGORY.Client
   },
   [API_ERROR_CODES.CLIENT_CANCELLED]: {
@@ -580,33 +582,33 @@ var ERROR_DEFINITIONS = {
   },
   [API_ERROR_CODES.CONFIG_VALIDATION_FAILED]: {
     code: API_ERROR_CODES.CONFIG_VALIDATION_FAILED,
-    status: po.BAD_REQUEST,
+    status: Bo.BAD_REQUEST,
     category: ERROR_CATEGORY.Validation
   },
   [API_ERROR_CODES.HEADER_PROCESSING_FAILED]: {
     code: API_ERROR_CODES.HEADER_PROCESSING_FAILED,
-    status: po.INTERNAL_SERVER_ERROR,
+    status: Bo.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Headers
   },
   [API_ERROR_CODES.NETWORK_OVERRIDE_FAILED]: {
     code: API_ERROR_CODES.NETWORK_OVERRIDE_FAILED,
-    status: po.INTERNAL_SERVER_ERROR,
+    status: Bo.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Network
   },
   // Headers
   [API_ERROR_CODES.HEADERS_ENRICHMENT_FAILED]: {
     code: API_ERROR_CODES.HEADERS_ENRICHMENT_FAILED,
-    status: po.BAD_REQUEST,
+    status: Bo.BAD_REQUEST,
     category: ERROR_CATEGORY.Headers
   },
   [API_ERROR_CODES.HEADERS_VALIDATION_FAILED]: {
     code: API_ERROR_CODES.HEADERS_VALIDATION_FAILED,
-    status: po.BAD_REQUEST,
+    status: Bo.BAD_REQUEST,
     category: ERROR_CATEGORY.Headers
   },
   [API_ERROR_CODES.HEADERS_MERGE_CONFLICT]: {
     code: API_ERROR_CODES.HEADERS_MERGE_CONFLICT,
-    status: po.CONFLICT,
+    status: Bo.CONFLICT,
     category: ERROR_CATEGORY.Headers
   },
   // Cache
@@ -631,7 +633,7 @@ var ERROR_DEFINITIONS = {
   // Retry
   [API_ERROR_CODES.RETRY_EXHAUSTED]: {
     code: API_ERROR_CODES.RETRY_EXHAUSTED,
-    status: po.SERVICE_UNAVAILABLE,
+    status: Bo.SERVICE_UNAVAILABLE,
     category: ERROR_CATEGORY.Retry
   },
   [API_ERROR_CODES.RETRY_STRATEGY_INVALID]: {
@@ -649,7 +651,7 @@ var ERROR_DEFINITIONS = {
   },
   [API_ERROR_CODES.STRATEGY_CONFLICT]: {
     code: API_ERROR_CODES.STRATEGY_CONFLICT,
-    status: po.CONFLICT,
+    status: Bo.CONFLICT,
     category: ERROR_CATEGORY.Strategy
   },
   // Regional
@@ -661,19 +663,19 @@ var ERROR_DEFINITIONS = {
   },
   [API_ERROR_CODES.REGION_DETECTION_FAILED]: {
     code: API_ERROR_CODES.REGION_DETECTION_FAILED,
-    status: po.INTERNAL_SERVER_ERROR,
+    status: Bo.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Regional
   },
   // Timeout
   [API_ERROR_CODES.TIMEOUT]: {
     code: API_ERROR_CODES.TIMEOUT,
-    status: po.REQUEST_TIMEOUT,
+    status: Bo.REQUEST_TIMEOUT,
     category: ERROR_CATEGORY.Timeout
   },
   // Unknown
   [API_ERROR_CODES.UNKNOWN_ERROR]: {
     code: API_ERROR_CODES.UNKNOWN_ERROR,
-    status: po.INTERNAL_SERVER_ERROR,
+    status: Bo.INTERNAL_SERVER_ERROR,
     category: ERROR_CATEGORY.Unknown
   }
 };
@@ -895,11 +897,53 @@ var UPDATE_STRATEGIES = {
   REPLACE: "replace",
   TEMPORARY: "temporary"
 };
+var CHANGE_TYPES = {
+  OVERRIDE: "override",
+  RESTORE: "restore",
+  PRESET_CHANGE: "preset_change",
+  USER_PREFERENCE: "user_preference",
+  AUTO_OPTIMIZATION: "auto_optimization"
+};
+var TRACKING_PHASES = {
+  INITIALIZATION: "initialization",
+  RUNTIME: "runtime",
+  UPDATE: "update"
+};
+var IMPACT_LEVELS = {
+  NONE: "NONE",
+  LOW: "LOW",
+  MEDIUM: "MEDIUM",
+  HIGH: "HIGH",
+  CRITICAL: "CRITICAL"
+};
+var ALERT_SEVERITIES = {
+  INFO: "info",
+  WARNING: "warning",
+  ERROR: "error",
+  CRITICAL: "critical"
+};
+var ALERT_TYPES = {
+  CONFLICT: "conflict",
+  PERFORMANCE: "performance",
+  NETWORK: "network"
+};
 var UNIFIED_OPERATIONS = {
   ...FACTORY_OPERATIONS,
   ...EVENT_OPERATIONS,
   ...QUEUE_OPERATIONS
 };
+function isValidOperation(operation) {
+  return Object.values(UNIFIED_OPERATIONS).includes(operation);
+}
+__name(isValidOperation, "isValidOperation");
+function isValidConfigSource(source) {
+  return Object.values(DEBUGGER_CONFIG_SOURCES).includes(source);
+}
+__name(isValidConfigSource, "isValidConfigSource");
+function isValidHistoryType(type) {
+  return Object.values(HISTORY_TYPES).includes(type);
+}
+__name(isValidHistoryType, "isValidHistoryType");
 
 // src/api/client/enum.ts
 var EVENT_CONSTANTS = {
@@ -1006,10 +1050,13 @@ var PUB_SUB_EVENT = {
   RequestAbort: "request:abort"
 };
 
+exports.ALERT_SEVERITIES = ALERT_SEVERITIES;
+exports.ALERT_TYPES = ALERT_TYPES;
 exports.ALL_EVENTS = ALL_EVENTS;
 exports.API_ERROR_CODES = API_ERROR_CODES;
 exports.CACHE_DURATION_MS = CACHE_DURATION_MS;
 exports.CACHE_EVENTS = CACHE_EVENTS;
+exports.CHANGE_TYPES = CHANGE_TYPES;
 exports.CLIENT_EVENTS = CLIENT_EVENTS;
 exports.CLIENT_HINT_HEADERS = CLIENT_HINT_HEADERS;
 exports.CONFIG_EVENTS = CONFIG_EVENTS;
@@ -1035,6 +1082,7 @@ exports.HANDLER_SCOPES = HANDLER_SCOPES;
 exports.HEADER_EVENTS = HEADER_EVENTS;
 exports.HEADER_STAGES = HEADER_STAGES;
 exports.HISTORY_TYPES = HISTORY_TYPES;
+exports.IMPACT_LEVELS = IMPACT_LEVELS;
 exports.NETWORK_CONFIDENCE_LEVELS = NETWORK_CONFIDENCE_LEVELS;
 exports.NETWORK_EVENTS = NETWORK_EVENTS;
 exports.NETWORK_QUALITY = NETWORK_QUALITY;
@@ -1051,8 +1099,12 @@ exports.REGION_TO_PRESET = REGION_TO_PRESET;
 exports.RTT_THRESHOLDS = RTT_THRESHOLDS;
 exports.SPEED_THRESHOLDS = SPEED_THRESHOLDS;
 exports.STORAGE_TYPES = STORAGE_TYPES;
+exports.TRACKING_PHASES = TRACKING_PHASES;
 exports.UNIFIED_OPERATIONS = UNIFIED_OPERATIONS;
 exports.UPDATE_STRATEGIES = UPDATE_STRATEGIES;
 exports.VALIDATION_RANGES = VALIDATION_RANGES;
+exports.isValidConfigSource = isValidConfigSource;
+exports.isValidHistoryType = isValidHistoryType;
+exports.isValidOperation = isValidOperation;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map