@diia-inhouse/diia-queue 13.3.3 → 14.0.10

package/dist/services/index.d.ts

@@ -0,0 +1,8 @@
+import { EventMessageValidator } from "./eventMessageValidator.js";
+import { EventMessageHandler } from "./eventMessageHandler.js";
+import { EventBus } from "./eventBus.js";
+import { ExternalCommunicator } from "./externalCommunicator.js";
+import { ExternalEventBus } from "./externalEventBus.js";
+import { Queue } from "./queue.js";
+import { ScheduledTask } from "./scheduledTask.js";
+import { Task } from "./task.js";

package/dist/services/index.js

@@ -1,26 +1,10 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./eventBus"), exports);
-__exportStar(require("./eventMessageHandler"), exports);
-__exportStar(require("./eventMessageValidator"), exports);
-__exportStar(require("./externalCommunicator"), exports);
-__exportStar(require("./externalEventBus"), exports);
-__exportStar(require("./scheduledTask"), exports);
-__exportStar(require("./task"), exports);
-__exportStar(require("./queue"), exports);
-__exportStar(require("./metrics"), exports);
-//# sourceMappingURL=index.js.map
+import "./eventBus.js";
+import "./eventMessageHandler.js";
+import "./eventMessageValidator.js";
+import "./externalCommunicator.js";
+import "./externalEventBus.js";
+import "./scheduledTask.js";
+import "./task.js";
+import "./metrics.js";
+import "./queue.js";
+export {};

package/dist/services/metrics.d.ts

@@ -0,0 +1,15 @@
+import { CommunicationDirection } from "../interfaces/metrics/index.js";
+import { ErrorType } from "@diia-inhouse/errors";
+import { MetricsService } from "@diia-inhouse/diia-metrics";
+
+//#region src/services/metrics.d.ts
+declare class RabbitMQMetricsService {
+  private metrics;
+  private readonly communicationsTotalMetric;
+  constructor(metrics: MetricsService);
+  collectResponseTotalMetric(startTime: bigint, route: string, source: string, destination: string, errorType?: ErrorType): void | never;
+  collectCommunicationsTotalMetric(event: string, source: string, destination: string, direction: CommunicationDirection, queue?: string): void;
+  collectRequestTotalMetric(startTime: bigint, route: string, source: string, destination: string, errorType?: ErrorType): void;
+}
+//#endregion
+export { RabbitMQMetricsService };

package/dist/services/metrics.js

@@ -1,49 +1,46 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const diia_metrics_1 = require("@diia-inhouse/diia-metrics");
-const metrics_1 = require("../interfaces/metrics");
-class RabbitMQMetricsService {
-    metrics;
-    communicationsTotalMetric = new diia_metrics_1.Counter(metrics_1.Metrics.CommunicationsTotal, metrics_1.communicationsTotalLabelsMap, 'Total rabbitmq communications made by service');
-    constructor(metrics) {
-        this.metrics = metrics;
-    }
-    collectResponseTotalMetric(startTime, route, source, destination, errorType) {
-        const labels = {
-            route,
-            source,
-            ...(errorType ? { errorType } : {}),
-            destination,
-            mechanism: diia_metrics_1.RequestMechanism.Rabbitmq,
-            status: errorType ? diia_metrics_1.RequestStatus.Failed : diia_metrics_1.RequestStatus.Successful,
-        };
-        const finishTime = process.hrtime.bigint();
-        const delta = finishTime - startTime;
-        this.metrics.responseTotalTimerMetric.observeSeconds(labels, delta);
-    }
-    collectCommunicationsTotalMetric(event, source, destination, direction, queue) {
-        const labels = {
-            event,
-            source,
-            destination,
-            direction,
-            ...(queue ? { queue } : {}),
-        };
-        this.communicationsTotalMetric.increment(labels, 1);
-    }
-    collectRequestTotalMetric(startTime, route, source, destination, errorType) {
-        const finishTime = process.hrtime.bigint();
-        const delta = finishTime - startTime;
-        const labels = {
-            route,
-            source,
-            destination,
-            mechanism: diia_metrics_1.RequestMechanism.Rabbitmq,
-            status: errorType ? diia_metrics_1.RequestStatus.Failed : diia_metrics_1.RequestStatus.Successful,
-            ...(errorType ? { errorType } : {}),
-        };
-        this.metrics.totalTimerMetric.observeSeconds(labels, delta);
-    }
-}
-exports.default = RabbitMQMetricsService;
-//# sourceMappingURL=metrics.js.map
+import { Metrics, communicationsTotalLabelsMap } from "../interfaces/metrics/index.js";
+import { Counter, RequestMechanism, RequestStatus } from "@diia-inhouse/diia-metrics";
+//#region src/services/metrics.ts
+var RabbitMQMetricsService = class {
+	metrics;
+	communicationsTotalMetric = new Counter(Metrics.CommunicationsTotal, communicationsTotalLabelsMap, "Total rabbitmq communications made by service");
+	constructor(metrics) {
+		this.metrics = metrics;
+	}
+	collectResponseTotalMetric(startTime, route, source, destination, errorType) {
+		const labels = {
+			route,
+			source,
+			...errorType ? { errorType } : {},
+			destination,
+			mechanism: RequestMechanism.Rabbitmq,
+			status: errorType ? RequestStatus.Failed : RequestStatus.Successful
+		};
+		const delta = process.hrtime.bigint() - startTime;
+		this.metrics.responseTotalTimerMetric.observeSeconds(labels, delta);
+	}
+	collectCommunicationsTotalMetric(event, source, destination, direction, queue) {
+		const labels = {
+			event,
+			source,
+			destination,
+			direction,
+			...queue ? { queue } : {}
+		};
+		this.communicationsTotalMetric.increment(labels, 1);
+	}
+	collectRequestTotalMetric(startTime, route, source, destination, errorType) {
+		const delta = process.hrtime.bigint() - startTime;
+		const labels = {
+			route,
+			source,
+			destination,
+			mechanism: RequestMechanism.Rabbitmq,
+			status: errorType ? RequestStatus.Failed : RequestStatus.Successful,
+			...errorType ? { errorType } : {}
+		};
+		this.metrics.totalTimerMetric.observeSeconds(labels, delta);
+	}
+};
+//#endregion
+export { RabbitMQMetricsService as default };

package/dist/services/optionsBuilder.d.ts

@@ -0,0 +1,14 @@
+import { ConsumerOptions, ExchangeName, QueueOptions } from "../interfaces/messageBrokerServiceConfig.js";
+import { QueueName } from "../interfaces/queueConfig/configs.js";
+import { RabbitMQProvider } from "../providers/rabbitmq/index.js";
+
+//#region src/services/optionsBuilder.d.ts
+declare class OptionsBuilder {
+  private readonly queueProvider;
+  constructor(queueProvider: RabbitMQProvider);
+  defineQueueOptionsBasedOnGlobalConfig(queueName?: QueueName, routingKey?: string): QueueOptions[];
+  defineConsumerOptionsBasedOnGlobalConfig(): ConsumerOptions;
+  getExchangeNamesByQueueName(queueName?: QueueName): ExchangeName[];
+}
+//#endregion
+export { OptionsBuilder };

package/dist/services/optionsBuilder.js

@@ -1,59 +1,44 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import { QueueTypes } from "../interfaces/messageBrokerServiceConfig.js";
+import constants_default from "../constants.js";
+//#region src/services/optionsBuilder.ts
+var OptionsBuilder = class {
+	queueProvider;
+	constructor(queueProvider) {
+		this.queueProvider = queueProvider;
+	}
+	defineQueueOptionsBasedOnGlobalConfig(queueName, routingKey = constants_default.DEFAULT_ROUTING_KEY) {
+		if (!queueName) return [];
+		const { rabbit: { listenerOptions: { queueOptions } = {}, declareOptions: { assertQueues, queuesOptions: overriddenQueuesOptions = {} } = {} } } = this.queueProvider.getConfig();
+		const exchangeNames = this.getExchangeNamesByQueueName(queueName);
+		const bindTo = [];
+		for (const exchangeName of exchangeNames) bindTo.push({
+			routingKey,
+			exchangeName,
+			bind: assertQueues
+		});
+		return [{
+			bindTo,
+			name: queueName,
+			declare: assertQueues,
+			options: queueOptions,
+			type: QueueTypes.Quorum,
+			consumerOptions: this.defineConsumerOptionsBasedOnGlobalConfig(),
+			...overriddenQueuesOptions
+		}];
+	}
+	defineConsumerOptionsBasedOnGlobalConfig() {
+		const { rabbit: { listenerOptions: { prefetchCount, recreateChannelOptions = {} } = {} } } = this.queueProvider.getConfig();
+		return {
+			prefetchCount,
+			recreateChannelOptions
+		};
+	}
+	getExchangeNamesByQueueName(queueName) {
+		if (!queueName) return [];
+		const { queues } = this.queueProvider.getConfig();
+		if (!queues) return [];
+		return queues[queueName]?.topics || [];
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = __importDefault(require("../constants"));
-const messageBrokerServiceConfig_1 = require("../interfaces/messageBrokerServiceConfig");
-class OptionsBuilder {
-    queueProvider;
-    constructor(queueProvider) {
-        this.queueProvider = queueProvider;
-    }
-    defineQueueOptionsBasedOnGlobalConfig(queueName, routingKey = constants_1.default.DEFAULT_ROUTING_KEY) {
-        if (!queueName) {
-            return [];
-        }
-        const { rabbit: { listenerOptions: { queueOptions } = {}, declareOptions: { assertQueues, queuesOptions: overriddenQueuesOptions = {} } = {}, }, } = this.queueProvider.getConfig();
-        const exchangeNames = this.getExchangeNamesByQueueName(queueName);
-        const bindTo = [];
-        for (const exchangeName of exchangeNames) {
-            bindTo.push({
-                routingKey,
-                exchangeName,
-                bind: assertQueues,
-            });
-        }
-        return [
-            {
-                bindTo,
-                name: queueName,
-                declare: assertQueues,
-                options: queueOptions,
-                type: messageBrokerServiceConfig_1.QueueTypes.Quorum,
-                consumerOptions: this.defineConsumerOptionsBasedOnGlobalConfig(),
-                ...overriddenQueuesOptions,
-            },
-        ];
-    }
-    defineConsumerOptionsBasedOnGlobalConfig() {
-        const { rabbit: { listenerOptions: { prefetchCount, recreateChannelOptions = {} } = {} }, } = this.queueProvider.getConfig();
-        return {
-            prefetchCount,
-            recreateChannelOptions,
-        };
-    }
-    getExchangeNamesByQueueName(queueName) {
-        if (!queueName) {
-            return [];
-        }
-        const { queues } = this.queueProvider.getConfig();
-        if (!queues) {
-            return [];
-        }
-        const queue = queues[queueName];
-        return queue?.topics || [];
-    }
-}
-exports.default = OptionsBuilder;
-//# sourceMappingURL=optionsBuilder.js.map
+//#endregion
+export { OptionsBuilder as default };

package/dist/services/queue.d.ts

@@ -0,0 +1,29 @@
+import { MessageBrokerExternalServiceType, MessageBrokerInternalServiceType } from "../interfaces/messageBrokerServiceConfig.js";
+import { QueueStatus } from "../interfaces/queueStatus.js";
+import { QueueContext } from "../interfaces/queueContext.js";
+import { QueueConnectionConfig } from "../interfaces/index.js";
+import { RabbitMQProvider } from "../providers/rabbitmq/index.js";
+import { HealthCheckResult, OnHealthCheck } from "@diia-inhouse/types";
+import { MetricsService } from "@diia-inhouse/diia-metrics";
+import Logger$1 from "@diia-inhouse/diia-logger";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/services/queue.d.ts
+declare class Queue implements OnHealthCheck {
+  private readonly systemServiceName;
+  private readonly metrics;
+  private readonly connectionConfig;
+  private readonly asyncLocalStorage;
+  private readonly logger;
+  private readonly internalRabbitMQProvidersMap;
+  private readonly externalRabbitMQProvidersMap;
+  constructor(systemServiceName: string, metrics: MetricsService, connectionConfig: QueueConnectionConfig, asyncLocalStorage: AsyncLocalStorage<QueueContext>, logger: Logger$1);
+  onHealthCheck(): Promise<HealthCheckResult<QueueStatus>>;
+  makeInternalRabbitMQProvider(serviceType: MessageBrokerInternalServiceType): RabbitMQProvider;
+  makeExternalRabbitMQProvider(serviceType: MessageBrokerExternalServiceType): RabbitMQProvider;
+  private getProvidersStatus;
+  private getProvidersStatusDetails;
+  private getMessageBrokerServiceConfig;
+}
+//#endregion
+export { Queue };

package/dist/services/queue.js

@@ -1,93 +1,78 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queue = void 0;
-const types_1 = require("@diia-inhouse/types");
-const interfaces_1 = require("../interfaces");
-const rabbitmq_1 = require("../providers/rabbitmq");
-class Queue {
-    systemServiceName;
-    metrics;
-    connectionConfig;
-    asyncLocalStorage;
-    logger;
-    internalRabbitMQProvidersMap = new Map();
-    externalRabbitMQProvidersMap = new Map();
-    constructor(systemServiceName, metrics, connectionConfig, asyncLocalStorage, logger) {
-        this.systemServiceName = systemServiceName;
-        this.metrics = metrics;
-        this.connectionConfig = connectionConfig;
-        this.asyncLocalStorage = asyncLocalStorage;
-        this.logger = logger;
-    }
-    async onHealthCheck() {
-        const status = this.getProvidersStatus();
-        return {
-            status,
-            details: {
-                rabbit: {
-                    internal: this.getProvidersStatusDetails(this.internalRabbitMQProvidersMap),
-                    external: this.getProvidersStatusDetails(this.externalRabbitMQProvidersMap),
-                },
-            },
-        };
-    }
-    makeInternalRabbitMQProvider(serviceType) {
-        const provider = this.internalRabbitMQProvidersMap.get(serviceType);
-        if (provider) {
-            return provider;
-        }
-        const { internal: rabbitMQConfig, serviceRulesConfig: { queuesConfig, servicesConfig = {}, topicsConfig, messageBrokerServices }, } = this.connectionConfig;
-        if (!rabbitMQConfig) {
-            throw new Error(`External rabbitMQ config is not provided`);
-        }
-        const messageBrokerServiceConfig = this.getMessageBrokerServiceConfig(serviceType, messageBrokerServices);
-        const serviceConfig = servicesConfig[interfaces_1.QueueConnectionType.Internal] || {};
-        const rabbitMQProvider = new rabbitmq_1.RabbitMQProvider(this.systemServiceName, rabbitMQConfig, serviceConfig, topicsConfig[interfaces_1.QueueConnectionType.Internal], [], this.logger, this.metrics, this.asyncLocalStorage, queuesConfig[interfaces_1.QueueConfigType.Internal], messageBrokerServiceConfig);
-        this.internalRabbitMQProvidersMap.set(serviceType, rabbitMQProvider);
-        return rabbitMQProvider;
-    }
-    makeExternalRabbitMQProvider(serviceType) {
-        const provider = this.externalRabbitMQProvidersMap.get(serviceType);
-        if (provider) {
-            return provider;
-        }
-        const { external: rabbitMQConfig, serviceRulesConfig: { servicesConfig = {}, topicsConfig, portalEvents = [], messageBrokerServices }, } = this.connectionConfig;
-        if (!rabbitMQConfig) {
-            throw new Error(`External rabbitMQ config is not provided`);
-        }
-        const messageBrokerServiceConfig = this.getMessageBrokerServiceConfig(serviceType, messageBrokerServices);
-        const serviceConfig = servicesConfig[interfaces_1.QueueConnectionType.External] || {};
-        const rabbitMQProvider = new rabbitmq_1.RabbitMQProvider(this.systemServiceName, rabbitMQConfig, serviceConfig, topicsConfig[interfaces_1.QueueConnectionType.External], portalEvents, this.logger, this.metrics, this.asyncLocalStorage, {}, messageBrokerServiceConfig);
-        this.externalRabbitMQProvidersMap.set(serviceType, rabbitMQProvider);
-        return rabbitMQProvider;
-    }
-    getProvidersStatus() {
-        for (const provider of this.internalRabbitMQProvidersMap.values()) {
-            const { listener: listenerStatus, publisher: publisherStatus } = provider.getStatus();
-            if (publisherStatus !== interfaces_1.ConnectionStatus.Connected) {
-                return types_1.HttpStatusCode.SERVICE_UNAVAILABLE;
-            }
-            if (listenerStatus !== undefined && listenerStatus !== interfaces_1.ConnectionStatus.Connected) {
-                return types_1.HttpStatusCode.SERVICE_UNAVAILABLE;
-            }
-        }
-        return types_1.HttpStatusCode.OK;
-    }
-    getProvidersStatusDetails(providersMap) {
-        const details = {};
-        for (const [serviceType, provider] of providersMap) {
-            details[serviceType] = provider.getStatus();
-        }
-        return details;
-    }
-    getMessageBrokerServiceConfig(serviceType, messageBrokerServices) {
-        const serviceConfig = messageBrokerServices?.[serviceType] || interfaces_1.emptyMessageBrokerServiceConfig;
-        const generalConfig = messageBrokerServices?.['general'] || interfaces_1.emptyMessageBrokerServiceConfig;
-        return {
-            queuesOptions: [...serviceConfig.queuesOptions, ...generalConfig.queuesOptions],
-            exchangesOptions: [...serviceConfig.exchangesOptions, ...generalConfig.exchangesOptions],
-        };
-    }
-}
-exports.Queue = Queue;
-//# sourceMappingURL=queue.js.map
+import "../interfaces/providers/rabbitmq/amqpConnection.js";
+import "../interfaces/queueStatus.js";
+import { emptyMessageBrokerServiceConfig } from "../interfaces/messageBrokerServiceConfig.js";
+import "../interfaces/queueConfig/configs.js";
+import "../interfaces/index.js";
+import { RabbitMQProvider } from "../providers/rabbitmq/index.js";
+import { HttpStatusCode } from "@diia-inhouse/types";
+//#region src/services/queue.ts
+var Queue = class {
+	systemServiceName;
+	metrics;
+	connectionConfig;
+	asyncLocalStorage;
+	logger;
+	internalRabbitMQProvidersMap = /* @__PURE__ */ new Map();
+	externalRabbitMQProvidersMap = /* @__PURE__ */ new Map();
+	constructor(systemServiceName, metrics, connectionConfig, asyncLocalStorage, logger) {
+		this.systemServiceName = systemServiceName;
+		this.metrics = metrics;
+		this.connectionConfig = connectionConfig;
+		this.asyncLocalStorage = asyncLocalStorage;
+		this.logger = logger;
+	}
+	async onHealthCheck() {
+		return {
+			status: this.getProvidersStatus(),
+			details: { rabbit: {
+				internal: this.getProvidersStatusDetails(this.internalRabbitMQProvidersMap),
+				external: this.getProvidersStatusDetails(this.externalRabbitMQProvidersMap)
+			} }
+		};
+	}
+	makeInternalRabbitMQProvider(serviceType) {
+		const provider = this.internalRabbitMQProvidersMap.get(serviceType);
+		if (provider) return provider;
+		const { internal: rabbitMQConfig, serviceRulesConfig: { queuesConfig, servicesConfig = {}, topicsConfig, messageBrokerServices } } = this.connectionConfig;
+		if (!rabbitMQConfig) throw new Error(`External rabbitMQ config is not provided`);
+		const messageBrokerServiceConfig = this.getMessageBrokerServiceConfig(serviceType, messageBrokerServices);
+		const serviceConfig = servicesConfig["internal"] || {};
+		const rabbitMQProvider = new RabbitMQProvider(this.systemServiceName, rabbitMQConfig, serviceConfig, topicsConfig["internal"], [], this.logger, this.metrics, this.asyncLocalStorage, queuesConfig["internal"], messageBrokerServiceConfig);
+		this.internalRabbitMQProvidersMap.set(serviceType, rabbitMQProvider);
+		return rabbitMQProvider;
+	}
+	makeExternalRabbitMQProvider(serviceType) {
+		const provider = this.externalRabbitMQProvidersMap.get(serviceType);
+		if (provider) return provider;
+		const { external: rabbitMQConfig, serviceRulesConfig: { servicesConfig = {}, topicsConfig, portalEvents = [], messageBrokerServices } } = this.connectionConfig;
+		if (!rabbitMQConfig) throw new Error(`External rabbitMQ config is not provided`);
+		const messageBrokerServiceConfig = this.getMessageBrokerServiceConfig(serviceType, messageBrokerServices);
+		const serviceConfig = servicesConfig["external"] || {};
+		const rabbitMQProvider = new RabbitMQProvider(this.systemServiceName, rabbitMQConfig, serviceConfig, topicsConfig["external"], portalEvents, this.logger, this.metrics, this.asyncLocalStorage, {}, messageBrokerServiceConfig);
+		this.externalRabbitMQProvidersMap.set(serviceType, rabbitMQProvider);
+		return rabbitMQProvider;
+	}
+	getProvidersStatus() {
+		for (const provider of this.internalRabbitMQProvidersMap.values()) {
+			const { listener: listenerStatus, publisher: publisherStatus } = provider.getStatus();
+			if (publisherStatus !== "connected") return HttpStatusCode.SERVICE_UNAVAILABLE;
+			if (listenerStatus !== void 0 && listenerStatus !== "connected") return HttpStatusCode.SERVICE_UNAVAILABLE;
+		}
+		return HttpStatusCode.OK;
+	}
+	getProvidersStatusDetails(providersMap) {
+		const details = {};
+		for (const [serviceType, provider] of providersMap) details[serviceType] = provider.getStatus();
+		return details;
+	}
+	getMessageBrokerServiceConfig(serviceType, messageBrokerServices) {
+		const serviceConfig = messageBrokerServices?.[serviceType] || emptyMessageBrokerServiceConfig;
+		const generalConfig = messageBrokerServices?.["general"] || emptyMessageBrokerServiceConfig;
+		return {
+			queuesOptions: [...serviceConfig.queuesOptions, ...generalConfig.queuesOptions],
+			exchangesOptions: [...serviceConfig.exchangesOptions, ...generalConfig.exchangesOptions]
+		};
+	}
+};
+//#endregion
+export { Queue };

package/dist/services/scheduledTask.d.ts

@@ -0,0 +1,30 @@
+import { ExchangeName, ExchangeOptions } from "../interfaces/messageBrokerServiceConfig.js";
+import { QueueName } from "../interfaces/queueConfig/configs.js";
+import { PublishingResult } from "../interfaces/providers/rabbitmq/amqpPublisher.js";
+import { EventBusListener, MessageBrokerServiceEventsListener, ScheduledTasksQueue } from "../interfaces/index.js";
+import { RabbitMQProvider } from "../providers/rabbitmq/index.js";
+import { Communicator } from "./communicator.js";
+import { EventMessageHandler } from "./eventMessageHandler.js";
+import { OnInit } from "@diia-inhouse/types";
+import Logger$1 from "@diia-inhouse/diia-logger";
+
+//#region src/services/scheduledTask.d.ts
+/**
+* @deprecated use pkg-workflow entities instead
+*/
+declare class ScheduledTask extends Communicator implements ScheduledTasksQueue, OnInit {
+  private readonly serviceName;
+  protected readonly scheduledTaskList: EventBusListener[];
+  private readonly queueName;
+  private readonly eventCommunicator;
+  private readonly eventRoutingPart;
+  constructor(serviceName: string, systemServiceName: string, queueProvider: RabbitMQProvider, scheduledTaskList: EventBusListener[], eventMessageHandler: EventMessageHandler, logger: Logger$1, hostName: string, queueName?: QueueName | undefined);
+  publish(eventName: string, serviceName: string): Promise<PublishingResult>;
+  protected getExchangeNameWithSuffix(exchangeName: ExchangeName): string;
+  protected getUnicastListeners(): MessageBrokerServiceEventsListener[];
+  protected getMulticastListeners(): MessageBrokerServiceEventsListener[];
+  protected override getProducerExchangesOptions(): ExchangeOptions[];
+  private getRoutingKey;
+}
+//#endregion
+export { ScheduledTask };