@zssz-soft/core-api 0.2.0

package/types/zssz-soft-core-api.d.ts

@@ -0,0 +1,1633 @@
+import { Identifiable, Meta, EntityTypeEnum, User, QueryOptions, CursorPaginatedResult, PaginatedResult, SearchParam, Message } from '@zssz-soft/common-api';
+import { Observable } from 'rxjs';
+import * as _angular_core from '@angular/core';
+import { Signal, InjectionToken, Provider, PipeTransform } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { KeyValue } from '@angular/common';
+import { SelectEntityId, EntityId } from '@ngrx/signals/entities';
+import { HttpClient } from '@angular/common/http';
+import { Translation } from '@jsverse/transloco';
+import { DateFormatOptions } from '@jsverse/transloco-locale';
+
+interface EntityHelper {
+    meta: Meta;
+}
+type Entity = Identifiable & EntityHelper;
+type EntityAdd = Omit<Entity, 'uid'>;
+type EntityUpdate = Partial<Entity> & Identifiable & EntityHelper;
+type EntityModel = Entity;
+type EntityModelAdd = Omit<EntityModel, 'uid'>;
+type EntityModelUpdate = Partial<EntityModel> & Identifiable & EntityHelper;
+type EntityType = EntityTypeEnum.Entity;
+type CustomEntityState = {
+    isLoading: boolean;
+    isNewEntityButtonEnabled: boolean;
+};
+
+interface EntityCollectionStoreView<E extends Entity> {
+    editEntity(entity: E): void;
+    deleteEntity(entity: E): void;
+    setSearchTerm(searchTerm: string): void;
+    setSorting(field: string, order: 'asc' | 'desc'): void;
+    setViewMode(viewMode: 'table' | 'dataview' | 'cards'): void;
+    toggleSortOrder(): void;
+    entities: Signal<E[]>;
+    isLoading: Signal<boolean>;
+}
+
+declare abstract class EntityFormLogic<E extends Entity, EA extends EntityAdd, EU extends EntityUpdate> {
+    abstract cancel(): void;
+    abstract createEntity(formValue: any): void;
+    abstract createFormGroup(entity?: E): FormGroup;
+    abstract getEntityById(entityId: string): E | undefined;
+    abstract updateEntity(entityId: string, formValue: any): void;
+    abstract validateAndProcessForm(form: FormGroup | null, entityId: string | null): {
+        isValid: boolean;
+        formValue?: any;
+        entityId?: string | null;
+    };
+}
+
+interface EntityFormStoreView<E extends Entity, EA extends EntityAdd, EU extends EntityUpdate> {
+    cancel(): void;
+    createEntity(formValue: any): void;
+    createFormGroup(entity: E | undefined): FormGroup;
+    updateEntity(entityId: string, formValue: any): void;
+    formGroup(): FormGroup | undefined;
+}
+
+/**
+ * Interface defining the contract for entity table stores.
+ * Provides standard methods for table operations like editing, deleting, and navigation.
+ */
+interface EntityTableStoreView<E extends Entity, EA extends EntityAdd, EU extends EntityUpdate> {
+    editEntity(entity: E): void;
+    deleteEntity(entity: E): void;
+    navigateToCreate(): void;
+    navigateToEdit(entityId: string): void;
+    setViewMode(viewMode: 'table' | 'dataview' | 'cards'): void;
+    setSearchTerm(searchTerm: string): void;
+    setSorting(field: string, order: 'asc' | 'desc'): void;
+    clearFilters(): void;
+    setCurrentPage(page: number): void;
+    setPageSize(size: number): void;
+    refresh(): void;
+}
+
+/**
+ * Interface defining the contract for resource-based entity table stores.
+ * Uses cursor-based pagination for Firestore cost optimization.
+ */
+interface EntityTableResourceStoreView<E extends Entity, EA extends EntityAdd, EU extends EntityUpdate> {
+    editEntity(entity: E): void;
+    deleteEntity(entity: E): void;
+    navigateToCreate(): void;
+    navigateToEdit(entityId: string): void;
+    setViewMode(viewMode: 'table' | 'dataview' | 'cards'): void;
+    setSearchTerm(searchTerm: string): void;
+    setSorting(field: string, order: 'asc' | 'desc'): void;
+    clearFilters(): void;
+    loadNextPage(): void;
+    resetPagination(): void;
+    setPageSize(size: number): void;
+    refresh(): void;
+}
+
+declare abstract class EntityAdapter<E extends Entity, EA extends EntityAdd, EU extends EntityUpdate, EM extends EntityModel, EMA extends EntityModelAdd, EMU extends EntityModelUpdate> {
+    user: Signal<User | undefined>;
+    abstract _sort(a: E, b: E): number;
+    abstract convertEntityAddToModelAdd(entityAdd: EA): EMA;
+    abstract convertEntityToModel(entity: E): EM;
+    abstract convertEntityUpdateToModelUpdate(entity: EU): EMU;
+    abstract convertModelToEntity(model: EM): E;
+    abstract convertModelUpdateToEntityUpdate(model: EMU): EU;
+}
+
+/**
+ * Abstract base class for entity effects
+ *
+ * Design Pattern: Template Method Pattern
+ * - Definiálja az entity műveletek absztrakt szerződését
+ * - A konkrét implementációk a domain-specifikus logikát adják
+ *
+ * Effects felelősségei:
+ * - Adapter hívások koordinálása (Entity <-> Model konverzió)
+ * - Error handling és logging
+ * - Repository művelet delegálás
+ */
+declare abstract class EntityEffect<E extends Entity, EA extends EntityAdd, EU extends EntityUpdate> {
+    abstract createEntity$(entityAdd: EA): Observable<E>;
+    abstract deleteEntity$(entity: E): Observable<E>;
+    abstract listEntities$(pathParams: string[], queryParams: KeyValue<string, string>[]): Observable<E[]>;
+    abstract loadEntity$(entityId: string): Observable<E>;
+    abstract updateEntity$(entityUpdate: EU): Observable<EU>;
+    /**
+     * Query entities with cursor-based pagination
+     * Optional method - can be overridden by domain effects for optimized queries
+     *
+     * @param options Query options including filters, sorting, and pagination
+     * @returns Observable of cursor-paginated result
+     */
+    queryCursorPaginated$(_options: QueryOptions): Observable<CursorPaginatedResult<E>>;
+    /**
+     * Query entities by parent ID (for subcollections)
+     * Optional method - can be overridden by effects that handle subcollections
+     *
+     * @param parentId The ID of the parent entity
+     * @param options Optional query options
+     * @returns Observable of entities belonging to parent
+     */
+    queryByParentId$(_parentId: string, _options?: QueryOptions): Observable<E[]>;
+}
+
+/**
+ * Batch operation interface
+ */
+interface BatchOperation<T> {
+    type: 'create' | 'update' | 'delete';
+    uid?: string;
+    data?: Partial<T>;
+}
+/**
+ * Context for resolving subcollection paths in Firestore
+ * Enables repositories to work with nested collections (e.g., apartments/{id}/rules)
+ */
+interface SubcollectionContext {
+    /**
+     * Name of parent collection (e.g., 'apartments')
+     */
+    parentCollection: string;
+    /**
+     * Field name on the entity that contains parent ID (e.g., 'entityId', 'apartmentId')
+     */
+    parentIdField: string;
+    /**
+     * Name of subcollection (e.g., 'rules')
+     */
+    subcollection: string;
+}
+/**
+ * Builder function type for dynamic collection paths
+ * Takes optional entity data and returns the resolved collection path
+ */
+type CollectionPathBuilder = (entityData?: Partial<EntityModel>) => string;
+/**
+ * Abstract base repository interface for database operations
+ * This interface defines the contract that all data repositories must implement
+ */
+declare abstract class Repository<EM extends EntityModel, EMA extends EntityModelAdd, EMU extends EntityModelUpdate> {
+    abstract create$(modelAdd: EMA): Observable<EM>;
+    abstract list$(pathParams: string[], queryParams: KeyValue<string, string>[]): Observable<EM[]>;
+    abstract listByIds$(ids: string[]): Observable<EM[]>;
+    abstract load$(uid: string): Observable<EM | undefined>;
+    abstract update$(modelUpdate: EMU): Observable<EMU>;
+    abstract delete$(model: EM): Observable<EM>;
+    abstract query(options: QueryOptions): Observable<EM[]>;
+    abstract queryPaginated(options: QueryOptions, pageSize: number, lastDocument?: EM): Observable<PaginatedResult<EM>>;
+    abstract count(options?: QueryOptions): Observable<number>;
+    abstract exists(uid: string): Observable<boolean>;
+    abstract batch(operations: BatchOperation<EM>[]): Observable<void>;
+    abstract search$(params: SearchParam[]): Observable<EM[]>;
+    /**
+     * Query entities by parent ID (for subcollections)
+     * Optional - only implemented for repositories with subcollection context
+     * @param parentId The ID of the parent entity
+     * @param options Optional query options for filtering/sorting
+     */
+    queryByParentId?(parentId: string, options?: QueryOptions): Observable<EM[]>;
+}
+
+declare abstract class RepositoryEngine<E extends EntityModel, EA extends EntityModelAdd, EU extends EntityModelUpdate> extends Repository<E, EA, EU> {
+}
+
+/**
+ * Type for a factory function that creates a repository engine
+ */
+type RepositoryEngineCreator = <R extends EntityModel, S extends EntityModelAdd, T extends EntityModelUpdate>(featureKey: string, subcollectionContext?: SubcollectionContext) => RepositoryEngine<R, S, T>;
+/**
+ * Injection token for the Firestore engine creator function
+ * This allows the actual Firebase implementation to be provided at the app level
+ * while keeping the factory testable
+ */
+declare const FIRESTORE_ENGINE_CREATOR: InjectionToken<RepositoryEngineCreator>;
+
+declare abstract class EntityRepository<EM extends EntityModel, EMA extends EntityModelAdd, EU extends EntityModelUpdate> extends Repository<EM, EMA, EU> {
+}
+
+interface EntityActions<E extends Entity> {
+    setLoading(isLoading: boolean): void;
+    setNewEntityButtonEnabled(enabled: boolean): void;
+    setSearchResult(searchResult: E[]): void;
+    setSelectedEntityId(selectedEntityId: string | undefined): void;
+}
+interface EntityConfig<E extends Entity> {
+    collection: string;
+    entity: E;
+    selectId: SelectEntityId<NoInfer<E>>;
+}
+interface EntitySignals<A extends string, E extends Entity> {
+    all: Signal<E[]>;
+    count: Signal<number>;
+    entities: Signal<Record<A, E>>;
+    error: Signal<string | null>;
+    ids: Signal<A[]>;
+    isLoading: Signal<boolean>;
+    selected: Signal<E | undefined>;
+    selectedId: Signal<A | null>;
+    selectEntityById(): Signal<E | undefined>;
+}
+interface EntityStore<E extends Entity, EA extends EntityAdd, EU extends EntityUpdate, V extends string> extends EntitySignals<V, E>, RxEntityActions<E, EA, EU>, EntityActions<E> {
+}
+interface RxEntityActions<E extends Entity, EA extends EntityAdd, EU extends EntityUpdate> {
+    createEntity$(entityAdd: EA): void;
+    deleteEntity$(entity: E): void;
+    listEntities$(): void;
+    updateEntity$(entityUpdate: EU): void;
+}
+interface EntityStoreView<E extends Entity, EA extends EntityAdd, EU extends EntityUpdate> {
+    entityMap: Signal<Record<string, E>>;
+    ids: Signal<EntityId[]>;
+    entities: Signal<E[]>;
+    selectedEntityId: Signal<string | undefined>;
+    isLoading: Signal<boolean>;
+    isNewEntityButtonEnabled: Signal<boolean>;
+    searchResult: Signal<E[]>;
+    error: Signal<string | null>;
+    getEntityBySelectedId: Signal<E | undefined>;
+    resourceEntities?: Signal<E[]>;
+    hasNextPage?: Signal<boolean>;
+    hasPreviousPage?: Signal<boolean>;
+    isLoaded?: Signal<boolean>;
+    getEntityById(entityId: string): E | undefined;
+    setSelectedEntityId(id?: string): void;
+    setNewEntityButtonEnabled(enabled: boolean): void;
+    setSearchResult(results: E[]): void;
+    setLoading(loading: boolean): void;
+    setQueryOptions?(options: QueryOptions): void;
+    updateQueryOptions?(options: Partial<QueryOptions>): void;
+    loadNextPage?(): void;
+    resetPagination?(): void;
+    reload?(): void;
+    parentId?: Signal<string | null>;
+    subcollectionOptions?: Signal<QueryOptions | null>;
+    loadEntitiesByParentId?(parentId: string, options?: QueryOptions): Promise<E[]>;
+    listEntities(params: {
+        pathParams: string[];
+        queryParams: KeyValue<string, string>[];
+    }): Promise<E[]>;
+    createEntity(entity: EA): Promise<E>;
+    updateEntity(entity: EU): Promise<EU>;
+    deleteEntity(entity: E): Promise<E>;
+    loadEntity(id: string): Promise<E>;
+}
+
+declare const AUDIT_FEATURE_KEY = "audit_logs";
+/**
+ * Audit log entry for tracking user actions
+ */
+interface AuditLog {
+    /** Unique audit log ID */
+    id?: string;
+    /** User who performed the action */
+    user: User | string;
+    /** Action performed */
+    action: AuditAction;
+    /** Resource affected by the action */
+    resource: AuditResource;
+    /** Timestamp when action occurred */
+    timestamp: Date;
+    /** Session information */
+    sessionId?: string;
+    /** Request metadata */
+    metadata: AuditMetadata;
+    /** Action result */
+    result: AuditResult;
+    /** Additional context data */
+    context?: Record<string, any>;
+}
+/**
+ * Types of actions that can be audited
+ */
+type AuditAction = 'auth.login' | 'auth.logout' | 'auth.register' | 'auth.password_reset' | 'auth.email_verification' | 'user.create' | 'user.update' | 'user.delete' | 'user.role_change' | 'user.status_change' | 'data.create' | 'data.read' | 'data.update' | 'data.delete' | 'data.export' | 'data.import' | 'system.configuration_change' | 'system.backup' | 'system.restore' | 'ui.page_view' | 'ui.button_click' | 'ui.form_submit' | 'ui.theme_change' | 'ui.search' | 'ui.filter' | 'ui.download' | 'ui.upload' | 'security.unauthorized_access' | 'security.permission_denied' | 'security.suspicious_activity' | string;
+/**
+ * Resource types that can be audited
+ */
+interface AuditResource {
+    /** Type of resource */
+    type: string;
+    /** Resource identifier */
+    id?: string;
+    /** Resource name or description */
+    name?: string;
+    /** Parent resource if applicable */
+    parent?: AuditResource;
+    /** Additional resource metadata */
+    metadata?: Record<string, any>;
+}
+/**
+ * Metadata associated with an audit action
+ */
+interface AuditMetadata {
+    /** IP address of the request */
+    ipAddress?: string;
+    /** User agent string */
+    userAgent?: string;
+    /** Geographic location */
+    location?: {
+        country?: string;
+        region?: string;
+        city?: string;
+        coordinates?: {
+            latitude: number;
+            longitude: number;
+        };
+    };
+    /** Request information */
+    request?: {
+        method?: string;
+        url?: string;
+        headers?: Record<string, string>;
+        body?: any;
+    };
+    /** Response information */
+    response?: {
+        statusCode?: number;
+        headers?: Record<string, string>;
+        body?: any;
+    };
+    /** Performance metrics */
+    performance?: {
+        duration?: number;
+        memoryUsage?: number;
+        cpuUsage?: number;
+    };
+    /** Additional custom metadata */
+    [key: string]: any;
+}
+/**
+ * Result of an audited action
+ */
+interface AuditResult {
+    /** Whether the action was successful */
+    success: boolean;
+    /** Status code or error code */
+    code?: string | number;
+    /** Human-readable message */
+    message?: string;
+    /** Error details if action failed */
+    error?: {
+        type: string;
+        message: string;
+        stack?: string;
+    };
+    /** Changes made (for update actions) */
+    changes?: {
+        before?: any;
+        after?: any;
+        fields?: string[];
+    };
+    /** Additional result data */
+    data?: any;
+}
+/**
+ * Audit log query filters
+ */
+interface AuditLogQuery {
+    /** Filter by user */
+    userId?: string;
+    /** Filter by action */
+    action?: AuditAction | AuditAction[];
+    /** Filter by resource type */
+    resourceType?: string;
+    /** Filter by date range */
+    dateRange?: {
+        start: Date;
+        end: Date;
+    };
+    /** Filter by success/failure */
+    success?: boolean;
+    /** Filter by session ID */
+    sessionId?: string;
+    /** Filter by IP address */
+    ipAddress?: string;
+    /** Pagination */
+    limit?: number;
+    offset?: number;
+    /** Sorting */
+    sortBy?: 'timestamp' | 'action' | 'user';
+    sortOrder?: 'asc' | 'desc';
+}
+/**
+ * Audit log summary statistics
+ */
+interface AuditLogStats {
+    /** Total number of logs */
+    totalLogs: number;
+    /** Actions by type */
+    actionCounts: Record<string, number>;
+    /** Success rate */
+    successRate: number;
+    /** Most active users */
+    topUsers: Array<{
+        userId: string;
+        actionCount: number;
+    }>;
+    /** Most common actions */
+    topActions: Array<{
+        action: string;
+        count: number;
+    }>;
+    /** Date range covered */
+    dateRange: {
+        start: Date;
+        end: Date;
+    };
+}
+interface Audit {
+    /** User who performed the action */
+    user: User | string;
+    /** Action performed */
+    action: AuditAction;
+    /** Resource affected by the action */
+    resource: AuditResource;
+    /** Timestamp when action occurred */
+    timestamp: Date;
+    /** Session information */
+    sessionId?: string;
+    /** Request metadata */
+    metadata: AuditMetadata;
+    /** Action result */
+    result: AuditResult;
+    /** Additional context data */
+    context?: Record<string, any>;
+}
+type AuditEntity = Audit & Entity;
+type AuditEntityAdd = Omit<AuditEntity, 'uid'>;
+type AuditEntityUpdate = Partial<AuditEntity> & Entity;
+type AuditModel = Audit & EntityModel;
+type AuditModelAdd = Omit<AuditModel, 'uid'>;
+type AuditModelUpdate = Partial<AuditModel> & EntityModel;
+
+/**
+ * Abstract interface for audit logging operations
+ * This defines the contract for audit logging without implementation details
+ */
+declare abstract class AuditService {
+    /**
+     * Log a user action with result
+     * @param user User performing the action
+     * @param action Action being performed
+     * @param resource Resource being acted upon
+     * @param result Action result (success/failure)
+     * @param context Additional context data
+     * @returns Observable with the audit log ID
+     */
+    abstract logAction(user: User, action: AuditAction, resource: AuditResource, result: 'success' | 'failure', context?: Record<string, any>): Observable<string>;
+    /**
+     * Log a successful action
+     * @param user User performing the action
+     * @param action Action being performed
+     * @param resource Resource being acted upon
+     * @param data Additional data about the action
+     * @param context Additional context data
+     * @returns Observable with the audit log ID
+     */
+    abstract logSuccess(user: User, action: AuditAction, resource: AuditResource, data?: any, context?: Record<string, any>): Observable<string>;
+    /**
+     * Log a failed action
+     * @param user User performing the action
+     * @param action Action being performed
+     * @param resource Resource being acted upon
+     * @param error Error that occurred
+     * @param context Additional context data
+     * @returns Observable with the audit log ID
+     */
+    abstract logFailure(user: User, action: AuditAction, resource: AuditResource, error: Error, context?: Record<string, any>): Observable<string>;
+    /**
+     * Log authentication events
+     * @param user User involved in auth event
+     * @param action Auth action performed
+     * @param success Whether the auth action was successful
+     * @param additionalData Additional auth-related data
+     * @returns Observable with the audit log ID
+     */
+    abstract logAuthEvent(user: User, action: AuditAction, success: boolean, additionalData?: Record<string, any>): Observable<string>;
+    /**
+     * Query audit logs with filters
+     * @param query Query filters
+     * @returns Observable with array of audit logs
+     */
+    abstract queryLogs(query: AuditLogQuery): Observable<AuditLog[]>;
+    /**
+     * Get audit log statistics
+     * @param timeRange Optional time range for statistics
+     * @returns Observable with audit statistics
+     */
+    abstract getStats(timeRange?: {
+        start: Date;
+        end: Date;
+    }): Observable<AuditLogStats>;
+    /**
+     * Get audit logs for a specific user
+     * @param userId User ID
+     * @param limit Optional limit on number of logs
+     * @returns Observable with array of user's audit logs
+     */
+    abstract getUserLogs(userId: string, limit?: number): Observable<AuditLog[]>;
+    /**
+     * Get recent audit logs
+     * @param limit Number of recent logs to retrieve
+     * @returns Observable with array of recent audit logs
+     */
+    abstract getRecentLogs(limit?: number): Observable<AuditLog[]>;
+}
+
+interface AuthResult<T = any> {
+    data?: T;
+    error?: {
+        code: AuthErrorCode;
+        message: string;
+    };
+    success: boolean;
+}
+interface AuthState {
+    error: string | null;
+    isAuthenticated: boolean;
+    loading: boolean;
+    user: AuthUser | null;
+}
+interface AuthUser {
+    createdAt?: string;
+    customClaims?: Record<string, any>;
+    displayName: string | null;
+    email: string | null;
+    emailVerified: boolean;
+    lastSignInAt?: string;
+    phoneNumber: string | null;
+    photoURL: string | null;
+    uid: string;
+}
+interface EmailPasswordCredentials {
+    email: string;
+    password: string;
+}
+interface UserRegistrationData extends EmailPasswordCredentials {
+    displayName?: string;
+    phoneNumber?: string;
+}
+type AuthCredentials = EmailPasswordCredentials;
+type AuthErrorCode = 'auth/user-not-found' | 'auth/wrong-password' | 'auth/email-already-in-use' | 'auth/weak-password' | 'auth/invalid-email' | 'auth/user-disabled' | 'auth/too-many-requests' | 'auth/network-request-failed' | 'auth/popup-closed-by-user' | 'auth/popup-blocked' | 'auth/cancelled-popup-request' | 'auth/account-exists-with-different-credential' | 'unknown-error';
+type AuthMethod = 'signIn' | 'signUp' | 'signOut' | 'resetPassword' | 'verifyEmail';
+type AuthProvider = 'email' | 'google' | 'facebook';
+declare const initialAuthState: AuthState;
+
+declare abstract class AuthenticationStoreService {
+    abstract signOut(): Promise<AuthResult<void>>;
+    abstract signInWithEmailAndPassword(email: string, password: string): Promise<void>;
+    abstract signInWithGoogle(): Promise<AuthResult<AuthUser>>;
+    abstract createUserWithEmailAndPassword(userData: UserRegistrationData): Promise<AuthResult<AuthUser>>;
+    abstract sendPasswordResetEmail(email: string): Promise<void>;
+    abstract updatePassword(newPassword: string): Promise<AuthResult<void>>;
+    abstract updateEmail(newEmail: string): Promise<AuthResult<void>>;
+    abstract getIdToken(forceRefresh: boolean): Promise<string | null>;
+    abstract getStore(): AuthenticationStoreView;
+}
+interface AuthenticationStoreView {
+    user: Signal<AuthUser | null>;
+    isAuthenticated: Signal<boolean>;
+    isLoading: Signal<boolean>;
+    error: Signal<string | null>;
+    isLoggedIn: Signal<boolean>;
+    userDisplayName: Signal<string>;
+    userInitials: Signal<string>;
+    setUser(user: AuthUser | null): void;
+    setLoading(isLoading: boolean): void;
+    setError(error: string | null): void;
+    clearError(): void;
+    clearUser(): void;
+    setInitialized(): void;
+}
+declare const AUTHENTICATION_STORE_SERVICE_TOKEN: InjectionToken<AuthenticationStoreService>;
+declare const AUTHENTICATION_STORE_VIEW_TOKEN: InjectionToken<AuthenticationStoreView>;
+
+declare abstract class AuthenticationService {
+    private readonly _authState;
+    readonly authState: _angular_core.Signal<AuthState>;
+    readonly currentUser: _angular_core.Signal<AuthState>;
+    readonly isAuthenticated: _angular_core.Signal<AuthState>;
+    abstract createUserWithEmailAndPassword(userData: UserRegistrationData): Promise<AuthResult<AuthUser>>;
+    abstract generateUserWithUID(email: string, displayName?: string): Promise<AuthResult<AuthUser>>;
+    abstract generateUserWithUIDAndSendReset(email: string, displayName?: string): Promise<AuthResult<AuthUser>>;
+    abstract getIdToken(forceRefresh: boolean): Promise<string | null>;
+    abstract getIdTokenResult(forceRefresh: boolean): Promise<any>;
+    abstract sendEmailVerification(): Promise<AuthResult<void>>;
+    abstract sendPasswordResetEmail(email: string): Promise<void>;
+    abstract signInWithEmailAndPassword(credentials: EmailPasswordCredentials): Promise<void>;
+    abstract signInWithGoogle(): Promise<AuthResult<AuthUser>>;
+    abstract signOut(): Promise<AuthResult<void>>;
+    abstract updateEmail(newEmail: string): Promise<AuthResult<void>>;
+    abstract updatePassword(newPassword: string): Promise<AuthResult<void>>;
+    abstract updateProfile(profile: Partial<Pick<AuthUser, 'displayName' | 'photoURL'>>): Promise<AuthResult<void>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AuthenticationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AuthenticationService>;
+}
+
+declare const DEFAULT_FIREBASE_CONFIG: FirebaseConfig;
+declare const DEFAULT_FIREBASE_AUTH_CONFIG: FirebaseAuthConfig;
+interface FirebaseConfig {
+    apiKey: string;
+    authDomain: string;
+    projectId: string;
+    storageBucket: string;
+    messagingSenderId: string;
+    appId: string;
+    measurementId?: string;
+}
+interface SessionConfig {
+    /** Inactivity timeout in milliseconds (default: 30 minutes) */
+    inactivityTimeout: number;
+    /** Warning before timeout in milliseconds (default: 5 minutes before timeout) */
+    warningBeforeTimeout?: number;
+    /** Events to track for activity (default: ['click', 'keypress', 'mousemove', 'touchstart']) */
+    events?: string[];
+    /** Whether to show warning dialog before logout */
+    showWarningDialog?: boolean;
+}
+interface UserConfig {
+    /** Firestore collection name for user documents (default: 'user') */
+    collection?: string;
+    /** Default role ID to assign to new OAuth users */
+    defaultRoleId: string;
+    /** Whether to automatically create user document on OAuth login (default: true) */
+    autoCreate?: boolean;
+}
+interface FirebaseAuthConfig {
+    firebase: FirebaseConfig;
+    enableRegistration?: boolean;
+    enableSocialLogin?: boolean;
+    enabledProviders?: ('email' | 'google' | 'facebook')[];
+    session?: SessionConfig;
+    /** Configuration for automatic user document creation on OAuth login */
+    userDocument?: UserConfig;
+}
+declare const FIREBASE_CONFIG: InjectionToken<FirebaseConfig>;
+declare const FIREBASE_AUTH_CONFIG: InjectionToken<FirebaseAuthConfig>;
+declare function provideFirebaseAuthConfig(config: FirebaseAuthConfig): Provider;
+
+/**
+ * Represents a permission in the authorization system
+ */
+interface Permission {
+    /**
+     * Unique identifier for the permission
+     */
+    id: string;
+    /**
+     * Human-readable name of the permission
+     */
+    name: string;
+    /**
+     * Optional description of what this permission allows
+     */
+    description?: string;
+    /**
+     * Optional category to group related permissions
+     */
+    category?: string;
+}
+/**
+ * Represents a role that can be assigned to users
+ */
+interface Role {
+    /**
+     * Unique identifier for the role
+     */
+    id: string;
+    /**
+     * Human-readable name of the role
+     */
+    name: string;
+    /**
+     * Optional description of the role's purpose
+     */
+    description?: string;
+    /**
+     * List of permission IDs granted to this role
+     */
+    permissions: string[];
+}
+/**
+ * Represents authorization context for a user
+ */
+interface AuthorizationContext {
+    /**
+     * User's assigned roles
+     */
+    roles: Role[];
+    /**
+     * Direct permissions assigned to the user (not through roles)
+     */
+    directPermissions: Permission[];
+    /**
+     * Additional context data that might affect authorization decisions
+     */
+    context?: Record<string, any>;
+}
+/**
+ * Configuration options for authorization checks
+ */
+interface AuthorizationOptions {
+    /**
+     * Whether to require ALL permissions (AND logic) or ANY permission (OR logic)
+     * @default 'any'
+     */
+    mode?: 'all' | 'any';
+    /**
+     * Whether to include permissions from roles
+     * @default true
+     */
+    includeRolePermissions?: boolean;
+    /**
+     * Whether to include direct permissions
+     * @default true
+     */
+    includeDirectPermissions?: boolean;
+}
+
+interface CloudFunctionResult<T = any> {
+    success: boolean;
+    message?: string;
+    data?: T;
+    userId?: string;
+    uid?: string;
+    userCreated?: boolean;
+}
+interface CreateUserAndSendPasswordResetResult extends CloudFunctionResult {
+    uid: string;
+    userId: string;
+}
+type BootstrapStatusResult = CloudFunctionResult<{
+    isBootstrapped: boolean;
+    userCount?: number;
+}>;
+interface CreateUserRequest {
+    email: string;
+    password?: string;
+    firstName: string;
+    lastName: string;
+    displayName?: string;
+    phoneNumber?: string;
+    photoURL?: string;
+    disabled?: boolean;
+    sendWelcomeEmail?: boolean;
+    loginUrl?: string;
+}
+interface CreateUserResponse {
+    success: boolean;
+    uid: string;
+    email: string;
+    emailSent?: boolean;
+    error?: string;
+}
+
+declare abstract class CloudService {
+    abstract checkBootstrapStatus(): Promise<BootstrapStatusResult>;
+    abstract createUserAndSendPasswordReset(email: string, displayName: string, sendEmail: boolean): Promise<CreateUserAndSendPasswordResetResult>;
+    abstract sendPasswordResetEmail(email: string): Promise<CloudFunctionResult>;
+    abstract sendWelcomeEmail(email: string, displayName: string, firstName?: string, lastName?: string, roles?: string[]): Promise<CloudFunctionResult>;
+    abstract systemBootstrap(adminEmail: string, adminDisplayName?: string, adminPassword?: string): Promise<CloudFunctionResult>;
+    abstract registerUserWithWelcomeEmail(email: string, password: string, firstName: string, lastName: string, options?: {
+        displayName?: string;
+        phoneNumber?: string;
+        photoURL?: string;
+        disabled?: boolean;
+        loginUrl?: string;
+    }): Promise<CreateUserResponse>;
+    abstract registerUserWithoutEmail(email: string, password: string, firstName: string, lastName: string, options?: {
+        displayName?: string;
+        phoneNumber?: string;
+        photoURL?: string;
+        disabled?: boolean;
+    }): Promise<CreateUserResponse>;
+    abstract generateThumbnail(params: {
+        path: string;
+        documentId?: string;
+        maxWidth?: number;
+        maxHeight?: number;
+        force?: boolean;
+    }): Promise<CloudFunctionResult & {
+        thumbPath?: string;
+        documentUpdated?: boolean;
+        originalFilePath?: string;
+    }>;
+}
+declare const CLOUD_SERVICE_TOKEN: InjectionToken<CloudService>;
+
+type AppBootstrapConfig = {
+    bootstrapAdmin: {
+        email: string;
+        displayName: string;
+        firstName: string;
+        lastName: string;
+        language: string;
+        roles: string[];
+    };
+};
+declare const APP_BOOTSTRAP_CONFIG: InjectionToken<AppBootstrapConfig>;
+declare function provideAppBootstrapConfig(config: AppBootstrapConfig): Provider;
+declare const DEFAULT_APP_BOOTSTRAP_CONFIG: AppBootstrapConfig;
+
+declare const DOCUMENTS_KEYS: {
+    ház: string;
+    hálószoba: string;
+    földszint: string;
+    emelet: string;
+    nappali: string;
+    étkező: string;
+    konyha: string;
+    fürdőszoba: string;
+    kültér: string;
+    stég: string;
+    parkoló: string;
+    bográcsozó: string;
+    terasz: string;
+    wc: string;
+};
+
+interface NotificationConfig {
+    closable?: boolean;
+    life?: number;
+    sticky?: boolean;
+}
+declare const NOTIFICATION_CONFIG_TOKEN: InjectionToken<NotificationConfig>;
+declare function provideNotificationConfig(config?: NotificationConfig): {
+    provide: InjectionToken<NotificationConfig>;
+    useValue: NotificationConfig;
+};
+declare const DEFAULT_NOTIFICATION_CONFIG: NotificationConfig;
+
+interface EmailConfig {
+    fromEmail: string;
+    fromName: string;
+    mailersendApiKey: string;
+}
+interface SendPasswordResetEmailData {
+    customMessage?: string;
+    email: string;
+}
+type CreateUserData = Omit<WelcomeEmailData, 'firstName' | 'lastName'> & {
+    sendEmail?: boolean;
+};
+type WelcomeEmailData = Omit<User, 'language' | 'phone' | 'photoUrl' | 'uid'> & {
+    roles?: string[];
+    temporaryPassword?: string;
+};
+type WelcomeEmailDataWithConfig = WelcomeEmailData & Omit<EmailConfig, 'mailersendApiKey'>;
+declare const EMAIL_CONFIG: InjectionToken<EmailConfig>;
+
+/**
+ * Email service for sending welcome and notification emails
+ * This can be implemented with different providers
+ */
+declare abstract class EmailService {
+    /**
+     * Send custom notification email
+     * @param to Recipient email
+     * @param subject Email subject
+     * @param body Email body (HTML or text)
+     * @param data Optional template data
+     * @returns Promise that resolves when email is sent
+     */
+    abstract sendNotificationEmail(to: string, subject: string, body: string, data?: Record<string, any>): Promise<void>;
+    /**
+     * Send welcome email to newly created user
+     * @param userData User data for the email
+     * @returns Promise that resolves when email is sent
+     */
+    abstract sendWelcomeEmail(userData: WelcomeEmailData): Promise<void>;
+}
+
+declare enum ErrorType {
+    HttpError = "http-error"
+}
+interface ErrorOptions {
+    type: ErrorType;
+    viewable?: boolean;
+}
+declare class KError extends Error {
+    options: ErrorOptions;
+    constructor(message: string, error: Error, options: ErrorOptions);
+}
+
+declare abstract class ErrorUtilService {
+    abstract createErrorMessage(error: KError): Message;
+    abstract throwEffectError(message: string, error: unknown, viewable?: boolean): KError;
+}
+
+declare abstract class DateTimePipeBase implements PipeTransform {
+    abstract transform(value: any, ...args: unknown[]): string;
+}
+
+declare abstract class DateUtil {
+    abstract createActionTime(minute: number, second: number): number;
+    abstract createFullTime(startTime: number, minute: number, second: number): number;
+    abstract getDateRange(firstDate: Date, lastDate: Date): Date[];
+    abstract getDateRangeWithoutBorder(firstDate: Date, lastDate: Date): Date[];
+    abstract getDateRangeAsString(dates: Date[], format: string): string[];
+    abstract getDateRangeLength(firstDate: Date, lastDate: Date): number;
+    abstract getFormattedDate(date: Date, format: string): string;
+    abstract getNextDay(baseDate: Date): Date;
+    abstract getNow(): number;
+    abstract getPreviousDay(baseDate: Date): Date;
+    abstract getToday(): Date;
+    abstract getTomorrow(): Date;
+}
+
+declare interface HashMapModel<T = unknown> {
+    [key: string]: T;
+}
+
+declare enum LanguagesEnum {
+    de = "de",
+    en = "en",
+    hu = "hu",
+    hr = "hr",
+    ro = "ro",
+    sk = "sk",
+    sl = "sl",
+    sr = "sr",
+    uk = "uk"
+}
+declare const LANGUAGES_TOKEN: InjectionToken<string[]>;
+declare const DEFAULT_LANGUAGE_TOKEN: InjectionToken<string>;
+
+type LoaderData = {
+    scope: string;
+};
+type I18nText = {
+    [key in string]: string;
+};
+interface I18nConfig {
+    availableLangs: LanguagesEnum[];
+    defaultLang: LanguagesEnum;
+    prodMode: boolean;
+    reRenderOnLangChange: boolean;
+}
+
+declare abstract class I18nService {
+    protected httpClient: HttpClient;
+    protected defaultPath: string;
+    constructor(httpClient: HttpClient);
+    abstract activeLanguageChanges$(): Observable<string>;
+    abstract getActiveLang(): LanguagesEnum;
+    abstract getActiveLangAsString(): string;
+    abstract getAvailableLanguages(): string[];
+    abstract getActiveLocale(): string;
+    abstract getDefaultI18nText(): I18nText;
+    abstract getValue(property: any, locale?: string): string;
+    abstract getValueByLanguage(i18nText: I18nText, language?: string): string;
+    abstract init(language: string): void;
+    abstract load(): Observable<Translation>;
+    abstract localizeDate(date: string | Date, locale: string, format: DateFormatOptions): string;
+    abstract nameComponentShorter(firstName: string, lastName: string): string[];
+    abstract translate<T>(key: string | string[], params?: HashMapModel<unknown>, lang?: string): string;
+    abstract selectTranslate$(key: string, params?: HashMapModel<unknown>, lang?: string): Observable<string>;
+}
+
+declare abstract class I18nUtil {
+    abstract getActiveLang(): LanguagesEnum;
+    abstract getDefaultI18nText(): I18nText;
+    abstract updateLanguage(language: string): void;
+    abstract getValueByLanguage(i18nText: I18nText, language?: string): string;
+    abstract getCurrentLocale(): string;
+}
+
+interface Localizable {
+    currentLanguage: string;
+}
+
+type IconType = 'material' | 'svg' | 'primeicons';
+type Icon = {
+    name: string;
+    class: string;
+    type?: IconType;
+    svgContent?: string;
+};
+/**
+ * Helper function to create a PrimeIcons icon
+ * @param name - PrimeIcons icon name without 'pi-' prefix (e.g., 'search', 'user', 'home')
+ */
+declare function primeIcon(name: string): Icon;
+declare const materialIcons: Icon[];
+/**
+ * Custom SVG icons for items not available in Material Symbols
+ */
+declare const customSvgIcons: Icon[];
+/**
+ * All available icons (Material + Custom SVG)
+ */
+declare const allIcons: Icon[];
+
+/**
+ * Abstract interface for logging operations
+ * This defines the contract for logging without implementation details
+ */
+declare abstract class Logger {
+    /**
+     * Set the current user for audit logging
+     * @param user Current authenticated user
+     */
+    abstract setCurrentUser(user: User | null): void;
+    /**
+     * Get the current user
+     * @returns Current user or null
+     */
+    abstract getCurrentUser(): User | null;
+    /**
+     * Log trace level message
+     * @param message Log message
+     * @param data Additional data
+     * @param context Context information
+     */
+    abstract trace(message: string, data?: any, context?: Record<string, any>): void;
+    /**
+     * Log debug level message
+     * @param message Log message
+     * @param data Additional data
+     * @param context Context information
+     */
+    abstract debug(message: string, data?: any, context?: Record<string, any>): void;
+    /**
+     * Log info level message
+     * @param message Log message
+     * @param data Additional data
+     * @param context Context information
+     */
+    abstract info(message: string, data?: any, context?: Record<string, any>): void;
+    /**
+     * Log warning level message
+     * @param message Log message
+     * @param data Additional data
+     * @param context Context information
+     */
+    abstract warn(message: string, data?: any, context?: Record<string, any>): void;
+    /**
+     * Log error level message
+     * @param message Log message
+     * @param data Additional data
+     * @param context Context information
+     */
+    abstract error(message: string, data?: any, context?: Record<string, any>): void;
+    /**
+     * Log fatal level message
+     * @param message Log message
+     * @param data Additional data
+     * @param context Context information
+     */
+    abstract fatal(message: string, data?: any, context?: Record<string, any>): void;
+    /**
+     * Audit user actions with automatic success/failure logging
+     * @param action Action being performed
+     * @param resource Resource being acted upon
+     * @param success Whether the action was successful
+     * @param data Additional action data
+     * @param context Additional context
+     */
+    abstract auditUserAction(action: AuditAction, resource: AuditResource, success: boolean, data?: any, context?: Record<string, any>): void;
+    /**
+     * Audit authentication events
+     * @param user User involved in auth event
+     * @param action Auth action performed
+     * @param success Whether the auth action was successful
+     * @param additionalData Additional auth-related data
+     */
+    abstract auditAuthEvent(user: User, action: AuditAction, success: boolean, additionalData?: Record<string, any>): void;
+    /**
+     * Audit UI interactions
+     * @param action UI action performed
+     * @param component Component where action occurred
+     * @param data Additional UI data
+     * @param context Additional context
+     */
+    abstract auditUIAction(action: string, component: string, data?: any, context?: Record<string, any>): void;
+    /**
+     * Audit data operations
+     * @param operation Type of data operation
+     * @param resourceType Type of resource
+     * @param resourceId Resource identifier
+     * @param success Whether operation was successful
+     * @param data Additional operation data
+     * @param context Additional context
+     */
+    abstract auditDataOperation(operation: 'create' | 'read' | 'update' | 'delete', resourceType: string, resourceId?: string, success?: boolean, data?: any, context?: Record<string, any>): void;
+    /**
+     * Log user action for tracking
+     * @param component Component where action occurred
+     * @param action Action performed
+     * @param data Additional action data
+     */
+    abstract logUserAction(component: string, action: string, data?: any): void;
+    /**
+     * Log performance metrics
+     * @param operation Operation being measured
+     * @param duration Duration in milliseconds
+     * @param component Component where operation occurred
+     */
+    abstract logPerformance(operation: string, duration: number, component?: string): void;
+    /**
+     * Log HTTP requests
+     * @param method HTTP method
+     * @param url Request URL
+     * @param status Response status code
+     * @param duration Request duration in milliseconds
+     */
+    abstract logHttpRequest(method: string, url: string, status: number, duration: number): void;
+    abstract logComponentLifecycle(component: string, lifecycle: string): void;
+    abstract logThemeChangeAudit(from: string, to: string): void;
+}
+
+interface LoggerEnvironmentConfig {
+    production: boolean;
+    logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+    enableConsoleLogging?: boolean;
+    enableStorageLogging?: boolean;
+    maxStoredLogs?: number;
+}
+/**
+ * Log levels for the logger
+ */
+type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+interface LoggerConfig {
+    level: LogLevel;
+    environment: 'development' | 'production' | 'test';
+    enableConsole: boolean;
+}
+interface LogEntry {
+    timestamp: string;
+    level: string;
+    message: string;
+    data?: any;
+    component?: string;
+    action?: string;
+}
+declare const LOGGER_ENVIRONMENT = "LOGGER_ENVIRONMENT";
+/**
+ * Decorator options for method logging
+ */
+interface LogMethodOptions {
+    /** Component name for logging context */
+    component?: string;
+    /** Log level to use */
+    level?: 'trace' | 'debug' | 'info' | 'warn' | 'error';
+    /** Whether to log method entry */
+    logEntry?: boolean;
+    /** Whether to log method exit */
+    logExit?: boolean;
+    /** Whether to log method duration */
+    logDuration?: boolean;
+    /** Additional context data */
+    context?: Record<string, any>;
+}
+/**
+ * Decorator options for user action logging
+ */
+interface LogUserActionOptions {
+    /** Component name */
+    component: string;
+    /** Action name - if not provided, method name will be used */
+    action?: string;
+    /** Additional data extractor function */
+    dataExtractor?: (args: any[]) => any;
+}
+/**
+ * Decorator options for data operation auditing
+ */
+interface LogDataOperationOptions {
+    /** Operation type */
+    operation: 'create' | 'read' | 'update' | 'delete';
+    /** Resource type */
+    resourceType: string;
+    /** Function to extract resource ID from method arguments */
+    resourceIdExtractor?: (args: any[]) => string | undefined;
+    /** Function to extract operation data from method arguments */
+    dataExtractor?: (args: any[]) => any;
+    /** Component name for context */
+    component?: string;
+}
+/**
+ * Decorator options for UI action auditing
+ */
+interface LogUIActionOptions {
+    /** Component name */
+    component: string;
+    /** Action name - if not provided, method name will be used */
+    action?: string;
+    /** Function to extract UI data from method arguments */
+    dataExtractor?: (args: any[]) => any;
+}
+
+interface StorageFile {
+    name: string;
+    path: string;
+    size: number;
+    contentType: string;
+    lastModified: Date;
+    downloadUrl?: string;
+}
+interface StorageUploadProgress {
+    bytesTransferred: number;
+    totalBytes: number;
+    progress: number;
+    state: 'running' | 'paused' | 'success' | 'canceled' | 'error';
+}
+interface StorageUploadOptions {
+    contentType?: string;
+    metadata?: Record<string, string>;
+    onProgress?: (progress: StorageUploadProgress) => void;
+}
+interface StorageListOptions {
+    maxResults?: number;
+    pageToken?: string;
+    prefix?: string;
+}
+interface StorageListResult {
+    items: StorageFile[];
+    nextPageToken?: string;
+    prefixes: string[];
+}
+interface StorageDeleteOptions {
+    recursive?: boolean;
+}
+type StorageError = {
+    code: string;
+    message: string;
+    serverResponse?: unknown;
+};
+
+declare abstract class StorageEngine {
+    /**
+     * Upload a file to storage
+     */
+    abstract upload(path: string, file: File | Blob, options?: StorageUploadOptions): Observable<StorageFile>;
+    /**
+     * Download a file as blob
+     */
+    abstract download(path: string): Observable<Blob>;
+    /**
+     * Get download URL for a file
+     */
+    abstract getDownloadUrl(path: string): Observable<string>;
+    /**
+     * Get file metadata
+     */
+    abstract getMetadata(path: string): Observable<StorageFile>;
+    /**
+     * List files in a directory
+     */
+    abstract list(path: string, options?: StorageListOptions): Observable<StorageListResult>;
+    /**
+     * Delete a file or directory
+     */
+    abstract delete(path: string, options?: StorageDeleteOptions): Observable<void>;
+    /**
+     * Check if file exists
+     */
+    abstract exists(path: string): Observable<boolean>;
+    /**
+     * Copy a file
+     */
+    abstract copy(sourcePath: string, destinationPath: string): Observable<StorageFile>;
+    /**
+     * Move a file
+     */
+    abstract move(sourcePath: string, destinationPath: string): Observable<StorageFile>;
+}
+
+type RuleTarget = {
+    kind: 'DocRef';
+    path: string;
+} | {
+    kind: 'TypedId';
+    type: string;
+    id: string;
+} | {
+    kind: 'Composite';
+    parts: Array<RuleTarget>;
+};
+interface RuleEffectBase {
+    type: string;
+    payload?: unknown;
+}
+interface TimeAsDateRange {
+    from: Date;
+    to: Date;
+}
+interface TimeAsString {
+    from: string;
+    to: string;
+}
+interface RuleWhen {
+    time?: TimeAsString | TimeAsDateRange;
+    conditions?: RuleCondition[];
+}
+interface Rule<RT extends RuleTarget = RuleTarget, W extends RuleWhen = RuleWhen, E extends RuleEffectBase = RuleEffectBase> {
+    description: I18nText;
+    enabled: boolean;
+    entityId: string;
+    name: I18nText;
+    priority: number;
+    tags?: string[];
+    target: RT;
+    when: W;
+    effect: E;
+}
+/**
+ * Condition for when a rule should be evaluated
+ */
+interface RuleCondition {
+    field: string;
+    operator: 'eq' | 'neq' | 'in' | 'gte' | 'lte' | 'gt' | 'lt';
+    value: unknown;
+}
+/**
+ * Context for rule evaluation
+ * Contains all information needed to evaluate rules
+ */
+interface RuleEvaluationContext<T = unknown> {
+    startDate?: Date;
+    endDate?: Date;
+    entityId: string;
+    entityType: string;
+    additionalContext?: T;
+}
+/**
+ * Result of rule evaluation
+ */
+interface RuleEvaluationResult<TResult = unknown> {
+    appliedRules: Rule[];
+    result: TResult;
+    conflicts: RuleConflict[];
+}
+/**
+ * Conflict between rules
+ */
+interface RuleConflict {
+    rule1: Rule;
+    rule2: Rule;
+    conflictType: string;
+    message: string;
+}
+/**
+ * Validation error for rules
+ */
+interface RuleValidationError {
+    ruleId: string;
+    field: string;
+    message: string;
+    conflictingRuleId?: string;
+}
+/**
+ * Validation result
+ */
+interface RuleValidationResult {
+    valid: boolean;
+    errors: RuleValidationError[];
+}
+
+/**
+ * Workflow Type Definitions
+ *
+ * These are the core workflow types used by entities that participate in workflows.
+ * The actual workflow engine and services are in the 'workflow' library.
+ */
+
+type WorkflowId = string;
+type StateId = string;
+type TransitionId = string;
+/**
+ * Workflow summary stored in the parent entity (e.g., BookingEntity).
+ * Contains only the current state and metadata for efficient queries.
+ * The full history is stored in the workflow_history subcollection.
+ */
+interface WorkflowSummary {
+    workflowDefinitionId: WorkflowId;
+    currentState: StateId;
+    initialState: StateId;
+    stateCount: number;
+    lastTransitionAt: string;
+    lastTransitionBy: string;
+}
+/**
+ * Interface for entities that can participate in workflows.
+ * Extend your entity with this interface to make it workflowable.
+ *
+ * @example
+ * ```typescript
+ * interface BookingEntity extends Entity, Workflowable {
+ *   // ... booking fields
+ * }
+ * ```
+ */
+interface Workflowable {
+    workflow?: WorkflowSummary;
+}
+/**
+ * Type helper for entities that require workflow to be present.
+ */
+type WithWorkflow<T extends Workflowable> = T & {
+    workflow: WorkflowSummary;
+};
+/**
+ * Core data fields for a workflow history entry (without Entity base fields).
+ */
+interface WorkflowHistoryEntryData {
+    bookingId: string;
+    sequence: number;
+    from: StateId;
+    to: StateId;
+    transitionId: TransitionId;
+    changedBy: string;
+    changedAt: string;
+    comment?: string;
+    payload?: unknown;
+}
+declare const WORKFLOW_HISTORY_FEATURE_KEY = "workflow_history";
+/**
+ * Workflow history entry entity stored in the subcollection.
+ * Extends Entity to include uid and meta for Firestore compatibility.
+ */
+interface WorkflowHistoryEntry extends Entity, WorkflowHistoryEntryData {
+}
+/**
+ * Type for adding a new workflow history entry.
+ * uid is auto-generated, meta is provided by the caller.
+ */
+type WorkflowHistoryEntryAdd = EntityAdd & WorkflowHistoryEntryData;
+/**
+ * Type for updating workflow history entries.
+ * NOTE: Updates are NOT allowed - this type exists only for type system compatibility.
+ */
+type WorkflowHistoryEntryUpdate = EntityUpdate & Partial<WorkflowHistoryEntryData>;
+/**
+ * Model types for Firestore storage.
+ */
+type WorkflowHistoryModel = WorkflowHistoryEntry;
+type WorkflowHistoryModelAdd = WorkflowHistoryEntryAdd;
+
+/**
+ * Abstract WorkflowEngine - defines the contract for workflow operations
+ *
+ * Implementations should handle:
+ * - Transition execution with guards and actions
+ * - Permission and role checking
+ * - Workflow history management
+ */
+
+/**
+ * Current user context for workflow operations
+ */
+interface WorkflowCurrentUser {
+    id: string;
+    roles: string[];
+    permissions: string[];
+}
+/**
+ * Result of checking if a transition can be executed
+ */
+interface CanExecuteTransitionResult {
+    allowed: boolean;
+    reason?: string;
+    failedCheck?: 'state' | 'permission' | 'role' | 'guard';
+}
+/**
+ * Result of bulk transition execution
+ */
+interface BulkTransitionResult<T extends Workflowable> {
+    succeeded: WithWorkflow<T>[];
+    failed: Array<{
+        entity: WithWorkflow<T>;
+        error: string;
+    }>;
+    stats: {
+        total: number;
+        succeeded: number;
+        failed: number;
+    };
+}
+/**
+ * Workflow state definition
+ */
+interface WorkflowState {
+    id: string;
+    label: string;
+    description?: string;
+    isInitial?: boolean;
+    isFinal?: boolean;
+    color?: string;
+    icon?: string;
+    requiredFields?: string[];
+    editableFields?: string[];
+    readonlyFields?: string[];
+}
+/**
+ * Workflow transition context passed to guards and actions
+ */
+interface WorkflowTransitionContext<T = unknown> {
+    entity: T;
+    currentUserId: string;
+    currentUserRoles: string[];
+    currentUserPermissions: string[];
+    payload?: unknown;
+}
+/**
+ * Guard function type - returns true if transition is allowed
+ */
+type WorkflowGuardFn<T = unknown> = (ctx: WorkflowTransitionContext<T>) => boolean | Promise<boolean>;
+/**
+ * Action function type - executed after successful transition
+ */
+type WorkflowActionFn<T = unknown> = (ctx: WorkflowTransitionContext<T>) => void | Promise<void>;
+/**
+ * Workflow transition definition
+ */
+interface WorkflowTransition<T = unknown> {
+    id: string;
+    from: string;
+    to: string;
+    label: string;
+    description?: string;
+    requiredPermissions?: string[];
+    requiredRoles?: string[];
+    guards?: WorkflowGuardFn<T>[];
+    actions?: WorkflowActionFn<T>[];
+    icon?: string;
+    severity?: 'primary' | 'secondary' | 'success' | 'info' | 'warn' | 'danger' | 'help';
+}
+/**
+ * Complete workflow definition
+ */
+interface WorkflowDefinition<T = unknown> {
+    id: string;
+    entityType: string;
+    label: string;
+    description?: string;
+    states: WorkflowState[];
+    transitions: WorkflowTransition<T>[];
+}
+/**
+ * Result of executing a transition - contains updated entity and history entry
+ */
+interface TransitionExecutionResult<T extends Workflowable> {
+    entity: WithWorkflow<T>;
+    historyEntry: WorkflowHistoryEntryData;
+}
+/**
+ * Abstract WorkflowEngine class
+ *
+ * Defines the contract for workflow operations.
+ * Implementations should be provided via dependency injection.
+ *
+ * @typeParam T - The entity type that extends Workflowable
+ */
+declare abstract class WorkflowEngine<T extends Workflowable> {
+    /**
+     * Check if a transition can be executed
+     */
+    abstract canExecuteTransition(definition: WorkflowDefinition<T>, transitionId: TransitionId, entity: WithWorkflow<T>, currentUser: WorkflowCurrentUser): CanExecuteTransitionResult;
+    /**
+     * Execute a workflow transition
+     * Returns both the updated entity and the history entry to be persisted
+     */
+    abstract executeTransition(definition: WorkflowDefinition<T>, transitionId: TransitionId, entity: WithWorkflow<T>, currentUser: WorkflowCurrentUser, payload?: unknown, comment?: string): Promise<TransitionExecutionResult<T>>;
+    /**
+     * Execute transition on multiple entities
+     */
+    abstract executeBulkTransition(definition: WorkflowDefinition<T>, transitionId: TransitionId, entities: WithWorkflow<T>[], currentUser: WorkflowCurrentUser, payload?: unknown): Promise<BulkTransitionResult<T>>;
+    /**
+     * Get available transitions from the current state
+     */
+    abstract getAvailableTransitions(definition: WorkflowDefinition<T>, entity: WithWorkflow<T>, currentUser: WorkflowCurrentUser): WorkflowTransition<T>[];
+    /**
+     * Get the current state definition for an entity
+     */
+    abstract getCurrentState(definition: WorkflowDefinition<T>, entity: WithWorkflow<T>): WorkflowState | undefined;
+    /**
+     * Get a state definition by ID
+     */
+    abstract getState(definition: WorkflowDefinition<T>, stateId: StateId): WorkflowState | undefined;
+    /**
+     * Get the initial state for a workflow
+     */
+    abstract getInitialState(definition: WorkflowDefinition<T>): WorkflowState | undefined;
+    /**
+     * Create initial workflow summary for a new entity
+     */
+    abstract createInitialSummary(definition: WorkflowDefinition<T>, userId: string): WorkflowSummary;
+    /**
+     * Check if entity is in a final state
+     */
+    abstract isFinalState(definition: WorkflowDefinition<T>, entity: WithWorkflow<T>): boolean;
+}
+
+export { APP_BOOTSTRAP_CONFIG, AUDIT_FEATURE_KEY, AUTHENTICATION_STORE_SERVICE_TOKEN, AUTHENTICATION_STORE_VIEW_TOKEN, AuditService, AuthenticationService, AuthenticationStoreService, CLOUD_SERVICE_TOKEN, CloudService, DEFAULT_APP_BOOTSTRAP_CONFIG, DEFAULT_FIREBASE_AUTH_CONFIG, DEFAULT_FIREBASE_CONFIG, DEFAULT_LANGUAGE_TOKEN, DEFAULT_NOTIFICATION_CONFIG, DOCUMENTS_KEYS, DateTimePipeBase, DateUtil, EMAIL_CONFIG, EmailService, EntityAdapter, EntityEffect, EntityFormLogic, EntityRepository, ErrorType, ErrorUtilService, FIREBASE_AUTH_CONFIG, FIREBASE_CONFIG, FIRESTORE_ENGINE_CREATOR, I18nService, I18nUtil, KError, LANGUAGES_TOKEN, LOGGER_ENVIRONMENT, LanguagesEnum, Logger, NOTIFICATION_CONFIG_TOKEN, Repository, RepositoryEngine, StorageEngine, WORKFLOW_HISTORY_FEATURE_KEY, WorkflowEngine, allIcons, customSvgIcons, initialAuthState, materialIcons, primeIcon, provideAppBootstrapConfig, provideFirebaseAuthConfig, provideNotificationConfig };
+export type { AppBootstrapConfig, Audit, AuditAction, AuditEntity, AuditEntityAdd, AuditEntityUpdate, AuditLog, AuditLogQuery, AuditLogStats, AuditMetadata, AuditModel, AuditModelAdd, AuditModelUpdate, AuditResource, AuditResult, AuthCredentials, AuthErrorCode, AuthMethod, AuthProvider, AuthResult, AuthState, AuthUser, AuthenticationStoreView, AuthorizationContext, AuthorizationOptions, BatchOperation, BootstrapStatusResult, BulkTransitionResult, CanExecuteTransitionResult, CloudFunctionResult, CollectionPathBuilder, CreateUserAndSendPasswordResetResult, CreateUserData, CreateUserRequest, CreateUserResponse, CustomEntityState, EmailConfig, EmailPasswordCredentials, Entity, EntityActions, EntityAdd, EntityCollectionStoreView, EntityConfig, EntityFormStoreView, EntityHelper, EntityModel, EntityModelAdd, EntityModelUpdate, EntitySignals, EntityStore, EntityStoreView, EntityTableResourceStoreView, EntityTableStoreView, EntityType, EntityUpdate, ErrorOptions, FirebaseAuthConfig, FirebaseConfig, HashMapModel, I18nConfig, I18nText, Icon, IconType, LoaderData, Localizable, LogDataOperationOptions, LogEntry, LogLevel, LogMethodOptions, LogUIActionOptions, LogUserActionOptions, LoggerConfig, LoggerEnvironmentConfig, NotificationConfig, Permission, RepositoryEngineCreator, Role, Rule, RuleCondition, RuleConflict, RuleEffectBase, RuleEvaluationContext, RuleEvaluationResult, RuleTarget, RuleValidationError, RuleValidationResult, RuleWhen, RxEntityActions, SendPasswordResetEmailData, SessionConfig, StateId, StorageDeleteOptions, StorageError, StorageFile, StorageListOptions, StorageListResult, StorageUploadOptions, StorageUploadProgress, SubcollectionContext, TimeAsDateRange, TimeAsString, TransitionExecutionResult, TransitionId, UserConfig, UserRegistrationData, WelcomeEmailData, WelcomeEmailDataWithConfig, WithWorkflow, WorkflowActionFn, WorkflowCurrentUser, WorkflowDefinition, WorkflowGuardFn, WorkflowHistoryEntry, WorkflowHistoryEntryAdd, WorkflowHistoryEntryData, WorkflowHistoryEntryUpdate, WorkflowHistoryModel, WorkflowHistoryModelAdd, WorkflowId, WorkflowState, WorkflowSummary, WorkflowTransition, WorkflowTransitionContext, Workflowable };