@bsb/syslog 9.0.0

package/README.md

@@ -0,0 +1,75 @@
+# @bsb/syslog
+
+Syslog server and client for BSB - receive syslog messages and send logs to syslog servers.
+
+## Installation
+
+```bash
+npm install @bsb/syslog
+```
+
+## Features
+
+### Syslog Server
+- **Receive syslog messages** - UDP/TCP protocols
+- **RFC compliance** - Supports RFC 3164 and RFC 5424
+- **Event emission** - Emit received messages as BSB events
+- **Client API** - Subscribe to syslog messages from other services
+
+### Syslog Client (Observable)
+- **Send BSB logs to syslog** - Forward application logs
+- **Multiple protocols** - UDP, TCP, TLS support
+- **RFC compliance** - RFC 3164 and RFC 5424
+- **Level filtering** - Control which log levels are sent
+
+## Configuration
+
+### Server Configuration
+
+```yaml
+plugins:
+  services:
+    - plugin: "@bsb/syslog"
+      service: "SyslogServerPlugin"
+      enabled: true
+      config:
+        port: 514
+        address: "0.0.0.0"
+        exclusive: false
+```
+
+### Client (Observable) Configuration
+
+```yaml
+plugins:
+  observables:
+    - plugin: "@bsb/syslog"
+      observable: "SyslogClientPlugin"
+      enabled: true
+      config:
+        host: "localhost"
+        port: 514
+        protocol: "udp"
+        facility: 16
+        appName: "my-app"
+        rfc: "5424"
+        levels:
+          debug: true
+          info: true
+          warn: true
+          error: true
+```
+
+## Usage
+
+```typescript
+import { 
+  SyslogServerPlugin, 
+  SyslogServerClient, 
+  SyslogClientPlugin 
+} from "@bsb/syslog";
+```
+
+## License
+
+Dual-licensed under AGPL-3.0-only OR Commercial License.

package/lib/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * BSB (Better-Service-Base) is an event-bus based microservice framework.
+ * Copyright (C) 2016 - 2025 BetterCorp (PTY) Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alternatively, you may obtain a commercial license for this program.
+ * The commercial license allows you to use the Program in a closed-source manner,
+ * including the right to create derivative works that are not subject to the terms
+ * of the AGPL.
+ *
+ * To obtain a commercial license, please contact the copyright holders at
+ * https://www.bettercorp.dev. The terms and conditions of the commercial license
+ * will be provided upon request.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+export { SyslogMessageSchema, type SyslogMessage, SyslogServerConfigSchema, type SyslogServerConfig, Config as SyslogServerConfigClass, EventSchemas as SyslogServerEventSchemas, Plugin as SyslogServerPlugin, Client as SyslogServerClient, } from "./plugins/service-syslog-server";
+export { SyslogClientConfigSchema, type SyslogClientConfig, Config as SyslogClientConfigClass, Plugin as SyslogClientPlugin, } from "./plugins/observable-syslog";

package/lib/index.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * BSB (Better-Service-Base) is an event-bus based microservice framework.
+ * Copyright (C) 2016 - 2025 BetterCorp (PTY) Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alternatively, you may obtain a commercial license for this program.
+ * The commercial license allows you to use the Program in a closed-source manner,
+ * including the right to create derivative works that are not subject to the terms
+ * of the AGPL.
+ *
+ * To obtain a commercial license, please contact the copyright holders at
+ * https://www.bettercorp.dev. The terms and conditions of the commercial license
+ * will be provided upon request.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyslogClientPlugin = exports.SyslogClientConfigClass = exports.SyslogClientConfigSchema = exports.SyslogServerClient = exports.SyslogServerPlugin = exports.SyslogServerEventSchemas = exports.SyslogServerConfigClass = exports.SyslogServerConfigSchema = exports.SyslogMessageSchema = void 0;
+// Syslog server exports (receives syslog messages)
+var service_syslog_server_1 = require("./plugins/service-syslog-server");
+Object.defineProperty(exports, "SyslogMessageSchema", { enumerable: true, get: function () { return service_syslog_server_1.SyslogMessageSchema; } });
+Object.defineProperty(exports, "SyslogServerConfigSchema", { enumerable: true, get: function () { return service_syslog_server_1.SyslogServerConfigSchema; } });
+Object.defineProperty(exports, "SyslogServerConfigClass", { enumerable: true, get: function () { return service_syslog_server_1.Config; } });
+Object.defineProperty(exports, "SyslogServerEventSchemas", { enumerable: true, get: function () { return service_syslog_server_1.EventSchemas; } });
+Object.defineProperty(exports, "SyslogServerPlugin", { enumerable: true, get: function () { return service_syslog_server_1.Plugin; } });
+Object.defineProperty(exports, "SyslogServerClient", { enumerable: true, get: function () { return service_syslog_server_1.Client; } });
+// Syslog client observable exports (sends logs to syslog)
+var observable_syslog_1 = require("./plugins/observable-syslog");
+Object.defineProperty(exports, "SyslogClientConfigSchema", { enumerable: true, get: function () { return observable_syslog_1.SyslogClientConfigSchema; } });
+Object.defineProperty(exports, "SyslogClientConfigClass", { enumerable: true, get: function () { return observable_syslog_1.Config; } });
+Object.defineProperty(exports, "SyslogClientPlugin", { enumerable: true, get: function () { return observable_syslog_1.Plugin; } });

package/lib/plugins/observable-syslog/index.d.ts

@@ -0,0 +1,141 @@
+/**
+ * BSB (Better-Service-Base) is an event-bus based microservice framework.
+ * Copyright (C) 2016 - 2025 BetterCorp (PTY) Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alternatively, you may obtain a commercial license for this program.
+ * The commercial license allows you to use the Program in a closed-source manner,
+ * including the right to create derivative works that are not subject to the terms
+ * of the AGPL.
+ *
+ * To obtain a commercial license, please contact the copyright holders at
+ * https://www.bettercorp.dev. The terms and conditions of the commercial license
+ * will be provided upon request.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import { BSBObservable, BSBObservableConstructor, BSBError } from "@bsb/base";
+import { DTrace, LogMeta } from "@bsb/base";
+import { z } from "zod";
+/**
+ * Configuration schema for syslog client observable
+ */
+export declare const SyslogClientConfigSchema: z.ZodObject<{
+    host: z.ZodDefault<z.ZodString>;
+    port: z.ZodDefault<z.ZodNumber>;
+    protocol: z.ZodDefault<z.ZodEnum<{
+        udp: "udp";
+        tcp: "tcp";
+        tls: "tls";
+    }>>;
+    tls: z.ZodOptional<z.ZodObject<{
+        rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
+        ca: z.ZodOptional<z.ZodString>;
+        cert: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    facility: z.ZodDefault<z.ZodNumber>;
+    hostname: z.ZodOptional<z.ZodString>;
+    appName: z.ZodDefault<z.ZodString>;
+    rfc: z.ZodDefault<z.ZodEnum<{
+        3164: "3164";
+        5424: "5424";
+    }>>;
+    levels: z.ZodObject<{
+        debug: z.ZodDefault<z.ZodBoolean>;
+        info: z.ZodDefault<z.ZodBoolean>;
+        warn: z.ZodDefault<z.ZodBoolean>;
+        error: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SyslogClientConfig = z.infer<typeof SyslogClientConfigSchema>;
+export declare const Config: import("@bsb/base").BSBPluginConfigClass<z.ZodObject<{
+    host: z.ZodDefault<z.ZodString>;
+    port: z.ZodDefault<z.ZodNumber>;
+    protocol: z.ZodDefault<z.ZodEnum<{
+        udp: "udp";
+        tcp: "tcp";
+        tls: "tls";
+    }>>;
+    tls: z.ZodOptional<z.ZodObject<{
+        rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
+        ca: z.ZodOptional<z.ZodString>;
+        cert: z.ZodOptional<z.ZodString>;
+        key: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    facility: z.ZodDefault<z.ZodNumber>;
+    hostname: z.ZodOptional<z.ZodString>;
+    appName: z.ZodDefault<z.ZodString>;
+    rfc: z.ZodDefault<z.ZodEnum<{
+        3164: "3164";
+        5424: "5424";
+    }>>;
+    levels: z.ZodObject<{
+        debug: z.ZodDefault<z.ZodBoolean>;
+        info: z.ZodDefault<z.ZodBoolean>;
+        warn: z.ZodDefault<z.ZodBoolean>;
+        error: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>>;
+/**
+ * Syslog client observable plugin - sends logs to syslog servers
+ */
+export declare class Plugin extends BSBObservable<InstanceType<typeof Config>> {
+    static Config: import("@bsb/base").BSBPluginConfigClass<z.ZodObject<{
+        host: z.ZodDefault<z.ZodString>;
+        port: z.ZodDefault<z.ZodNumber>;
+        protocol: z.ZodDefault<z.ZodEnum<{
+            udp: "udp";
+            tcp: "tcp";
+            tls: "tls";
+        }>>;
+        tls: z.ZodOptional<z.ZodObject<{
+            rejectUnauthorized: z.ZodDefault<z.ZodBoolean>;
+            ca: z.ZodOptional<z.ZodString>;
+            cert: z.ZodOptional<z.ZodString>;
+            key: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        facility: z.ZodDefault<z.ZodNumber>;
+        hostname: z.ZodOptional<z.ZodString>;
+        appName: z.ZodDefault<z.ZodString>;
+        rfc: z.ZodDefault<z.ZodEnum<{
+            3164: "3164";
+            5424: "5424";
+        }>>;
+        levels: z.ZodObject<{
+            debug: z.ZodDefault<z.ZodBoolean>;
+            info: z.ZodDefault<z.ZodBoolean>;
+            warn: z.ZodDefault<z.ZodBoolean>;
+            error: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    private logFormatter;
+    private client;
+    private isDisposed;
+    constructor(config: BSBObservableConstructor<InstanceType<typeof Config>>);
+    init(): Promise<void>;
+    run(): Promise<void>;
+    /**
+     * Send log to syslog server
+     */
+    private sendLog;
+    /**
+     * Format and send log
+     */
+    private writeLog;
+    debug(trace: DTrace, pluginName: string, message: string, meta: LogMeta<any>): void;
+    info(trace: DTrace, pluginName: string, message: string, meta: LogMeta<any>): void;
+    warn(trace: DTrace, pluginName: string, message: string, meta: LogMeta<any>): void;
+    error(trace: DTrace, pluginName: string, message: string | BSBError<any>, meta?: LogMeta<any>): void;
+    dispose(): void;
+}

package/lib/plugins/observable-syslog/index.js

@@ -0,0 +1,235 @@
+"use strict";
+/**
+ * BSB (Better-Service-Base) is an event-bus based microservice framework.
+ * Copyright (C) 2016 - 2025 BetterCorp (PTY) Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alternatively, you may obtain a commercial license for this program.
+ * The commercial license allows you to use the Program in a closed-source manner,
+ * including the right to create derivative works that are not subject to the terms
+ * of the AGPL.
+ *
+ * To obtain a commercial license, please contact the copyright holders at
+ * https://www.bettercorp.dev. The terms and conditions of the commercial license
+ * will be provided upon request.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plugin = exports.Config = exports.SyslogClientConfigSchema = void 0;
+const base_1 = require("@bsb/base");
+const zod_1 = require("zod");
+// @ts-ignore - no types available
+const SyslogClient = __importStar(require("syslog-client"));
+/**
+ * Configuration schema for syslog client observable
+ */
+exports.SyslogClientConfigSchema = zod_1.z.object({
+    host: zod_1.z.string().default("localhost"),
+    port: zod_1.z.number().int().min(1).max(65535).default(514),
+    protocol: zod_1.z.enum(["udp", "tcp", "tls"]).default("udp"),
+    tls: zod_1.z.object({
+        rejectUnauthorized: zod_1.z.boolean().default(true),
+        ca: zod_1.z.string().optional(),
+        cert: zod_1.z.string().optional(),
+        key: zod_1.z.string().optional(),
+    }).optional(),
+    facility: zod_1.z.number().int().min(0).max(23).default(16), // local0
+    hostname: zod_1.z.string().optional(),
+    appName: zod_1.z.string().default("bsb-app"),
+    rfc: zod_1.z.enum(["3164", "5424"]).default("5424"),
+    // Log level filtering
+    levels: zod_1.z.object({
+        debug: zod_1.z.boolean().default(true),
+        info: zod_1.z.boolean().default(true),
+        warn: zod_1.z.boolean().default(true),
+        error: zod_1.z.boolean().default(true),
+    }),
+});
+exports.Config = (0, base_1.createConfigSchema)({
+    name: 'observable-syslog',
+    description: 'Syslog client observable plugin for forwarding logs to syslog servers',
+    version: '9.0.0',
+    image: './assets/syslog-icon.png',
+    tags: ['syslog', 'logging', 'observable', 'network'],
+}, exports.SyslogClientConfigSchema);
+/**
+ * Convert BSB log level to syslog severity
+ */
+function bsbLevelToSyslogSeverity(level) {
+    const normalized = level.toLowerCase();
+    switch (normalized) {
+        case "error":
+            return SyslogClient.Severity.Error;
+        case "warn":
+        case "warning":
+            return SyslogClient.Severity.Warning;
+        case "info":
+            return SyslogClient.Severity.Informational;
+        case "debug":
+            return SyslogClient.Severity.Debug;
+        default:
+            return SyslogClient.Severity.Informational;
+    }
+}
+/**
+ * Syslog client observable plugin - sends logs to syslog servers
+ */
+class Plugin extends base_1.BSBObservable {
+    static Config = exports.Config;
+    logFormatter = new base_1.LogFormatter();
+    client = null;
+    isDisposed = false;
+    constructor(config) {
+        super(config);
+    }
+    async init() {
+        const options = {
+            syslogHostname: this.config.hostname || require("os").hostname(),
+            appName: this.config.appName,
+            facility: this.config.facility,
+            rfc: this.config.rfc === "3164" ? SyslogClient.RFC3164 : SyslogClient.RFC5424,
+        };
+        if (this.config.protocol === "tcp") {
+            options.transport = SyslogClient.Transport.Tcp;
+        }
+        else if (this.config.protocol === "tls") {
+            options.transport = SyslogClient.Transport.Tls;
+            if (this.config.tls) {
+                options.tlsOptions = {
+                    rejectUnauthorized: this.config.tls.rejectUnauthorized,
+                    ca: this.config.tls.ca,
+                    cert: this.config.tls.cert,
+                    key: this.config.tls.key,
+                };
+            }
+        }
+        else {
+            options.transport = SyslogClient.Transport.Udp;
+        }
+        this.client = SyslogClient.createClient(this.config.host, options);
+        // Handle connection errors
+        this.client.on("error", (err) => {
+            console.error(`[observable-syslog] Connection error: ${err.message}`);
+        });
+    }
+    async run() {
+        // No runtime setup needed
+    }
+    /**
+     * Send log to syslog server
+     */
+    sendLog(severity, message) {
+        if (this.isDisposed || !this.client) {
+            return;
+        }
+        try {
+            this.client.log(message, { severity }, (err) => {
+                if (err) {
+                    console.error(`[observable-syslog] Failed to send log: ${err.message}`);
+                }
+            });
+        }
+        catch (err) {
+            console.error(`[observable-syslog] Send error: ${err.message}`);
+        }
+    }
+    /**
+     * Format and send log
+     */
+    writeLog(level, trace, pluginName, message, meta) {
+        if (this.isDisposed) {
+            return;
+        }
+        const formattedMessage = this.logFormatter.formatLog(trace, message, meta);
+        const fullMessage = `[${pluginName.toUpperCase()}] ${formattedMessage}`;
+        const severity = bsbLevelToSyslogSeverity(level);
+        this.sendLog(severity, fullMessage);
+    }
+    // Logging methods
+    debug(trace, pluginName, message, meta) {
+        if (this.mode === "production" || !this.config.levels.debug) {
+            return;
+        }
+        this.writeLog("debug", trace, pluginName, message, meta);
+    }
+    info(trace, pluginName, message, meta) {
+        if (!this.config.levels.info) {
+            return;
+        }
+        this.writeLog("info", trace, pluginName, message, meta);
+    }
+    warn(trace, pluginName, message, meta) {
+        if (!this.config.levels.warn) {
+            return;
+        }
+        this.writeLog("warn", trace, pluginName, message, meta);
+    }
+    error(trace, pluginName, message, meta) {
+        if (!this.config.levels.error) {
+            return;
+        }
+        if (message instanceof base_1.BSBError) {
+            if (message.raw !== null) {
+                this.writeLog("error", message.raw.trace, pluginName, message.raw.message, message.raw.meta);
+            }
+            else {
+                this.writeLog("error", trace, pluginName, message.message);
+            }
+        }
+        else {
+            this.writeLog("error", trace, pluginName, message, meta);
+        }
+    }
+    dispose() {
+        this.isDisposed = true;
+        if (this.client) {
+            this.client.close();
+            this.client = null;
+        }
+    }
+}
+exports.Plugin = Plugin;

package/lib/plugins/service-syslog-server/index.d.ts

@@ -0,0 +1,143 @@
+/**
+ * BSB (Better-Service-Base) is an event-bus based microservice framework.
+ * Copyright (C) 2016 - 2025 BetterCorp (PTY) Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Alternatively, you may obtain a commercial license for this program.
+ * The commercial license allows you to use the Program in a closed-source manner,
+ * including the right to create derivative works that are not subject to the terms
+ * of the AGPL.
+ *
+ * To obtain a commercial license, please contact the copyright holders at
+ * https://www.bettercorp.dev. The terms and conditions of the commercial license
+ * will be provided upon request.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import { BSBService, BSBServiceConstructor, BSBServiceClient } from "@bsb/base";
+import { Observable } from "@bsb/base";
+import { z } from "zod";
+/**
+ * Syslog message structure
+ */
+export declare const SyslogMessageSchema: z.ZodObject<{
+    gatewayTime: z.ZodNumber;
+    date: z.ZodNumber;
+    host: z.ZodString;
+    protocol: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type SyslogMessage = z.infer<typeof SyslogMessageSchema>;
+/**
+ * Configuration schema for syslog server
+ */
+export declare const SyslogServerConfigSchema: z.ZodObject<{
+    port: z.ZodDefault<z.ZodNumber>;
+    address: z.ZodDefault<z.ZodString>;
+    exclusive: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type SyslogServerConfig = z.infer<typeof SyslogServerConfigSchema>;
+export declare const Config: import("@bsb/base").BSBPluginConfigClass<z.ZodObject<{
+    port: z.ZodDefault<z.ZodNumber>;
+    address: z.ZodDefault<z.ZodString>;
+    exclusive: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>>;
+/**
+ * Event schemas for syslog server
+ */
+export declare const EventSchemas: {
+    readonly emitEvents: {
+        readonly onMessage: {
+            input: {
+                _bsb: "object";
+                properties: {
+                    readonly gatewayTime: import("@bsb/base").BSBNumberType;
+                    readonly date: import("@bsb/base").BSBNumberType;
+                    readonly host: import("@bsb/base").BSBStringType;
+                    readonly protocol: import("@bsb/base").BSBStringType;
+                    readonly message: import("@bsb/base").BSBStringType;
+                };
+                required: string[];
+                description?: string;
+                optional?: boolean;
+                nullable?: boolean;
+            };
+            description?: string;
+            readonly __brand: "fire-and-forget";
+        };
+    };
+    readonly onEvents: {};
+    readonly emitReturnableEvents: {};
+    readonly onReturnableEvents: {};
+    readonly emitBroadcast: {};
+    readonly onBroadcast: {};
+};
+/**
+ * Syslog server service plugin - receives syslog messages
+ */
+export declare class Plugin extends BSBService<InstanceType<typeof Config>, typeof EventSchemas> {
+    static Config: import("@bsb/base").BSBPluginConfigClass<z.ZodObject<{
+        port: z.ZodDefault<z.ZodNumber>;
+        address: z.ZodDefault<z.ZodString>;
+        exclusive: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    static EventSchemas: {
+        readonly emitEvents: {
+            readonly onMessage: {
+                input: {
+                    _bsb: "object";
+                    properties: {
+                        readonly gatewayTime: import("@bsb/base").BSBNumberType;
+                        readonly date: import("@bsb/base").BSBNumberType;
+                        readonly host: import("@bsb/base").BSBStringType;
+                        readonly protocol: import("@bsb/base").BSBStringType;
+                        readonly message: import("@bsb/base").BSBStringType;
+                    };
+                    required: string[];
+                    description?: string;
+                    optional?: boolean;
+                    nullable?: boolean;
+                };
+                description?: string;
+                readonly __brand: "fire-and-forget";
+            };
+        };
+        readonly onEvents: {};
+        readonly emitReturnableEvents: {};
+        readonly onReturnableEvents: {};
+        readonly emitBroadcast: {};
+        readonly onBroadcast: {};
+    };
+    initBeforePlugins?: string[] | undefined;
+    initAfterPlugins?: string[] | undefined;
+    runBeforePlugins?: string[] | undefined;
+    runAfterPlugins?: string[] | undefined;
+    private _server;
+    constructor(config: BSBServiceConstructor<InstanceType<typeof Config>, typeof EventSchemas>);
+    init(): Promise<void>;
+    run(obs: Observable): Promise<void>;
+    dispose(): void;
+}
+/**
+ * Syslog server client - allows other services to subscribe to syslog messages
+ */
+export declare class Client extends BSBServiceClient<Plugin> {
+    initBeforePlugins?: string[] | undefined;
+    initAfterPlugins?: string[] | undefined;
+    runBeforePlugins?: string[] | undefined;
+    runAfterPlugins?: string[] | undefined;
+    dispose?(): void;
+    run?(): Promise<void>;
+    readonly pluginName: string;
+    init(obs: Observable): Promise<void>;
+}