@plyaz/types 1.19.3 → 1.19.5

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

@@ -8,7 +8,7 @@ declare const Role: {
     Publisher: string;
     Scout: string;
 };
-export interface DBUser {
+export interface CoreDBUser {
     email: string;
     password_hash: string;
     clerk_user_id: string;

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

@@ -0,0 +1,5 @@
+/**
+ * Core Domain Types
+ * Type definitions for @plyaz/core domain services
+ */
+export type { CoreBaseDomainServiceInterface, CoreEventSubscribable, CoreProviderSubscribable, CoreValidationResult, CoreValidatorConfig, CoreBaseValidatorInstance, CoreBaseMapperInstance, CoreBaseDomainServiceConfig, CoreMapperClass, CoreValidatorClass, CoreBaseServiceConfig, } from './types';

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

@@ -0,0 +1,123 @@
+/**
+ * Base Domain Service Interfaces
+ *
+ * Interfaces for domain services that consumers can code against.
+ * Use these for dependency injection and type-checking.
+ */
+import type { ValidationIssue, InternalValidationSchema } from '../../errors';
+import type { FeatureFlagValue } from '../../features';
+import type { CoreServiceRuntime } from '../modules';
+import type { ApiClientOptions } from '../../api';
+/**
+ * Base interface for all domain services.
+ *
+ * Provides lifecycle management and configuration access.
+ * All domain services (backend and frontend) implement this.
+ */
+export interface CoreBaseDomainServiceInterface {
+    /** Check if service is available and ready to use */
+    isAvailable(): boolean;
+    /** Dispose/cleanup the service and release resources */
+    dispose(): void;
+    /** Whether the service is enabled via config */
+    readonly isServiceEnabled: boolean;
+    /** Whether the service has been initialized */
+    readonly isInitialized: boolean;
+}
+/**
+ * Interface for services that support event subscription.
+ */
+export interface CoreEventSubscribable<TEventType extends string = string> {
+    /** Subscribe to service events */
+    on(event: TEventType, handler: (data: unknown) => void): () => void;
+}
+/**
+ * Interface for services that support provider subscription.
+ */
+export interface CoreProviderSubscribable {
+    /** Subscribe to provider/data changes */
+    subscribe(callback: () => void): () => void;
+}
+/**
+ * Validation result type
+ */
+export interface CoreValidationResult<T> {
+    success: boolean;
+    data?: T;
+    errors?: ValidationIssue[];
+}
+/**
+ * Validator configuration
+ */
+export interface CoreValidatorConfig<TCreate = unknown, TUpdate = unknown, TPatch = unknown, TDelete = unknown, TQuery = unknown> {
+    createSchema?: InternalValidationSchema<TCreate>;
+    updateSchema?: InternalValidationSchema<TUpdate>;
+    patchSchema?: InternalValidationSchema<TPatch>;
+    deleteSchema?: InternalValidationSchema<TDelete>;
+    querySchema?: InternalValidationSchema<TQuery>;
+}
+/**
+ * Base Validator interface
+ */
+export interface CoreBaseValidatorInstance<TCreate = unknown, TUpdate = unknown, TPatch = unknown, TDelete = unknown, TQuery = unknown> {
+    validateCreate(data: unknown): CoreValidationResult<TCreate>;
+    validateUpdate(data: unknown): CoreValidationResult<TUpdate>;
+    validatePatch(data: unknown): CoreValidationResult<TPatch>;
+    validateDelete(data: unknown): CoreValidationResult<TDelete>;
+    validateQuery(data: unknown): CoreValidationResult<TQuery>;
+    validateCreateOrThrow(data: unknown): TCreate;
+    validateUpdateOrThrow(data: unknown): TUpdate;
+    validatePatchOrThrow(data: unknown): TPatch;
+    validateDeleteOrThrow(data: unknown): TDelete;
+    validateQueryOrThrow(data: unknown): TQuery;
+}
+/**
+ * Base mapper interface defining all mapping concerns
+ */
+export interface CoreBaseMapperInstance<TDomain = unknown, TResponseDTO = unknown, TCreateDTO = unknown, TUpdateDTO = TCreateDTO, TPatchDTO = Partial<TCreateDTO>, TQueryDTO = unknown, TStoreState = TDomain> {
+    toDomain(dto: TResponseDTO): TDomain;
+    toDomainList(dtos: TResponseDTO[]): TDomain[];
+    toCreateDTO?(data: Partial<TDomain>): TCreateDTO;
+    toUpdateDTO?(data: Partial<TDomain>): TUpdateDTO;
+    toPatchDTO?(data: Partial<TDomain>): TPatchDTO;
+    toQueryDTO?(filters: Partial<TQueryDTO>): TQueryDTO;
+    toStoreState(domain: TDomain): TStoreState;
+    toStoreStateList?(domains: TDomain[]): Partial<TStoreState>;
+    fromStoreState(state: TStoreState): TDomain;
+}
+/**
+ * Base configuration interface for all domain services
+ */
+export interface CoreBaseDomainServiceConfig {
+    /** Whether the service is enabled (default: true) */
+    enabled?: boolean;
+    /** Default values for feature flags or other defaults */
+    defaults?: Record<string, FeatureFlagValue>;
+}
+/**
+ * Type for mapper class constructor
+ */
+export type CoreMapperClass<T extends CoreBaseMapperInstance<unknown, unknown> = CoreBaseMapperInstance<unknown, unknown>> = new () => T;
+/**
+ * Type for validator class constructor
+ */
+export type CoreValidatorClass<T extends CoreBaseValidatorInstance = CoreBaseValidatorInstance> = new () => T;
+/**
+ * Base service configuration passed to constructor
+ */
+export interface CoreBaseServiceConfig<TConfig extends CoreBaseDomainServiceConfig = CoreBaseDomainServiceConfig, TMapper extends CoreBaseMapperInstance<unknown, unknown> = CoreBaseMapperInstance<unknown, unknown>, TValidator extends CoreBaseValidatorInstance = CoreBaseValidatorInstance> {
+    /** Service name for logging and error messages */
+    serviceName: string;
+    /** Supported runtimes for this service */
+    supportedRuntimes: readonly CoreServiceRuntime[];
+    /** Service-specific configuration */
+    serviceConfig: TConfig;
+    /** API client configuration (optional - for frontend services) */
+    apiClientConfig?: ApiClientOptions;
+    /** Set this API client as the default for all fetchers */
+    setAsDefaultClient?: boolean;
+    /** Mapper class for API response transformations */
+    mapperClass?: CoreMapperClass<TMapper>;
+    /** Validator class for input validation */
+    validatorClass?: CoreValidatorClass<TValidator>;
+}

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

@@ -26,6 +26,7 @@ export declare const CoreEventScope: {
     readonly API: "api";
     readonly CACHE: "cache";
     readonly AUTH: "auth";
+    readonly DATABASE: "database";
     readonly FEATURE_FLAG: "featureFlag";
     readonly STORE: "store";
 };
@@ -104,6 +105,18 @@ export declare const AuthEventAction: {
     readonly SESSION_EXPIRED: "sessionExpired";
     readonly UNAUTHORIZED: "unauthorized";
 };
+/**
+ * Database event actions
+ */
+export declare const DatabaseEventAction: {
+    readonly CONNECTED: "connected";
+    readonly DISCONNECTED: "disconnected";
+    readonly QUERY: "query";
+    readonly ERROR: "error";
+    readonly TRANSACTION_START: "transactionStart";
+    readonly TRANSACTION_COMMIT: "transactionCommit";
+    readonly TRANSACTION_ROLLBACK: "transactionRollback";
+};
 /**
  * Feature flag event actions
  */
@@ -183,6 +196,15 @@ export declare const CORE_EVENTS: {
         readonly SESSION_EXPIRED: "auth:sessionExpired";
         readonly UNAUTHORIZED: "auth:unauthorized";
     };
+    readonly DATABASE: {
+        readonly CONNECTED: "database:connected";
+        readonly DISCONNECTED: "database:disconnected";
+        readonly QUERY: "database:query";
+        readonly ERROR: "database:error";
+        readonly TRANSACTION_START: "database:transactionStart";
+        readonly TRANSACTION_COMMIT: "database:transactionCommit";
+        readonly TRANSACTION_ROLLBACK: "database:transactionRollback";
+    };
     readonly FEATURE_FLAG: {
         readonly CHANGED: "featureFlag:changed";
         readonly EVALUATED: "featureFlag:evaluated";
@@ -208,6 +230,8 @@ export type ApiEventType = (typeof CORE_EVENTS.API)[keyof typeof CORE_EVENTS.API
 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 database event types */
+export type DatabaseEventType = (typeof CORE_EVENTS.DATABASE)[keyof typeof CORE_EVENTS.DATABASE];
 /** All feature flag event types */
 export type FeatureFlagEventType = (typeof CORE_EVENTS.FEATURE_FLAG)[keyof typeof CORE_EVENTS.FEATURE_FLAG];
 /** All store event types */
@@ -215,4 +239,4 @@ export type StoreEventType = (typeof CORE_EVENTS.STORE)[keyof typeof CORE_EVENTS
 /**
  * Union of all core event types
  */
-export type CoreEventType = SystemEventType | EntityEventType | ValidationEventType | SanitizationEventType | ApiEventType | CacheEventType | AuthEventType | FeatureFlagEventType | StoreEventType;
+export type CoreEventType = SystemEventType | EntityEventType | ValidationEventType | SanitizationEventType | ApiEventType | CacheEventType | AuthEventType | DatabaseEventType | FeatureFlagEventType | StoreEventType;

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

@@ -17,6 +17,6 @@
  * );
  * ```
  */
-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';
+export { CoreEventScope, SystemEventAction, EntityEventAction, ValidationEventAction, SanitizationEventAction, ApiEventAction, CacheEventAction, AuthEventAction, DatabaseEventAction, FeatureFlagEventAction, StoreEventAction, 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';

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

@@ -12,6 +12,21 @@
  * }
  * ```
  */
+import type { CORE_EVENTS } from './enums';
+import type { PackageErrorLike } from '../../errors';
+/**
+ * Core event structure
+ *
+ * @typeParam TData - Event payload type
+ * @typeParam TScope - Event scope type
+ */
+export interface CoreEvent<TData = unknown, TScope extends string = string> {
+    type: string;
+    scope: TScope;
+    timestamp: number;
+    correlationId: string;
+    data: TData;
+}
 /**
  * CRUD operation types
  */
@@ -289,6 +304,62 @@ export interface CoreCacheClearPayload {
 export interface CoreCacheExpiredPayload {
     key: string;
 }
+/**
+ * Payload for database:connected events
+ */
+export interface CoreDatabaseConnectedPayload {
+    adapter: string;
+    connectionTime: number;
+}
+/**
+ * Payload for database:disconnected events
+ */
+export interface CoreDatabaseDisconnectedPayload {
+    adapter: string;
+    reason?: string;
+    graceful: boolean;
+}
+/**
+ * Payload for database:query events
+ */
+export interface CoreDatabaseQueryPayload {
+    query: string;
+    table?: string;
+    operation: 'select' | 'insert' | 'update' | 'delete' | 'other';
+    duration: number;
+    rowCount?: number;
+}
+/**
+ * Payload for database:error events
+ */
+export interface CoreDatabaseErrorPayload {
+    error: unknown;
+    query?: string;
+    table?: string;
+    operation?: string;
+    recoverable: boolean;
+}
+/**
+ * Payload for database:transactionStart events
+ */
+export interface CoreDatabaseTransactionStartPayload {
+    transactionId: string;
+}
+/**
+ * Payload for database:transactionCommit events
+ */
+export interface CoreDatabaseTransactionCommitPayload {
+    transactionId: string;
+    duration: number;
+}
+/**
+ * Payload for database:transactionRollback events
+ */
+export interface CoreDatabaseTransactionRollbackPayload {
+    transactionId: string;
+    reason?: string;
+    error?: unknown;
+}
 /**
  * Payload for auth:login events
  */
@@ -316,6 +387,7 @@ export interface CoreAuthTokenRefreshPayload {
 export interface CoreAuthSessionExpiredPayload {
     userId?: string;
     expiredAt: number;
+    error?: PackageErrorLike;
 }
 /**
  * Payload for auth:unauthorized events
@@ -323,6 +395,7 @@ export interface CoreAuthSessionExpiredPayload {
 export interface CoreAuthUnauthorizedPayload {
     resource?: string;
     action?: string;
+    error?: PackageErrorLike;
 }
 /**
  * Payload for featureFlag:changed events
@@ -369,7 +442,6 @@ 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.
  *
@@ -422,6 +494,13 @@ export interface CoreEventPayloadMap {
     [CORE_EVENTS.CACHE.DELETE]: CoreCacheDeletePayload;
     [CORE_EVENTS.CACHE.CLEAR]: CoreCacheClearPayload;
     [CORE_EVENTS.CACHE.EXPIRED]: CoreCacheExpiredPayload;
+    [CORE_EVENTS.DATABASE.CONNECTED]: CoreDatabaseConnectedPayload;
+    [CORE_EVENTS.DATABASE.DISCONNECTED]: CoreDatabaseDisconnectedPayload;
+    [CORE_EVENTS.DATABASE.QUERY]: CoreDatabaseQueryPayload;
+    [CORE_EVENTS.DATABASE.ERROR]: CoreDatabaseErrorPayload;
+    [CORE_EVENTS.DATABASE.TRANSACTION_START]: CoreDatabaseTransactionStartPayload;
+    [CORE_EVENTS.DATABASE.TRANSACTION_COMMIT]: CoreDatabaseTransactionCommitPayload;
+    [CORE_EVENTS.DATABASE.TRANSACTION_ROLLBACK]: CoreDatabaseTransactionRollbackPayload;
     [CORE_EVENTS.AUTH.LOGIN]: CoreAuthLoginPayload;
     [CORE_EVENTS.AUTH.LOGOUT]: CoreAuthLogoutPayload;
     [CORE_EVENTS.AUTH.TOKEN_REFRESH]: CoreAuthTokenRefreshPayload;

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

@@ -5,13 +5,33 @@
  * including table schemas, query interfaces, and data transformation types.
  * These types ensure type safety across the entire database layer.
  */
-import type { FEATURES } from '@plyaz/config';
-import type { FeatureFlagCondition, FeatureFlagConfig, FeatureFlagValue } from '../../features';
+import type { FeatureFlagCondition, FeatureFlagConfig, FeatureFlagProviderType, FeatureFlagValue } from '../../features';
 import type { ApiClientWithEvents } from '../../api';
+/**
+ * Feature flags for authentication providers and other features
+ */
+export declare const FEATURES: {
+    /**
+     * Enable Google OAuth authentication
+     */
+    readonly AUTH_GOOGLE: true;
+    /**
+     * Enable Discord OAuth authentication (dev only)
+     */
+    readonly AUTH_DISCORD: false;
+    /**
+     * Enable Facebook OAuth authentication
+     */
+    readonly AUTH_FACEBOOK: false;
+    /**
+     * Enable GitHub OAuth authentication
+     */
+    readonly AUTH_GITHUB: true;
+};
 /**
  * Raw database row interface for feature flags table
  */
-export interface DatabaseFeatureFlagRow {
+export interface CoreDatabaseFeatureFlagRow {
     key: string;
     value: FeatureFlagValue;
     isEnabled?: boolean;
@@ -26,7 +46,7 @@ export interface DatabaseFeatureFlagRow {
 /**
  * Raw database row interface for feature flag rules
  */
-export interface DatabaseFeatureFlagRuleRow {
+export interface CoreDatabaseFeatureFlagRuleRow {
     id: string;
     flagKey: string;
     flag_key?: string;
@@ -40,7 +60,7 @@ export interface DatabaseFeatureFlagRuleRow {
 /**
  * Database override row interface
  */
-export interface DatabaseOverrideRow {
+export interface CoreDatabaseOverrideRow {
     id: string;
     flag_key: string;
     user_id: string;
@@ -51,7 +71,7 @@ export interface DatabaseOverrideRow {
 /**
  * Database evaluation log row interface
  */
-export interface DatabaseEvaluationRow {
+export interface CoreDatabaseEvaluationRow {
     id: string;
     flag_key: string;
     user_id?: string;
@@ -65,21 +85,21 @@ export interface DatabaseEvaluationRow {
 /**
  * Environment filter interface
  */
-export interface EnvironmentFilterRow {
+export interface CoreEnvironmentFilterRow {
     environments?: string[];
 }
 /**
  * Validation result interface
  */
-export interface FeatureFlagValidationResult {
+export interface CoreFeatureFlagValidationResult {
     isValid: boolean;
-    errors: ValidationError[];
-    warnings: ValidationWarning[];
+    errors: CoreFeatureFlagValidationError[];
+    warnings: CoreFeatureFlagValidationWarning[];
 }
 /**
  * Validation error interface
  */
-export interface ValidationError {
+export interface CoreFeatureFlagValidationError {
     field: string;
     message: string;
     code: string;
@@ -87,7 +107,7 @@ export interface ValidationError {
 /**
  * Validation warning interface
  */
-export interface ValidationWarning {
+export interface CoreFeatureFlagValidationWarning {
     field: string;
     message: string;
     code: string;
@@ -95,7 +115,7 @@ export interface ValidationWarning {
 /**
  * Database configuration interface
  */
-export interface FeatureFlagDatabaseConfig {
+export interface CoreFeatureFlagDatabaseConfig {
     connectionString: string;
     tableName: string;
     poolSize?: number;
@@ -104,8 +124,8 @@ export interface FeatureFlagDatabaseConfig {
 /**
  * Environment-specific feature flag configuration
  */
-export interface FeatureFlagEnvironmentConfig extends Omit<FeatureFlagConfig<FeatureFlagKey>, 'databaseConfig'> {
-    databaseConfig?: FeatureFlagDatabaseConfig;
+export interface CoreFeatureFlagEnvironmentConfig extends Omit<FeatureFlagConfig<FeatureFlagKey>, 'databaseConfig'> {
+    databaseConfig?: CoreFeatureFlagDatabaseConfig;
 }
 /**
  * Union type of all available feature flag keys.
@@ -118,7 +138,7 @@ export type FeatureFlags = typeof FEATURES extends Record<FeatureFlagKey, Featur
  */
 export interface CoreFeatureFlagModuleConfig {
     /** Provider type for flag storage */
-    provider?: 'memory' | 'database' | 'redis' | 'api' | 'file';
+    provider?: FeatureFlagProviderType;
     /** How often to refresh flag data in seconds (0 = no auto-refresh) */
     refreshInterval?: number;
     /** Enable debug logging */
@@ -233,7 +253,7 @@ export interface CoreFeatureFlagModuleConfig {
  * Configuration for database table names.
  * Allows customization of table names for different environments (dev, test, prod).
  */
-export interface FeatureFlagTableConfig {
+export interface CoreFeatureFlagTableConfig {
     /** Table name for feature flags (default: 'feature_flags') */
     flagsTable: string;
     /** Table name for feature flag rules (default: 'feature_flag_rules') */

package/dist/core/frontend/featureFlags.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Feature Flag Types (Frontend)
+ *
+ * Type definitions for the frontend FeatureFlagDomainService.
+ */
+import type { FeatureFlagContext, FeatureFlagValue, FeatureFlagEvaluation, CreateFlagRequest, FeatureFlag, FeatureFlagRule, FeatureFlagProvider } from '../../features';
+import type { CoreBaseDomainServiceInterface, CoreEventSubscribable, CoreProviderSubscribable } from '../domain';
+import type { CoreBaseFrontendStore, CoreBaseFrontendServiceConfig } from './types';
+import type { CoreServiceInitConfig } from '../init';
+/**
+ * Feature flag event types (frontend)
+ */
+export type CoreFrontendFeatureFlagEventType = 'featureFlag:evaluating' | 'featureFlag:evaluated' | 'featureFlag:evaluate:error' | 'featureFlag:creating' | 'featureFlag:created' | 'featureFlag:create:error' | 'featureFlag:updating' | 'featureFlag:updated' | 'featureFlag:update:error' | 'featureFlag:deleting' | 'featureFlag:deleted' | 'featureFlag:delete:error' | 'featureFlag:override:setting' | 'featureFlag:override:set' | 'featureFlag:override:removing' | 'featureFlag:override:removed' | 'featureFlag:provider:initialized' | 'featureFlag:provider:refreshed' | 'featureFlag:provider:disposed';
+/**
+ * Store interface for feature flag state.
+ * Compatible with @plyaz/store's FeatureFlagStoreSlice.
+ */
+export interface CoreFeatureFlagStore extends CoreBaseFrontendStore<Record<string, FeatureFlagValue>> {
+    /** Replace all flags in the store */
+    setFlags(flags: Record<string, FeatureFlagValue>): void;
+    /** Update/merge flags in the store */
+    updateFlags?(flags: Record<string, FeatureFlagValue>): void;
+}
+/**
+ * Service configuration (when creating manually with provider)
+ */
+export interface CoreFeatureFlagServiceConfig extends CoreBaseFrontendServiceConfig<Record<string, FeatureFlagValue>, CoreFeatureFlagStore> {
+    /** Default context for evaluations */
+    defaultContext?: FeatureFlagContext;
+    /** Feature flag provider (ApiFeatureFlagProvider for frontend) */
+    provider: FeatureFlagProvider<string>;
+    /** Required flags that must be enabled for the service to work */
+    requiredFlags?: string[];
+}
+/**
+ * Service init configuration (for ServiceRegistry auto-initialization)
+ */
+export interface CoreFeatureFlagServiceInitConfig extends CoreBaseFrontendServiceConfig<Record<string, FeatureFlagValue>, CoreFeatureFlagStore>, CoreServiceInitConfig {
+    /** API base path for feature flag endpoints (default: '/feature-flags') */
+    apiBasePath?: string;
+    /** Default context for evaluations */
+    defaultContext?: FeatureFlagContext;
+    /** Cache TTL in seconds (default: 300) */
+    cacheTtl?: number;
+    /** Refresh interval in milliseconds (default: 60000) */
+    refreshInterval?: number;
+    /** Whether to fallback to default values when flags are not found (default: true) */
+    shouldFallbackToDefaults?: boolean;
+    /** Default flag values */
+    defaults?: Record<string, FeatureFlagValue>;
+    /** Known feature flag keys (for type safety in provider) */
+    featureKeys?: Record<string, FeatureFlagValue>;
+}
+/**
+ * Base interface for frontend services with store integration
+ */
+export interface CoreBaseFrontendServiceInterface<TStore extends CoreBaseFrontendStore = CoreBaseFrontendStore> extends CoreBaseDomainServiceInterface {
+    /** Connect a store to receive updates */
+    connectStore(store: TStore): void;
+    /** Disconnect a store from receiving updates */
+    disconnectStore(store: TStore): void;
+    /** Disconnect all connected stores */
+    disconnectAllStores(): void;
+    /** Number of connected stores */
+    readonly connectedStoreCount: number;
+    /** Whether any stores are connected */
+    readonly hasConnectedStores: boolean;
+}
+/**
+ * Public interface for FeatureFlagDomainService.
+ *
+ * Extends:
+ * - BaseFrontendServiceInterface<FeatureFlagStore> - Lifecycle + store management
+ * - ProviderSubscribable - Provider subscription
+ * - EventSubscribable<FeatureFlagEventType> - Event subscription
+ */
+export interface CoreFeatureFlagServiceInterface extends CoreBaseFrontendServiceInterface<CoreFeatureFlagStore>, CoreProviderSubscribable, CoreEventSubscribable<CoreFrontendFeatureFlagEventType> {
+    /** Refresh the provider cache and sync to stores */
+    refresh(): Promise<void>;
+    /** Evaluate a single flag */
+    evaluate<TKey extends string = string>(key: TKey, context?: FeatureFlagContext): Promise<FeatureFlagEvaluation<TKey>>;
+    /** Check if a flag is enabled */
+    isEnabled<TKey extends string = string>(key: TKey, context?: FeatureFlagContext): Promise<boolean>;
+    /** Get flag value */
+    getValue<T = FeatureFlagValue, TKey extends string = string>(key: TKey, context?: FeatureFlagContext): Promise<T>;
+    /** Evaluate all flags */
+    evaluateAll<TKey extends string = string>(context?: FeatureFlagContext): Promise<Record<string, FeatureFlagEvaluation<TKey>>>;
+    /** Fetch all flags and sync to stores */
+    fetchAndSyncAll(context?: FeatureFlagContext): Promise<Record<string, FeatureFlagValue>>;
+    /** Create a new flag */
+    create<TKey extends string = string>(data: CreateFlagRequest<TKey>): Promise<FeatureFlag<TKey>>;
+    /** Update an existing flag */
+    update<TKey extends string = string>(key: TKey, data: Partial<CreateFlagRequest<TKey>>): Promise<FeatureFlag<TKey>>;
+    /** Delete a flag */
+    delete<TKey extends string = string>(key: TKey): Promise<void>;
+    /** Get rules for a flag */
+    getRules<TKey extends string = string>(key: TKey): Promise<FeatureFlagRule<TKey>[]>;
+    /** Get all rules */
+    getAllRules<TKey extends string = string>(): Promise<FeatureFlagRule<TKey>[]>;
+    /** Set a runtime override */
+    setOverride<TKey extends string = string>(key: TKey, value: FeatureFlagValue): void;
+    /** Remove a runtime override */
+    removeOverride<TKey extends string = string>(key: TKey): void;
+    /** Clear all overrides */
+    clearOverrides(): void;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Core Frontend Types
+ * Type definitions for @plyaz/core frontend services
+ */
+export type { CoreBaseFrontendStore, CoreBaseFrontendServiceConfig, CoreBaseFrontendServiceInterface, CorePlyazApiConfig, FrontendFeatureFlagProvider, CorePlyazFeatureFlagConfig, CorePlyazStoreConfig, CorePlyazConfig, CoreFeatureFlagServiceLike, CoreFeatureFlagFetcherOptions, CoreFeatureFlagStoreInitConfig, CoreBaseFrontendServiceConstructorConfig, CoreInitializationErrorProps, CoreInitializationLoadingProps, CorePlyazServices, CorePlyazContextValue, CorePlyazProviderProps, } from './types';
+export type { CoreFrontendFeatureFlagEventType, CoreFeatureFlagStore, CoreFeatureFlagServiceConfig, CoreFeatureFlagServiceInitConfig, CoreFeatureFlagServiceInterface, } from './featureFlags';