@futdevpro/fsm-dynamo 1.20.88 → 1.20.93

package/build-esm/_modules/security/_models/stored-secret.control-model.js

@@ -0,0 +1,52 @@
+/**
+ * Univerzalis tarolt-secret forma (bedrock SSOT) a USER-SAJAT private API-kulcsok / titkos
+ * ertekek tarolasara — minden FDP-rendszer ugyanezt hasznalja, igy kozos eredetet kapnak
+ * (auth per-user AI-kulcs, Organizer user-kulcs, jovobeli).
+ *
+ * FONTOS scope: ez a forma a USER altal megadott sajat kulcsokra valo (ezek titkositva
+ * tarolodnak a `FDP_PRIVATE_API_KEY_CRYPT_KEY`-jel). Az FDP SAJAT rendszer-api-kulcsai NEM
+ * ezen at mennek — azok env-var-ok (nem titkositott DB-tarolas).
+ *
+ * A lenyeg: a secret-bol tarolaskor levezetheto egy ENCRYPT/DECRYPT NELKUL megjelenitheto
+ * azonosito-resz — egy `label` (a user altal beallithato nev) + egy `maskedPreview`
+ * (`<prefix>...<suffix>`) + a `kind` (detektalt fajta) + a `keyLength`. Igy a UI / a fogyasztok
+ * visszafejtes nelkul azonositjak MELYIK kulcs ez, anelkul hogy a nyers ertek valaha
+ * kliensre / logba kerulne.
+ *
+ * Az `encryptedValue` a titkositott nyers secret — KIZAROLAG szerver-oldalon. A titkositas
+ * kulcsa NEM ennek a bedrock-modellnek a felelossege (a host/auth adja a kulcsot a DyFM_Crypto-nak);
+ * itt csak a mar titkositott string tarolodik. A masked-mezoket a `DyFM_StoredSecret_Util`
+ * szamolja a nyers ertekbol.
+ *
+ * Embeddable control-model (NEM extends DyFM_Metadata) — provider-config-okba / kulcs-listakba agyazhato.
+ */
+export class DyFM_StoredSecret_ControlModel {
+    /**
+     * A user altal BEALLITHATO megjelenitendo nev (settable feature; a host/UI allitja be, pl.
+     * "OpenAI Production"). Decrypt nelkul megjelenitheto; tisztan ember-baratti azonositas.
+     */
+    label;
+    /** A secret detektalt fajtaja a masking-patternek alapjan (pl. 'openai-key', 'anthropic-key', 'github-pat'). */
+    kind;
+    /** Decrypt NELKUL megjelenitheto elonezet: `<prefix>...<suffix>` (pl. `sk-a...7890`). */
+    maskedPreview;
+    /** A nyers secret hossza karakterben — decrypt nelkul megjelenitheto / validalashoz hasznos. */
+    keyLength;
+    /**
+     * A titkositott nyers secret — KIZAROLAG szerver-oldalon. SOHA nem kerul kliensre / logba.
+     * A titkositas kulcsa NEM ennek a bedrock-modellnek a felelossege (a host/auth adja); itt csak
+     * a mar titkositott string tarolodik.
+     */
+    encryptedValue;
+    isActive;
+    expiresAt;
+    lastUsedAt;
+    constructor(set) {
+        if (set) {
+            Object.assign(this, set);
+        }
+    }
+}
+Object.defineProperty(DyFM_StoredSecret_ControlModel, 'name', { value: 'DyFM_StoredSecret' });
+/** @deprecated Use DyFM_StoredSecret_ControlModel. Same constructor; no API removal. */
+export { DyFM_StoredSecret_ControlModel as DyFM_StoredSecret };

package/build-esm/_modules/security/index.js

@@ -0,0 +1,7 @@
+// security ("out + security alapok") modul — a titkos-ertek tarolas/maszkolas bedrock SSOT-ja.
+// Erre epit minden FDP-rendszer (auth per-user AI-kulcs, Organizer MCP-kulcs, rendszer-kulcsok):
+// kozos forma (DyFM_StoredSecret) + decrypt-nelkuli preview-derive + a meglevo secret-maszkolas.
+export * from './_models/stored-secret.control-model';
+export * from './_collections/stored-secret.util';
+// a mar letezo univerzalis secret-maszkolas (log/output-redaction) is innen elerheto, egy helyrol
+export * from '../../_collections/utils/secret-mask.util';

package/build-esm/_modules/socket/_enums/sck-event-key.enum.js

@@ -0,0 +1,18 @@
+/**
+ * Names of socket.io events used by the framework.
+ */
+export var DyFM_SocketEvent_Key;
+(function (DyFM_SocketEvent_Key) {
+    /** incoming connection in socket.io */
+    DyFM_SocketEvent_Key["incomingNewConnection"] = "connection";
+    /** outgoing connection in socket.io */
+    DyFM_SocketEvent_Key["outgoingNewConnection"] = "connect";
+    DyFM_SocketEvent_Key["subscribe"] = "subscribe";
+    DyFM_SocketEvent_Key["subscriptionSuccessful"] = "subscriptionSuccessful";
+    DyFM_SocketEvent_Key["unsubscribe"] = "unsubscribe";
+    DyFM_SocketEvent_Key["unsubscribeSuccessful"] = "unsubscribeSuccessful";
+    DyFM_SocketEvent_Key["disconnect"] = "disconnect";
+    DyFM_SocketEvent_Key["ping"] = "ping";
+    DyFM_SocketEvent_Key["event"] = "event";
+    DyFM_SocketEvent_Key["error"] = "error";
+})(DyFM_SocketEvent_Key || (DyFM_SocketEvent_Key = {}));

package/build-esm/_modules/socket/_models/sck-client-params.control-model.js

@@ -0,0 +1,47 @@
+import { second } from '../../../_collections/constants/times.const';
+import { DyFM_Log } from '../../../_collections/utils/log.util';
+/**
+ * Configuration parameters for a socket client.
+ *
+ * @example
+ * ```ts
+ * new DyFM_SckClientParams_ControlModel({
+ *   name: 'demo',
+ *   address: 'http://localhost',
+ *   port: 3000
+ * });
+ * ```
+ */
+export class DyFM_SckClientParams_ControlModel {
+    name;
+    service;
+    address;
+    port;
+    reconnectDelay = second * 30;
+    /** @deprecated Use isReconnectEnabled; reconnect remains the serialized compatibility key. */
+    reconnect = true;
+    socketOptions;
+    constructor(set) {
+        Object.assign(this, set);
+        this.reconnect = !!this.reconnectDelay;
+        if (this.socketOptions?.autoConnect ||
+            this.socketOptions?.reconnection ||
+            this.socketOptions?.reconnectionDelay) {
+            DyFM_Log.warn('autoConnect or reconnection is set to true in socketOptions, so reconnect is set to false', '\nThis means that the reconnection will use the socket.io reconnection logic, ', 'not the Dynamo implementations.');
+            this.reconnect = false;
+        }
+    }
+}
+Object.defineProperty(DyFM_SckClientParams_ControlModel, 'name', { value: 'DyFM_SocketClient_Params' });
+/** @deprecated Use DyFM_SckClientParams_ControlModel. Same constructor; no API removal. */
+export { DyFM_SckClientParams_ControlModel as DyFM_SocketClient_Params };
+Object.defineProperty(DyFM_SckClientParams_ControlModel.prototype, 'isReconnectEnabled', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return this.reconnect;
+    },
+    set: function (isValue) {
+        this.reconnect = isValue;
+    },
+});

package/build-esm/_modules/socket/_models/sck-socket-event.control-model.js

@@ -0,0 +1,133 @@
+import { DyFM_global_settings } from '../../../_collections/constants/global-settings.const';
+import { DyFM_Array } from '../../../_collections/utils/array.util';
+import { DyFM_Log } from '../../../_collections/utils/log.util';
+import { DyFM_getConstructionStackLocation } from '../../../_collections/utils/stack.util';
+import { DyFM_Error } from '../../../_models/control-models/error.control-model';
+import { DyFM_SocketEvent_Key } from '../_enums/sck-event-key.enum';
+/**
+ * Describes a socket.io event with pre-processing and task handling.
+ *
+ * Use this model to define how incoming socket events should be processed
+ * and what actions should be executed once the data is prepared.
+ *
+ * @example
+ * ```ts
+ * const event = new DyFM_SckSocketEvent_ControlModel<string>({
+ *   eventKey: DyFM_SocketEvent_Key.subscribe,
+ *   tasks: [async msg => console.log(msg)]
+ * });
+ * ```
+ */
+export class DyFM_SckSocketEvent_ControlModel {
+    name;
+    eventKey;
+    serviceName;
+    preProcesses;
+    tasks;
+    /** @deprecated Use isEventLoggingEnabled; logEvent remains the serialized compatibility key. */
+    logEvent;
+    /** @deprecated Use isEventContentLoggingEnabled; logEventContent remains the serialized compatibility key. */
+    logEventContent;
+    stackLocation;
+    constructor(set) {
+        try {
+            this.name = set.name ?? set.eventKey;
+            this.eventKey = set.eventKey;
+            this.serviceName = set.serviceName ?? 'UnknownSocketService';
+            this.preProcesses = set.preProcesses ?? [];
+            this.tasks = set.tasks ?? [];
+            this.stackLocation = DyFM_getConstructionStackLocation();
+            if (set.logEvent !== undefined) {
+                this.logEvent = set.logEvent;
+            }
+            else if (this.eventKey === DyFM_SocketEvent_Key.subscribe) {
+                this.logEvent = false;
+            }
+            else if ([
+                DyFM_SocketEvent_Key.incomingNewConnection,
+                DyFM_SocketEvent_Key.outgoingNewConnection,
+                DyFM_SocketEvent_Key.disconnect,
+            ].includes(this.eventKey)) {
+                this.logEvent = DyFM_global_settings.log_settings.socket_allEvents ||
+                    DyFM_global_settings.log_settings.socket_mainEvents;
+            }
+            else {
+                this.logEvent = DyFM_global_settings.log_settings.socket_allEvents;
+            }
+            this.logEventContent = set.logEventContent ??
+                DyFM_global_settings.log_settings.socket_eventContent;
+        }
+        catch (error) {
+            DyFM_Log.error(`\nSocket Event params setup failed (${this.serviceName}): ${set.eventKey}`, error);
+            throw error;
+        }
+    }
+    /**
+     *
+     * @returns
+     */
+    async getPreLog(content) {
+        try {
+            if (this.logEventContent && this.eventKey !== DyFM_SocketEvent_Key.incomingNewConnection) {
+                DyFM_Log.log(`--->   incoming socket(${this.serviceName}) event: ${this.eventKey};
+          \ncontent:`, content);
+            }
+            else {
+                DyFM_Log.log(`--->   incoming socket(${this.serviceName}) event: ${this.eventKey}...`);
+            }
+        }
+        catch (error) {
+            DyFM_Log.error(`PreLog failed... (socket:  ${this.serviceName})`, error);
+        }
+    }
+    /** Executes the ordered preprocessors and tasks for one received event. */
+    async executeEventTasks(content, issuer, transportContext) {
+        try {
+            if (this.logEvent || this.logEventContent) {
+                await this.getPreLog(content);
+            }
+            await DyFM_Array.asyncForEach(this.preProcesses, async (preProcess) => {
+                content = await preProcess(content);
+            });
+            await DyFM_Array.asyncForEach(this.tasks, async (task) => {
+                if (transportContext === undefined) {
+                    await task(content, issuer);
+                }
+                else {
+                    await task(content, issuer, transportContext);
+                }
+            });
+        }
+        catch (error) {
+            if (error instanceof DyFM_Error) {
+                error.logShort('Socket Event tasks failed to execute');
+            }
+            else {
+                DyFM_Log.error(`Socket Event tasks failed to execute on ${this.serviceName}.... (${this.eventKey})`, error, 'content:', content);
+            }
+        }
+    }
+}
+Object.defineProperty(DyFM_SckSocketEvent_ControlModel, 'name', { value: 'DyFM_SocketEvent' });
+/** @deprecated Use DyFM_SckSocketEvent_ControlModel. Same constructor; no API removal. */
+export { DyFM_SckSocketEvent_ControlModel as DyFM_SocketEvent };
+Object.defineProperty(DyFM_SckSocketEvent_ControlModel.prototype, 'isEventLoggingEnabled', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return this.logEvent;
+    },
+    set: function (isValue) {
+        this.logEvent = isValue;
+    },
+});
+Object.defineProperty(DyFM_SckSocketEvent_ControlModel.prototype, 'isEventContentLoggingEnabled', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return this.logEventContent;
+    },
+    set: function (isValue) {
+        this.logEventContent = isValue;
+    },
+});

package/build-esm/_modules/socket/_services/sck-client.service-base.js

@@ -0,0 +1,314 @@
+import * as SocketIOClient from 'socket.io-client';
+import { BehaviorSubject } from 'rxjs';
+import { DyFM_global_settings } from '../../../_collections/constants/global-settings.const';
+import { DyFM_Array } from '../../../_collections/utils/array.util';
+import { DyFM_Log } from '../../../_collections/utils/log.util';
+import { DyFM_Async } from '../../../_collections/utils/async.util';
+import { DyFM_Error } from '../../../_models/control-models/error.control-model';
+import { DyFM_SocketEvent_Key } from '../_enums/sck-event-key.enum';
+import { DyFM_SocketEvent } from '../_models/sck-socket-event.control-model';
+/**
+ * Base implementation for socket.io clients used by Dynamo.
+ * Handles connection logic, subscriptions and default events.
+ */
+export class DyFM_SckClient_ServiceBase {
+    _params;
+    get params() {
+        return this._params;
+    }
+    get name() {
+        return this.params.name;
+    }
+    socket;
+    incomingEvents;
+    _connected_BS = new BehaviorSubject(false);
+    get connected() {
+        return this._connected_BS.value;
+    }
+    connected$ = this._connected_BS.asObservable();
+    _subscribed_BS = new BehaviorSubject(false);
+    get subscribed() {
+        return this._subscribed_BS.value;
+    }
+    subscribed$ = this._subscribed_BS.asObservable();
+    /** @deprecated Use isDebugLogEnabled; debugLog remains the serialized compatibility key. */
+    debugLog = DyFM_global_settings.log_settings.setup;
+    /** @deprecated Use isLogFunctionEnabled; logFn remains the serialized compatibility key. */
+    logFn = DyFM_global_settings.log_settings.functions;
+    defaultEvents = [
+        new DyFM_SocketEvent({
+            eventKey: DyFM_SocketEvent_Key.outgoingNewConnection,
+            tasks: [
+                async () => {
+                    this._connected_BS.next(true);
+                    if (this.subscribed) {
+                        this._subscribed_BS.next(false);
+                    }
+                    DyFM_Log.success(`<   >  socket-client(${this.params.name}) connected!`);
+                },
+            ],
+        }),
+        new DyFM_SocketEvent({
+            eventKey: DyFM_SocketEvent_Key.disconnect,
+            tasks: [
+                async () => {
+                    this._connected_BS.next(false);
+                    if (this.subscribed) {
+                        this._subscribed_BS.next(false);
+                    }
+                    DyFM_Log.warn(`<x  >  socket-client(${this.params.name}) disconnected!`);
+                    if (this._params.reconnect) {
+                        await DyFM_Async.delay(this._params.reconnectDelay);
+                        this.connectSocket();
+                    }
+                },
+            ],
+        }),
+        new DyFM_SocketEvent({
+            eventKey: DyFM_SocketEvent_Key.subscriptionSuccessful,
+            tasks: [
+                async () => {
+                    DyFM_Log.success(`<=-->  socket-client(${this.params.name}) subscription successful!`);
+                    this._subscribed_BS.next(true);
+                },
+            ],
+        }),
+        new DyFM_SocketEvent({
+            eventKey: DyFM_SocketEvent_Key.unsubscribeSuccessful,
+            tasks: [
+                async () => {
+                    DyFM_Log.success(`<x-->  socket-client(${this.params.name}) unsubscribe successful!`);
+                    this._subscribed_BS.next(false);
+                },
+            ],
+        }),
+        new DyFM_SocketEvent({
+            eventKey: DyFM_SocketEvent_Key.error,
+            tasks: [
+                async (content) => {
+                    DyFM_Error.logSimple(`=-->   socket-client(${this.params.name}) ERROR`, content);
+                },
+            ],
+        }),
+    ];
+    constructor() {
+        this.asyncConstructor().catch((error) => {
+            DyFM_Error.logSimple(`socket-client "${this.params?.name}" Service setup failed! ` +
+                `(DyFM_SocketClientService constructor catch)` +
+                `\n    ERROR:`, error);
+        });
+    }
+    /** @deprecated Use isSubscriptionInProgress; subscriptionInProgress remains the serialized compatibility key. */
+    subscriptionInProgress = false;
+    async subscribe() {
+        try {
+            if (this.subscribed) {
+                DyFM_Log.warn(`socket-client(${this.params.name}) already subscribed!`);
+                return;
+            }
+            if (this.subscriptionInProgress) {
+                DyFM_Log.warn(`socket-client(${this.params.name}) subscription in progress!`);
+                return;
+            }
+            this.subscriptionInProgress = true;
+            const subscriptionContent = await this.getSubscriptionContent();
+            await this.emitEvent(DyFM_SocketEvent_Key.subscribe, subscriptionContent);
+            this.subscriptionInProgress = false;
+        }
+        catch (error) {
+            DyFM_Log.error(`socket-client(${this.params.name}) Service Subscribe failed!`, error);
+            this.subscriptionInProgress = false;
+            throw error;
+        }
+    }
+    async unsubscribe() {
+        try {
+            await this.emitEvent(DyFM_SocketEvent_Key.unsubscribe, null);
+        }
+        catch (error) {
+            DyFM_Log.error(`socket-client(${this.params.name}) Service Unsubscribe failed!`, error);
+            throw error;
+        }
+    }
+    /**
+     * Emit event to the socket
+     * @param eventType event name
+     * @param content event content
+     */
+    async emitEvent(eventType, content) {
+        try {
+            DyFM_Log.log(`<=--   outgoing socket-client(${this.params.name}) event: ${eventType}`);
+            this.socket.emit(eventType, content);
+        }
+        catch (error) {
+            DyFM_Log.error(`socket-client(${this.params.name}) ` +
+                `Service Emit Event failed: ${this.params?.name} (${this.params?.port})`, error);
+            throw error;
+        }
+    }
+    async asyncConstructor() {
+        try {
+            this._params = this.getParams();
+            this.incomingEvents = this.getIncomingEvents() ?? [];
+            const socketAddress = this.params.port ? `${this.params.address}:${this.params.port}` : this.params.address;
+            this.socket = SocketIOClient.io(socketAddress, {
+                /* reconnection: this.params.reconnect,
+                reconnectionDelay: this.params.reconnectDelay, */
+                ...this.params.socketOptions,
+            });
+            await this.setupDefaultEvents();
+            await this.setupSocketEvents();
+            DyFM_Log.success(`\nsocket-client(${this.params?.name}) Service setup finished`);
+            await this.connectSocket();
+        }
+        catch (error) {
+            DyFM_Log.error(`socket-client(${this.params?.name}) Service setup failed!`, error);
+            throw new DyFM_Error({
+                errorCode: 'FM-SCS-001',
+                error: error,
+            });
+        }
+    }
+    async setupDefaultEvents() {
+        try {
+            if (this.logFn)
+                console.log('\nFn:. setupDefaultEvents');
+            this.defaultEvents.forEach((defaultEvent) => {
+                defaultEvent.serviceName = this.params.name;
+                const eventDeclared = this.incomingEvents.find((event) => event.eventKey === defaultEvent.eventKey);
+                if (!eventDeclared) {
+                    this.incomingEvents.push(defaultEvent);
+                }
+                else {
+                    eventDeclared.tasks.unshift(...defaultEvent.tasks);
+                }
+            });
+        }
+        catch (error) {
+            DyFM_Log.error(`socket-client(${this.params.name}) Service Setup Default Events failed, ` +
+                `ERROR:`, error);
+            throw error;
+        }
+    }
+    async setupSocketEvents() {
+        try {
+            if (this.debugLog)
+                console.log(`Setup socket-client(${this.params.name}) Events...`);
+            await DyFM_Array.asyncForEach(this.incomingEvents, async (event) => {
+                event.serviceName = this.params.name;
+                this.socket.on(event.eventKey, async (content) => {
+                    try {
+                        await event.executeEventTasks(content, this.params.service);
+                    }
+                    catch (error) {
+                        DyFM_Log.error(`socket-client(${this.params.name}) Event failed, ERROR:`, error);
+                        await this.emitEvent(DyFM_SocketEvent_Key.error, error);
+                    }
+                });
+            });
+        }
+        catch (error) {
+            DyFM_Log.error(`socket-client(${this.params.name}) Service Setup Socket Events failed, ` +
+                `ERROR:`, error);
+            throw error;
+        }
+    }
+    async connectSocket() {
+        try {
+            DyFM_Log.info(`< .. > socket-client(${this.params.name}) ` +
+                `connecting to ${this.params.address}:${this.params.port} ...`);
+            this.socket.connect();
+            if (this.params.reconnect) {
+                await this.tryReconnectIfNeeded();
+            }
+        }
+        catch (error) {
+            DyFM_Log.error(`socket-client(${this.params.name}) Service Connect Socket failed, ` +
+                `ERROR:`, error);
+            throw error;
+        }
+    }
+    /** @deprecated Use isTryingToReconnect; tryingToReconnect remains the serialized compatibility key. */
+    tryingToReconnect = false;
+    async tryReconnectIfNeeded() {
+        try {
+            console.log('tryReconnectIfNeeded', this._params.reconnectDelay);
+            if (this.tryingToReconnect) {
+                DyFM_Log.warn(`socket-client(${this.params.name}) already trying to reconnect!`);
+                return;
+            }
+            if (!this.params.reconnect) {
+                DyFM_Log.warn(`socket-client(${this.params.name}) Dynamo reconnection is disabled!`);
+                return;
+            }
+            this.tryingToReconnect = true;
+            if (this.logFn)
+                console.log(`\nFn:. tryReconnectIfNeeded`);
+            await DyFM_Async.delay(this._params.reconnectDelay);
+            if (!this.connected) {
+                this.tryingToReconnect = false;
+                await this.connectSocket();
+            }
+        }
+        catch (error) {
+            DyFM_Log.error(`socket-client(${this.params.name}) Service Try Reconnect failed, ` +
+                `ERROR:`, error);
+            this.tryingToReconnect = false;
+            throw error;
+        }
+    }
+    /**
+     * Manuális újracsatlakozás: disconnect majd connectSocket.
+     * A tryingToReconnect flag törlődik, hogy az azonnali connectSocket ne ütközzön az automata retry-vel.
+     */
+    reconnect() {
+        this.tryingToReconnect = false;
+        if (this.socket) {
+            this.socket.disconnect();
+        }
+        this.connectSocket();
+    }
+}
+Object.defineProperty(DyFM_SckClient_ServiceBase, 'name', { value: 'DyFM_SocketClient_ServiceBase' });
+/** @deprecated Use DyFM_SckClient_ServiceBase. Same constructor; no API removal. */
+export { DyFM_SckClient_ServiceBase as DyFM_SocketClient_ServiceBase };
+Object.defineProperty(DyFM_SckClient_ServiceBase.prototype, 'isDebugLogEnabled', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return this.debugLog;
+    },
+    set: function (isValue) {
+        this.debugLog = isValue;
+    },
+});
+Object.defineProperty(DyFM_SckClient_ServiceBase.prototype, 'isLogFunctionEnabled', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return this.logFn;
+    },
+    set: function (isValue) {
+        this.logFn = isValue;
+    },
+});
+Object.defineProperty(DyFM_SckClient_ServiceBase.prototype, 'isSubscriptionInProgress', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return this.subscriptionInProgress;
+    },
+    set: function (isValue) {
+        this.subscriptionInProgress = isValue;
+    },
+});
+Object.defineProperty(DyFM_SckClient_ServiceBase.prototype, 'isTryingToReconnect', {
+    configurable: true,
+    enumerable: false,
+    get: function () {
+        return this.tryingToReconnect;
+    },
+    set: function (isValue) {
+        this.tryingToReconnect = isValue;
+    },
+});

package/build-esm/_modules/socket/index.js

@@ -0,0 +1,7 @@
+// ENUMS
+export * from './_enums/sck-event-key.enum';
+// MODELS
+export * from './_models/sck-client-params.control-model';
+export * from './_models/sck-socket-event.control-model';
+// SERVICES
+export * from './_services/sck-client.service-base';

package/build-esm/_modules/state-machine/_models/state-machine-config.interface.js

@@ -0,0 +1 @@
+export {};

package/build-esm/_modules/state-machine/_models/state-machine-event.interface.js

@@ -0,0 +1 @@
+export {};