@wildo-ai/saas-backend-lib 1.0.1

package/dist/esm/runtime/services/start-application.backend.service.js

@@ -0,0 +1,977 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import 'reflect-metadata';
+import { injectable, inject } from 'inversify';
+import { ErrorType, ErrorCustomMessageReference, FeatureUnavailabilityBehavior, FeatureUnavailabilityReason, BILLING_RESOURCE_TYPES, BILLING_SCOPE_RESOURCE_TYPES, BILLING_SCOPES, LIFECYCLE_RESOURCE_TYPES, ActivationCriterionType } from '@wildo-ai/saas-models';
+import { SAAS_SERVICE_TYPES } from '../../inject/models/service-types.js';
+import { LoggerService } from '../../monitoring/logger/services/logger.service.js';
+import { AppConfigurationService } from '../../config/services/app-configuration.backend.service.js';
+import { ApplicationStartupConfigValidatorService } from '../../config/services/application-startup-config-validator.backend.service.js';
+import { ResourcesRegistryBackendService } from '../../resources/services/resources-registry.backend.service.js';
+import { ExternalProvidersRegistryBackendService } from '../../external-providers/services/external-providers-registry.backend.service.js';
+import { LazyProviderRegistryBackendService } from '../../external-providers/services/lazy-provider-registry.backend.service.js';
+import { CapabilityBindingsBackendService } from '../../external-providers/services/feature-bindings.backend.service.js';
+import { FeatureDefinitionRegistryBackendService } from '../../features/services/feature-definition-registry.backend.service.js';
+import { MilestoneDefinitionRegistryBackendService } from '../../guidance/services/milestone-definition-registry.backend.service.js';
+import { MilestoneConditionRegistryBackendService } from '../../guidance/services/milestone-condition-registry.backend.service.js';
+import { LifecycleEvaluatorBackendService } from '../../guidance/services/lifecycle-evaluator.backend.service.js';
+import { initializeLifecycleCustomImplementations } from '../../guidance/services/lifecycle-custom-implementations.backend.js';
+import { createDormancyDetectionBatch, DORMANCY_DETECTION_BATCH_REF } from '../../guidance/batches/dormancy-detection.batch.backend.service.js';
+import { FlowsActorsRegistryService } from '../../flows-actors/services/flows-actors-registry.service.js';
+import { RepositoriesRegistryHandlerBackendService } from '../../base-classes/services/repositories/repositories-registry-handler.backend.service.js';
+import { ServicesRegistryHandlerBackendService } from '../../base-classes/services/services/services-registry-handler.backend.service.js';
+import { ControllersRegistryHandlerBackendService } from '../../base-classes/services/controllers/controllers-registry-handler.backend.service.js';
+import { getManualControllersBackend } from '../../base-classes/models/manual-controllers.backend.definition.js';
+import { HttpServerBackendService } from './http-server.backend.service.js';
+import { ErrorBuilderBackendService } from '../../errors/services/error-builder.backend.service.js';
+import { ErrorHandlerService } from '../../errors/services/error-handler.backend.service.js';
+import { AuthorizationsBackendService } from '../../security/authorizations/services/authorizations.backend.service.js';
+import { BatchesCronjobsExecutor_BackendService } from '../../base-classes/services/batches/batches-cronjobs-executor.backend.service.js';
+import { ExecutionContextCreatorBackendService } from '../../runtime/services/execution-context-creator.backend.service.js';
+import { ResourceOperationCustomImplementationRegistryBackendService } from '../../base-classes/services/services/resource-operation-custom-implementation-registry.backend.service.js';
+import { CoreBackend_ServiceImplementationsFactories } from '../../resources/models/custom-service-implementations.backend.definition.js';
+import { createFilesCleanupBatch, FILES_CLEANUP_BATCH_REF } from '../../files/batches/files-cleanup.batch.backend.service.js';
+import { createConsumableTokensCleanupBatch, CONSUMABLE_TOKENS_CLEANUP_BATCH_REF } from '../../security/consumable-tokens/batches/consumable-tokens-cleanup.batch.backend.service.js';
+import { createAnonymousSessionCleanupBatch, ANONYMOUS_SESSION_CLEANUP_BATCH_REF } from '../../security/authentications/batches/anonymous-session-cleanup.batch.backend.service.js';
+import { MongoDBService } from '../../databases/services/mongodb.service.js';
+import { RedisService } from '../../databases/services/redis.service.js';
+import { I18nBackendService } from '../../i18n/services/i18n.backend.service.js';
+import { FileStorageRouterBackendService } from '../../files/storage/file-storage-router.backend.service.js';
+import { QueueWorkerInitializerBackendService } from '../../queue/queue-worker-initializer.backend.service.js';
+import { CronJobSyncBackendService } from '../../queue/cron-job-sync.backend.service.js';
+import { initializeBillingCustomImplementations, registerBillingPostOperationHooks, setBillingWebSocketService } from '../../billing/services/custom-impl/billing-custom-implementations.backend.js';
+import { BillingWebhookAdapter } from '../../billing/services/webhooks/billing-webhook-adapter.backend.service.js';
+import { BillingWebhookCapabilityHandler } from '../../billing/services/webhooks/billing-webhook-capability-handler.backend.service.js';
+import { BillingWebhookEventRouterBackendService } from '../../billing/services/webhooks/billing-webhook-event-router.backend.service.js';
+import { ChartRegistryBackendService } from '../../charts/services/chart-registry.backend.service.js';
+import { GuidanceTriggerEvaluatorBackendService } from '../../guidance/services/guidance-trigger-evaluator.backend.service.js';
+import { EmailTemplateRegistryBackendService } from '../../notifications/email/services/email-template-registry.backend.service.js';
+/**
+ * Start Application Backend Service
+ *
+ * Orchestrates the initialization of the backend application by:
+ * 1. Initializing application configuration
+ * 1.5. Initializing roles configuration (defaults + custom roles)
+ * 2. Initializing resources registry with all 4 sources
+ * 3. Initializing repositories registry with mongoose models
+ * 4. Initializing services registry with business logic layer
+ * 5. Initializing controllers registry with HTTP endpoints layer
+ * 6. Initializing HTTP server with Express.js and middleware
+ * 7. Validating all components are properly initialized
+ *
+ * This service ensures proper startup sequence and dependency management.
+ */
+let StartApplicationBackendService = class StartApplicationBackendService {
+    logger;
+    appConfigService;
+    applicationStartupConfigValidator;
+    resourcesRegistryService;
+    repositoriesRegistryService;
+    servicesRegistryService;
+    controllersRegistryService;
+    httpServerService;
+    errorBuilder;
+    errorHandler;
+    authorizationsService;
+    batchesExecutor;
+    executionContextCreatorBackendService;
+    customImplRegistry;
+    mongoDBService;
+    redisService;
+    i18nService;
+    externalProvidersRegistryService;
+    lazyProviderRegistryService;
+    capabilityBindingsService;
+    featureDefinitionRegistryService;
+    milestoneDefinitionRegistry;
+    milestoneConditionRegistry;
+    lifecycleEvaluator;
+    flowsActorsRegistryService;
+    queueWorkerInitializer;
+    cronJobSyncService;
+    chartRegistryService;
+    guidanceTriggerEvaluator;
+    emailTemplateRegistryService;
+    fileStorageRouter;
+    logDebug;
+    isInitialized = false;
+    isPlatformMode = false;
+    constructor(logger, appConfigService, applicationStartupConfigValidator, resourcesRegistryService, repositoriesRegistryService, servicesRegistryService, controllersRegistryService, httpServerService, errorBuilder, errorHandler, authorizationsService, batchesExecutor, executionContextCreatorBackendService, customImplRegistry, mongoDBService, redisService, i18nService, externalProvidersRegistryService, lazyProviderRegistryService, capabilityBindingsService, featureDefinitionRegistryService, milestoneDefinitionRegistry, milestoneConditionRegistry, lifecycleEvaluator, flowsActorsRegistryService, queueWorkerInitializer, cronJobSyncService, chartRegistryService, guidanceTriggerEvaluator, emailTemplateRegistryService, fileStorageRouter) {
+        this.logger = logger;
+        this.appConfigService = appConfigService;
+        this.applicationStartupConfigValidator = applicationStartupConfigValidator;
+        this.resourcesRegistryService = resourcesRegistryService;
+        this.repositoriesRegistryService = repositoriesRegistryService;
+        this.servicesRegistryService = servicesRegistryService;
+        this.controllersRegistryService = controllersRegistryService;
+        this.httpServerService = httpServerService;
+        this.errorBuilder = errorBuilder;
+        this.errorHandler = errorHandler;
+        this.authorizationsService = authorizationsService;
+        this.batchesExecutor = batchesExecutor;
+        this.executionContextCreatorBackendService = executionContextCreatorBackendService;
+        this.customImplRegistry = customImplRegistry;
+        this.mongoDBService = mongoDBService;
+        this.redisService = redisService;
+        this.i18nService = i18nService;
+        this.externalProvidersRegistryService = externalProvidersRegistryService;
+        this.lazyProviderRegistryService = lazyProviderRegistryService;
+        this.capabilityBindingsService = capabilityBindingsService;
+        this.featureDefinitionRegistryService = featureDefinitionRegistryService;
+        this.milestoneDefinitionRegistry = milestoneDefinitionRegistry;
+        this.milestoneConditionRegistry = milestoneConditionRegistry;
+        this.lifecycleEvaluator = lifecycleEvaluator;
+        this.flowsActorsRegistryService = flowsActorsRegistryService;
+        this.queueWorkerInitializer = queueWorkerInitializer;
+        this.cronJobSyncService = cronJobSyncService;
+        this.chartRegistryService = chartRegistryService;
+        this.guidanceTriggerEvaluator = guidanceTriggerEvaluator;
+        this.emailTemplateRegistryService = emailTemplateRegistryService;
+        this.fileStorageRouter = fileStorageRouter;
+        this.logger = logger;
+        this.appConfigService = appConfigService;
+        this.resourcesRegistryService = resourcesRegistryService;
+        this.repositoriesRegistryService = repositoriesRegistryService;
+        this.servicesRegistryService = servicesRegistryService;
+        this.controllersRegistryService = controllersRegistryService;
+        this.httpServerService = httpServerService;
+        this.authorizationsService = authorizationsService;
+        this.logDebug = this.logger.debugByType('StartApplicationBackendService');
+        this.logger.setDebugTypeLogging('StartApplicationBackendService', false);
+        this.logDebug('Start application service created');
+    }
+    /**
+     * Initialize the backend application with a structured configuration object.
+     */
+    async initialize(config) {
+        if (this.isInitialized) {
+            this.logDebug('Application already initialized, skipping');
+            return;
+        }
+        const { sharedResourceConfigurations, sharedResourceFieldIdentifiers, sharedResourceRelationships, backendResourceConfigurations, backendResourceFieldIdentifiers, backendResourceRelationships = [], customServiceImplementations, customRoles, customControllers, container, controllerWhiteList, isPlatformApplication = false, customBatchesFactory, flowsActorsRegistry, customLabels, providerCatalog, customFeatureDefinitions, customFeatureConfiguration, chartDefinitions, customMilestoneDefinitions, customMilestoneConditions, productDefinitions, emailTemplateDefinitions, backendConfig, guidanceFlowDefinitions, } = config;
+        try {
+            this.logDebug('🚀 Starting backend application initialization...');
+            // Step 1: Initialize application configuration
+            this.logDebug('📋 Initializing application configuration...');
+            // Persist platform mode for validation differences
+            this.isPlatformMode = !!isPlatformApplication;
+            if (!isPlatformApplication) {
+                await this.appConfigService.initialize();
+                this.appConfigService.applyBackendConfig(backendConfig ?? {});
+                if (backendConfig) {
+                    this.logger.info('Backend config applied', {
+                        sections: Object.keys(backendConfig),
+                    });
+                }
+                this.appConfigService.assertNoPreOverridePlaceholders();
+                this.logDebug('✅ Application configuration initialized successfully');
+                // Establish default MongoDB connection using loaded app secrets
+                try {
+                    await this.mongoDBService.connect();
+                    this.logDebug('✅ MongoDB default connection established');
+                }
+                catch (e) {
+                    this.logger.error('❌ MongoDB default connection failed', e);
+                    throw e;
+                }
+                // Establish Redis connection for caching, sessions, and WebSocket sync
+                // Redis is optional - graceful fallback to in-memory if unavailable
+                try {
+                    await this.redisService.connect();
+                    this.logDebug('✅ Redis connection established');
+                }
+                catch (e) {
+                    this.logger.warn('⚠️ Redis connection failed, using in-memory fallbacks', { error: e instanceof Error ? e.message : String(e) });
+                }
+                // Initialize file storage (MinIO/S3) — optional, skipped when not configured
+                if (this.fileStorageRouter.isConfigured()) {
+                    try {
+                        await this.fileStorageRouter.initialize();
+                        this.logDebug('✅ File storage initialized');
+                    }
+                    catch (e) {
+                        this.logger.warn('⚠️ File storage initialization failed, file operations will fail at runtime', { error: e instanceof Error ? e.message : String(e) });
+                    }
+                }
+                else {
+                    this.logDebug('📦 File storage not configured, skipping initialization');
+                }
+            }
+            if (!isPlatformApplication) {
+                this.applicationStartupConfigValidator.validate(this.appConfigService.config);
+            }
+            // Step 1.5: Initialize roles configuration
+            this.logDebug('🔐 Initializing roles configuration...');
+            if (customRoles) {
+                this.authorizationsService.initializeRolesWithCustom(customRoles);
+                this.logDebug('✅ Roles configuration initialized with custom roles');
+            }
+            else {
+                // Roles are already initialized with defaults in the constructor
+                this.logDebug('✅ Roles configuration using default roles only');
+            }
+            // Step 2: Initialize resources registry with all 4 sources
+            this.logDebug('🔧 Initializing resources registry...');
+            // Read lifecycle config early — needed for both resource exclusion and evaluator init
+            // Platform apps don't use lifecycle, billing, or feature gating
+            const lifecycleConfig = isPlatformApplication ? undefined : this.appConfigService.config?.lifecycle;
+            // Compute excluded resource types based on app configuration.
+            // When billing/lifecycle is disabled, their resource types are excluded
+            // from the registry (no routes, no repositories, no frontend resources).
+            // When billing IS enabled, scope variants for scopes not in enabledScopes
+            // are also excluded (e.g., USER variants when only ORG billing is enabled).
+            const excludedResourceTypes = (() => {
+                if (isPlatformApplication)
+                    return undefined;
+                const excluded = new Set();
+                const billingConfig = this.appConfigService.config?.billing;
+                if (!billingConfig?.enabled) {
+                    BILLING_RESOURCE_TYPES.forEach(t => excluded.add(t));
+                }
+                else {
+                    // Billing is enabled — exclude variants for scopes NOT in enabledScopes.
+                    // Non-polymorphic resources (Products, Prices, etc.) are always kept.
+                    const enabledScopesSet = new Set(billingConfig.enabledScopes ?? []);
+                    for (const scope of BILLING_SCOPES) {
+                        if (!enabledScopesSet.has(scope)) {
+                            const scopeTypes = BILLING_SCOPE_RESOURCE_TYPES[scope];
+                            if (scopeTypes) {
+                                scopeTypes.forEach(t => excluded.add(t));
+                            }
+                        }
+                    }
+                }
+                if (!lifecycleConfig?.enabled) {
+                    LIFECYCLE_RESOURCE_TYPES.forEach(t => excluded.add(t));
+                }
+                return excluded.size > 0 ? excluded : undefined;
+            })();
+            if (excludedResourceTypes) {
+                this.logDebug(`Feature-gated resources excluded: ${excludedResourceTypes.size} types`, {
+                    billingDisabled: !this.appConfigService.config?.billing?.enabled,
+                    billingDisabledScopes: (() => {
+                        const billingConfig = this.appConfigService.config?.billing;
+                        if (!billingConfig?.enabled)
+                            return 'all';
+                        const enabledSet = new Set(billingConfig.enabledScopes ?? []);
+                        return BILLING_SCOPES.filter(s => !enabledSet.has(s));
+                    })(),
+                    lifecycleDisabled: !lifecycleConfig?.enabled,
+                });
+            }
+            await this.resourcesRegistryService.initialize(sharedResourceConfigurations, sharedResourceFieldIdentifiers, sharedResourceRelationships, (backendResourceConfigurations ?? {}), backendResourceFieldIdentifiers, backendResourceRelationships, undefined, // customNotificationBadgeDefinitions
+            undefined, // customAdditionalUserNotificationDefinitions
+            excludedResourceTypes);
+            this.logDebug('✅ Resources registry initialized successfully');
+            // Step 2.0.1: Initialize feature definition registry
+            this.logDebug('🏷️ Initializing feature definition registry...');
+            this.featureDefinitionRegistryService.registerCoreFeatures();
+            if (customFeatureDefinitions && customFeatureDefinitions.length > 0) {
+                this.featureDefinitionRegistryService.registerCustomFeatures(customFeatureDefinitions);
+            }
+            this.featureDefinitionRegistryService.validateDefinitions();
+            this.featureDefinitionRegistryService.logStartupSummary();
+            // Build and set the merged FeatureConfiguration (profiles + policy)
+            if (customFeatureConfiguration) {
+                const allDefinitions = this.featureDefinitionRegistryService.getAllDefinitions();
+                this.featureDefinitionRegistryService.setConfiguration({
+                    definitions: allDefinitions,
+                    profiles: customFeatureConfiguration.profiles ?? {},
+                    defaultProfile: customFeatureConfiguration.defaultProfile,
+                    unavailabilityPolicy: {
+                        defaultBehavior: customFeatureConfiguration.unavailabilityPolicy?.defaultBehavior ?? FeatureUnavailabilityBehavior.UPGRADE_PROMPT,
+                        whenBillingDisabled: customFeatureConfiguration.unavailabilityPolicy?.whenBillingDisabled ?? FeatureUnavailabilityBehavior.HIDE,
+                        roleDefaults: customFeatureConfiguration.unavailabilityPolicy?.roleDefaults ?? {},
+                        reasonDefaults: customFeatureConfiguration.unavailabilityPolicy?.reasonDefaults ?? {
+                            [FeatureUnavailabilityReason.FEATURE_NOT_ENABLED]: FeatureUnavailabilityBehavior.UPGRADE_PROMPT,
+                            [FeatureUnavailabilityReason.LIMIT_EXCEEDED]: FeatureUnavailabilityBehavior.LIMIT_UPGRADE_PROMPT,
+                            [FeatureUnavailabilityReason.NOT_CONFIGURED]: FeatureUnavailabilityBehavior.HIDE,
+                        },
+                    },
+                });
+                this.logDebug('✅ Feature configuration set (profiles + unavailability policy)');
+            }
+            const analyticsValueMoments = this.appConfigService.isInitialized()
+                ? this.appConfigService.config.analytics?.valueMoments
+                : undefined;
+            this.featureDefinitionRegistryService.warnMisplacedLimitFeatures();
+            this.featureDefinitionRegistryService.warnInvalidFeatureReferences({
+                featureProfiles: customFeatureConfiguration?.profiles,
+                chartDefinitions,
+                guidanceFlowDefinitions,
+                productDefinitions,
+                analyticsValueMoments,
+            });
+            this.logDebug('✅ Feature definition registry initialized successfully');
+            // Step 2.0.2: Initialize milestone definition registry
+            this.logDebug('🏅 Initializing milestone definition registry...');
+            if (customMilestoneConditions && customMilestoneConditions.length > 0) {
+                for (const { ref, fn } of customMilestoneConditions) {
+                    this.milestoneConditionRegistry.registerCondition(ref, fn);
+                }
+                this.logDebug(`Registered ${customMilestoneConditions.length} custom milestone condition(s)`);
+            }
+            if (customMilestoneDefinitions && customMilestoneDefinitions.length > 0) {
+                this.milestoneDefinitionRegistry.registerCustomMilestones(customMilestoneDefinitions);
+                this.milestoneDefinitionRegistry.validateDefinitions();
+                this.milestoneDefinitionRegistry.logStartupSummary();
+            }
+            this.logDebug('✅ Milestone definition registry initialized successfully');
+            // Step 2.0.3: Initialize lifecycle evaluator configuration
+            if (!isPlatformApplication && lifecycleConfig?.enabled) {
+                this.logDebug('🔄 Initializing lifecycle evaluator...');
+                this.lifecycleEvaluator.setLifecycleConfig(lifecycleConfig);
+                // Late-binding initialization for lifecycle custom implementations
+                initializeLifecycleCustomImplementations(this.lifecycleEvaluator, lifecycleConfig, this.errorBuilder);
+                // Validate activation criteria refs against registries
+                if (lifecycleConfig.activationCriteria?.criteria) {
+                    for (const criterion of lifecycleConfig.activationCriteria.criteria) {
+                        if (criterion.criterionType === ActivationCriterionType.MILESTONE) {
+                            const exists = !!this.milestoneDefinitionRegistry.getDefinition(criterion.milestoneRef);
+                            if (!exists) {
+                                this.logger.warn(`Lifecycle activation criterion references unknown milestone: '${criterion.milestoneRef}'`);
+                            }
+                        }
+                        else if (criterion.criterionType === ActivationCriterionType.GUIDANCE_COMPLETED) {
+                            this.logDebug(`Lifecycle activation criterion references guidance flow: '${criterion.guidanceFlowRef}' (validated at runtime)`);
+                        }
+                    }
+                }
+                this.logDebug('✅ Lifecycle evaluator configured', {
+                    dormancyThresholdDays: lifecycleConfig.dormancyThresholdDays,
+                    activityDebounceMinutes: lifecycleConfig.activityDebounceMinutes,
+                    dormancyCronSchedule: lifecycleConfig.dormancyCronSchedule,
+                    activationCriteriaCount: lifecycleConfig.activationCriteria?.criteria?.length ?? 0,
+                });
+            }
+            else if (!isPlatformApplication) {
+                this.logDebug('🔄 Lifecycle system disabled (lifecycle.enabled = false or not configured)');
+            }
+            // Step 2.1: Initialize lazy provider registry (on-demand provider definitions)
+            if (providerCatalog) {
+                this.logDebug('📦 Initializing lazy provider registry with catalog...');
+                await this.lazyProviderRegistryService.initialize(providerCatalog);
+                this.logDebug('✅ Lazy provider registry initialized successfully');
+            }
+            else {
+                this.logDebug('📦 Skipping lazy provider registry (no catalog provided)');
+            }
+            // Step 2.2: Initialize capability bindings + external providers registry
+            // Order matters: bindings compute the registry from policy, then registry consumes it.
+            // Skip for platform applications - they initialize config later and will refresh the registry
+            if (!isPlatformApplication) {
+                this.logDebug('🎯 Initializing feature bindings service...');
+                await this.capabilityBindingsService.initialize();
+                this.logDebug('✅ Feature bindings service initialized successfully');
+                this.logDebug('🔌 Initializing external providers registry...');
+                await this.externalProvidersRegistryService.initialize();
+                this.logDebug('✅ External providers registry initialized successfully');
+            }
+            else {
+                this.logDebug('🔌 Skipping external providers registry initialization (platform app - will initialize after config is ready)');
+            }
+            // Step 2.3: Initialize flows-actors registry
+            this.logDebug('🎭 Initializing flows-actors registry...');
+            const mergedFlowActorSystemsFactoryMap = {
+                ...(flowsActorsRegistry?.flowActorSystemsFactoryMap || {}),
+            };
+            const mergedAgents = [
+                ...(flowsActorsRegistry?.agents || []),
+            ];
+            await this.flowsActorsRegistryService.initialize(mergedFlowActorSystemsFactoryMap, mergedAgents);
+            this.logDebug('✅ Flows-actors registry initialized successfully');
+            if (!isPlatformApplication) {
+                this.logDebug('🧭 Validating initialized runtime contracts...');
+                this.applicationStartupConfigValidator.validateInitializedRuntimeContracts();
+                this.logDebug('✅ Initialized runtime contracts validated successfully');
+            }
+            // Step 2.4: Initialize I18n service with custom labels
+            this.logDebug('🌐 Initializing I18n service...');
+            this.i18nService.initialize(customLabels || {}, {
+                suppressEmptyWarning: isPlatformApplication,
+            });
+            this.logDebug('✅ I18n service initialized successfully');
+            // Step 2.4b: Initialize email template registry
+            if (emailTemplateDefinitions && Object.keys(emailTemplateDefinitions).length > 0) {
+                this.emailTemplateRegistryService.initialize(emailTemplateDefinitions);
+            }
+            // Step 2.5: Register chart definitions
+            if (chartDefinitions && chartDefinitions.length > 0) {
+                this.logDebug('📊 Registering chart definitions...', { count: chartDefinitions.length });
+                for (const chartDef of chartDefinitions) {
+                    this.chartRegistryService.registerChart(chartDef);
+                }
+                this.logDebug('✅ Chart definitions registered successfully', { count: chartDefinitions.length });
+            }
+            else {
+                this.logDebug('📊 No chart definitions provided, skipping chart registration');
+            }
+            // Step 2.5b: Register guidance flow definitions
+            if (guidanceFlowDefinitions && guidanceFlowDefinitions.length > 0) {
+                this.logDebug('🧭 Registering guidance flow definitions...', { count: guidanceFlowDefinitions.length });
+                this.guidanceTriggerEvaluator.initializeFlows(guidanceFlowDefinitions);
+                this.logDebug('✅ Guidance flow definitions registered successfully', { count: guidanceFlowDefinitions.length });
+            }
+            else {
+                this.logDebug('🧭 No guidance flow definitions provided, skipping guidance registration');
+            }
+            // Step 2.6: Debug URL generation
+            this.logDebug('🌐 Displaying generated URLs for debugging...');
+            this.resourcesRegistryService.debugDisplayGeneratedUrls();
+            // Step 3: Initialize repositories registry
+            this.logDebug('🗄️ Initializing repositories registry...');
+            const resourcesRegistry = this.resourcesRegistryService.getResourcesRegistry();
+            const resourceConfigurations = new Map(Object.entries(resourcesRegistry.resourceConfigurations));
+            // Initialize repositories registry on the active default connection
+            const activeConnection = this.mongoDBService.getConnection();
+            await this.repositoriesRegistryService.initializeRepositories(resourceConfigurations, activeConnection || undefined);
+            this.logDebug('✅ Repositories registry initialized successfully');
+            // Step 2.1: Initialize custom service implementations registry (backend defaults)
+            this.customImplRegistry.initialize([...CoreBackend_ServiceImplementationsFactories, ...customServiceImplementations]);
+            // Step 4: Initialize services registry (business logic layer)
+            this.logDebug('🏢 Initializing services registry...');
+            await this.servicesRegistryService.initializeServices();
+            this.logDebug('✅ Services registry initialized successfully');
+            // Step 4.5: Initialize billing services (if enabled)
+            if (!isPlatformApplication && this.appConfigService.config?.billing?.enabled && container) {
+                await this.initializeBillingServices(container, this.appConfigService.config.billing, productDefinitions);
+            }
+            // Step 4.6: Initialize webhook auto-controller (must happen before controllers registry)
+            if (!isPlatformApplication && container) {
+                await this.initializeWebhookAutoController(container);
+            }
+            // Step 5: Initialize controllers registry (HTTP endpoints layer)
+            this.logDebug('🌐 Initializing controllers registry...');
+            // Get manual controllers from provided container
+            let allCustomControllers = [];
+            if (container) {
+                // G-4: directoryProvisioningEnabled moved to organizationTypes[t].scimProvisioning — hardcode false until migration
+                const directoryProvisioningEnabled = false;
+                const analyticsEnabled = isPlatformApplication ? false : !!this.appConfigService.config?.analytics?.enabled;
+                const manualControllers = isPlatformApplication ? [] : getManualControllersBackend(container, { directoryProvisioningEnabled, analyticsEnabled });
+                allCustomControllers = [
+                    ...manualControllers,
+                    ...(customControllers || [])
+                ];
+                this.logDebug('📋 Controllers to register', {
+                    manualControllers: manualControllers.length,
+                    runtimeCustomControllers: customControllers?.length || 0,
+                    totalCustomControllers: allCustomControllers.length
+                });
+            }
+            else {
+                allCustomControllers = customControllers || [];
+                this.logDebug('📋 Controllers to register', {
+                    manualControllers: 0,
+                    runtimeCustomControllers: customControllers?.length || 0,
+                    totalCustomControllers: allCustomControllers.length
+                });
+            }
+            if (!isPlatformApplication) {
+                await this.controllersRegistryService.initialize(allCustomControllers.length > 0 ? allCustomControllers : undefined, controllerWhiteList);
+                this.logDebug('✅ Controllers registry initialized successfully');
+            }
+            else {
+                this.logDebug('Skipping controllers registry initialization in platform mode (will be started by apps-manager)');
+            }
+            // Step 5.5: Initialize batches/cronjobs (core engine + custom + resource-based)
+            this.logDebug('🧵 Initializing batches & cronjobs...');
+            const customBatches = customBatchesFactory
+                ? customBatchesFactory({
+                    logger: this.logger,
+                    errorBuilder: this.errorBuilder,
+                    errorHandler: this.errorHandler,
+                    executionContextCreatorService: this.executionContextCreatorBackendService,
+                    resourcesRegistryService: this.resourcesRegistryService,
+                    repositoriesRegistryService: this.repositoriesRegistryService,
+                    servicesRegistryService: this.servicesRegistryService,
+                })
+                : new Map();
+            // Register core engine batches (always present, independent of custom app)
+            customBatches.set(FILES_CLEANUP_BATCH_REF, createFilesCleanupBatch());
+            customBatches.set(CONSUMABLE_TOKENS_CLEANUP_BATCH_REF, createConsumableTokensCleanupBatch());
+            if (this.appConfigService.anonymousSessionsEnabled) {
+                customBatches.set(ANONYMOUS_SESSION_CLEANUP_BATCH_REF, createAnonymousSessionCleanupBatch());
+                this.logDebug('✅ Anonymous session cleanup batch registered');
+            }
+            // Register lifecycle dormancy detection batch (only when lifecycle is enabled)
+            if (lifecycleConfig?.enabled) {
+                customBatches.set(DORMANCY_DETECTION_BATCH_REF, createDormancyDetectionBatch(lifecycleConfig.dormancyCronSchedule));
+                this.logDebug('✅ Dormancy detection batch registered', { cronSchedule: lifecycleConfig.dormancyCronSchedule });
+            }
+            await this.batchesExecutor.initialize(customBatches);
+            this.logDebug('✅ Batches & cronjobs initialized');
+            // Step 6: Initialize HTTP server (skip here in platform mode; apps-manager will start it later)
+            if (!this.isPlatformMode) {
+                this.logger.info('🌍 Initializing HTTP server...');
+                try {
+                    await this.httpServerService.initialize();
+                    this.logger.info('✅ HTTP server initialized successfully');
+                }
+                catch (error) {
+                    this.logger.error('❌ HTTP server initialization failed:', error);
+                    throw error;
+                }
+            }
+            else {
+                this.logDebug('Skipping HTTP server initialization in platform mode (will be started by apps-manager)');
+            }
+            // Step 7: Initialize queue workers (for background job processing)
+            if (!this.isPlatformMode) {
+                this.logger.info('🐰 Initializing queue workers...');
+                try {
+                    await this.queueWorkerInitializer.initialize();
+                    this.logger.info('✅ Queue workers initialized (if RabbitMQ configured)');
+                }
+                catch (error) {
+                    // Queue workers failing shouldn't prevent app from starting
+                    this.logger.warn('⚠️ Queue worker initialization skipped or failed:', error);
+                }
+                // Step 7.5: Sync cron jobs to crontabs-batches-manager
+                this.logger.info('🕐 Syncing cron jobs to crontabs-manager...');
+                try {
+                    // Initialize the sync service
+                    this.cronJobSyncService.initialize();
+                    // Sync cron jobs (non-blocking - errors are logged but don't fail startup)
+                    await this.cronJobSyncService.syncCronJobsToManager();
+                    this.logger.info('✅ Cron job sync completed (if crontabs-manager configured)');
+                }
+                catch (error) {
+                    // Cron sync failing shouldn't prevent app from starting
+                    this.logger.warn('⚠️ Cron job sync skipped or failed:', error);
+                }
+            }
+            else {
+                this.logDebug('Skipping queue worker initialization in platform mode');
+            }
+            // Step 7.6: Run one-time SIEM DLQ migration (non-blocking)
+            try {
+                const siemService = container.get(SAAS_SERVICE_TYPES.SIEMWebhookDeliveryService);
+                if (siemService?.migrateRedisDLQToMongoDB) {
+                    await siemService.migrateRedisDLQToMongoDB();
+                }
+            }
+            catch (error) {
+                this.logger.warn('⚠️ SIEM DLQ migration skipped or failed:', error);
+            }
+            // Step 8: Validate initialization
+            await this.validateInitialization();
+            this.isInitialized = true;
+            // Step 8: Display debug information (after initialization is complete)
+            this.logDebug('📋 Displaying implemented Mongoose schemas...');
+            this.debugDisplayMongooseSchemas({
+                showSchemaStructure: true,
+                showIndexes: true,
+                maxFieldDepth: 2,
+            });
+            this.logDebug('🌐 Displaying registered routes...');
+            this.debugDisplayRegisteredRoutes();
+            this.logDebug('🎉 Backend application initialization completed successfully');
+        }
+        catch (error) {
+            this.logger.error('❌ Backend application initialization failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Initialize the webhook auto-controller with its dependencies.
+     * Must be called before controllers registry so that setupRoutes() can discover providers.
+     * Async because it pre-loads protocols from the lazy registry (ProtocolCatalogEntry only has loaders).
+     */
+    async initializeWebhookAutoController(container) {
+        try {
+            const webhookHandler = container.get(SAAS_SERVICE_TYPES.WebhookHandlerService);
+            const providerRegistry = container.get(SAAS_SERVICE_TYPES.LazyProviderRegistryService);
+            const webhookAutoController = container.get(SAAS_SERVICE_TYPES.WebhookAutoController);
+            await webhookAutoController.initialize(webhookHandler, providerRegistry);
+            this.logDebug('🔗 Webhook auto-controller initialized');
+        }
+        catch (error) {
+            // Non-fatal — if no webhook providers are registered, this is expected
+            this.logger.warn('Webhook auto-controller initialization skipped', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Initialize billing services when billing is enabled.
+     *
+     * Resolves the billing provider from the external connectors system
+     * and initializes all billing services (product catalog sync,
+     * usage metering, promotions, custom implementations) and wires up webhooks.
+     */
+    async initializeBillingServices(container, billingConfig, appProductDefinitions) {
+        this.logDebug('💳 Initializing billing services...');
+        try {
+            // 1. Resolve the billing provider via external connectors
+            const billingProvider = await this.resolveBillingProvider(billingConfig);
+            if (!billingProvider) {
+                this.logger.warn('⚠️ Billing is enabled but no provider could be resolved — billing services will NOT be initialized');
+                return;
+            }
+            // 2. Get billing services from DI container
+            const catalogSync = container.get(SAAS_SERVICE_TYPES.ProductCatalogSyncService);
+            const usageMetering = container.get(SAAS_SERVICE_TYPES.UsageMeteringService);
+            // 3. Product definitions from the custom app (like customRoles, customFeatureDefinitions)
+            const productDefinitions = appProductDefinitions ?? [];
+            // 4. Initialize services in dependency order
+            await catalogSync.initialize(productDefinitions, billingProvider);
+            await usageMetering.initialize(billingProvider);
+            // 4a. Sync product catalog to DB (ensures products/prices exist before billing state endpoint queries them)
+            try {
+                const syncResult = await catalogSync.syncProductCatalog();
+                this.logDebug('📦 Product catalog synced at startup', {
+                    synced: syncResult.synced,
+                    created: syncResult.created,
+                    updated: syncResult.updated,
+                    featuresDirty: syncResult.featuresDirty.length,
+                });
+            }
+            catch (syncError) {
+                this.logger.warn('⚠️ Product catalog startup sync failed (non-fatal)', {
+                    error: syncError instanceof Error ? syncError.message : String(syncError),
+                });
+            }
+            // 4b. Initialize billing custom implementations (late-binding for resource-centric operations)
+            const featureSync = container.get(SAAS_SERVICE_TYPES.BillingFeatureSyncService);
+            const billingStateService = container.get(SAAS_SERVICE_TYPES.BillingStateService);
+            initializeBillingCustomImplementations(billingProvider, featureSync, billingStateService, billingConfig, this.errorBuilder);
+            // 4c. Register post-operation hooks (feature sync fires automatically after subscription mutations)
+            registerBillingPostOperationHooks(this.servicesRegistryService);
+            // 5. Wire up billing webhooks
+            // The WebhookAutoControllerBackendService auto-registers routes from provider definitions,
+            // so we only need to register the adapter (verify+parse) and handler (dispatch).
+            const webhookHandler = container.get(SAAS_SERVICE_TYPES.WebhookHandlerService);
+            const webhookAutoController = container.get(SAAS_SERVICE_TYPES.WebhookAutoController);
+            const billingAdapter = new BillingWebhookAdapter(billingProvider, billingConfig.providerRef);
+            webhookHandler.registerAdapter(billingConfig.providerRef, 'billing', billingAdapter);
+            const webSocketService = container.get(SAAS_SERVICE_TYPES.WebSocketService);
+            setBillingWebSocketService(webSocketService);
+            const webhookEventRouter = new BillingWebhookEventRouterBackendService(this.servicesRegistryService, this.logger, webSocketService);
+            const billingCapabilityHandler = new BillingWebhookCapabilityHandler(webhookEventRouter);
+            webhookAutoController.registerCapabilityHandler(billingCapabilityHandler);
+            this.logDebug('✅ Billing services initialized successfully', {
+                providerRef: billingConfig.providerRef,
+                enabledScopes: billingConfig.enabledScopes,
+            });
+        }
+        catch (error) {
+            // Billing initialization failure is non-fatal: the app can still run without billing
+            this.logger.error('❌ Billing services initialization failed (billing will be unavailable)', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    /**
+     * Resolve the StandardBilling_Interface from the external providers system.
+     *
+     * Flow:
+     * 1. Get the billing providerRef from config (e.g., 'stripe')
+     * 2. Use the CapabilityBindingsService to check if billing capability is available
+     * 3. Load the billing protocol/transformer from the lazy provider registry
+     *
+     * Returns null if the provider cannot be resolved (e.g., no provider configured,
+     * connector not installed, credentials missing).
+     */
+    async resolveBillingProvider(billingConfig) {
+        const providerRef = billingConfig.providerRef;
+        if (!providerRef) {
+            this.logDebug('No billing providerRef configured');
+            return null;
+        }
+        try {
+            // Check if the provider exists in the lazy registry
+            if (!this.lazyProviderRegistryService.hasProvider(providerRef)) {
+                this.logDebug('Billing provider not found in catalog', { providerRef });
+                return null;
+            }
+            // Check if required SDK packages are installed (fail-fast for optional dependencies).
+            // Provider SDK packages (e.g., 'stripe') are optional peer dependencies of
+            // @wildo-ai/external-connectors. The consuming app must add them explicitly.
+            const sdkCheck = this.lazyProviderRegistryService.checkRequiredPackages(providerRef);
+            if (sdkCheck.available === false) {
+                const { missing } = sdkCheck;
+                this.logger.error(`Billing provider '${providerRef}' requires SDK packages that are not installed: [${missing.join(', ')}]. ` +
+                    `Add them to your app's dependencies: pnpm add ${missing.join(' ')}`, { providerRef, missingPackages: missing });
+                return null;
+            }
+            // Load the billing protocol from the lazy provider registry.
+            // The billing protocol should implement StandardBilling_Interface.
+            // This is loaded from the provider's registered protocol catalog entry
+            // for the 'REST_API' kind (billing operations are REST-based).
+            const protocol = await this.lazyProviderRegistryService.getProtocol(providerRef, 'REST_API');
+            if (!protocol) {
+                this.logDebug('No billing protocol found for provider', { providerRef });
+                return null;
+            }
+            // The protocol should expose a billing transformer that implements StandardBilling_Interface.
+            // Cast it — the concrete provider connector (e.g., Stripe) registers this interface
+            // when it registers its protocol in the provider catalog.
+            const billingInterface = protocol.billingInterface;
+            if (billingInterface) {
+                this.logDebug('Billing provider resolved from protocol', { providerRef });
+                return billingInterface;
+            }
+            // Fallback: the protocol itself may implement the interface directly
+            if (typeof protocol.createCustomer === 'function') {
+                this.logDebug('Billing provider resolved (protocol implements StandardBilling_Interface)', { providerRef });
+                return protocol;
+            }
+            this.logDebug('Billing protocol found but does not implement StandardBilling_Interface', { providerRef });
+            return null;
+        }
+        catch (error) {
+            this.logger.warn('Failed to resolve billing provider', {
+                providerRef,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return null;
+        }
+    }
+    async shutdown() {
+        this.logDebug('Starting graceful shutdown');
+        // Shutdown queue workers first (wait for in-flight jobs)
+        try {
+            await this.queueWorkerInitializer.shutdown();
+        }
+        catch (error) {
+            this.logger.error('Error during queue worker shutdown', error);
+        }
+    }
+    /**
+     * Check if the application is initialized
+     */
+    isApplicationInitialized() {
+        return this.isInitialized;
+    }
+    /**
+     * Get application configuration
+     */
+    async getAppConfig() {
+        this.ensureInitialized();
+        return this.appConfigService.config;
+    }
+    /**
+     * Get resources registry
+     */
+    getResourcesRegistry() {
+        this.ensureInitialized();
+        return this.resourcesRegistryService.getResourcesRegistry();
+    }
+    /**
+     * Get repositories registry handler
+     */
+    getRepositoriesRegistry() {
+        this.ensureInitialized();
+        return this.repositoriesRegistryService;
+    }
+    /**
+     * Debug function to display all implemented Mongoose schemas
+     * Convenient access to schema debugging from the main application service
+     */
+    debugDisplayMongooseSchemas(options = {}) {
+        this.logDebug('\n🚀 === WILDO.AI BACKEND - MONGOOSE SCHEMAS DEBUG ===\n');
+        if (!this.isInitialized) {
+            this.logDebug('⚠️  Application not initialized yet. Schemas may not be available.');
+            return;
+        }
+        this.repositoriesRegistryService.debugDisplayMongooseSchemas(options);
+    }
+    /**
+     * Quick debug summary of all schemas
+     */
+    debugShowSchemasSummary() {
+        this.logDebug('\n🚀 === WILDO.AI BACKEND - SCHEMAS SUMMARY ===\n');
+        if (!this.isInitialized) {
+            this.logDebug('⚠️  Application not initialized yet. Schemas may not be available.');
+            return;
+        }
+        this.repositoriesRegistryService.debugShowSchemasSummary();
+    }
+    /**
+     * Debug function to display all registered routes
+     */
+    debugDisplayRegisteredRoutes() {
+        this.logDebug('\n🌐 === WILDO.AI BACKEND - REGISTERED ROUTES ===\n');
+        if (!this.isInitialized) {
+            this.logDebug('⚠️  Application not initialized yet. Routes may not be available.');
+            return;
+        }
+        this.controllersRegistryService.displayAllRoutes();
+    }
+    /**
+     * Get the controllers registry for route registration
+     */
+    getControllersRegistry() {
+        this.ensureInitialized();
+        return this.controllersRegistryService;
+    }
+    /**
+     * Get the services registry for business logic access
+     */
+    getServicesRegistry() {
+        this.ensureInitialized();
+        return this.servicesRegistryService;
+    }
+    /**
+     * Get the HTTP server service instance
+     */
+    getHttpServer() {
+        this.ensureInitialized();
+        return this.httpServerService;
+    }
+    /**
+     * Get the authorizations service instance
+     */
+    getAuthorizationsService() {
+        this.ensureInitialized();
+        return this.authorizationsService;
+    }
+    /**
+     * Validate that all components are properly initialized
+     */
+    async validateInitialization() {
+        this.logDebug('Validating application initialization...');
+        try {
+            // Validate app config is accessible
+            if (!this.isPlatformMode) {
+                const config = this.appConfigService.config;
+                if (!config) {
+                    const error = this.errorBuilder.buildError(ErrorType.CONFIGURATION, undefined, { customMessageReference: ErrorCustomMessageReference.START_APPLICATION_CONFIGURATION_FAILED });
+                    throw error;
+                }
+            }
+            // Validate resources registry is accessible
+            const registry = this.resourcesRegistryService.getResourcesRegistry();
+            if (!registry) {
+                const error = this.errorBuilder.buildError(ErrorType.INTERNAL, undefined, { customMessageReference: ErrorCustomMessageReference.START_APPLICATION_INITIALIZATION_FAILED });
+                throw error;
+            }
+            // Validate repositories registry is accessible
+            // const repositoriesDebugInfo = this.repositoriesRegistryService.getDebugInfo();
+            // if (!repositoriesDebugInfo.isInitialized) {
+            //     throw new Error('Repositories registry is not initialized');
+            // }
+            // Validate services registry is accessible
+            // const servicesDebugInfo = this.servicesRegistryService.getDebugInfo();
+            // if (!servicesDebugInfo.isInitialized) {
+            //     throw new Error('Services registry is not initialized');
+            // }
+            // Validate controllers registry is accessible
+            // const controllersDebugInfo = this.controllersRegistryService.getDebugInfo();
+            // if (!controllersDebugInfo.isInitialized) {
+            //     throw new Error('Controllers registry is not initialized');
+            // }
+            // // Validate HTTP server is running
+            // if (!this.httpServerService.isRunning()) {
+            //     throw new Error('HTTP server is not running');
+            // }
+            const serverInfo = this.httpServerService.getServerInfo();
+            // this.logDebug('Application initialization validation successful', {
+            //     appName: config.appIdentity.appName,
+            //     environment: process.env.APPLICATION_ENV,
+            //     resourcesCount: Object.keys(registry.resourceConfigurations).length,
+            //     repositoriesCount: repositoriesDebugInfo.repositoryCount,
+            //     repositoriesOperationPaths: repositoriesDebugInfo.operationPathsCount,
+            //     servicesCount: servicesDebugInfo.serviceCount,
+            //     servicesOperationPaths: servicesDebugInfo.operationPathsCount,
+            //     controllersCount: controllersDebugInfo.controllerCount,
+            //     controllersOperationPaths: controllersDebugInfo.operationPathsCount,
+            //     totalRoutes: controllersDebugInfo.totalRoutes,
+            //     httpServerRunning: this.httpServerService.isRunning(),
+            //     serverHost: serverInfo?.host,
+            //     serverPort: serverInfo?.port
+            // });
+        }
+        catch (error) {
+            this.logger.error('Application initialization validation failed:', error);
+            throw error;
+        }
+    }
+    /**
+     * Ensure the application is initialized before operations
+     */
+    ensureInitialized() {
+        if (!this.isInitialized) {
+            const error = this.errorBuilder.buildError(ErrorType.INTERNAL, undefined, { customMessageReference: ErrorCustomMessageReference.START_APPLICATION_STARTUP_FAILED });
+            throw error;
+        }
+    }
+};
+StartApplicationBackendService = __decorate([
+    injectable(),
+    __param(0, inject(SAAS_SERVICE_TYPES.Logger)),
+    __param(1, inject(SAAS_SERVICE_TYPES.AppConfigService)),
+    __param(2, inject(SAAS_SERVICE_TYPES.ApplicationStartupConfigValidatorService)),
+    __param(3, inject(SAAS_SERVICE_TYPES.ResourceRegistryService)),
+    __param(4, inject(SAAS_SERVICE_TYPES.RepositoriesRegistryHandlerService)),
+    __param(5, inject(SAAS_SERVICE_TYPES.ServicesRegistryHandlerService)),
+    __param(6, inject(SAAS_SERVICE_TYPES.ControllersRegistryHandlerService)),
+    __param(7, inject(SAAS_SERVICE_TYPES.HttpServerService)),
+    __param(8, inject(SAAS_SERVICE_TYPES.ErrorBuilderService)),
+    __param(9, inject(SAAS_SERVICE_TYPES.ErrorHandlerService)),
+    __param(10, inject(SAAS_SERVICE_TYPES.AuthorizationsService)),
+    __param(11, inject(SAAS_SERVICE_TYPES.BatchesCronjobsExecutorService)),
+    __param(12, inject(SAAS_SERVICE_TYPES.ExecutionContextCreatorBackendService)),
+    __param(13, inject(SAAS_SERVICE_TYPES.ResourceOperationCustomImplementationRegistryService)),
+    __param(14, inject(SAAS_SERVICE_TYPES.MongoDBService)),
+    __param(15, inject(SAAS_SERVICE_TYPES.RedisService)),
+    __param(16, inject(SAAS_SERVICE_TYPES.I18nService)),
+    __param(17, inject(SAAS_SERVICE_TYPES.ExternalProvidersRegistryService)),
+    __param(18, inject(SAAS_SERVICE_TYPES.LazyProviderRegistryService)),
+    __param(19, inject(SAAS_SERVICE_TYPES.CapabilityBindingsService)),
+    __param(20, inject(SAAS_SERVICE_TYPES.FeatureDefinitionRegistryService)),
+    __param(21, inject(SAAS_SERVICE_TYPES.MilestoneDefinitionRegistry)),
+    __param(22, inject(SAAS_SERVICE_TYPES.MilestoneConditionRegistry)),
+    __param(23, inject(SAAS_SERVICE_TYPES.LifecycleEvaluator)),
+    __param(24, inject(SAAS_SERVICE_TYPES.FlowsActorsRegistryService)),
+    __param(25, inject(SAAS_SERVICE_TYPES.QueueWorkerInitializerService)),
+    __param(26, inject(SAAS_SERVICE_TYPES.CronJobSyncService)),
+    __param(27, inject(SAAS_SERVICE_TYPES.ChartRegistryService)),
+    __param(28, inject(SAAS_SERVICE_TYPES.GuidanceTriggerEvaluator)),
+    __param(29, inject(SAAS_SERVICE_TYPES.EmailTemplateRegistry)),
+    __param(30, inject(SAAS_SERVICE_TYPES.FileStorageRouter)),
+    __metadata("design:paramtypes", [LoggerService,
+        AppConfigurationService,
+        ApplicationStartupConfigValidatorService,
+        ResourcesRegistryBackendService,
+        RepositoriesRegistryHandlerBackendService,
+        ServicesRegistryHandlerBackendService,
+        ControllersRegistryHandlerBackendService,
+        HttpServerBackendService,
+        ErrorBuilderBackendService,
+        ErrorHandlerService,
+        AuthorizationsBackendService,
+        BatchesCronjobsExecutor_BackendService,
+        ExecutionContextCreatorBackendService,
+        ResourceOperationCustomImplementationRegistryBackendService,
+        MongoDBService,
+        RedisService,
+        I18nBackendService,
+        ExternalProvidersRegistryBackendService,
+        LazyProviderRegistryBackendService,
+        CapabilityBindingsBackendService,
+        FeatureDefinitionRegistryBackendService,
+        MilestoneDefinitionRegistryBackendService,
+        MilestoneConditionRegistryBackendService,
+        LifecycleEvaluatorBackendService,
+        FlowsActorsRegistryService,
+        QueueWorkerInitializerBackendService,
+        CronJobSyncBackendService,
+        ChartRegistryBackendService,
+        GuidanceTriggerEvaluatorBackendService,
+        EmailTemplateRegistryBackendService,
+        FileStorageRouterBackendService])
+], StartApplicationBackendService);
+export { StartApplicationBackendService };
+//# sourceMappingURL=start-application.backend.service.js.map