@plyaz/types 1.16.9 → 1.18.0

package/dist/core/index.d.ts

@@ -11,3 +11,4 @@ export type * from './auth/types';
 export type * from './featureFlag/types';
 export * from './featureFlag/enums';
 export * from './featureFlag/constants';
+export type * from './types';

package/dist/core/types.d.ts

@@ -0,0 +1,40 @@
+import type { BaseErrorContext } from '../errors/types';
+/**
+ * Core-specific error context
+ * Extends BaseErrorContext with core-related properties
+ */
+export interface CoreErrorContext extends BaseErrorContext {
+    /** Feature flag name */
+    flagName?: string;
+    /** Cache key */
+    cacheKey?: string;
+    /** Engine name */
+    engineName?: string;
+    /** Provider name */
+    providerName?: string;
+    /** API client name */
+    clientName?: string;
+    /** Database service name */
+    serviceName?: string;
+    /** Validation schema name */
+    schemaName?: string;
+    /** Hash algorithm */
+    algorithm?: string;
+    /** Context data */
+    contextData?: Record<string, unknown>;
+}
+/**
+ * Options for creating core errors
+ */
+export interface CoreErrorOptions {
+    /** Additional error context */
+    context?: Partial<CoreErrorContext>;
+    /** Original error that caused this error */
+    cause?: Error;
+    /** Additional metadata */
+    metadata?: Record<string, string | number | boolean | null>;
+    /** Correlation ID for tracking */
+    correlationId?: string;
+    /** HTTP status code override */
+    statusCode?: number;
+}

package/dist/errors/codes.d.ts

@@ -250,6 +250,45 @@ export declare const ERROR_CODES: {
     readonly STORAGE_QUOTA_EXCEEDED: "storage.quota.exceeded";
     readonly STORAGE_INSUFFICIENT_SPACE: "storage.insufficient.space";
     readonly STORAGE_FEATURE_NOT_IMPLEMENTED: "storage.feature.not.implemented";
+    readonly CORE_FEATURE_FLAG_NOT_FOUND: "core.feature_flag.not_found";
+    readonly CORE_FEATURE_FLAG_INVALID_CONFIG: "core.feature_flag.invalid_config";
+    readonly CORE_FEATURE_FLAG_EVALUATION_FAILED: "core.feature_flag.evaluation_failed";
+    readonly CORE_FEATURE_FLAG_PROVIDER_ERROR: "core.feature_flag.provider_error";
+    readonly CORE_FEATURE_FLAG_CACHE_ERROR: "core.feature_flag.cache_error";
+    readonly CORE_FEATURE_FLAG_CONTEXT_INVALID: "core.feature_flag.context_invalid";
+    readonly CORE_FEATURE_FLAG_RULE_INVALID: "core.feature_flag.rule_invalid";
+    readonly CORE_FEATURE_FLAG_TOGGLE_FAILED: "core.feature_flag.toggle_failed";
+    readonly CORE_CACHE_INITIALIZATION_FAILED: "core.cache.initialization_failed";
+    readonly CORE_CACHE_STRATEGY_NOT_FOUND: "core.cache.strategy_not_found";
+    readonly CORE_CACHE_OPERATION_FAILED: "core.cache.operation_failed";
+    readonly CORE_CACHE_INVALIDATION_FAILED: "core.cache.invalidation_failed";
+    readonly CORE_CACHE_SERIALIZATION_FAILED: "core.cache.serialization_failed";
+    readonly CORE_API_CLIENT_INITIALIZATION_FAILED: "core.api_client.initialization_failed";
+    readonly CORE_API_CLIENT_REQUEST_FAILED: "core.api_client.request_failed";
+    readonly CORE_API_CLIENT_TIMEOUT: "core.api_client.timeout";
+    readonly CORE_API_CLIENT_INVALID_RESPONSE: "core.api_client.invalid_response";
+    readonly CORE_API_CLIENT_AUTHENTICATION_FAILED: "core.api_client.authentication_failed";
+    readonly CORE_DATABASE_SERVICE_INITIALIZATION_FAILED: "core.database_service.initialization_failed";
+    readonly CORE_DATABASE_SERVICE_CONNECTION_FAILED: "core.database_service.connection_failed";
+    readonly CORE_DATABASE_SERVICE_QUERY_FAILED: "core.database_service.query_failed";
+    readonly CORE_DATABASE_SERVICE_TRANSACTION_FAILED: "core.database_service.transaction_failed";
+    readonly CORE_VALIDATION_FAILED: "core.validation.failed";
+    readonly CORE_VALIDATION_SCHEMA_INVALID: "core.validation.schema_invalid";
+    readonly CORE_VALIDATION_REQUIRED_FIELD_MISSING: "core.validation.required_field_missing";
+    readonly CORE_HASH_GENERATION_FAILED: "core.hash.generation_failed";
+    readonly CORE_HASH_VERIFICATION_FAILED: "core.hash.verification_failed";
+    readonly CORE_ENGINE_INITIALIZATION_FAILED: "core.engine.initialization_failed";
+    readonly CORE_ENGINE_EXECUTION_FAILED: "core.engine.execution_failed";
+    readonly CORE_ENGINE_CONFIGURATION_INVALID: "core.engine.configuration_invalid";
+    readonly CORE_PROVIDER_NOT_FOUND: "core.provider.not_found";
+    readonly CORE_PROVIDER_INITIALIZATION_FAILED: "core.provider.initialization_failed";
+    readonly CORE_PROVIDER_OPERATION_FAILED: "core.provider.operation_failed";
+    readonly CORE_CONTEXT_INVALID: "core.context.invalid";
+    readonly CORE_CONTEXT_MISSING_REQUIRED_DATA: "core.context.missing_required_data";
+    readonly CORE_INITIALIZATION_FAILED: "core.initialization_failed";
+    readonly CORE_CONFIGURATION_INVALID: "core.configuration_invalid";
+    readonly CORE_OPERATION_FAILED: "core.operation_failed";
+    readonly CORE_UNKNOWN_ERROR: "core.unknown_error";
     readonly ERROR_SYSTEM_NOT_INITIALIZED: "error.system.not.initialized";
     readonly EVENT_FACTORY_NOT_REGISTERED: "error.event.factory.not.registered";
     readonly DATABASE_ERROR: "error.database";
@@ -735,6 +774,51 @@ export declare const STORAGE_ERROR_CODES: {
     readonly INSUFFICIENT_SPACE: "storage.insufficient.space";
     readonly FEATURE_NOT_IMPLEMENTED: "storage.feature.not.implemented";
 };
+/**
+ * Core-specific error codes
+ * Subset of ERROR_CODES for @plyaz/core package
+ */
+export declare const CORE_ERROR_CODES: {
+    readonly FEATURE_FLAG_NOT_FOUND: "core.feature_flag.not_found";
+    readonly FEATURE_FLAG_INVALID_CONFIG: "core.feature_flag.invalid_config";
+    readonly FEATURE_FLAG_EVALUATION_FAILED: "core.feature_flag.evaluation_failed";
+    readonly FEATURE_FLAG_PROVIDER_ERROR: "core.feature_flag.provider_error";
+    readonly FEATURE_FLAG_CACHE_ERROR: "core.feature_flag.cache_error";
+    readonly FEATURE_FLAG_CONTEXT_INVALID: "core.feature_flag.context_invalid";
+    readonly FEATURE_FLAG_RULE_INVALID: "core.feature_flag.rule_invalid";
+    readonly FEATURE_FLAG_TOGGLE_FAILED: "core.feature_flag.toggle_failed";
+    readonly CACHE_INITIALIZATION_FAILED: "core.cache.initialization_failed";
+    readonly CACHE_STRATEGY_NOT_FOUND: "core.cache.strategy_not_found";
+    readonly CACHE_OPERATION_FAILED: "core.cache.operation_failed";
+    readonly CACHE_INVALIDATION_FAILED: "core.cache.invalidation_failed";
+    readonly CACHE_SERIALIZATION_FAILED: "core.cache.serialization_failed";
+    readonly API_CLIENT_INITIALIZATION_FAILED: "core.api_client.initialization_failed";
+    readonly API_CLIENT_REQUEST_FAILED: "core.api_client.request_failed";
+    readonly API_CLIENT_TIMEOUT: "core.api_client.timeout";
+    readonly API_CLIENT_INVALID_RESPONSE: "core.api_client.invalid_response";
+    readonly API_CLIENT_AUTHENTICATION_FAILED: "core.api_client.authentication_failed";
+    readonly DATABASE_SERVICE_INITIALIZATION_FAILED: "core.database_service.initialization_failed";
+    readonly DATABASE_SERVICE_CONNECTION_FAILED: "core.database_service.connection_failed";
+    readonly DATABASE_SERVICE_QUERY_FAILED: "core.database_service.query_failed";
+    readonly DATABASE_SERVICE_TRANSACTION_FAILED: "core.database_service.transaction_failed";
+    readonly VALIDATION_FAILED: "core.validation.failed";
+    readonly VALIDATION_SCHEMA_INVALID: "core.validation.schema_invalid";
+    readonly VALIDATION_REQUIRED_FIELD_MISSING: "core.validation.required_field_missing";
+    readonly HASH_GENERATION_FAILED: "core.hash.generation_failed";
+    readonly HASH_VERIFICATION_FAILED: "core.hash.verification_failed";
+    readonly ENGINE_INITIALIZATION_FAILED: "core.engine.initialization_failed";
+    readonly ENGINE_EXECUTION_FAILED: "core.engine.execution_failed";
+    readonly ENGINE_CONFIGURATION_INVALID: "core.engine.configuration_invalid";
+    readonly PROVIDER_NOT_FOUND: "core.provider.not_found";
+    readonly PROVIDER_INITIALIZATION_FAILED: "core.provider.initialization_failed";
+    readonly PROVIDER_OPERATION_FAILED: "core.provider.operation_failed";
+    readonly CONTEXT_INVALID: "core.context.invalid";
+    readonly CONTEXT_MISSING_REQUIRED_DATA: "core.context.missing_required_data";
+    readonly INITIALIZATION_FAILED: "core.initialization_failed";
+    readonly CONFIGURATION_INVALID: "core.configuration_invalid";
+    readonly OPERATION_FAILED: "core.operation_failed";
+    readonly UNKNOWN_ERROR: "core.unknown_error";
+};
 /**
  * PAYMENT-specific error codes
  * Subset of ERROR_CODES for @plyaz/payments package
@@ -942,6 +1026,7 @@ export type ApiErrorCodeValue = (typeof API_ERROR_CODES)[keyof typeof API_ERROR_
 export type NotificationErrorCodeValue = (typeof NOTIFICATION_ERROR_CODES)[keyof typeof NOTIFICATION_ERROR_CODES];
 export type StorageErrorCode = (typeof STORAGE_ERROR_CODES)[keyof typeof STORAGE_ERROR_CODES];
 export type DatabaseErrorCodeValue = (typeof DATABASE_ERROR_CODES)[keyof typeof DATABASE_ERROR_CODES];
+export type CoreErrorCodeValue = (typeof CORE_ERROR_CODES)[keyof typeof CORE_ERROR_CODES];
 export type PaymentErrorCodeValue = (typeof PAYMENT_ERROR_CODES)[keyof typeof PAYMENT_ERROR_CODES];
 /**
  * Unified ERROR_DEFINITIONS

package/dist/errors/index.cjs

@@ -671,6 +671,56 @@ var ERROR_CODES = {
   STORAGE_INSUFFICIENT_SPACE: "storage.insufficient.space",
   // Feature Implementation
   STORAGE_FEATURE_NOT_IMPLEMENTED: "storage.feature.not.implemented",
+  // ===== Core Package Errors =====
+  // Feature Flags
+  CORE_FEATURE_FLAG_NOT_FOUND: "core.feature_flag.not_found",
+  CORE_FEATURE_FLAG_INVALID_CONFIG: "core.feature_flag.invalid_config",
+  CORE_FEATURE_FLAG_EVALUATION_FAILED: "core.feature_flag.evaluation_failed",
+  CORE_FEATURE_FLAG_PROVIDER_ERROR: "core.feature_flag.provider_error",
+  CORE_FEATURE_FLAG_CACHE_ERROR: "core.feature_flag.cache_error",
+  CORE_FEATURE_FLAG_CONTEXT_INVALID: "core.feature_flag.context_invalid",
+  CORE_FEATURE_FLAG_RULE_INVALID: "core.feature_flag.rule_invalid",
+  CORE_FEATURE_FLAG_TOGGLE_FAILED: "core.feature_flag.toggle_failed",
+  // Cache
+  CORE_CACHE_INITIALIZATION_FAILED: "core.cache.initialization_failed",
+  CORE_CACHE_STRATEGY_NOT_FOUND: "core.cache.strategy_not_found",
+  CORE_CACHE_OPERATION_FAILED: "core.cache.operation_failed",
+  CORE_CACHE_INVALIDATION_FAILED: "core.cache.invalidation_failed",
+  CORE_CACHE_SERIALIZATION_FAILED: "core.cache.serialization_failed",
+  // API Client
+  CORE_API_CLIENT_INITIALIZATION_FAILED: "core.api_client.initialization_failed",
+  CORE_API_CLIENT_REQUEST_FAILED: "core.api_client.request_failed",
+  CORE_API_CLIENT_TIMEOUT: "core.api_client.timeout",
+  CORE_API_CLIENT_INVALID_RESPONSE: "core.api_client.invalid_response",
+  CORE_API_CLIENT_AUTHENTICATION_FAILED: "core.api_client.authentication_failed",
+  // Database Service
+  CORE_DATABASE_SERVICE_INITIALIZATION_FAILED: "core.database_service.initialization_failed",
+  CORE_DATABASE_SERVICE_CONNECTION_FAILED: "core.database_service.connection_failed",
+  CORE_DATABASE_SERVICE_QUERY_FAILED: "core.database_service.query_failed",
+  CORE_DATABASE_SERVICE_TRANSACTION_FAILED: "core.database_service.transaction_failed",
+  // Validation
+  CORE_VALIDATION_FAILED: "core.validation.failed",
+  CORE_VALIDATION_SCHEMA_INVALID: "core.validation.schema_invalid",
+  CORE_VALIDATION_REQUIRED_FIELD_MISSING: "core.validation.required_field_missing",
+  // Hash Utilities
+  CORE_HASH_GENERATION_FAILED: "core.hash.generation_failed",
+  CORE_HASH_VERIFICATION_FAILED: "core.hash.verification_failed",
+  // Engine
+  CORE_ENGINE_INITIALIZATION_FAILED: "core.engine.initialization_failed",
+  CORE_ENGINE_EXECUTION_FAILED: "core.engine.execution_failed",
+  CORE_ENGINE_CONFIGURATION_INVALID: "core.engine.configuration_invalid",
+  // Provider
+  CORE_PROVIDER_NOT_FOUND: "core.provider.not_found",
+  CORE_PROVIDER_INITIALIZATION_FAILED: "core.provider.initialization_failed",
+  CORE_PROVIDER_OPERATION_FAILED: "core.provider.operation_failed",
+  // Context
+  CORE_CONTEXT_INVALID: "core.context.invalid",
+  CORE_CONTEXT_MISSING_REQUIRED_DATA: "core.context.missing_required_data",
+  // General Core
+  CORE_INITIALIZATION_FAILED: "core.initialization_failed",
+  CORE_CONFIGURATION_INVALID: "core.configuration_invalid",
+  CORE_OPERATION_FAILED: "core.operation_failed",
+  CORE_UNKNOWN_ERROR: "core.unknown_error",
   // ===== Errors Package Errors =====
   ERROR_SYSTEM_NOT_INITIALIZED: "error.system.not.initialized",
   EVENT_FACTORY_NOT_REGISTERED: "error.event.factory.not.registered",
@@ -1210,6 +1260,57 @@ var STORAGE_ERROR_CODES = {
   // Feature Implementation
   FEATURE_NOT_IMPLEMENTED: ERROR_CODES.STORAGE_FEATURE_NOT_IMPLEMENTED
 };
+var CORE_ERROR_CODES = {
+  // Feature Flags
+  FEATURE_FLAG_NOT_FOUND: ERROR_CODES.CORE_FEATURE_FLAG_NOT_FOUND,
+  FEATURE_FLAG_INVALID_CONFIG: ERROR_CODES.CORE_FEATURE_FLAG_INVALID_CONFIG,
+  FEATURE_FLAG_EVALUATION_FAILED: ERROR_CODES.CORE_FEATURE_FLAG_EVALUATION_FAILED,
+  FEATURE_FLAG_PROVIDER_ERROR: ERROR_CODES.CORE_FEATURE_FLAG_PROVIDER_ERROR,
+  FEATURE_FLAG_CACHE_ERROR: ERROR_CODES.CORE_FEATURE_FLAG_CACHE_ERROR,
+  FEATURE_FLAG_CONTEXT_INVALID: ERROR_CODES.CORE_FEATURE_FLAG_CONTEXT_INVALID,
+  FEATURE_FLAG_RULE_INVALID: ERROR_CODES.CORE_FEATURE_FLAG_RULE_INVALID,
+  FEATURE_FLAG_TOGGLE_FAILED: ERROR_CODES.CORE_FEATURE_FLAG_TOGGLE_FAILED,
+  // Cache
+  CACHE_INITIALIZATION_FAILED: ERROR_CODES.CORE_CACHE_INITIALIZATION_FAILED,
+  CACHE_STRATEGY_NOT_FOUND: ERROR_CODES.CORE_CACHE_STRATEGY_NOT_FOUND,
+  CACHE_OPERATION_FAILED: ERROR_CODES.CORE_CACHE_OPERATION_FAILED,
+  CACHE_INVALIDATION_FAILED: ERROR_CODES.CORE_CACHE_INVALIDATION_FAILED,
+  CACHE_SERIALIZATION_FAILED: ERROR_CODES.CORE_CACHE_SERIALIZATION_FAILED,
+  // API Client
+  API_CLIENT_INITIALIZATION_FAILED: ERROR_CODES.CORE_API_CLIENT_INITIALIZATION_FAILED,
+  API_CLIENT_REQUEST_FAILED: ERROR_CODES.CORE_API_CLIENT_REQUEST_FAILED,
+  API_CLIENT_TIMEOUT: ERROR_CODES.CORE_API_CLIENT_TIMEOUT,
+  API_CLIENT_INVALID_RESPONSE: ERROR_CODES.CORE_API_CLIENT_INVALID_RESPONSE,
+  API_CLIENT_AUTHENTICATION_FAILED: ERROR_CODES.CORE_API_CLIENT_AUTHENTICATION_FAILED,
+  // Database Service
+  DATABASE_SERVICE_INITIALIZATION_FAILED: ERROR_CODES.CORE_DATABASE_SERVICE_INITIALIZATION_FAILED,
+  DATABASE_SERVICE_CONNECTION_FAILED: ERROR_CODES.CORE_DATABASE_SERVICE_CONNECTION_FAILED,
+  DATABASE_SERVICE_QUERY_FAILED: ERROR_CODES.CORE_DATABASE_SERVICE_QUERY_FAILED,
+  DATABASE_SERVICE_TRANSACTION_FAILED: ERROR_CODES.CORE_DATABASE_SERVICE_TRANSACTION_FAILED,
+  // Validation
+  VALIDATION_FAILED: ERROR_CODES.CORE_VALIDATION_FAILED,
+  VALIDATION_SCHEMA_INVALID: ERROR_CODES.CORE_VALIDATION_SCHEMA_INVALID,
+  VALIDATION_REQUIRED_FIELD_MISSING: ERROR_CODES.CORE_VALIDATION_REQUIRED_FIELD_MISSING,
+  // Hash Utilities
+  HASH_GENERATION_FAILED: ERROR_CODES.CORE_HASH_GENERATION_FAILED,
+  HASH_VERIFICATION_FAILED: ERROR_CODES.CORE_HASH_VERIFICATION_FAILED,
+  // Engine
+  ENGINE_INITIALIZATION_FAILED: ERROR_CODES.CORE_ENGINE_INITIALIZATION_FAILED,
+  ENGINE_EXECUTION_FAILED: ERROR_CODES.CORE_ENGINE_EXECUTION_FAILED,
+  ENGINE_CONFIGURATION_INVALID: ERROR_CODES.CORE_ENGINE_CONFIGURATION_INVALID,
+  // Provider
+  PROVIDER_NOT_FOUND: ERROR_CODES.CORE_PROVIDER_NOT_FOUND,
+  PROVIDER_INITIALIZATION_FAILED: ERROR_CODES.CORE_PROVIDER_INITIALIZATION_FAILED,
+  PROVIDER_OPERATION_FAILED: ERROR_CODES.CORE_PROVIDER_OPERATION_FAILED,
+  // Context
+  CONTEXT_INVALID: ERROR_CODES.CORE_CONTEXT_INVALID,
+  CONTEXT_MISSING_REQUIRED_DATA: ERROR_CODES.CORE_CONTEXT_MISSING_REQUIRED_DATA,
+  // General Core
+  INITIALIZATION_FAILED: ERROR_CODES.CORE_INITIALIZATION_FAILED,
+  CONFIGURATION_INVALID: ERROR_CODES.CORE_CONFIGURATION_INVALID,
+  OPERATION_FAILED: ERROR_CODES.CORE_OPERATION_FAILED,
+  UNKNOWN_ERROR: ERROR_CODES.CORE_UNKNOWN_ERROR
+};
 var PAYMENT_ERROR_CODES = {
   // Timeout & Network
   PAYMENT_TIMEOUT: ERROR_CODES.PAYMENT_TIMEOUT,
@@ -3385,6 +3486,329 @@ var ERROR_DEFINITIONS = {
     retryable: false,
     userMessage: "errors.storage.feature.not_implemented"
   },
+  // ===== Core Package Error Definitions =====
+  // Feature Flags
+  [ERROR_CODES.CORE_FEATURE_FLAG_NOT_FOUND]: {
+    code: ERROR_CODES.CORE_FEATURE_FLAG_NOT_FOUND,
+    status: HTTP_STATUS.NOT_FOUND,
+    category: ERROR_CATEGORY.NotFound,
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false,
+    userMessage: "errors.core.feature_flag.not_found"
+  },
+  [ERROR_CODES.CORE_FEATURE_FLAG_INVALID_CONFIG]: {
+    code: ERROR_CODES.CORE_FEATURE_FLAG_INVALID_CONFIG,
+    status: HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Configuration,
+    severity: ERROR_SEVERITY.High,
+    retryable: false,
+    userMessage: "errors.core.feature_flag.invalid_config"
+  },
+  [ERROR_CODES.CORE_FEATURE_FLAG_EVALUATION_FAILED]: {
+    code: ERROR_CODES.CORE_FEATURE_FLAG_EVALUATION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Processing,
+    severity: ERROR_SEVERITY.High,
+    retryable: true,
+    userMessage: "errors.core.feature_flag.evaluation_failed"
+  },
+  [ERROR_CODES.CORE_FEATURE_FLAG_PROVIDER_ERROR]: {
+    code: ERROR_CODES.CORE_FEATURE_FLAG_PROVIDER_ERROR,
+    status: HTTP_STATUS.BAD_GATEWAY,
+    category: ERROR_CATEGORY.Provider,
+    severity: ERROR_SEVERITY.High,
+    retryable: true,
+    userMessage: "errors.core.feature_flag.provider_error"
+  },
+  [ERROR_CODES.CORE_FEATURE_FLAG_CACHE_ERROR]: {
+    code: ERROR_CODES.CORE_FEATURE_FLAG_CACHE_ERROR,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Cache,
+    severity: ERROR_SEVERITY.Medium,
+    retryable: true,
+    userMessage: "errors.core.feature_flag.cache_error"
+  },
+  [ERROR_CODES.CORE_FEATURE_FLAG_CONTEXT_INVALID]: {
+    code: ERROR_CODES.CORE_FEATURE_FLAG_CONTEXT_INVALID,
+    status: HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false,
+    userMessage: "errors.core.feature_flag.context_invalid"
+  },
+  [ERROR_CODES.CORE_FEATURE_FLAG_RULE_INVALID]: {
+    code: ERROR_CODES.CORE_FEATURE_FLAG_RULE_INVALID,
+    status: HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false,
+    userMessage: "errors.core.feature_flag.rule_invalid"
+  },
+  [ERROR_CODES.CORE_FEATURE_FLAG_TOGGLE_FAILED]: {
+    code: ERROR_CODES.CORE_FEATURE_FLAG_TOGGLE_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Processing,
+    severity: ERROR_SEVERITY.High,
+    retryable: true,
+    userMessage: "errors.core.feature_flag.toggle_failed"
+  },
+  // Cache
+  [ERROR_CODES.CORE_CACHE_INITIALIZATION_FAILED]: {
+    code: ERROR_CODES.CORE_CACHE_INITIALIZATION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Configuration,
+    severity: ERROR_SEVERITY.Critical,
+    retryable: false,
+    userMessage: "errors.core.cache.initialization_failed"
+  },
+  [ERROR_CODES.CORE_CACHE_STRATEGY_NOT_FOUND]: {
+    code: ERROR_CODES.CORE_CACHE_STRATEGY_NOT_FOUND,
+    status: HTTP_STATUS.NOT_FOUND,
+    category: ERROR_CATEGORY.Configuration,
+    severity: ERROR_SEVERITY.High,
+    retryable: false,
+    userMessage: "errors.core.cache.strategy_not_found"
+  },
+  [ERROR_CODES.CORE_CACHE_OPERATION_FAILED]: {
+    code: ERROR_CODES.CORE_CACHE_OPERATION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Cache,
+    severity: ERROR_SEVERITY.Medium,
+    retryable: true,
+    userMessage: "errors.core.cache.operation_failed"
+  },
+  [ERROR_CODES.CORE_CACHE_INVALIDATION_FAILED]: {
+    code: ERROR_CODES.CORE_CACHE_INVALIDATION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Cache,
+    severity: ERROR_SEVERITY.Medium,
+    retryable: true,
+    userMessage: "errors.core.cache.invalidation_failed"
+  },
+  [ERROR_CODES.CORE_CACHE_SERIALIZATION_FAILED]: {
+    code: ERROR_CODES.CORE_CACHE_SERIALIZATION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Processing,
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false,
+    userMessage: "errors.core.cache.serialization_failed"
+  },
+  // API Client
+  [ERROR_CODES.CORE_API_CLIENT_INITIALIZATION_FAILED]: {
+    code: ERROR_CODES.CORE_API_CLIENT_INITIALIZATION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Configuration,
+    severity: ERROR_SEVERITY.Critical,
+    retryable: false,
+    userMessage: "errors.core.api_client.initialization_failed"
+  },
+  [ERROR_CODES.CORE_API_CLIENT_REQUEST_FAILED]: {
+    code: ERROR_CODES.CORE_API_CLIENT_REQUEST_FAILED,
+    status: HTTP_STATUS.BAD_GATEWAY,
+    category: ERROR_CATEGORY.Network,
+    severity: ERROR_SEVERITY.High,
+    retryable: true,
+    userMessage: "errors.core.api_client.request_failed"
+  },
+  [ERROR_CODES.CORE_API_CLIENT_TIMEOUT]: {
+    code: ERROR_CODES.CORE_API_CLIENT_TIMEOUT,
+    status: HTTP_STATUS.GATEWAY_TIMEOUT,
+    category: ERROR_CATEGORY.Timeout,
+    severity: ERROR_SEVERITY.High,
+    retryable: true,
+    userMessage: "errors.core.api_client.timeout"
+  },
+  [ERROR_CODES.CORE_API_CLIENT_INVALID_RESPONSE]: {
+    code: ERROR_CODES.CORE_API_CLIENT_INVALID_RESPONSE,
+    status: HTTP_STATUS.BAD_GATEWAY,
+    category: ERROR_CATEGORY.Server,
+    severity: ERROR_SEVERITY.High,
+    retryable: false,
+    userMessage: "errors.core.api_client.invalid_response"
+  },
+  [ERROR_CODES.CORE_API_CLIENT_AUTHENTICATION_FAILED]: {
+    code: ERROR_CODES.CORE_API_CLIENT_AUTHENTICATION_FAILED,
+    status: HTTP_STATUS.UNAUTHORIZED,
+    category: ERROR_CATEGORY.Authentication,
+    severity: ERROR_SEVERITY.High,
+    retryable: false,
+    userMessage: "errors.core.api_client.authentication_failed"
+  },
+  // Database Service
+  [ERROR_CODES.CORE_DATABASE_SERVICE_INITIALIZATION_FAILED]: {
+    code: ERROR_CODES.CORE_DATABASE_SERVICE_INITIALIZATION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Configuration,
+    severity: ERROR_SEVERITY.Critical,
+    retryable: false,
+    userMessage: "errors.core.database_service.initialization_failed"
+  },
+  [ERROR_CODES.CORE_DATABASE_SERVICE_CONNECTION_FAILED]: {
+    code: ERROR_CODES.CORE_DATABASE_SERVICE_CONNECTION_FAILED,
+    status: HTTP_STATUS.SERVICE_UNAVAILABLE,
+    category: ERROR_CATEGORY.Network,
+    severity: ERROR_SEVERITY.High,
+    retryable: true,
+    userMessage: "errors.core.database_service.connection_failed"
+  },
+  [ERROR_CODES.CORE_DATABASE_SERVICE_QUERY_FAILED]: {
+    code: ERROR_CODES.CORE_DATABASE_SERVICE_QUERY_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Server,
+    severity: ERROR_SEVERITY.High,
+    retryable: false,
+    userMessage: "errors.core.database_service.query_failed"
+  },
+  [ERROR_CODES.CORE_DATABASE_SERVICE_TRANSACTION_FAILED]: {
+    code: ERROR_CODES.CORE_DATABASE_SERVICE_TRANSACTION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Server,
+    severity: ERROR_SEVERITY.High,
+    retryable: true,
+    userMessage: "errors.core.database_service.transaction_failed"
+  },
+  // Validation
+  [ERROR_CODES.CORE_VALIDATION_FAILED]: {
+    code: ERROR_CODES.CORE_VALIDATION_FAILED,
+    status: HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false,
+    userMessage: "errors.core.validation.failed"
+  },
+  [ERROR_CODES.CORE_VALIDATION_SCHEMA_INVALID]: {
+    code: ERROR_CODES.CORE_VALIDATION_SCHEMA_INVALID,
+    status: HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    severity: ERROR_SEVERITY.High,
+    retryable: false,
+    userMessage: "errors.core.validation.schema_invalid"
+  },
+  [ERROR_CODES.CORE_VALIDATION_REQUIRED_FIELD_MISSING]: {
+    code: ERROR_CODES.CORE_VALIDATION_REQUIRED_FIELD_MISSING,
+    status: HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false,
+    userMessage: "errors.core.validation.required_field_missing"
+  },
+  // Hash Utilities
+  [ERROR_CODES.CORE_HASH_GENERATION_FAILED]: {
+    code: ERROR_CODES.CORE_HASH_GENERATION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Processing,
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false,
+    userMessage: "errors.core.hash.generation_failed"
+  },
+  [ERROR_CODES.CORE_HASH_VERIFICATION_FAILED]: {
+    code: ERROR_CODES.CORE_HASH_VERIFICATION_FAILED,
+    status: HTTP_STATUS.UNAUTHORIZED,
+    category: ERROR_CATEGORY.Authentication,
+    severity: ERROR_SEVERITY.High,
+    retryable: false,
+    userMessage: "errors.core.hash.verification_failed"
+  },
+  // Engine
+  [ERROR_CODES.CORE_ENGINE_INITIALIZATION_FAILED]: {
+    code: ERROR_CODES.CORE_ENGINE_INITIALIZATION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Configuration,
+    severity: ERROR_SEVERITY.Critical,
+    retryable: false,
+    userMessage: "errors.core.engine.initialization_failed"
+  },
+  [ERROR_CODES.CORE_ENGINE_EXECUTION_FAILED]: {
+    code: ERROR_CODES.CORE_ENGINE_EXECUTION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Processing,
+    severity: ERROR_SEVERITY.High,
+    retryable: true,
+    userMessage: "errors.core.engine.execution_failed"
+  },
+  [ERROR_CODES.CORE_ENGINE_CONFIGURATION_INVALID]: {
+    code: ERROR_CODES.CORE_ENGINE_CONFIGURATION_INVALID,
+    status: HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Configuration,
+    severity: ERROR_SEVERITY.High,
+    retryable: false,
+    userMessage: "errors.core.engine.configuration_invalid"
+  },
+  // Provider
+  [ERROR_CODES.CORE_PROVIDER_NOT_FOUND]: {
+    code: ERROR_CODES.CORE_PROVIDER_NOT_FOUND,
+    status: HTTP_STATUS.NOT_FOUND,
+    category: ERROR_CATEGORY.NotFound,
+    severity: ERROR_SEVERITY.High,
+    retryable: false,
+    userMessage: "errors.core.provider.not_found"
+  },
+  [ERROR_CODES.CORE_PROVIDER_INITIALIZATION_FAILED]: {
+    code: ERROR_CODES.CORE_PROVIDER_INITIALIZATION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Configuration,
+    severity: ERROR_SEVERITY.Critical,
+    retryable: false,
+    userMessage: "errors.core.provider.initialization_failed"
+  },
+  [ERROR_CODES.CORE_PROVIDER_OPERATION_FAILED]: {
+    code: ERROR_CODES.CORE_PROVIDER_OPERATION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Provider,
+    severity: ERROR_SEVERITY.High,
+    retryable: true,
+    userMessage: "errors.core.provider.operation_failed"
+  },
+  // Context
+  [ERROR_CODES.CORE_CONTEXT_INVALID]: {
+    code: ERROR_CODES.CORE_CONTEXT_INVALID,
+    status: HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false,
+    userMessage: "errors.core.context.invalid"
+  },
+  [ERROR_CODES.CORE_CONTEXT_MISSING_REQUIRED_DATA]: {
+    code: ERROR_CODES.CORE_CONTEXT_MISSING_REQUIRED_DATA,
+    status: HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Validation,
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false,
+    userMessage: "errors.core.context.missing_required_data"
+  },
+  // General Core
+  [ERROR_CODES.CORE_INITIALIZATION_FAILED]: {
+    code: ERROR_CODES.CORE_INITIALIZATION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Configuration,
+    severity: ERROR_SEVERITY.Critical,
+    retryable: false,
+    userMessage: "errors.core.initialization_failed"
+  },
+  [ERROR_CODES.CORE_CONFIGURATION_INVALID]: {
+    code: ERROR_CODES.CORE_CONFIGURATION_INVALID,
+    status: HTTP_STATUS.BAD_REQUEST,
+    category: ERROR_CATEGORY.Configuration,
+    severity: ERROR_SEVERITY.High,
+    retryable: false,
+    userMessage: "errors.core.configuration_invalid"
+  },
+  [ERROR_CODES.CORE_OPERATION_FAILED]: {
+    code: ERROR_CODES.CORE_OPERATION_FAILED,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Processing,
+    severity: ERROR_SEVERITY.High,
+    retryable: true,
+    userMessage: "errors.core.operation_failed"
+  },
+  [ERROR_CODES.CORE_UNKNOWN_ERROR]: {
+    code: ERROR_CODES.CORE_UNKNOWN_ERROR,
+    status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+    category: ERROR_CATEGORY.Unknown,
+    severity: ERROR_SEVERITY.Medium,
+    retryable: false,
+    userMessage: "errors.core.unknown_error"
+  },
   // ===== Errors Package Errors =====
   [ERROR_CODES.ERROR_SYSTEM_NOT_INITIALIZED]: {
     code: ERROR_CODES.ERROR_SYSTEM_NOT_INITIALIZED,
@@ -5025,6 +5449,7 @@ exports.API_ERROR_CODES = API_ERROR_CODES;
 exports.COMMON_FIELDS = COMMON_FIELDS;
 exports.COMMON_OPERATIONS = COMMON_OPERATIONS;
 exports.COMMON_STORAGE_TYPES = COMMON_STORAGE_TYPES;
+exports.CORE_ERROR_CODES = CORE_ERROR_CODES;
 exports.DATABASE_ERROR_CODES = DATABASE_ERROR_CODES;
 exports.ERROR_CATEGORY = ERROR_CATEGORY;
 exports.ERROR_CATEGORY_TO_EMITTER_KEY = ERROR_CATEGORY_TO_EMITTER_KEY;