@matter/protocol 0.13.1-alpha.0-20250520-d699cd56d → 0.14.0-alpha.0-20250524-51a7e1721

package/src/cluster/server/ClusterDatasource.ts

@@ -1,17 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { OccurrenceManager } from "#events/OccurrenceManager.js";
-import { Fabric } from "#fabric/Fabric.js";
-import { SupportedStorageTypes } from "#general";
-
-export interface ClusterDatasource {
-    readonly version: number;
-    readonly eventHandler?: OccurrenceManager;
-    readonly fabrics: Fabric[];
-    increaseVersion(): number;
-    changed(key: string, value: SupportedStorageTypes): void;
-}

package/src/cluster/server/ClusterServer.ts

@@ -1,46 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { ClusterId } from "#types";
-import { AnyAttributeServer } from "./AttributeServer.js";
-import { ClusterDatasource } from "./ClusterDatasource.js";
-import { CommandServer } from "./CommandServer.js";
-import { AnyEventServer } from "./EventServer.js";
-
-/**
- * A collection of servers for a cluster's attributes, commands and events.
- */
-export interface ClusterServer {
-    /**
-     * Cluster ID
-     */
-    id: ClusterId;
-
-    /**
-     * Cluster name
-     */
-    readonly name: string;
-
-    /**
-     * Cluster datasource
-     */
-    datasource?: ClusterDatasource;
-
-    /**
-     * Cluster attributes as named object that can be used to programmatically work with available attributes
-     */
-    readonly attributes: Record<string, AnyAttributeServer>;
-
-    /**
-     * Cluster commands as array
-     */
-    readonly commands: Record<string, CommandServer>;
-
-    /**
-     * Cluster events as named object
-     */
-    readonly events: Record<string, AnyEventServer>;
-}

package/src/cluster/server/CommandServer.ts

@@ -1,89 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { Diagnostic, Logger } from "#general";
-import { AccessLevel, FabricIndex } from "#model";
-import { CommandId, StatusCode, TlvSchema, TlvStream } from "#types";
-import { Message } from "../../codec/MessageCodec.js";
-import { EndpointInterface } from "../../endpoint/EndpointInterface.js";
-import { SecureSession } from "../../session/SecureSession.js";
-import { Session } from "../../session/Session.js";
-
-const logger = Logger.get("CommandServer");
-
-export class CommandServer<RequestT = any, ResponseT = any> {
-    readonly #invokeAcl: AccessLevel;
-
-    constructor(
-        readonly invokeId: CommandId,
-        readonly responseId: CommandId,
-        readonly name: string,
-        readonly requestSchema: TlvSchema<RequestT>,
-        readonly responseSchema: TlvSchema<ResponseT>,
-        readonly requiresTimedInteraction: boolean,
-        invokeAcl: AccessLevel,
-        protected readonly handler: (
-            request: RequestT,
-            session: Session,
-            message: Message,
-            endpoint: EndpointInterface,
-        ) => Promise<ResponseT> | ResponseT,
-    ) {
-        this.#invokeAcl = invokeAcl;
-    }
-
-    async invoke(
-        session: Session,
-        args: TlvStream,
-        message: Message,
-        endpoint: EndpointInterface,
-    ): Promise<{
-        /** Primary StatusCode of the invoke request  as defined by Interaction proptocol. */
-        code: StatusCode;
-
-        /** Cluster specific StatusCode of the invoke request if required */
-        clusterCode?: number;
-
-        /** ID of the response */
-        responseId: CommandId;
-
-        /** Response data */
-        response: TlvStream;
-    }> {
-        let request = this.requestSchema.decodeTlv(args);
-
-        // Inject fabric index into structures in general if undefined, if set it will be used
-        if (session.isSecure) {
-            const fabric = (session as SecureSession).fabric;
-            if (fabric) {
-                request = this.requestSchema.injectField(
-                    request,
-                    <number>FabricIndex.id,
-                    session.associatedFabric.fabricIndex,
-                    () => true, // Noone should send any index and if we simply SHALL ignore it
-                );
-            }
-        }
-
-        this.requestSchema.validate(request);
-        this.debug(`Invoke ${this.name} with data ${Diagnostic.json(request)}`);
-        const response = await this.handler(request, session, message, endpoint);
-        this.debug(`Invoke ${this.name} response : ${Diagnostic.json(response)}`);
-        return {
-            code: StatusCode.Success,
-            responseId: this.responseId,
-            response: this.responseSchema.encodeTlv(response),
-        };
-    }
-
-    debug(message: string) {
-        logger.debug(message);
-    }
-
-    get invokeAcl() {
-        return this.#invokeAcl ?? AccessLevel.Operate; // or View?? Re "Read/Invoke" in Access table
-    }
-}

package/src/cluster/server/EventServer.ts

@@ -1,202 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { NumberedOccurrence, Occurrence } from "#events/Occurrence.js";
-import { OccurrenceManager } from "#events/OccurrenceManager.js";
-import {
-    ImplementationError,
-    InternalError,
-    isObject,
-    MatterAggregateError,
-    MaybePromise,
-    Storage,
-    StorageOperationResult,
-    Time,
-} from "#general";
-import { AccessLevel, ClusterModel, EventModel, MatterModel } from "#model";
-import {
-    Attributes,
-    BitSchema,
-    Cluster,
-    ClusterId,
-    Commands,
-    Event,
-    EventId,
-    EventPriority,
-    Events,
-    FabricIndex,
-    TlvEventFilter,
-    TlvSchema,
-    TypeFromPartialBitSchema,
-    TypeFromSchema,
-} from "#types";
-import { Message } from "../../codec/MessageCodec.js";
-import { EndpointInterface } from "../../endpoint/EndpointInterface.js";
-import { SecureSession } from "../../session/SecureSession.js";
-import { Session } from "../../session/Session.js";
-
-export type AnyEventServer<T = any, S extends Storage = any> = EventServer<T, S> | FabricSensitiveEventServer<T, S>;
-
-export function createEventServer<
-    T,
-    F extends BitSchema,
-    SF extends TypeFromPartialBitSchema<F>,
-    A extends Attributes,
-    C extends Commands,
-    E extends Events,
-    S extends Storage,
->(
-    clusterDef: Cluster<F, SF, A, C, E>,
-    eventDef: Event<T, F>,
-    eventName: string,
-    schema: TlvSchema<T>,
-    priority: EventPriority,
-    readAcl: AccessLevel | undefined,
-): EventServer<T, S> {
-    let fabricSensitive = false;
-    const clusterFromModel = MatterModel.standard.get(ClusterModel, clusterDef.id);
-    if (clusterFromModel !== undefined) {
-        const eventModel = clusterFromModel.get(EventModel, eventDef.id);
-        if (eventModel !== undefined) {
-            fabricSensitive = eventModel.fabricSensitive;
-        }
-    }
-    if (fabricSensitive) {
-        return new FabricSensitiveEventServer(eventDef.id, clusterDef.id, eventName, schema, priority, readAcl);
-    }
-    return new EventServer(eventDef.id, clusterDef.id, eventName, schema, priority, readAcl);
-}
-
-export class EventServer<T = any, S extends Storage = any> {
-    private eventList = new Array<Occurrence>();
-    private readonly listeners = new Array<(event: NumberedOccurrence) => void>();
-    protected endpoint?: EndpointInterface;
-    protected eventHandler?: OccurrenceManager;
-    #readAcl: AccessLevel | undefined;
-    hasFabricSensitiveData = false;
-
-    constructor(
-        readonly id: EventId,
-        readonly clusterId: ClusterId,
-        readonly name: string,
-        readonly schema: TlvSchema<T>,
-        readonly priority: EventPriority,
-        readAcl: AccessLevel | undefined,
-    ) {
-        this.#readAcl = readAcl;
-    }
-
-    get readAcl() {
-        return this.#readAcl ?? AccessLevel.View; // ???
-    }
-
-    assignToEndpoint(endpoint: EndpointInterface) {
-        this.endpoint = endpoint;
-    }
-
-    // TODO Try to get rid of that late binding and simply things again
-    //      potentially with refactoring out MatterDevice and MatterController
-    bindToEventHandler(eventHandler: OccurrenceManager) {
-        this.eventHandler = eventHandler;
-        // Send all stored events to the new listener
-        const promises = new Array<PromiseLike<void>>();
-        for (const event of this.eventList) {
-            const finalEvent = this.eventHandler.add(event);
-            if (finalEvent !== undefined && MaybePromise.is(finalEvent)) {
-                promises.push(finalEvent.then(e => this.listeners.forEach(listener => listener(e))));
-            } else {
-                this.listeners.forEach(listener => listener(finalEvent));
-            }
-        }
-        this.eventList = [];
-        if (promises.length > 0) {
-            return MatterAggregateError.allSettled(promises, "Error binding events to the event handlers").then(
-                () => {},
-            ) as StorageOperationResult<S>;
-        }
-        return undefined as StorageOperationResult<S>;
-    }
-
-    triggerEvent(data: T) {
-        if (this.endpoint === undefined || this.endpoint.number === undefined) {
-            throw new InternalError("Endpoint not assigned");
-        }
-        const occurrence: Occurrence = {
-            eventId: this.id,
-            clusterId: this.clusterId,
-            endpointId: this.endpoint.number,
-            epochTimestamp: Time.nowMs(),
-            priority: this.priority,
-            payload: data,
-        };
-        if (this.eventHandler === undefined) {
-            // As long as we have no occurrence manager, we store the events
-            this.eventList.push(occurrence);
-        } else {
-            const finalEvent = this.eventHandler.add(occurrence);
-            return MaybePromise.then(finalEvent, e => {
-                this.listeners.forEach(listener => listener(e));
-            }) as StorageOperationResult<S>;
-        }
-        return undefined as StorageOperationResult<S>;
-    }
-
-    addListener(listener: (event: NumberedOccurrence) => void) {
-        this.listeners.push(listener);
-    }
-
-    removeListener(listener: (event: NumberedOccurrence) => void) {
-        const entryIndex = this.listeners.indexOf(listener);
-        if (entryIndex !== -1) {
-            this.listeners.splice(entryIndex, 1);
-        }
-    }
-
-    get(
-        session: Session,
-        isFabricFiltered: boolean,
-        _message?: Message,
-        filters?: TypeFromSchema<typeof TlvEventFilter>[],
-    ) {
-        if (this.eventHandler === undefined) {
-            throw new InternalError("EventServer not bound to OccurrenceManager");
-        }
-        if (this.endpoint === undefined) {
-            throw new InternalError("EventServer not bound to Endpoint");
-        }
-
-        return this.eventHandler.query(
-            { endpointId: this.endpoint.number, clusterId: this.clusterId, eventId: this.id },
-            filters,
-            // When request is fabric filtered or the event is Fabric sensitive then filter the events for the fabrics
-            isFabricFiltered ? ((session as SecureSession).fabric?.fabricIndex ?? FabricIndex.NO_FABRIC) : undefined,
-        );
-    }
-}
-
-export class FabricSensitiveEventServer<T, S extends Storage> extends EventServer<T, S> {
-    override hasFabricSensitiveData = true;
-
-    override get(
-        session: Session,
-        _isFabricFiltered: boolean,
-        message?: Message,
-        filters?: TypeFromSchema<typeof TlvEventFilter>[],
-    ) {
-        // because the event is fabric sensitive it is always filtered out when another fabric tries to access it
-        return super.get(session, true, message, filters);
-    }
-
-    override triggerEvent(data: T) {
-        if (!isObject(data) || data === null) {
-            throw new ImplementationError("FabricSensitive events need to have an object as data.");
-        }
-        if (!("fabricIndex" in data)) {
-            throw new InternalError("FabricSensitive events requires fabricIndex in data.");
-        }
-        return super.triggerEvent(data);
-    }
-}

package/src/cluster/server/index.ts

@@ -1,11 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-export * from "./AttributeServer.js";
-export * from "./ClusterDatasource.js";
-export * from "./ClusterServer.js";
-export * from "./CommandServer.js";
-export * from "./EventServer.js";

package/src/endpoint/EndpointInterface.ts

@@ -1,41 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { ClusterId, ClusterType, DeviceTypeId, EndpointNumber } from "#types";
-import { ClusterClientObj } from "../cluster/index.js";
-import { ClusterServer } from "../cluster/server/ClusterServer.js";
-
-/**
- * The primary interface for Matter.js endpoint implementations.
- *
- * TODO - this is a transitional interface that allows us to have multiple implementations of the legacy endpoint API
- */
-export interface EndpointInterface {
-    name: string;
-    number: EndpointNumber | undefined;
-    deviceType: DeviceTypeId;
-    getNumber(): EndpointNumber;
-    removeFromStructure(): void;
-    updatePartsList(): EndpointNumber[];
-    getChildEndpoints(): EndpointInterface[];
-    determineUniqueID(): string | undefined;
-    verifyRequiredClusters(): void;
-    close(): void;
-    setStructureChangedCallback(callback: () => void): void;
-
-    addClusterServer(server: ClusterServer): void;
-    hasClusterServer(cluster: ClusterType): boolean;
-    getClusterServer<T extends ClusterType>(cluster: T): ClusterServer | undefined;
-    getClusterServerById(clusterId: ClusterId): ClusterServer | undefined;
-    getAllClusterServers(): ClusterServer[];
-
-    addClusterClient(client: ClusterClientObj): void;
-    getClusterClient<const T extends ClusterType>(cluster: T): ClusterClientObj<T> | undefined;
-    getAllClusterClients(): ClusterClientObj[];
-
-    addChildEndpoint(endpoint: EndpointInterface): void;
-    getChildEndpoint(id: EndpointNumber): EndpointInterface | undefined;
-}

package/src/endpoint/EndpointStructureLogger.ts

@@ -1,270 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { Diagnostic, Logger } from "#general";
-import { GlobalAttributes } from "#types";
-import { SupportedAttributeClient, UnknownSupportedAttributeClient } from "../cluster/client/AttributeClient.js";
-import { ClusterClientObj } from "../cluster/client/ClusterClientTypes.js";
-import { AnyAttributeServer, FabricScopeError } from "../cluster/server/AttributeServer.js";
-import { ClusterServer } from "../cluster/server/ClusterServer.js";
-import { EndpointInterface } from "../endpoint/EndpointInterface.js";
-
-const logger = Logger.get("EndpointStructureLogger");
-
-/**
- * Options for logging endpoint structure. The default is that anything is logged beside "Non Supported" attributes and
- * events on ClusterClients. The Filter methods can be used to filter out specific endpoints or clusters if wanted.
- */
-export type EndpointLoggingOptions = {
-    logClusterServers?: boolean;
-    logClusterClients?: boolean;
-    logChildEndpoints?: boolean;
-    logClusterGlobalAttributes?: boolean;
-    logClusterAttributes?: boolean;
-    logNotSupportedClusterAttributes?: boolean;
-    logClusterCommands?: boolean;
-    logClusterEvents?: boolean;
-    logNotSupportedClusterEvents?: boolean;
-    logNotSupportedClusterCommands?: boolean;
-    logAttributePrimitiveValues?: boolean;
-    logAttributeObjectValues?: boolean;
-
-    clusterServerFilter?: (endpoint: EndpointInterface, cluster: ClusterServer) => boolean;
-    clusterClientFilter?: (endpoint: EndpointInterface, cluster: ClusterClientObj) => boolean;
-    endpointFilter?: (endpoint: EndpointInterface) => boolean;
-};
-
-function getAttributeServerValue(attribute: AnyAttributeServer<any>, options: EndpointLoggingOptions = {}) {
-    let value = "";
-    try {
-        const attributeValue = attribute.getLocal();
-        const attributeValueType = typeof attributeValue;
-        if (
-            (attributeValueType !== "object" || attributeValue === null) &&
-            options.logAttributePrimitiveValues !== false
-        ) {
-            value = attributeValue === null ? "null" : attributeValue.toString();
-        } else if (
-            attributeValueType === "object" &&
-            attributeValue !== null &&
-            options.logAttributeObjectValues !== false
-        ) {
-            value = Diagnostic.json(attributeValue);
-        }
-    } catch (error) {
-        if (error instanceof FabricScopeError) {
-            value = "Fabric-Scoped";
-        } else {
-            value = `Error: ${(error as any).message}`;
-        }
-    }
-    return value;
-}
-
-function logClusterServer(
-    endpoint: EndpointInterface,
-    clusterServer: ClusterServer,
-    options: EndpointLoggingOptions = {},
-) {
-    if (options.clusterServerFilter !== undefined && !options.clusterServerFilter(endpoint, clusterServer)) return;
-
-    const featureMap = clusterServer.attributes.featureMap?.getLocal() ?? {};
-    const globalAttributes = GlobalAttributes<any>(featureMap);
-    const supportedFeatures = new Array<string>();
-    for (const featureName in featureMap) {
-        if (featureMap[featureName] === true) supportedFeatures.push(featureName);
-    }
-    logger.info(
-        `Cluster-Server "${clusterServer.name}" (${Diagnostic.hex(clusterServer.id)}) ${
-            supportedFeatures.length ? `(Features: ${supportedFeatures.join(", ")})` : ""
-        }`,
-    );
-    if (options.logClusterGlobalAttributes !== false) {
-        Logger.nest(() => {
-            logger.info("Global-Attributes:");
-            Logger.nest(() => {
-                for (const attributeName in globalAttributes) {
-                    const attribute = clusterServer.attributes[attributeName];
-                    if (attribute === undefined) continue;
-
-                    const value = getAttributeServerValue(attribute, options);
-                    logger.info(
-                        `"${attribute.name}" (${Diagnostic.hex(attribute.id)})${value !== "" ? `: value = ${value}` : ""}`,
-                    );
-                }
-            });
-        });
-    }
-    if (options.logClusterAttributes !== false) {
-        Logger.nest(() => {
-            logger.info("Attributes:");
-            Logger.nest(() => {
-                for (const attributeName in clusterServer.attributes) {
-                    if (attributeName in globalAttributes) continue;
-                    const attribute = clusterServer.attributes[attributeName];
-                    if (attribute === undefined) continue;
-
-                    const value = getAttributeServerValue(attribute, options);
-                    logger.info(
-                        `"${attribute.name}" (${Diagnostic.hex(attribute.id)})${value !== "" ? `: value = ${value}` : ""}`,
-                    );
-                }
-            });
-        });
-    }
-    if (options.logClusterCommands !== false) {
-        Logger.nest(() => {
-            logger.info("Commands:");
-            Logger.nest(() => {
-                const commands = clusterServer.commands;
-                for (const commandName in commands) {
-                    const command = commands[commandName];
-                    if (command === undefined) continue;
-                    logger.info(
-                        `"${command.name}" (${Diagnostic.hex(command.invokeId)}/${Diagnostic.hex(command.responseId)})`,
-                    );
-                }
-            });
-        });
-    }
-    if (options.logClusterEvents !== false) {
-        Logger.nest(() => {
-            logger.info("Events:");
-            Logger.nest(() => {
-                const events = clusterServer.events;
-                for (const eventName in events) {
-                    const event = events[eventName];
-                    if (event === undefined) continue;
-                    logger.info(`"${event.name}" (${Diagnostic.hex(event.id)})`);
-                }
-            });
-        });
-    }
-}
-
-function logClusterClient(
-    endpoint: EndpointInterface,
-    clusterClient: ClusterClientObj,
-    options: EndpointLoggingOptions = {},
-) {
-    if (options.clusterClientFilter !== undefined && !options.clusterClientFilter(endpoint, clusterClient)) return;
-
-    const { supportedFeatures: features } = clusterClient;
-    const globalAttributes = GlobalAttributes<any>(features);
-    const supportedFeatures = new Array<string>();
-    for (const featureName in features) {
-        if (features[featureName] === true) supportedFeatures.push(featureName);
-    }
-
-    logger.info(
-        `Cluster-Client "${clusterClient.name}" (${Diagnostic.hex(clusterClient.id)}) ${
-            supportedFeatures.length ? `(Features: ${supportedFeatures.join(", ")})` : ""
-        }`,
-    );
-    if (options.logClusterGlobalAttributes !== false) {
-        Logger.nest(() => {
-            logger.info("Global-Attributes:");
-            Logger.nest(() => {
-                for (const attributeName in globalAttributes) {
-                    const attribute = clusterClient.attributes[attributeName];
-                    if (attribute === undefined) continue;
-
-                    logger.info(`"${attribute.name}" (${Diagnostic.hex(attribute.id)})`);
-                }
-            });
-        });
-    }
-    if (options.logClusterAttributes !== false) {
-        Logger.nest(() => {
-            logger.info("Attributes:");
-            Logger.nest(() => {
-                for (const attributeName in clusterClient.attributes) {
-                    if (attributeName in globalAttributes) continue;
-                    const attribute = clusterClient.attributes[attributeName];
-                    if (attribute === undefined) continue;
-                    const supported = attribute instanceof SupportedAttributeClient;
-                    if (!supported && options.logNotSupportedClusterAttributes === false) continue;
-                    const unknown = attribute instanceof UnknownSupportedAttributeClient;
-
-                    let info = "";
-                    if (!supported) info += " (Not Supported)";
-                    if (unknown) info += " (Unknown)";
-
-                    logger.info(`"${attribute.name}" (${Diagnostic.hex(attribute.id)})${info}`);
-                }
-            });
-        });
-    }
-    if (options.logClusterCommands !== false) {
-        Logger.nest(() => {
-            logger.info("Commands:");
-            Logger.nest(() => {
-                for (const commandName in clusterClient.commands) {
-                    if (commandName.match(/^\d+$/)) continue;
-                    const supported = clusterClient.isCommandSupportedByName(commandName);
-                    if (!supported && options.logNotSupportedClusterCommands === false) continue;
-                    logger.info(`"${commandName}"${supported ? "" : " (Not Supported)"}`);
-                }
-            });
-        });
-    }
-    if (options.logClusterEvents !== false) {
-        Logger.nest(() => {
-            logger.info("Events:");
-            Logger.nest(() => {
-                for (const eventName in clusterClient.events) {
-                    const event = clusterClient.events[eventName];
-                    if (event === undefined) continue;
-
-                    logger.info(`"${event.name}" (${Diagnostic.hex(event.id)})`);
-                }
-            });
-        });
-    }
-}
-
-export function logEndpoint(
-    endpoint: EndpointInterface,
-    options: EndpointLoggingOptions = {
-        logNotSupportedClusterAttributes: false,
-        logNotSupportedClusterEvents: false,
-        logNotSupportedClusterCommands: false,
-    },
-) {
-    if (options.endpointFilter !== undefined && !options.endpointFilter(endpoint)) return;
-
-    logger.info(`Endpoint ${endpoint.number} (${endpoint.name}):`);
-    if (options.logClusterServers !== false) {
-        Logger.nest(() => {
-            logger.info("Cluster-Servers:");
-            Logger.nest(() => {
-                for (const clusterServer of endpoint.getAllClusterServers()) {
-                    logClusterServer(endpoint, clusterServer, options);
-                }
-            });
-        });
-    }
-    if (options.logClusterClients !== false) {
-        Logger.nest(() => {
-            logger.info("Cluster-Clients:");
-            Logger.nest(() => {
-                for (const clusterClient of endpoint.getAllClusterClients()) {
-                    logClusterClient(endpoint, clusterClient, options);
-                }
-            });
-        });
-    }
-    if (options.logChildEndpoints !== false) {
-        Logger.nest(() => {
-            logger.info("Child-Endpoints:");
-            Logger.nest(() => {
-                for (const childEndpoint of endpoint.getChildEndpoints()) {
-                    logEndpoint(childEndpoint, options);
-                }
-            });
-        });
-    }
-}

package/src/endpoint/index.ts

@@ -1,8 +0,0 @@
-/**
- * @license
- * Copyright 2022-2025 Matter.js Authors
- * SPDX-License-Identifier: Apache-2.0
- */
-
-export * from "./EndpointInterface.js";
-export * from "./EndpointStructureLogger.js";