@plyaz/types 1.7.17 → 1.7.19

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';

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

@@ -0,0 +1,127 @@
+import type { Endpoint, Req } from 'fetchff';
+/**
+ * Job Status Response
+ * Used by endpoints that monitor job/task progress
+ */
+interface JobStatusResponse {
+    jobId: string;
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+    progress?: number;
+    message?: string;
+    result?: unknown;
+    error?: string;
+    startedAt?: string;
+    completedAt?: string;
+}
+/**
+ * Health Check Response
+ * Used by health monitoring endpoints
+ */
+interface HealthCheckResponse {
+    status: 'up' | 'down' | 'degraded';
+    healthy: boolean;
+    version: string;
+    uptime: number;
+    services: {
+        database: boolean;
+        cache: boolean;
+        queue: boolean;
+    };
+}
+/**
+ * Live Data Response
+ * Used by real-time data endpoints
+ */
+interface LiveDataResponse<T = unknown> {
+    data: T;
+    timestamp: string;
+    noUpdates?: boolean;
+    lastUpdateId?: string;
+}
+/**
+ * Data Sync Response
+ * Used by data synchronization endpoints
+ */
+interface DataSyncResponse {
+    syncId: string;
+    status: 'pending' | 'syncing' | 'completed' | 'failed';
+    syncComplete?: boolean;
+    hasConflicts?: boolean;
+    conflictCount?: number;
+    itemsSynced?: number;
+    totalItems?: number;
+}
+/**
+ * Resource Status Response
+ * Used by resource availability endpoints
+ */
+interface ResourceStatusResponse {
+    resourceId: string;
+    available: boolean;
+    status: 'preparing' | 'ready' | 'busy' | 'unavailable';
+    estimatedAvailableAt?: string;
+}
+/**
+ * Path parameters for job endpoints
+ */
+interface JobPathParams {
+    jobId: string;
+}
+/**
+ * Path parameters for resource endpoints
+ */
+interface ResourcePathParams {
+    resourceId: string;
+}
+/**
+ * Query parameters for live data
+ */
+interface LiveDataParams {
+    since?: string;
+    limit?: number;
+}
+/**
+ * Body for starting a job
+ */
+interface StartJobBody {
+    type: string;
+    parameters?: Record<string, unknown>;
+}
+/**
+ * Body for sync operations
+ */
+interface StartSyncBody {
+    source: string;
+    target: string;
+    options?: {
+        resolveConflicts?: 'source' | 'target' | 'manual';
+        dryRun?: boolean;
+    };
+}
+/**
+ * Polling example endpoint types with full TypeScript support
+ * These demonstrate how endpoints should be typed for polling scenarios
+ */
+export interface PollingEndpointTypes {
+    getJobStatus: Endpoint<Req<JobStatusResponse, never, never, JobPathParams>>;
+    startJob: Endpoint<Req<JobStatusResponse, StartJobBody>>;
+    cancelJob: Endpoint<Req<{
+        success: boolean;
+    }, never, never, JobPathParams>>;
+    healthCheck: Endpoint<Req<HealthCheckResponse>>;
+    getLiveData: Endpoint<Req<LiveDataResponse, never, LiveDataParams>>;
+    getDashboardMetrics: Endpoint<Req<LiveDataResponse<{
+        activeUsers: number;
+        requests: number;
+        responseTime: number;
+    }>, never, LiveDataParams>>;
+    startSync: Endpoint<Req<DataSyncResponse, StartSyncBody>>;
+    getSyncStatus: Endpoint<Req<DataSyncResponse, never, never, {
+        syncId: string;
+    }>>;
+    getResourceStatus: Endpoint<Req<ResourceStatusResponse, never, never, ResourcePathParams>>;
+    reserveResource: Endpoint<Req<ResourceStatusResponse, {
+        duration: number;
+    }, never, ResourcePathParams>>;
+}
+export {};

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

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

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

@@ -0,0 +1,5 @@
+/**
+ * Query parameters type - matches fetchff's flexible param handling
+ * Supports objects, URLSearchParams, and arrays of name-value pairs
+ */
+export type QueryParams = Record<string, string | number | boolean | string[] | number[]> | URLSearchParams | Array<[string, string]>;

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

@@ -0,0 +1,182 @@
+/**
+ * Typed constants for API error handling
+ */
+import type { ErrorDefinitions } from '..';
+/**
+ * Operation types for error context
+ */
+export declare const OPERATIONS: {
+    readonly STORAGE: "storage";
+    readonly RETRIEVAL: "retrieval";
+    readonly INVALIDATION: "invalidation";
+    readonly ENRICHMENT: "enrichment";
+    readonly VALIDATION: "validation";
+    readonly PRESET_LOOKUP: "preset-lookup";
+    readonly INITIALIZATION: "initialization";
+    readonly CONFIGURATION: "configuration";
+    readonly REQUEST: "request";
+    readonly RESPONSE: "response";
+    readonly RETRY: "retry";
+    readonly REVALIDATION: "revalidation";
+    readonly STRATEGY_EXECUTION: "strategy-execution";
+    readonly POLLING: "polling";
+    readonly SUBSCRIPTION: "subscription";
+    readonly PUBLICATION: "publication";
+    readonly DEBUG: "debug";
+    readonly DEBUG_TRACKING: "debug-tracking";
+    readonly ENDPOINT_BUILD: "endpoint-build";
+    readonly TRACKING: "tracking";
+    readonly NETWORK_CHECK: "network-check";
+    readonly EVENT_HANDLING: "event-handling";
+    readonly SERIALIZATION: "serialization";
+    readonly DESERIALIZATION: "deserialization";
+    readonly REGIONAL_DETECTION: "regional-detection";
+    readonly MONITORING: "monitoring";
+    readonly CONTEXT_SETUP: "context-setup";
+    readonly FALLBACK: "fallback";
+};
+/**
+ * Field types for error context
+ */
+export declare const ERROR_FIELDS: {
+    readonly STORAGE: "storage";
+    readonly CACHE: "cache";
+    readonly HEADERS: "headers";
+    readonly PRESET_NAME: "presetName";
+    readonly PRESET_ID: "presetId";
+    readonly CONFIG: "config";
+    readonly URL: "url";
+    readonly METHOD: "method";
+    readonly STRATEGY: "strategy";
+    readonly RETRY_COUNT: "retryCount";
+    readonly MAX_RETRIES: "maxRetries";
+    readonly POLLING_INTERVAL: "pollingInterval";
+    readonly TOPIC: "topic";
+    readonly CHANNEL: "channel";
+    readonly ENDPOINT: "endpoint";
+    readonly CLIENT: "client";
+    readonly NETWORK_TYPE: "networkType";
+    readonly TIME_INTERVAL: "timeInterval";
+};
+/**
+ * Storage types for API errors
+ */
+export declare const STORAGE_TYPES: {
+    readonly PRIMARY: "primary";
+    readonly FALLBACK: "fallback";
+    readonly MEMORY: "memory";
+    readonly SESSION: "session";
+    readonly LOCAL: "local";
+};
+/**
+ * API Error Codes - domain-specific and grouped by category
+ */
+export declare const API_ERROR_CODES: {
+    readonly CLIENT_INITIALIZATION_FAILED: "CLIENT_INITIALIZATION_FAILED";
+    readonly CLIENT_INVALID_CONFIG: "CLIENT_INVALID_CONFIG";
+    readonly CLIENT_MISSING_BASE_URL: "CLIENT_MISSING_BASE_URL";
+    readonly CLIENT_CANCELLED: "CLIENT_CANCELLED";
+    readonly CONFIG_VALIDATION_FAILED: "CONFIG_VALIDATION_FAILED";
+    readonly HEADER_PROCESSING_FAILED: "HEADER_PROCESSING_FAILED";
+    readonly NETWORK_OVERRIDE_FAILED: "NETWORK_OVERRIDE_FAILED";
+    readonly REQUEST_TIMEOUT: "REQUEST_TIMEOUT";
+    readonly REQUEST_ABORTED: "REQUEST_ABORTED";
+    readonly REQUEST_INVALID_PARAMS: "REQUEST_INVALID_PARAMS";
+    readonly REQUEST_PREPARATION_FAILED: "REQUEST_PREPARATION_FAILED";
+    readonly RESPONSE_INVALID_FORMAT: "RESPONSE_INVALID_FORMAT";
+    readonly RESPONSE_PARSING_FAILED: "RESPONSE_PARSING_FAILED";
+    readonly NETWORK_CONNECTION_FAILED: "NETWORK_CONNECTION_FAILED";
+    readonly NETWORK_OFFLINE: "NETWORK_OFFLINE";
+    readonly NETWORK_DNS_FAILED: "NETWORK_DNS_FAILED";
+    readonly NETWORK_TIMEOUT: "NETWORK_TIMEOUT";
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    readonly NETWORK_PRESET_NOT_FOUND: "NETWORK_PRESET_NOT_FOUND";
+    readonly NETWORK_CONFIGURATION_INVALID: "NETWORK_CONFIGURATION_INVALID";
+    readonly REGIONAL_PRESET_NOT_FOUND: "REGIONAL_PRESET_NOT_FOUND";
+    readonly REGION_DETECTION_FAILED: "REGION_DETECTION_FAILED";
+    readonly HEADERS_ENRICHMENT_FAILED: "HEADERS_ENRICHMENT_FAILED";
+    readonly HEADERS_VALIDATION_FAILED: "HEADERS_VALIDATION_FAILED";
+    readonly HEADERS_MERGE_CONFLICT: "HEADERS_MERGE_CONFLICT";
+    readonly CACHE_STORAGE_FAILED: "CACHE_STORAGE_FAILED";
+    readonly CACHE_RETRIEVAL_FAILED: "CACHE_RETRIEVAL_FAILED";
+    readonly CACHE_INVALIDATION_FAILED: "CACHE_INVALIDATION_FAILED";
+    readonly RETRY_EXHAUSTED: "RETRY_EXHAUSTED";
+    readonly RETRY_STRATEGY_INVALID: "RETRY_STRATEGY_INVALID";
+    readonly STRATEGY_INVALID: "STRATEGY_INVALID";
+    readonly STRATEGY_CONFLICT: "STRATEGY_CONFLICT";
+    readonly STRATEGY_EXECUTION_FAILED: "STRATEGY_EXECUTION_FAILED";
+    readonly POLLING_TIMEOUT: "POLLING_TIMEOUT";
+    readonly POLLING_CANCELLED: "POLLING_CANCELLED";
+    readonly POLLING_INVALID_CONFIG: "POLLING_INVALID_CONFIG";
+    readonly PUBSUB_SUBSCRIPTION_FAILED: "PUBSUB_SUBSCRIPTION_FAILED";
+    readonly PUBSUB_PUBLICATION_FAILED: "PUBSUB_PUBLICATION_FAILED";
+    readonly PUBSUB_INVALID_TOPIC: "PUBSUB_INVALID_TOPIC";
+    readonly PUBSUB_CHANNEL_ERROR: "PUBSUB_CHANNEL_ERROR";
+    readonly REVALIDATION_FAILED: "REVALIDATION_FAILED";
+    readonly REVALIDATION_IN_PROGRESS: "REVALIDATION_IN_PROGRESS";
+    readonly DEBUG_TRACKING_FAILED: "DEBUG_TRACKING_FAILED";
+    readonly DEBUG_OVERRIDE_FAILED: "DEBUG_OVERRIDE_FAILED";
+    readonly DEBUG_CONFLICT_DETECTED: "DEBUG_CONFLICT_DETECTED";
+    readonly ENDPOINT_BUILD_FAILED: "ENDPOINT_BUILD_FAILED";
+    readonly ENDPOINT_NOT_FOUND: "ENDPOINT_NOT_FOUND";
+    readonly ENDPOINT_INVALID_CONFIG: "ENDPOINT_INVALID_CONFIG";
+    readonly EVENT_HANDLER_FAILED: "EVENT_HANDLER_FAILED";
+    readonly EVENT_EMISSION_FAILED: "EVENT_EMISSION_FAILED";
+    readonly MONITORING_FAILED: "MONITORING_FAILED";
+    readonly CONTEXT_OPERATION_FAILED: "CONTEXT_OPERATION_FAILED";
+    readonly AUTH_TOKEN_EXPIRED: "AUTH_TOKEN_EXPIRED";
+    readonly AUTH_UNAUTHORIZED: "AUTH_UNAUTHORIZED";
+    readonly AUTH_FORBIDDEN: "AUTH_FORBIDDEN";
+    readonly AUTH_INVALID_CREDENTIALS: "AUTH_INVALID_CREDENTIALS";
+    readonly RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED";
+    readonly RESOURCE_NOT_FOUND: "RESOURCE_NOT_FOUND";
+    readonly INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR";
+    readonly SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+    readonly EXTERNAL_SERVICE_ERROR: "EXTERNAL_SERVICE_ERROR";
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    readonly VALIDATION_FAILED: "VALIDATION_FAILED";
+    readonly REQUIRED_FIELD_MISSING: "REQUIRED_FIELD_MISSING";
+    readonly INVALID_FORMAT: "INVALID_FORMAT";
+    readonly VALIDATION_INVALID_FORMAT: "INVALID_FORMAT";
+    readonly STRING_TOO_SHORT: "STRING_TOO_SHORT";
+    readonly STRING_TOO_LONG: "STRING_TOO_LONG";
+    readonly CLIENT_ERROR: "CLIENT_ERROR";
+    readonly SERVER_ERROR: "SERVER_ERROR";
+    readonly TIMEOUT: "TIMEOUT";
+};
+/**
+ * Internal package status codes (non-HTTP)
+ * Used for internal configuration and validation errors that aren't HTTP-related
+ */
+export declare const PACKAGE_STATUS_CODES: {
+    readonly INVALID_CONFIGURATION: 1001;
+    readonly MISSING_CONFIGURATION: 1002;
+    readonly CONFIGURATION_CONFLICT: 1003;
+    readonly CONFIGURATION_TRACKING_FAILED: 1004;
+    readonly DEBUG_TRACKING_FAILED: 1005;
+    readonly RESOURCE_NOT_FOUND: 1010;
+    readonly RESOURCE_ALREADY_EXISTS: 1011;
+    readonly RESOURCE_UNAVAILABLE: 1012;
+    readonly INVALID_PARAMETER: 1020;
+    readonly MISSING_PARAMETER: 1021;
+    readonly PARAMETER_OUT_OF_RANGE: 1022;
+    readonly STRATEGY_NOT_FOUND: 1030;
+    readonly PRESET_NOT_FOUND: 1031;
+    readonly INVALID_STRATEGY: 1032;
+    readonly REQUEST_FAILED: 1035;
+    readonly INITIALIZATION_FAILED: 1040;
+    readonly OPERATION_FAILED: 1041;
+    readonly STATE_CORRUPTION: 1042;
+    readonly SERIALIZATION_FAILED: 1043;
+    readonly DESERIALIZATION_FAILED: 1044;
+    readonly CONFIGURATION_INVALID: 1045;
+    readonly HEADER_PROCESSING_ERROR: 1046;
+    readonly REGION_DETECTION_ERROR: 1047;
+    readonly NETWORK_OVERRIDE_ERROR: 1048;
+};
+/**
+ * Centralized error definitions mapping
+ * Maps error codes to their HTTP status and metadata
+ */
+export declare const ERROR_DEFINITIONS: ErrorDefinitions;

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

@@ -3,3 +3,4 @@
  * Re-exports all error-related types for the API package
  */
 export type * from './types';
+export * from './enum';

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

@@ -2,24 +2,76 @@
  * Error handling types for @plyaz/api package
  * Following the Confluence architecture specifications
  */
-import type { OPERATIONS, ERROR_FIELDS, STORAGE_TYPES } from '@plyaz/config';
-import type { ERROR_CATEGORY, BaseErrorResponse, ErrorDetail } from '../../errors';
+/**
+ * Import ResponseError and RequestConfig types from fetchff
+ */
+import type { ResponseError, RequestConfig } from 'fetchff';
+import type { ERROR_CATEGORY, ErrorDetail, ErrorResponse } from '../../errors';
+import type { API_ERROR_CODES, OPERATIONS, ERROR_FIELDS, STORAGE_TYPES } from '..';
 /**
  * Typed constants as types for convenience
  */
 export type ErrorOperation = (typeof OPERATIONS)[keyof typeof OPERATIONS];
 export type ErrorField = (typeof ERROR_FIELDS)[keyof typeof ERROR_FIELDS];
 export type StorageType = (typeof STORAGE_TYPES)[keyof typeof STORAGE_TYPES];
+/**
+ * Type for API error codes
+ */
+export type ApiErrorCode = (typeof API_ERROR_CODES)[keyof typeof API_ERROR_CODES];
 /**
  * Translation interpolation variables
  */
 export interface I18nContext {
     [key: string]: string | number | boolean | null | undefined;
 }
+/**
+ * Base error context with common fields
+ */
+export interface BaseErrorContext {
+    operation?: ErrorOperation;
+    originalError?: string;
+    i18n?: I18nContext;
+    url?: string;
+    method?: string;
+    strategyName?: string;
+    fallback?: string;
+    eventType?: string;
+    reason?: string;
+    debuggerOperation?: string;
+    timeoutMs?: number;
+    timeout?: number;
+    elapsed?: number;
+    routerType?: string;
+    storageType?: string;
+    availableStrategies?: string;
+    requestedStrategy?: string;
+    fallbackUsed?: string;
+    requestedPreset?: string;
+    availablePresets?: string;
+    retryable?: boolean;
+    field?: string;
+    value?: unknown;
+    constraints?: Record<string, string>;
+    realm?: string;
+    scheme?: string;
+    limit?: number;
+    remaining?: number;
+    resetAt?: string;
+    retryAfter?: number;
+    serverMessage?: string;
+    traceId?: string;
+    input?: unknown;
+    errors?: Array<{
+        field: string;
+        message: string;
+        code?: string;
+    }>;
+    headers?: Record<string, string>;
+}
 /**
  * Cache error context
  */
-export interface CacheErrorContext extends BaseErrorResponse {
+export interface CacheErrorContext extends BaseErrorContext {
     operation: ErrorOperation;
     cacheKey?: string;
     keyPrefix?: string;
@@ -30,7 +82,7 @@ export interface CacheErrorContext extends BaseErrorResponse {
 /**
  * Headers error context
  */
-export interface HeadersErrorContext extends BaseErrorResponse {
+export interface HeadersErrorContext extends BaseErrorContext {
     operation: ErrorOperation;
     warningCount?: number;
     warnings?: string;
@@ -38,7 +90,7 @@ export interface HeadersErrorContext extends BaseErrorResponse {
 /**
  * Regional error context
  */
-export interface RegionalErrorContext extends BaseErrorResponse {
+export interface RegionalErrorContext extends BaseErrorContext {
     operation: ErrorOperation;
     requestedPreset?: string;
     availablePresets?: string;
@@ -47,7 +99,7 @@ export interface RegionalErrorContext extends BaseErrorResponse {
 /**
  * Network error context
  */
-export interface NetworkErrorContext extends BaseErrorResponse {
+export interface NetworkErrorContext extends BaseErrorContext {
     operation: ErrorOperation;
     requestedPreset?: string;
     availablePresets?: string;
@@ -58,7 +110,7 @@ export interface NetworkErrorContext extends BaseErrorResponse {
 export interface ErrorDefinition {
     code: string;
     status: number;
-    category: typeof ERROR_CATEGORY;
+    category: (typeof ERROR_CATEGORY)[keyof typeof ERROR_CATEGORY];
     fieldsLeft?: string[];
 }
 /**
@@ -70,7 +122,7 @@ export type ErrorDefinitions = {
 /**
  * Union type for all error contexts
  */
-export type ErrorContext = BaseErrorResponse | CacheErrorContext | HeadersErrorContext | RegionalErrorContext | NetworkErrorContext;
+export type ErrorContext = BaseErrorContext | CacheErrorContext | HeadersErrorContext | RegionalErrorContext | NetworkErrorContext;
 /**
  * Options for creating an ApiPackageError
  * Note: ApiPackageError class itself is not migrated as it contains implementation
@@ -84,29 +136,76 @@ export interface ApiPackageErrorOptionsErrorDetail<ValueGiven, AllowedValues, Co
     context?: ErrorContext;
     clientContext?: unknown;
 }
+/**
+ * Interface representing the public API of ApiPackageError
+ * Useful for type-checking without requiring the actual class instance
+ *
+ * This interface allows for:
+ * - Duck typing compatibility
+ * - Easier mocking in tests
+ * - Type-safe function parameters without importing the class
+ * - Clearer documentation of the public API contract
+ *
+ * @example
+ * ```typescript
+ * function handleError(error: ApiPackageErrorLike): void {
+ *   if (error.isRetryable()) {
+ *     // Retry logic
+ *   }
+ *   console.error(error.getUserMessage());
+ * }
+ * ```
+ */
+export interface ApiPackageErrorLike extends Error {
+    readonly statusCode: number;
+    readonly errorCode: string;
+    readonly message: string;
+    readonly errors?: ErrorDetail<unknown, unknown, unknown>[];
+    readonly correlationId?: string;
+    readonly timestamp: string;
+    readonly responseError?: ResponseError;
+    readonly category: typeof ERROR_CATEGORY;
+    readonly cause?: Error;
+    readonly context?: ErrorContext;
+    readonly requestConfig?: RequestConfig;
+    readonly responseData?: ResponseError['response'];
+    readonly details?: ErrorDetail<unknown, unknown, unknown>[];
+    readonly originalError?: Error;
+    readonly metadata?: Record<string, string | number | boolean | null>;
+    readonly code: string;
+    isAuthError(): boolean;
+    isValidationError(): boolean;
+    isNetworkError(): boolean;
+    isServerError(): boolean;
+    isClientError(): boolean;
+    isRetryable(): boolean;
+    toJSON(): ErrorResponse;
+    toString(): string;
+    getUserMessage(): string;
+}
 /**
  * Event handler types for API package errors
  * Note: ApiPackageError is not imported here to avoid implementation dependencies
  */
 export interface ErrorEventHandlers {
-    onValidationError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onNetworkError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onAuthenticationError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onAuthorizationError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onRateLimitError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onTimeoutError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onConflictError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onNotFoundError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onServerError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onClientError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onExternalServiceError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onCacheError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onHeadersError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onRetryError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onStrategyError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onRegionalError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onUnknownError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
-    onAnyError?: ((error: unknown) => void) | Array<(error: unknown) => void>;
+    onValidationError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onNetworkError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onAuthenticationError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onAuthorizationError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onRateLimitError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onTimeoutError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onConflictError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onNotFoundError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onServerError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onClientError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onExternalServiceError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onCacheError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onHeadersError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onRetryError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onStrategyError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onRegionalError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onUnknownError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
+    onAnyError?: ((error: ApiPackageErrorLike) => void) | Array<(error: ApiPackageErrorLike) => void>;
 }
 /**
  * Options for error handler registration