@plyaz/types 1.18.4 → 1.18.6

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

@@ -14,8 +14,7 @@
  * - Use FeatureFlagErrorResponse in hooks/consumers for typed error handling
  */
 import type { Endpoint, Req } from 'fetchff';
-import type { EvaluateFlagRequest, EvaluateFlagParams, EvaluateFlagResponse, IsEnabledRequest, IsEnabledParams, IsEnabledResponse, EvaluateAllFlagsRequest, EvaluateAllFlagsResponse, CreateFlagResponse, UpdateFlagParams, UpdateFlagRequest, UpdateFlagResponse, DeleteFlagParams, DeleteFlagResponse, SetOverrideParams, SetOverrideRequest, SetOverrideResponse, RemoveOverrideParams, RemoveOverrideResponse, GetFlagRulesParams, GetFlagRulesResponse, RefreshCacheResponse, FeatureFlagHealthResponse } from './types';
-import type { CreateFlagRequest } from '../../../features';
+import type { EvaluateFlagRequest, EvaluateFlagParams, EvaluateFlagResponse, IsEnabledRequest, IsEnabledParams, IsEnabledResponse, EvaluateAllFlagsRequest, EvaluateAllFlagsResponse, CreateFlagResponse, UpdateFlagParams, UpdateFlagRequest, UpdateFlagResponse, DeleteFlagParams, DeleteFlagResponse, SetOverrideParams, SetOverrideRequest, SetOverrideResponse, RemoveOverrideParams, RemoveOverrideResponse, GetFlagRulesParams, GetFlagRulesResponse, RefreshCacheResponse, FeatureFlagHealthResponse, CreateFeatureFlagRequest } from './types';
 /**
  * Feature Flag API endpoint types
  * Complete type definitions for feature flag endpoints
@@ -40,7 +39,7 @@ export interface FeatureFlagEndpointTypes {
      * POST /feature-flags - Create flag
      * Req<Response, Body>
      */
-    createFeatureFlag: Endpoint<Req<CreateFlagResponse, CreateFlagRequest<string>>>;
+    createFeatureFlag: Endpoint<Req<CreateFlagResponse, CreateFeatureFlagRequest<string>>>;
     /**
      * PUT /feature-flags/:key - Update flag
      * Req<Response, Body, Params>

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

@@ -151,3 +151,23 @@ export interface FeatureFlagHealthResponse {
     isInitialized: boolean;
     provider: string;
 }
+/**
+ * Request DTO for creating a feature flag.
+ * Used by both the provider interface and API endpoints.
+ * @typeParam FeatureFlagKey - Feature flag key type (defaults to string)
+ */
+export interface CreateFeatureFlagRequest<FeatureFlagKey extends string = string> {
+    /** Environment(s) this entity applies to */
+    /** Whether this entity is enabled */
+    isEnabled: boolean;
+    environment: 'development' | 'staging' | 'production' | 'all' | string;
+    rolloutPercentage?: number;
+    /** Name of the entity */
+    name: string;
+    /** Description of the entity */
+    description: string;
+    /** The key */
+    key: FeatureFlagKey;
+    /** The value */
+    value: FeatureFlagValue;
+}

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

@@ -0,0 +1,218 @@
+/**
+ * Core Event Enums and Constants
+ *
+ * Type-safe event definitions for the CoreEventManager.
+ * All event types follow the pattern: SCOPE:ACTION
+ *
+ * @example
+ * ```typescript
+ * import { CoreEventType, CORE_EVENTS } from '@plyaz/types/core';
+ *
+ * // Use constants for type-safe event emission
+ * CoreEventManager.emit(CORE_EVENTS.ENTITY.CREATED, payload);
+ *
+ * // Subscribe with typed payloads
+ * CoreEventManager.on<EntityCreatedPayload>(CORE_EVENTS.ENTITY.CREATED, handler);
+ * ```
+ */
+/**
+ * Event scope categories
+ */
+export declare const CoreEventScope: {
+    readonly SYSTEM: "system";
+    readonly ENTITY: "entity";
+    readonly VALIDATION: "validation";
+    readonly SANITIZATION: "sanitization";
+    readonly API: "api";
+    readonly CACHE: "cache";
+    readonly AUTH: "auth";
+    readonly FEATURE_FLAG: "featureFlag";
+    readonly STORE: "store";
+};
+export type CoreEventScopeType = (typeof CoreEventScope)[keyof typeof CoreEventScope];
+/**
+ * System event actions
+ */
+export declare const SystemEventAction: {
+    readonly INITIALIZED: "initialized";
+    readonly READY: "ready";
+    readonly SHUTDOWN: "shutdown";
+    readonly ERROR: "error";
+    readonly WARNING: "warning";
+};
+/**
+ * Entity CRUD event actions
+ */
+export declare const EntityEventAction: {
+    readonly CREATING: "creating";
+    readonly UPDATING: "updating";
+    readonly PATCHING: "patching";
+    readonly DELETING: "deleting";
+    readonly CREATED: "created";
+    readonly UPDATED: "updated";
+    readonly PATCHED: "patched";
+    readonly DELETED: "deleted";
+    readonly ERROR: "error";
+    readonly COMPLETE: "complete";
+    readonly BULK_CREATED: "bulkCreated";
+    readonly BULK_DELETED: "bulkDeleted";
+};
+/**
+ * Validation event actions
+ */
+export declare const ValidationEventAction: {
+    readonly STARTED: "started";
+    readonly SUCCESS: "success";
+    readonly FAILED: "failed";
+};
+/**
+ * Sanitization event actions
+ */
+export declare const SanitizationEventAction: {
+    readonly STARTED: "started";
+    readonly SUCCESS: "success";
+    readonly FAILED: "failed";
+};
+/**
+ * API event actions
+ */
+export declare const ApiEventAction: {
+    readonly REQUEST_START: "requestStart";
+    readonly REQUEST_SUCCESS: "requestSuccess";
+    readonly REQUEST_ERROR: "requestError";
+    readonly RETRY: "retry";
+    readonly TIMEOUT: "timeout";
+};
+/**
+ * Cache event actions
+ */
+export declare const CacheEventAction: {
+    readonly HIT: "hit";
+    readonly MISS: "miss";
+    readonly SET: "set";
+    readonly DELETE: "delete";
+    readonly CLEAR: "clear";
+    readonly EXPIRED: "expired";
+};
+/**
+ * Auth event actions
+ */
+export declare const AuthEventAction: {
+    readonly LOGIN: "login";
+    readonly LOGOUT: "logout";
+    readonly TOKEN_REFRESH: "tokenRefresh";
+    readonly SESSION_EXPIRED: "sessionExpired";
+    readonly UNAUTHORIZED: "unauthorized";
+};
+/**
+ * Feature flag event actions
+ */
+export declare const FeatureFlagEventAction: {
+    readonly CHANGED: "changed";
+    readonly EVALUATED: "evaluated";
+    readonly REFRESHED: "refreshed";
+};
+/**
+ * Store event actions
+ */
+export declare const StoreEventAction: {
+    readonly UPDATED: "updated";
+    readonly RESET: "reset";
+    readonly HYDRATED: "hydrated";
+};
+/**
+ * All core event type constants
+ *
+ * @example
+ * ```typescript
+ * CoreEventManager.emit(CORE_EVENTS.ENTITY.CREATED, { entity, storeState });
+ * CoreEventManager.on(CORE_EVENTS.API.REQUEST_ERROR, handleApiError);
+ * ```
+ */
+export declare const CORE_EVENTS: {
+    readonly SYSTEM: {
+        readonly INITIALIZED: "system:initialized";
+        readonly READY: "system:ready";
+        readonly SHUTDOWN: "system:shutdown";
+        readonly ERROR: "system:error";
+        readonly WARNING: "system:warning";
+    };
+    readonly ENTITY: {
+        readonly CREATING: "entity:creating";
+        readonly UPDATING: "entity:updating";
+        readonly PATCHING: "entity:patching";
+        readonly DELETING: "entity:deleting";
+        readonly CREATED: "entity:created";
+        readonly UPDATED: "entity:updated";
+        readonly PATCHED: "entity:patched";
+        readonly DELETED: "entity:deleted";
+        readonly ERROR: "entity:error";
+        readonly COMPLETE: "entity:complete";
+        readonly BULK_CREATED: "entity:bulkCreated";
+        readonly BULK_DELETED: "entity:bulkDeleted";
+    };
+    readonly VALIDATION: {
+        readonly STARTED: "validation:started";
+        readonly SUCCESS: "validation:success";
+        readonly FAILED: "validation:failed";
+    };
+    readonly SANITIZATION: {
+        readonly STARTED: "sanitization:started";
+        readonly SUCCESS: "sanitization:success";
+        readonly FAILED: "sanitization:failed";
+    };
+    readonly API: {
+        readonly REQUEST_START: "api:requestStart";
+        readonly REQUEST_SUCCESS: "api:requestSuccess";
+        readonly REQUEST_ERROR: "api:requestError";
+        readonly RETRY: "api:retry";
+        readonly TIMEOUT: "api:timeout";
+    };
+    readonly CACHE: {
+        readonly HIT: "cache:hit";
+        readonly MISS: "cache:miss";
+        readonly SET: "cache:set";
+        readonly DELETE: "cache:delete";
+        readonly CLEAR: "cache:clear";
+        readonly EXPIRED: "cache:expired";
+    };
+    readonly AUTH: {
+        readonly LOGIN: "auth:login";
+        readonly LOGOUT: "auth:logout";
+        readonly TOKEN_REFRESH: "auth:tokenRefresh";
+        readonly SESSION_EXPIRED: "auth:sessionExpired";
+        readonly UNAUTHORIZED: "auth:unauthorized";
+    };
+    readonly FEATURE_FLAG: {
+        readonly CHANGED: "featureFlag:changed";
+        readonly EVALUATED: "featureFlag:evaluated";
+        readonly REFRESHED: "featureFlag:refreshed";
+    };
+    readonly STORE: {
+        readonly UPDATED: "store:updated";
+        readonly RESET: "store:reset";
+        readonly HYDRATED: "store:hydrated";
+    };
+};
+/** All system event types */
+export type SystemEventType = (typeof CORE_EVENTS.SYSTEM)[keyof typeof CORE_EVENTS.SYSTEM];
+/** All entity event types */
+export type EntityEventType = (typeof CORE_EVENTS.ENTITY)[keyof typeof CORE_EVENTS.ENTITY];
+/** All validation event types */
+export type ValidationEventType = (typeof CORE_EVENTS.VALIDATION)[keyof typeof CORE_EVENTS.VALIDATION];
+/** All sanitization event types */
+export type SanitizationEventType = (typeof CORE_EVENTS.SANITIZATION)[keyof typeof CORE_EVENTS.SANITIZATION];
+/** All API event types */
+export type ApiEventType = (typeof CORE_EVENTS.API)[keyof typeof CORE_EVENTS.API];
+/** All cache event types */
+export type CacheEventType = (typeof CORE_EVENTS.CACHE)[keyof typeof CORE_EVENTS.CACHE];
+/** All auth event types */
+export type AuthEventType = (typeof CORE_EVENTS.AUTH)[keyof typeof CORE_EVENTS.AUTH];
+/** All feature flag event types */
+export type FeatureFlagEventType = (typeof CORE_EVENTS.FEATURE_FLAG)[keyof typeof CORE_EVENTS.FEATURE_FLAG];
+/** All store event types */
+export type StoreEventType = (typeof CORE_EVENTS.STORE)[keyof typeof CORE_EVENTS.STORE];
+/**
+ * Union of all core event types
+ */
+export type CoreEventType = SystemEventType | EntityEventType | ValidationEventType | SanitizationEventType | ApiEventType | CacheEventType | AuthEventType | FeatureFlagEventType | StoreEventType;

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

@@ -1,4 +1,22 @@
 /**
  * Core Events Types
+ *
+ * Type-safe event system with enums, constants, and typed payloads.
+ *
+ * @example
+ * ```typescript
+ * import { CORE_EVENTS, CoreEventPayloadMap } from '@plyaz/types/core';
+ *
+ * // Use constants for type-safe event emission
+ * CoreEventManager.emit(CORE_EVENTS.ENTITY.CREATED, payload);
+ *
+ * // Subscribe with typed payloads
+ * CoreEventManager.on<CoreEventPayloadMap[typeof CORE_EVENTS.API.REQUEST_ERROR]>(
+ *   CORE_EVENTS.API.REQUEST_ERROR,
+ *   handler
+ * );
+ * ```
  */
-export type { CoreCrudOperation, CoreValidationStartedPayload, CoreValidationSuccessPayload, CoreValidationFailedPayload, CoreSanitizationStartedPayload, CoreSanitizationSuccessPayload, CoreSanitizationFailedPayload, CoreEntityCreatedPayload, CoreEntityUpdatedPayload, CoreEntityPatchedPayload, CoreEntityDeletedPayload, CoreEntityCreatingPayload, CoreEntityUpdatingPayload, CoreEntityPatchingPayload, CoreEntityDeletingPayload, CoreEntityErrorPayload, CoreEntityCompletePayload, CoreBulkCreatedPayload, CoreBulkDeletedPayload, } from './payloads';
+export { CoreEventScope, SystemEventAction, EntityEventAction, ValidationEventAction, SanitizationEventAction, ApiEventAction, CacheEventAction, AuthEventAction, FeatureFlagEventAction, StoreEventAction, CORE_EVENTS, } from './enums';
+export type { CoreEventScopeType, SystemEventType, EntityEventType, ValidationEventType, SanitizationEventType, ApiEventType, CacheEventType, AuthEventType, FeatureFlagEventType, StoreEventType, CoreEventType, } from './enums';
+export type { 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, CoreAuthLoginPayload, CoreAuthLogoutPayload, CoreAuthTokenRefreshPayload, CoreAuthSessionExpiredPayload, CoreAuthUnauthorizedPayload, CoreFeatureFlagChangedPayload, CoreFeatureFlagEvaluatedPayload, CoreFeatureFlagRefreshedPayload, CoreStoreUpdatedPayload, CoreStoreResetPayload, CoreStoreHydratedPayload, CoreEventPayloadMap, } from './payloads';

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

@@ -166,3 +166,271 @@ export interface CoreBulkDeletedPayload {
     soft: boolean;
     total: number;
 }
+/**
+ * Payload for system:initialized events
+ */
+export interface CoreSystemInitializedPayload {
+    services: string[];
+    environment: string;
+}
+/**
+ * Payload for system:ready events
+ */
+export interface CoreSystemReadyPayload {
+    startupTime: number;
+}
+/**
+ * Payload for system:shutdown events
+ */
+export interface CoreSystemShutdownPayload {
+    reason?: string;
+    graceful: boolean;
+}
+/**
+ * Payload for system:error events
+ */
+export interface CoreSystemErrorPayload {
+    error: unknown;
+    context?: string;
+    recoverable: boolean;
+}
+/**
+ * Payload for system:warning events
+ */
+export interface CoreSystemWarningPayload {
+    message: string;
+    context?: string;
+}
+/**
+ * Payload for api:requestStart events
+ */
+export interface CoreApiRequestStartPayload {
+    method: string;
+    url: string;
+    requestId: string;
+}
+/**
+ * Payload for api:requestSuccess events
+ */
+export interface CoreApiRequestSuccessPayload {
+    method: string;
+    url: string;
+    requestId: string;
+    status: number;
+    duration: number;
+}
+/**
+ * Payload for api:requestError events
+ */
+export interface CoreApiRequestErrorPayload {
+    method: string;
+    url: string;
+    requestId: string;
+    status?: number;
+    error: unknown;
+    duration: number;
+}
+/**
+ * Payload for api:retry events
+ */
+export interface CoreApiRetryPayload {
+    method: string;
+    url: string;
+    requestId: string;
+    attempt: number;
+    maxAttempts: number;
+    delay: number;
+}
+/**
+ * Payload for api:timeout events
+ */
+export interface CoreApiTimeoutPayload {
+    method: string;
+    url: string;
+    requestId: string;
+    timeout: number;
+}
+/**
+ * Payload for cache:hit events
+ */
+export interface CoreCacheHitPayload {
+    key: string;
+    ttl?: number;
+}
+/**
+ * Payload for cache:miss events
+ */
+export interface CoreCacheMissPayload {
+    key: string;
+}
+/**
+ * Payload for cache:set events
+ */
+export interface CoreCacheSetPayload {
+    key: string;
+    ttl?: number;
+}
+/**
+ * Payload for cache:delete events
+ */
+export interface CoreCacheDeletePayload {
+    key: string;
+}
+/**
+ * Payload for cache:clear events
+ */
+export interface CoreCacheClearPayload {
+    pattern?: string;
+    count: number;
+}
+/**
+ * Payload for cache:expired events
+ */
+export interface CoreCacheExpiredPayload {
+    key: string;
+}
+/**
+ * Payload for auth:login events
+ */
+export interface CoreAuthLoginPayload {
+    userId: string;
+    method: string;
+}
+/**
+ * Payload for auth:logout events
+ */
+export interface CoreAuthLogoutPayload {
+    userId: string;
+    reason?: string;
+}
+/**
+ * Payload for auth:tokenRefresh events
+ */
+export interface CoreAuthTokenRefreshPayload {
+    userId: string;
+    expiresAt: number;
+}
+/**
+ * Payload for auth:sessionExpired events
+ */
+export interface CoreAuthSessionExpiredPayload {
+    userId?: string;
+    expiredAt: number;
+}
+/**
+ * Payload for auth:unauthorized events
+ */
+export interface CoreAuthUnauthorizedPayload {
+    resource?: string;
+    action?: string;
+}
+/**
+ * Payload for featureFlag:changed events
+ */
+export interface CoreFeatureFlagChangedPayload {
+    flag: string;
+    previousValue: boolean;
+    newValue: boolean;
+}
+/**
+ * Payload for featureFlag:evaluated events
+ */
+export interface CoreFeatureFlagEvaluatedPayload {
+    flag: string;
+    value: boolean;
+    source: 'cache' | 'provider' | 'default';
+}
+/**
+ * Payload for featureFlag:refreshed events
+ */
+export interface CoreFeatureFlagRefreshedPayload {
+    flagCount: number;
+    changedFlags: string[];
+}
+/**
+ * Payload for store:updated events
+ */
+export interface CoreStoreUpdatedPayload<T = unknown> {
+    storeName: string;
+    previousState?: T;
+    newState: T;
+    changedKeys?: string[];
+}
+/**
+ * Payload for store:reset events
+ */
+export interface CoreStoreResetPayload {
+    storeName: string;
+}
+/**
+ * Payload for store:hydrated events
+ */
+export interface CoreStoreHydratedPayload {
+    storeName: string;
+    source: string;
+}
+import type { CORE_EVENTS } from './enums';
+/**
+ * Maps event types to their payload types for type-safe event handling.
+ *
+ * Uses computed property keys from CORE_EVENTS for:
+ * - Single source of truth for event names
+ * - Automatic updates if CORE_EVENTS values change
+ * - Better IDE support and refactoring
+ *
+ * @example
+ * ```typescript
+ * // Type-safe event emission and subscription
+ * function emit<T extends keyof CoreEventPayloadMap>(
+ *   event: T,
+ *   payload: CoreEventPayloadMap[T]
+ * ): void;
+ * ```
+ */
+export interface CoreEventPayloadMap {
+    [CORE_EVENTS.SYSTEM.INITIALIZED]: CoreSystemInitializedPayload;
+    [CORE_EVENTS.SYSTEM.READY]: CoreSystemReadyPayload;
+    [CORE_EVENTS.SYSTEM.SHUTDOWN]: CoreSystemShutdownPayload;
+    [CORE_EVENTS.SYSTEM.ERROR]: CoreSystemErrorPayload;
+    [CORE_EVENTS.SYSTEM.WARNING]: CoreSystemWarningPayload;
+    [CORE_EVENTS.ENTITY.CREATING]: CoreEntityCreatingPayload<unknown>;
+    [CORE_EVENTS.ENTITY.UPDATING]: CoreEntityUpdatingPayload<unknown>;
+    [CORE_EVENTS.ENTITY.PATCHING]: CoreEntityPatchingPayload<unknown>;
+    [CORE_EVENTS.ENTITY.DELETING]: CoreEntityDeletingPayload;
+    [CORE_EVENTS.ENTITY.CREATED]: CoreEntityCreatedPayload<unknown>;
+    [CORE_EVENTS.ENTITY.UPDATED]: CoreEntityUpdatedPayload<unknown>;
+    [CORE_EVENTS.ENTITY.PATCHED]: CoreEntityPatchedPayload<unknown>;
+    [CORE_EVENTS.ENTITY.DELETED]: CoreEntityDeletedPayload;
+    [CORE_EVENTS.ENTITY.ERROR]: CoreEntityErrorPayload;
+    [CORE_EVENTS.ENTITY.COMPLETE]: CoreEntityCompletePayload;
+    [CORE_EVENTS.ENTITY.BULK_CREATED]: CoreBulkCreatedPayload<unknown>;
+    [CORE_EVENTS.ENTITY.BULK_DELETED]: CoreBulkDeletedPayload;
+    [CORE_EVENTS.VALIDATION.STARTED]: CoreValidationStartedPayload;
+    [CORE_EVENTS.VALIDATION.SUCCESS]: CoreValidationSuccessPayload;
+    [CORE_EVENTS.VALIDATION.FAILED]: CoreValidationFailedPayload;
+    [CORE_EVENTS.SANITIZATION.STARTED]: CoreSanitizationStartedPayload;
+    [CORE_EVENTS.SANITIZATION.SUCCESS]: CoreSanitizationSuccessPayload;
+    [CORE_EVENTS.SANITIZATION.FAILED]: CoreSanitizationFailedPayload;
+    [CORE_EVENTS.API.REQUEST_START]: CoreApiRequestStartPayload;
+    [CORE_EVENTS.API.REQUEST_SUCCESS]: CoreApiRequestSuccessPayload;
+    [CORE_EVENTS.API.REQUEST_ERROR]: CoreApiRequestErrorPayload;
+    [CORE_EVENTS.API.RETRY]: CoreApiRetryPayload;
+    [CORE_EVENTS.API.TIMEOUT]: CoreApiTimeoutPayload;
+    [CORE_EVENTS.CACHE.HIT]: CoreCacheHitPayload;
+    [CORE_EVENTS.CACHE.MISS]: CoreCacheMissPayload;
+    [CORE_EVENTS.CACHE.SET]: CoreCacheSetPayload;
+    [CORE_EVENTS.CACHE.DELETE]: CoreCacheDeletePayload;
+    [CORE_EVENTS.CACHE.CLEAR]: CoreCacheClearPayload;
+    [CORE_EVENTS.CACHE.EXPIRED]: CoreCacheExpiredPayload;
+    [CORE_EVENTS.AUTH.LOGIN]: CoreAuthLoginPayload;
+    [CORE_EVENTS.AUTH.LOGOUT]: CoreAuthLogoutPayload;
+    [CORE_EVENTS.AUTH.TOKEN_REFRESH]: CoreAuthTokenRefreshPayload;
+    [CORE_EVENTS.AUTH.SESSION_EXPIRED]: CoreAuthSessionExpiredPayload;
+    [CORE_EVENTS.AUTH.UNAUTHORIZED]: CoreAuthUnauthorizedPayload;
+    [CORE_EVENTS.FEATURE_FLAG.CHANGED]: CoreFeatureFlagChangedPayload;
+    [CORE_EVENTS.FEATURE_FLAG.EVALUATED]: CoreFeatureFlagEvaluatedPayload;
+    [CORE_EVENTS.FEATURE_FLAG.REFRESHED]: CoreFeatureFlagRefreshedPayload;
+    [CORE_EVENTS.STORE.UPDATED]: CoreStoreUpdatedPayload;
+    [CORE_EVENTS.STORE.RESET]: CoreStoreResetPayload;
+    [CORE_EVENTS.STORE.HYDRATED]: CoreStoreHydratedPayload;
+}

package/dist/core/index.d.ts

@@ -6,8 +6,8 @@
  */
 export type { ApiEnvironmentConfig, ApiProviderProps } from './services';
 export type { CoreIdempotencyStoreType, CoreInMemoryIdempotencyAdapterConfig, CoreRedisIdempotencyAdapterConfig, CoreIdempotencyStoreOptions, CoreIdempotencyStoreConfig, } from './idempotency';
-export type { CoreServices, CoreRouteContext, CoreRouteHandler, CoreRouteDefinition, CoreModuleConfigSchema, CoreServiceFactory, CoreModuleLifecycle, CoreModuleDefinition, CoreRegisteredModule, CoreConfiguredModule, CoreModuleFactory, CoreFrameworkType, CoreServerConfig, CoreFrameworkAdapter, CoreAdapterFactory, CoreRuntimeEnvironment, CoreRuntimeContext, CoreNextJsHandlerContext, CoreNextJsHandlerResult, CoreNextJsHandler, CoreNextJsHandlerOptions, CoreEnvVars, CoreAppEnvironment, CoreApiInitOptions, CoreInitOptions, CoreServicesResult, CoreNestJsModuleOptions, CoreNestJsModuleAsyncOptions, } from './modules';
-export { BACKEND_RUNTIMES, FRONTEND_RUNTIMES, UNIVERSAL_RUNTIMES } from './modules';
+export type { CoreServices, CoreRouteContext, CoreRouteHandler, CoreRouteDefinition, CoreModuleConfigSchema, CoreServiceFactory, CoreModuleLifecycle, CoreModuleDefinition, CoreRegisteredModule, CoreConfiguredModule, CoreModuleFactory, CoreFrameworkType, CoreServerConfig, CoreFrameworkAdapter, CoreAdapterFactory, CoreRuntimeEnvironment, CoreRuntimeContext, CoreNextJsHandlerContext, CoreNextJsHandlerResult, CoreNextJsHandler, CoreNextJsHandlerOptions, CoreEnvVars, CoreAppEnvironment, CoreApiInitOptions, CoreInitOptions, CoreServicesResult, CoreNestJsModuleOptions, CoreNestJsModuleAsyncOptions, CoreAppContext, CoreServiceRuntime, CoreDomainServiceConfig, } from './modules';
+export { BACKEND_RUNTIMES, FRONTEND_RUNTIMES, UNIVERSAL_RUNTIMES, APP_CONTEXTS, } from './modules';
 export * from './tables/enum';
 export type * from './auth/types';
 export type * from './featureFlag/types';

package/dist/db/eventEmitter.d.ts

@@ -3,16 +3,47 @@
  * Defines the contract for database event emission
  */
 import type { DatabaseEvent, DBEventHandler, DatabaseOperationType } from './event.types';
-import type { ContextType } from '@nestjs/common';
+/**
+ * Base execution context interface for database operations.
+ * Extend this interface to add framework-specific context.
+ *
+ * @example
+ * ```typescript
+ * // NestJS context
+ * interface NestJsDbContext extends DatabaseExecutionContext {
+ *   requestId: string;
+ *   userId?: string;
+ *   ip?: string;
+ * }
+ *
+ * // Express context
+ * interface ExpressDbContext extends DatabaseExecutionContext {
+ *   req: Request;
+ *   res: Response;
+ * }
+ * ```
+ */
+export interface DatabaseExecutionContext {
+    /** Optional request ID for tracing */
+    requestId?: string;
+    /** Optional user ID for audit */
+    userId?: string;
+    /** Optional tenant ID for multi-tenancy */
+    tenantId?: string;
+    /** Additional context data */
+    [key: string]: unknown;
+}
 /**
  * Emit a query error event
+ *
+ * @typeParam TContext - Custom context type extending DatabaseExecutionContext
  */
-export interface EmitQueryErrorOptions {
+export interface EmitQueryErrorOptions<TContext extends DatabaseExecutionContext = DatabaseExecutionContext> {
     table: string;
     operation: DatabaseOperationType;
     error: Error;
     params?: Record<string, object>;
-    context?: ContextType;
+    context?: TContext;
 }
 export interface DatabaseError extends Error {
     code?: string;
@@ -71,7 +102,7 @@ export interface BeforeQueryEvent extends DatabaseEvent {
     table: string;
     operation: DatabaseOperationType;
     params?: Record<string, object>;
-    context?: ContextType;
+    context?: DatabaseExecutionContext;
 }
 export interface AfterQueryEvent extends DatabaseEvent {
     type: 'afterQuery';
@@ -88,13 +119,13 @@ export interface QueryErrorEvent extends DatabaseEvent {
     operation: DatabaseOperationType;
     error: Error;
     params?: Record<string, object>;
-    context?: ContextType;
+    context?: DatabaseExecutionContext;
 }
 export interface BeforeTransactionEvent extends DatabaseEvent {
     type: 'beforeTransaction';
     adapter: string;
     transactionId: string;
-    context?: ContextType;
+    context?: DatabaseExecutionContext;
 }
 export interface AfterTransactionEvent extends DatabaseEvent {
     type: 'afterTransaction';

package/dist/db/index.d.ts

@@ -18,3 +18,4 @@ export type * from './migrations.types';
 export type * from './seeds.types';
 export type * from './health.types';
 export type * from './tenant.types';
+export type * from './query.types';

package/dist/db/query.types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Query Builder Types
+ *
+ * Types for SQL query building utilities used by database adapters.
+ */
+/**
+ * Options for building SQL WHERE clause conditions
+ */
+export interface BuildWhereClauseOptions {
+    /** Field name to filter on */
+    field: string;
+    /** Comparison operator (e.g., '=', '>', '<', 'LIKE', 'IN') */
+    operator: string;
+    /** Value to compare against */
+    value: unknown;
+    /** Array to collect parameterized values */
+    params: unknown[];
+    /** Starting index for parameter placeholders ($1, $2, etc.) */
+    startIndex: number;
+}