@plyaz/types 1.23.1 → 1.24.0

package/dist/core/domain/types.d.ts

@@ -94,6 +94,12 @@ export interface CoreBaseDomainServiceConfig {
     enabled?: boolean;
     /** Default values for feature flags or other defaults */
     defaults?: Record<string, FeatureFlagValue>;
+    /**
+     * Custom observability adapter to use instead of the injected global/dedicated one.
+     * Useful when a service needs a different provider or custom configuration.
+     * Takes precedence over injected observability.
+     */
+    observabilityOverride?: unknown;
 }
 /**
  * Type for mapper class constructor
@@ -126,7 +132,7 @@ export type CoreValidatorClass<T extends CoreBaseValidatorInstance = CoreBaseVal
  * interface BasicInjectedServices extends CoreInjectedServices {}
  * ```
  */
-export interface CoreInjectedServices<TCache = unknown, TDb = unknown, TApi = unknown, TStores = unknown, TObservability = unknown> {
+export interface CoreInjectedServices<TCache = unknown, TDb = unknown, TApi = unknown, TStores = unknown, TObservability = unknown, TStorage = unknown, TNotifications = unknown> {
     /** Cache manager instance */
     cache?: TCache;
     /** Database service instance */
@@ -144,6 +150,18 @@ export interface CoreInjectedServices<TCache = unknown, TDb = unknown, TApi = un
      * Supports adapter-based providers (Datadog, Grafana, OpenTelemetry, etc.)
      */
     observability?: TObservability;
+    /**
+     * Storage service instance for file uploads, downloads, and management.
+     * Supports multi-provider setup (Cloudflare R2, Supabase, etc.) with automatic failover.
+     * Backend-only - not available in browser/frontend runtimes.
+     */
+    storage?: TStorage;
+    /**
+     * Notification service instance for email, SMS, and push notifications.
+     * Supports multi-provider setup (SendGrid, Infobip, etc.) with automatic failover.
+     * Backend-only - not available in browser/frontend runtimes.
+     */
+    notifications?: TNotifications;
 }
 /**
  * Base service configuration passed to constructor

package/dist/core/events/enums.d.ts

@@ -29,6 +29,8 @@ export declare const CoreEventScope: {
     readonly DATABASE: "database";
     readonly FEATURE_FLAG: "featureFlag";
     readonly STORE: "store";
+    readonly STORAGE: "storage";
+    readonly NOTIFICATION: "notification";
 };
 export type CoreEventScopeType = (typeof CoreEventScope)[keyof typeof CoreEventScope];
 /**
@@ -133,6 +135,28 @@ export declare const StoreEventAction: {
     readonly RESET: "reset";
     readonly HYDRATED: "hydrated";
 };
+/**
+ * Storage event actions (file uploads, downloads, deletions)
+ */
+export declare const StorageEventAction: {
+    readonly UPLOADED: "uploaded";
+    readonly DOWNLOADED: "downloaded";
+    readonly DELETED: "deleted";
+    readonly ERROR: "error";
+    readonly HEALTH_CHECK: "healthCheck";
+};
+/**
+ * Notification event actions (email, sms, push)
+ */
+export declare const NotificationEventAction: {
+    readonly SENT: "sent";
+    readonly FAILED: "failed";
+    readonly DELIVERED: "delivered";
+    readonly OPENED: "opened";
+    readonly CLICKED: "clicked";
+    readonly ERROR: "error";
+    readonly HEALTH_CHECK: "healthCheck";
+};
 /**
  * All core event type constants
  *
@@ -215,6 +239,22 @@ export declare const CORE_EVENTS: {
         readonly RESET: "store:reset";
         readonly HYDRATED: "store:hydrated";
     };
+    readonly STORAGE: {
+        readonly UPLOADED: "storage:uploaded";
+        readonly DOWNLOADED: "storage:downloaded";
+        readonly DELETED: "storage:deleted";
+        readonly ERROR: "storage:error";
+        readonly HEALTH_CHECK: "storage:healthCheck";
+    };
+    readonly NOTIFICATION: {
+        readonly SENT: "notification:sent";
+        readonly FAILED: "notification:failed";
+        readonly DELIVERED: "notification:delivered";
+        readonly OPENED: "notification:opened";
+        readonly CLICKED: "notification:clicked";
+        readonly ERROR: "notification:error";
+        readonly HEALTH_CHECK: "notification:healthCheck";
+    };
 };
 /** All system event types */
 export type SystemEventType = (typeof CORE_EVENTS.SYSTEM)[keyof typeof CORE_EVENTS.SYSTEM];

package/dist/core/events/index.d.ts

@@ -17,6 +17,6 @@
  * );
  * ```
  */
-export { CoreEventScope, SystemEventAction, EntityEventAction, ValidationEventAction, SanitizationEventAction, ApiEventAction, CacheEventAction, AuthEventAction, DatabaseEventAction, FeatureFlagEventAction, StoreEventAction, CORE_EVENTS, } from './enums';
+export { CoreEventScope, SystemEventAction, EntityEventAction, ValidationEventAction, SanitizationEventAction, ApiEventAction, CacheEventAction, AuthEventAction, DatabaseEventAction, FeatureFlagEventAction, StoreEventAction, StorageEventAction, NotificationEventAction, CORE_EVENTS, } from './enums';
 export type { CoreEventScopeType, SystemEventType, EntityEventType, ValidationEventType, SanitizationEventType, ApiEventType, CacheEventType, AuthEventType, DatabaseEventType, FeatureFlagEventType, StoreEventType, CoreEventType, } from './enums';
-export type { CoreEvent, CoreCrudOperation, CoreValidationStartedPayload, CoreValidationSuccessPayload, CoreValidationFailedPayload, CoreSanitizationStartedPayload, CoreSanitizationSuccessPayload, CoreSanitizationFailedPayload, CoreEntityCreatedPayload, CoreEntityUpdatedPayload, CoreEntityPatchedPayload, CoreEntityDeletedPayload, CoreEntityCreatingPayload, CoreEntityUpdatingPayload, CoreEntityPatchingPayload, CoreEntityDeletingPayload, CoreEntityErrorPayload, CoreEntityCompletePayload, CoreBulkCreatedPayload, CoreBulkDeletedPayload, CoreSystemInitializedPayload, CoreSystemReadyPayload, CoreSystemShutdownPayload, CoreSystemErrorPayload, CoreSystemWarningPayload, CoreApiRequestStartPayload, CoreApiRequestSuccessPayload, CoreApiRequestErrorPayload, CoreApiRetryPayload, CoreApiTimeoutPayload, CoreCacheHitPayload, CoreCacheMissPayload, CoreCacheSetPayload, CoreCacheDeletePayload, CoreCacheClearPayload, CoreCacheExpiredPayload, CoreDatabaseConnectedPayload, CoreDatabaseDisconnectedPayload, CoreDatabaseQueryPayload, CoreDatabaseErrorPayload, CoreDatabaseTransactionStartPayload, CoreDatabaseTransactionCommitPayload, CoreDatabaseTransactionRollbackPayload, CoreAuthLoginPayload, CoreAuthLogoutPayload, CoreAuthTokenRefreshPayload, CoreAuthSessionExpiredPayload, CoreAuthUnauthorizedPayload, CoreFeatureFlagChangedPayload, CoreFeatureFlagEvaluatedPayload, CoreFeatureFlagRefreshedPayload, CoreStoreUpdatedPayload, CoreStoreResetPayload, CoreStoreHydratedPayload, CoreEventPayloadMap, } from './payloads';
+export type { CoreEvent, CoreCrudOperation, CoreValidationStartedPayload, CoreValidationSuccessPayload, CoreValidationFailedPayload, CoreSanitizationStartedPayload, CoreSanitizationSuccessPayload, CoreSanitizationFailedPayload, CoreEntityCreatedPayload, CoreEntityUpdatedPayload, CoreEntityPatchedPayload, CoreEntityDeletedPayload, CoreEntityCreatingPayload, CoreEntityUpdatingPayload, CoreEntityPatchingPayload, CoreEntityDeletingPayload, CoreEntityErrorPayload, CoreEntityCompletePayload, CoreBulkCreatedPayload, CoreBulkDeletedPayload, CoreSystemInitializedPayload, CoreSystemReadyPayload, CoreSystemShutdownPayload, CoreSystemErrorPayload, CoreSystemWarningPayload, CoreApiRequestStartPayload, CoreApiRequestSuccessPayload, CoreApiRequestErrorPayload, CoreApiRetryPayload, CoreApiTimeoutPayload, CoreCacheHitPayload, CoreCacheMissPayload, CoreCacheSetPayload, CoreCacheDeletePayload, CoreCacheClearPayload, CoreCacheExpiredPayload, CoreDatabaseConnectedPayload, CoreDatabaseDisconnectedPayload, CoreDatabaseQueryPayload, CoreDatabaseErrorPayload, CoreDatabaseTransactionStartPayload, CoreDatabaseTransactionCommitPayload, CoreDatabaseTransactionRollbackPayload, CoreAuthLoginPayload, CoreAuthLogoutPayload, CoreAuthTokenRefreshPayload, CoreAuthSessionExpiredPayload, CoreAuthUnauthorizedPayload, CoreFeatureFlagChangedPayload, CoreFeatureFlagEvaluatedPayload, CoreFeatureFlagRefreshedPayload, CoreStoreUpdatedPayload, CoreStoreResetPayload, CoreStoreHydratedPayload, CoreStorageUploadedPayload, CoreStorageDownloadedPayload, CoreStorageDeletedPayload, CoreStorageErrorPayload, CoreStorageHealthCheckPayload, CoreNotificationSentPayload, CoreNotificationFailedPayload, CoreNotificationDeliveredPayload, CoreNotificationOpenedPayload, CoreNotificationClickedPayload, CoreNotificationErrorPayload, CoreNotificationHealthCheckPayload, CoreEventPayloadMap, } from './payloads';

package/dist/core/events/payloads.d.ts

@@ -446,6 +446,121 @@ export interface CoreStoreHydratedPayload {
     storeName: string;
     source: string;
 }
+/**
+ * Payload for storage:uploaded events
+ */
+export interface CoreStorageUploadedPayload {
+    fileId: string;
+    filename: string;
+    size: number;
+    mimeType?: string;
+    bucket?: string;
+    adapter?: string;
+}
+/**
+ * Payload for storage:downloaded events
+ */
+export interface CoreStorageDownloadedPayload {
+    fileId: string;
+    filename?: string;
+    size?: number;
+}
+/**
+ * Payload for storage:deleted events
+ */
+export interface CoreStorageDeletedPayload {
+    fileId: string;
+    permanent?: boolean;
+}
+/**
+ * Payload for storage:error events
+ */
+export interface CoreStorageErrorPayload {
+    error: unknown;
+    operation: string;
+    fileId?: string;
+    filename?: string;
+    recoverable: boolean;
+}
+/**
+ * Payload for storage:healthCheck events
+ */
+export interface CoreStorageHealthCheckPayload {
+    healthy: boolean;
+    adapters?: {
+        name: string;
+        healthy: boolean;
+    }[];
+}
+/**
+ * Payload for notification:sent events
+ */
+export interface CoreNotificationSentPayload {
+    notificationId: string;
+    recipientId: string;
+    channel: 'email' | 'sms' | 'push';
+    templateId?: string;
+    provider?: string;
+}
+/**
+ * Payload for notification:failed events
+ */
+export interface CoreNotificationFailedPayload {
+    notificationId?: string;
+    recipientId: string;
+    channel: 'email' | 'sms' | 'push';
+    error: unknown;
+    retryable?: boolean;
+}
+/**
+ * Payload for notification:delivered events
+ */
+export interface CoreNotificationDeliveredPayload {
+    notificationId: string;
+    recipientId: string;
+    channel: 'email' | 'sms' | 'push';
+    deliveredAt: Date;
+}
+/**
+ * Payload for notification:opened events
+ */
+export interface CoreNotificationOpenedPayload {
+    notificationId: string;
+    recipientId: string;
+    channel: 'email' | 'sms' | 'push';
+    openedAt: Date;
+}
+/**
+ * Payload for notification:clicked events
+ */
+export interface CoreNotificationClickedPayload {
+    notificationId: string;
+    recipientId: string;
+    channel: 'email' | 'sms' | 'push';
+    link?: string;
+    clickedAt: Date;
+}
+/**
+ * Payload for notification:error events
+ */
+export interface CoreNotificationErrorPayload {
+    error: unknown;
+    operation: string;
+    recipientId?: string;
+    channel?: string;
+    recoverable: boolean;
+}
+/**
+ * Payload for notification:healthCheck events
+ */
+export interface CoreNotificationHealthCheckPayload {
+    healthy: boolean;
+    providers?: {
+        name: string;
+        channel: string;
+        healthy: boolean;
+    }[];
+}
 /**
  * Maps event types to their payload types for type-safe event handling.
  *
@@ -516,4 +631,16 @@ export interface CoreEventPayloadMap {
     [CORE_EVENTS.STORE.UPDATED]: CoreStoreUpdatedPayload;
     [CORE_EVENTS.STORE.RESET]: CoreStoreResetPayload;
     [CORE_EVENTS.STORE.HYDRATED]: CoreStoreHydratedPayload;
+    [CORE_EVENTS.STORAGE.UPLOADED]: CoreStorageUploadedPayload;
+    [CORE_EVENTS.STORAGE.DOWNLOADED]: CoreStorageDownloadedPayload;
+    [CORE_EVENTS.STORAGE.DELETED]: CoreStorageDeletedPayload;
+    [CORE_EVENTS.STORAGE.ERROR]: CoreStorageErrorPayload;
+    [CORE_EVENTS.STORAGE.HEALTH_CHECK]: CoreStorageHealthCheckPayload;
+    [CORE_EVENTS.NOTIFICATION.SENT]: CoreNotificationSentPayload;
+    [CORE_EVENTS.NOTIFICATION.FAILED]: CoreNotificationFailedPayload;
+    [CORE_EVENTS.NOTIFICATION.DELIVERED]: CoreNotificationDeliveredPayload;
+    [CORE_EVENTS.NOTIFICATION.OPENED]: CoreNotificationOpenedPayload;
+    [CORE_EVENTS.NOTIFICATION.CLICKED]: CoreNotificationClickedPayload;
+    [CORE_EVENTS.NOTIFICATION.ERROR]: CoreNotificationErrorPayload;
+    [CORE_EVENTS.NOTIFICATION.HEALTH_CHECK]: CoreNotificationHealthCheckPayload;
 }

package/dist/core/init/index.d.ts

@@ -2,4 +2,4 @@
  * Core Init Types
  * Service registry and initialization type definitions
  */
-export type { CoreDomainServiceInstance, CoreServiceInitConfig, CoreServiceCreateOptions, CoreInitializableDomainService, CoreServiceEntry, CoreServiceRegistryConfig, CoreExtractServiceConfig, CoreExtractServiceInstance, CoreFeatureFlagInitConfig, CoreErrorHandlerInitConfig, CoreCacheConfig, CoreObservabilityConfig, CoreInitOptionsBase, CoreServicesResultBase, } from './types';
+export type { CoreDomainServiceInstance, CoreServiceInitConfig, CoreServiceCreateOptions, CoreInitializableDomainService, CoreServiceEntry, CoreServiceRegistryConfig, CoreExtractServiceConfig, CoreExtractServiceInstance, CoreFeatureFlagInitConfig, CoreErrorHandlerInitConfig, CoreCacheConfig, CoreObservabilityConfig, CoreStorageConfig, CoreNotificationConfig, CoreInitOptionsBase, CoreServicesResultBase, } from './types';

package/dist/core/init/types.d.ts

@@ -12,6 +12,21 @@ import type { RootStoreSlice } from '../../store';
 import type { CoreAppEnvironment, CoreAppContext, CoreRuntimeEnvironment, CoreServiceRuntime } from '../modules';
 import type { CoreDbServiceConfig } from '../services';
 import type { CoreInjectedServices } from '../domain';
+import type { MonitoringObservabilityAdapter, MonitoringAdapterWithPriority } from '../../observability';
+import type { StorageServiceConfig } from '../../storage';
+import type { NotificationServiceConfig } from '../../notifications';
+/**
+ * Storage service configuration for Core initialization.
+ * Uses the StorageServiceConfig from @plyaz/storage.
+ * Backend-only - not available in browser/frontend runtimes.
+ */
+export type CoreStorageConfig = StorageServiceConfig;
+/**
+ * Notification service configuration for Core initialization.
+ * Uses the NotificationServiceConfig from @plyaz/notifications.
+ * Backend-only - not available in browser/frontend runtimes.
+ */
+export type CoreNotificationConfig = NotificationServiceConfig;
 /**
  * Base interface that all domain service instances must implement.
  * This allows the registry to manage services generically.
@@ -245,6 +260,75 @@ export interface CoreServiceInitConfig {
      * ```
      */
     dedicatedObservability?: boolean | CoreObservabilityConfig;
+    /**
+     * Create a dedicated storage instance for this service.
+     *
+     * By default, services share the global storage service. Use this when
+     * a service needs its own isolated storage (e.g., different adapters,
+     * separate buckets, compliance requirements).
+     *
+     * - `false` or `undefined`: Use global shared storage (default)
+     * - `true`: Create dedicated instance using global config
+     * - `CoreStorageConfig`: Create dedicated instance with custom config
+     *
+     * Note: This is only available in backend/Node.js contexts.
+     *
+     * @example
+     * ```typescript
+     * // Use global shared storage (default)
+     * { service: UserService, config: { enabled: true } }
+     *
+     * // Create dedicated storage with global config
+     * { service: DocumentService, config: { dedicatedStorage: true } }
+     *
+     * // Create dedicated storage with custom config (compliance documents)
+     * {
+     *   service: TaxDocumentService,
+     *   config: {
+     *     dedicatedStorage: {
+     *       adapters: [cloudflareR2Adapter],
+     *       compliance: { retentionYears: 7, immutable: true },
+     *     },
+     *   },
+     * }
+     * ```
+     */
+    dedicatedStorage?: boolean | CoreStorageConfig;
+    /**
+     * Create a dedicated notifications instance for this service.
+     *
+     * By default, services share the global notification service. Use this when
+     * a service needs its own isolated notifications (e.g., different providers,
+     * separate templates, custom preferences).
+     *
+     * - `false` or `undefined`: Use global shared notifications (default)
+     * - `true`: Create dedicated instance using global config
+     * - `CoreNotificationConfig`: Create dedicated instance with custom config
+     *
+     * Note: This is only available in backend/Node.js contexts.
+     *
+     * @example
+     * ```typescript
+     * // Use global shared notifications (default)
+     * { service: UserService, config: { enabled: true } }
+     *
+     * // Create dedicated notifications with global config
+     * { service: MarketingService, config: { dedicatedNotifications: true } }
+     *
+     * // Create dedicated notifications with custom config
+     * {
+     *   service: TransactionalService,
+     *   config: {
+     *     dedicatedNotifications: {
+     *       providers: {
+     *         email: [sendGridAdapter], // SendGrid only for transactional
+     *       },
+     *     },
+     *   },
+     * }
+     * ```
+     */
+    dedicatedNotifications?: boolean | CoreNotificationConfig;
 }
 /**
  * Options passed to the service factory method
@@ -357,12 +441,56 @@ export interface CoreServiceCreateOptions<TConfig = unknown, TMapper = unknown,
          */
         instance?: unknown;
     };
+    /**
+     * Storage configuration and mode.
+     * Backend-only - not available in browser/frontend runtimes.
+     */
+    storage?: {
+        /**
+         * Whether to use a dedicated (isolated) storage instance.
+         * - `false`: Use global shared instance (default)
+         * - `true`: Create dedicated instance
+         */
+        dedicated: boolean;
+        /**
+         * Storage config (merged global + per-service config).
+         * Used to create dedicated instance or configure global.
+         */
+        config?: CoreStorageConfig;
+        /**
+         * Actual StorageService instance to use.
+         * Injected by ServiceRegistry, not created by service.
+         */
+        instance?: unknown;
+    };
+    /**
+     * Notifications configuration and mode.
+     * Backend-only - not available in browser/frontend runtimes.
+     */
+    notifications?: {
+        /**
+         * Whether to use a dedicated (isolated) notifications instance.
+         * - `false`: Use global shared instance (default)
+         * - `true`: Create dedicated instance
+         */
+        dedicated: boolean;
+        /**
+         * Notifications config (merged global + per-service config).
+         * Used to create dedicated instance or configure global.
+         */
+        config?: CoreNotificationConfig;
+        /**
+         * Actual NotificationService instance to use.
+         * Injected by ServiceRegistry, not created by service.
+         */
+        instance?: unknown;
+    };
     /** Logger prefix */
     loggerPrefix?: string;
     /** Whether this is a singleton instance */
     isSingleton?: boolean;
     /**
-     * Injected service instances (cache, db, api).
+     * Injected service instances (cache, db, api, storage, notifications).
      * Services built by ServiceRegistry will receive these automatically.
      */
     injected?: CoreInjectedServices;
@@ -442,6 +570,10 @@ export interface CoreServiceRegistryConfig {
     cache?: CoreCacheConfig;
     /** Global observability config (shared by all services unless overridden) */
     observability?: CoreObservabilityConfig;
+    /** Global storage config (shared by all services unless overridden) - backend only */
+    storage?: CoreStorageConfig;
+    /** Global notifications config (shared by all services unless overridden) - backend only */
+    notifications?: CoreNotificationConfig;
     /**
      * Store registry interface for injecting stores into services.
      * Provides type-safe store access via store keys.
@@ -637,12 +769,18 @@ export interface CoreObservabilityConfig {
         /** Export interval in milliseconds */
         exportInterval?: number;
     };
+    /**
+     * Pre-initialized adapters for observability.
+     * Can be plain adapters or adapters with priority/failover config.
+     * LoggerAdapter is auto-added as failover if not included.
+     */
+    adapters?: (MonitoringObservabilityAdapter | MonitoringAdapterWithPriority)[];
 }
 /**
  * Base core initialization options
  * Extended by @plyaz/core's CoreInitOptions with specific types
  */
-export interface CoreInitOptionsBase<TDb = unknown, TApi = unknown> {
+export interface CoreInitOptionsBase<TDb = unknown, TApi = unknown, TStorage = unknown, TNotifications = unknown> {
     /** Path to .env file (backend only) */
     envPath?: string;
     /** Global environment (production, staging, development) */
@@ -659,6 +797,10 @@ export interface CoreInitOptionsBase<TDb = unknown, TApi = unknown> {
     cache?: CoreCacheConfig;
     /** Observability configuration */
     observability?: CoreObservabilityConfig;
+    /** Storage configuration (backend only) */
+    storage?: TStorage;
+    /** Notifications configuration (backend only) */
+    notifications?: TNotifications;
     /** Skip database initialization */
     skipDb?: boolean;
     /** Skip API client initialization */
@@ -667,6 +809,10 @@ export interface CoreInitOptionsBase<TDb = unknown, TApi = unknown> {
     skipCache?: boolean;
     /** Skip observability initialization */
     skipObservability?: boolean;
+    /** Skip storage initialization (backend only) */
+    skipStorage?: boolean;
+    /** Skip notifications initialization (backend only) */
+    skipNotifications?: boolean;
     /** Enable verbose logging */
     verbose?: boolean;
     /** Error handler configuration */
@@ -679,7 +825,7 @@ export interface CoreInitOptionsBase<TDb = unknown, TApi = unknown> {
 /**
  * Core services result from initialization
  */
-export interface CoreServicesResultBase<TDb = unknown, TApi = unknown, TCache = unknown, TObservability = unknown> {
+export interface CoreServicesResultBase<TDb = unknown, TApi = unknown, TCache = unknown, TObservability = unknown, TStorage = unknown, TNotifications = unknown> {
     /** Database service instance (null if skipped or on frontend) */
     db: TDb | null;
     /** API client service class */
@@ -688,6 +834,10 @@ export interface CoreServicesResultBase<TDb = unknown, TApi = unknown, TCache =
     cache: TCache | null;
     /** Observability adapter instance (null if skipped) */
     observability: TObservability | null;
+    /** Storage service instance (null if skipped or on frontend) */
+    storage: TStorage | null;
+    /** Notification service instance (null if skipped or on frontend) */
+    notifications: TNotifications | null;
     /** Loaded environment variables */
     env: Record<string, string | undefined>;
     /** Detected runtime environment */

package/dist/core/modules.d.ts

@@ -311,7 +311,7 @@ export interface CoreApiInitOptions {
 /**
  * Core initialization options
  */
-export interface CoreInitOptions<TDbConfig = unknown, TApiConfig = CoreApiInitOptions, TCacheConfig = unknown> {
+export interface CoreInitOptions<TDbConfig = unknown, TApiConfig = CoreApiInitOptions, TCacheConfig = unknown, TStorageConfig = unknown, TNotificationsConfig = unknown> {
     /** Path to .env file */
     envPath?: string;
     /** Global application environment */
@@ -326,22 +326,32 @@ export interface CoreInitOptions<TDbConfig = unknown, TApiConfig = CoreApiInitOp
     api?: TApiConfig;
     /** Cache configuration */
     cache?: TCacheConfig;
+    /** Storage configuration (backend only) */
+    storage?: TStorageConfig;
+    /** Notifications configuration (backend only) */
+    notifications?: TNotificationsConfig;
     /** Skip database initialization */
     skipDb?: boolean;
     /** Skip API client initialization */
     skipApi?: boolean;
     /** Skip cache initialization */
     skipCache?: boolean;
+    /** Skip storage initialization */
+    skipStorage?: boolean;
+    /** Skip notifications initialization */
+    skipNotifications?: boolean;
     /** Enable verbose logging */
     verbose?: boolean;
 }
 /**
  * Core initialization result
  */
-export interface CoreServicesResult<TDb = unknown, TApi = unknown, TCache = unknown> {
+export interface CoreServicesResult<TDb = unknown, TApi = unknown, TCache = unknown, TStorage = unknown, TNotifications = unknown> {
     db: TDb | null;
     api: TApi | null;
     cache: TCache | null;
+    storage: TStorage | null;
+    notifications: TNotifications | null;
     env: CoreEnvVars;
     runtime: CoreRuntimeEnvironment;
     appContext: CoreAppContext;

package/dist/index.cjs

@@ -192,7 +192,9 @@ var CoreEventScope = {
   AUTH: "auth",
   DATABASE: "database",
   FEATURE_FLAG: "featureFlag",
-  STORE: "store"
+  STORE: "store",
+  STORAGE: "storage",
+  NOTIFICATION: "notification"
 };
 var SystemEventAction = {
   INITIALIZED: "initialized",
@@ -270,6 +272,22 @@ var StoreEventAction = {
   RESET: "reset",
   HYDRATED: "hydrated"
 };
+var StorageEventAction = {
+  UPLOADED: "uploaded",
+  DOWNLOADED: "downloaded",
+  DELETED: "deleted",
+  ERROR: "error",
+  HEALTH_CHECK: "healthCheck"
+};
+var NotificationEventAction = {
+  SENT: "sent",
+  FAILED: "failed",
+  DELIVERED: "delivered",
+  OPENED: "opened",
+  CLICKED: "clicked",
+  ERROR: "error",
+  HEALTH_CHECK: "healthCheck"
+};
 var CORE_EVENTS = {
   SYSTEM: {
     INITIALIZED: `${CoreEventScope.SYSTEM}:${SystemEventAction.INITIALIZED}`,
@@ -342,6 +360,22 @@ var CORE_EVENTS = {
     UPDATED: `${CoreEventScope.STORE}:${StoreEventAction.UPDATED}`,
     RESET: `${CoreEventScope.STORE}:${StoreEventAction.RESET}`,
     HYDRATED: `${CoreEventScope.STORE}:${StoreEventAction.HYDRATED}`
+  },
+  STORAGE: {
+    UPLOADED: `${CoreEventScope.STORAGE}:${StorageEventAction.UPLOADED}`,
+    DOWNLOADED: `${CoreEventScope.STORAGE}:${StorageEventAction.DOWNLOADED}`,
+    DELETED: `${CoreEventScope.STORAGE}:${StorageEventAction.DELETED}`,
+    ERROR: `${CoreEventScope.STORAGE}:${StorageEventAction.ERROR}`,
+    HEALTH_CHECK: `${CoreEventScope.STORAGE}:${StorageEventAction.HEALTH_CHECK}`
+  },
+  NOTIFICATION: {
+    SENT: `${CoreEventScope.NOTIFICATION}:${NotificationEventAction.SENT}`,
+    FAILED: `${CoreEventScope.NOTIFICATION}:${NotificationEventAction.FAILED}`,
+    DELIVERED: `${CoreEventScope.NOTIFICATION}:${NotificationEventAction.DELIVERED}`,
+    OPENED: `${CoreEventScope.NOTIFICATION}:${NotificationEventAction.OPENED}`,
+    CLICKED: `${CoreEventScope.NOTIFICATION}:${NotificationEventAction.CLICKED}`,
+    ERROR: `${CoreEventScope.NOTIFICATION}:${NotificationEventAction.ERROR}`,
+    HEALTH_CHECK: `${CoreEventScope.NOTIFICATION}:${NotificationEventAction.HEALTH_CHECK}`
   }
 };
 
@@ -8696,6 +8730,7 @@ exports.NOTIFICATION_ERROR_CODES = NOTIFICATION_ERROR_CODES;
 exports.NOTIFICATION_PROVIDERS = NOTIFICATION_PROVIDERS;
 exports.NetworkPresetNames = NetworkPresetNames;
 exports.NotificationCategorySchema = NotificationCategorySchema;
+exports.NotificationEventAction = NotificationEventAction;
 exports.OBSERVABILITY_METRICS = OBSERVABILITY_METRICS;
 exports.OBSERVABILITY_SPANS = OBSERVABILITY_SPANS;
 exports.OPERATIONS = COMMON_OPERATIONS;
@@ -8766,6 +8801,7 @@ exports.SanitizationEventAction = SanitizationEventAction;
 exports.SendGridEventSchema = SendGridEventSchema;
 exports.SendGridWebhookSchema = SendGridWebhookSchema;
 exports.SignupFormSchema = SignupFormSchema;
+exports.StorageEventAction = StorageEventAction;
 exports.StorageMediaProcessingPayloadSchema = StorageMediaProcessingPayloadSchema;
 exports.StorageProcessingOutputSchema = StorageProcessingOutputSchema;
 exports.StoreEventAction = StoreEventAction;