@espressif/rainmaker-neo-base-sdk 1.0.0

package/dist/cjs/ESPRMNeoNode.js

@@ -0,0 +1,283 @@
+'use strict';
+
+var NodeUpdatesBus = require('./services/NodeUpdatesBus.js');
+var logger$1 = require('./utils/logger.js');
+var NodeMQTTOrchestrator = require('./services/NodeMQTTOrchestrator.js');
+var ESPRMNeoService = require('./ESPRMNeoService.js');
+var ESPRMNeoDevice = require('./ESPRMNeoDevice.js');
+var shadowUtils = require('./utils/shadowUtils.js');
+var nodeTransform = require('./utils/nodeTransform.js');
+var ESPRMNeoStorage = require('./services/ESPRMNeoStorage/ESPRMNeoStorage.js');
+var constants = require('./utils/constants.js');
+var nodeNcfgVersionHandler = require('./utils/nodeNcfgVersionHandler.js');
+var paramValues = require('./utils/paramValues.js');
+var ESPRMNeoBase = require('./ESPRMNeoBase.js');
+var transport = require('./types/transport.js');
+var common = require('./utils/common.js');
+var ESPConfigError = require('./utils/error/ESPConfigError.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("ESPRMNeoNode");
+/**
+ * Represents a node in the ESP Rainmaker Neo SDK.
+ * Provides access to node configuration and metadata.
+ *
+ * Live updates arrive via the subscription manager
+ * (`subscribeToNode` → {@link handleNodeUpdate}) and are re-broadcast on the
+ * process-wide node-updates bus for `user.subscribe(nodeUpdates)`.
+ */
+class ESPRMNeoNode {
+    nodeId;
+    config;
+    /** API/cache snapshot (snake_case devices/services) used for local persistence. */
+    wireConfig;
+    groupId;
+    /** All subgroup IDs this node belongs to under {@link groupId} (shadow segment order from {@link constructShadowName}). Empty when the node lives only at the root group. */
+    subgroupIds = [];
+    devices = [];
+    services = [];
+    connectivityStatus = {
+        isConnected: false,
+        lastConnectionTimestamp: 0,
+    };
+    /**
+     * Transports currently usable for this node, keyed by mode.
+     * - `mqtt` (cloud) is added when the node reports online and removed when
+     *   it goes offline (via shadow updates or seeded `connectivity_status`).
+     * - `local` is added/removed at runtime by a `localDiscovery` subscriber as the
+     *   node appears/disappears on the LAN (via {@link addTransport}/{@link removeTransport}).
+     * Apps may also add custom string-keyed entries (pair with
+     * {@link customTransportManagers}).
+     */
+    availableTransports = {};
+    /**
+     * Transport priority order for this node. Initialized from the global default
+     * ({@link ESPRMNeoBase.getTransportOrder}); override per-node via
+     * {@link setTransportOrder}.
+     */
+    transportOrder = [];
+    /**
+     * Optional per-node custom transport implementations keyed by mode. When a
+     * mode in {@link transportOrder} has an entry here, the transport handler uses
+     * it in preference to the built-in local/MQTT backends. Enables BLE, WebSocket
+     * or proprietary transports without modifying the SDK.
+     */
+    customTransportManagers;
+    /**
+     * Optional per-node subscription channel order, overriding the global order
+     * on {@link ESPRMNeoBase.subscriptionManager}. Set and read via the
+     * `setSubscriptionChannelOrder` / `getSubscriptionChannelOrder` methods
+     * added by module augmentation in
+     * `src/methods/ESPRMNeoNode/SubscriptionConfig.ts`.
+     */
+    subscriptionConfig;
+    constructor(config, groupId, subgroupIdOrIds) {
+        this.groupId = groupId;
+        this.subgroupIds = common.asStringArray(subgroupIdOrIds);
+        this.transportOrder = ESPRMNeoBase.ESPRMNeoBase.getTransportOrder();
+        this.availableTransports = {};
+        this.applyNodeConfig(config);
+        if (config.connectivity_status) {
+            this.connectivityStatus = config.connectivity_status;
+        }
+        if (this.connectivityStatus.isConnected) {
+            this.addTransport(transport.ESPTransportMode.mqtt, {
+                type: transport.ESPTransportMode.mqtt,
+                metadata: {},
+            });
+        }
+        this.subscribeToMqttUpdates();
+    }
+    /**
+     * Adds (or replaces) an available transport for this node, keyed by mode.
+     * Works for built-in modes ({@link ESPTransportMode}) and custom string modes.
+     * For a custom transport, also register its implementation via
+     * {@link addCustomTransportManager}.
+     *
+     * @param mode - Transport mode key (e.g. `local`, `mqtt`, or a custom string).
+     * @param config - The transport config (`{ type, metadata }`).
+     */
+    addTransport(mode, config) {
+        if (!mode || !config)
+            return;
+        this.availableTransports[mode] = config;
+    }
+    /**
+     * Removes an available transport for this node by mode.
+     *
+     * @param mode - Transport mode key to remove.
+     */
+    removeTransport(mode) {
+        delete this.availableTransports[mode];
+    }
+    /**
+     * Registers (or replaces) a custom transport manager for a mode. The transport
+     * handler prefers it over the built-in backend for that mode. Pair with
+     * {@link addTransport} so the mode also appears in {@link availableTransports}
+     * and participates in {@link transportOrder}.
+     *
+     * @param mode - Transport mode key the manager handles.
+     * @param manager - Implementation of {@link ESPTransportInterface}.
+     */
+    addCustomTransportManager(mode, manager) {
+        if (!mode || !manager)
+            return;
+        if (!this.customTransportManagers) {
+            this.customTransportManagers = {};
+        }
+        this.customTransportManagers[mode] = manager;
+    }
+    /**
+     * Removes the custom transport manager registered for a mode (if any).
+     *
+     * @param mode - Transport mode key to clear.
+     */
+    removeCustomTransportManager(mode) {
+        if (this.customTransportManagers) {
+            delete this.customTransportManagers[mode];
+        }
+    }
+    /**
+     * Overrides the transport priority order for this node only.
+     *
+     * @param order - Non-empty ordered list of transport modes.
+     * @throws {ESPConfigError} If the order is empty or not an array.
+     */
+    setTransportOrder(order) {
+        if (!Array.isArray(order) || order.length === 0) {
+            throw new ESPConfigError.ESPConfigError(constants.ConfigErrorCodes.INVALID_TRANSPORT_ORDER);
+        }
+        this.transportOrder = [...order];
+    }
+    /**
+     * Replaces config and rebuilds devices/services (used after cloud sync).
+     *
+     * Sets {@link config} so `config.devices` / `config.services` are the same
+     * live {@link ESPRMNeoDevice} / {@link ESPRMNeoService} instances as
+     * {@link devices} / {@link services}.
+     */
+    applyNodeConfig(config) {
+        this.nodeId = config.node_id ?? this.nodeId ?? "";
+        const info = nodeTransform.transformNodeInfo(config.info);
+        const nodeRef = new WeakRef(this);
+        const deviceRecords = Array.isArray(config.devices) ? config.devices : [];
+        const serviceRecords = Array.isArray(config.services) ? config.services : [];
+        this.devices = deviceRecords.map((d) => new ESPRMNeoDevice.ESPRMNeoDevice(nodeTransform.transformNodeDevice(d), nodeRef));
+        this.services = serviceRecords.map((s) => new ESPRMNeoService.ESPRMNeoService(nodeTransform.transformNodeService(s), nodeRef));
+        // Keep wire records for cache writes (never persist live class instances).
+        this.wireConfig = {
+            ...config,
+            info,
+            devices: deviceRecords,
+            services: serviceRecords,
+        };
+        this.config = {
+            ...config,
+            info,
+            devices: this.devices,
+            services: this.services,
+        };
+        paramValues.applyParamValues(this, config.params ?? {});
+    }
+    getShadowName() {
+        return shadowUtils.constructShadowName(this.groupId, this.subgroupIds);
+    }
+    /**
+     * RainMaker params channel: rainmaker/nodes/{nodeId}/user/{shadowName}/params
+     */
+    getParamsTopic() {
+        return shadowUtils.constructDeviceParamsTopic(this.nodeId, this.groupId, this.subgroupIds);
+    }
+    /**
+     * Registers this node with the MQTT orchestrator and subscribes via the
+     * subscription manager so the highest-priority available channel serves it
+     * (MQTT today; Matter/BLE when a satellite SDK registers one). Fire-and-forget
+     * from the constructor — failures are logged, not thrown.
+     */
+    async subscribeToMqttUpdates() {
+        const shadowName = this.getShadowName();
+        try {
+            // The MQTT channel reuses this registration rather than re-resolving
+            // the shadow.
+            NodeMQTTOrchestrator.NodeMQTTOrchestrator.registerNode(this.nodeId, shadowName);
+            await ESPRMNeoBase.ESPRMNeoBase.subscriptionManager.subscribeToNode(this, (update) => this.handleNodeUpdate(update));
+            // Warm read: the shadow GET response also arrives on the live
+            // subscription, delivering the node's current params right after subscribe.
+            await NodeMQTTOrchestrator.NodeMQTTOrchestrator.getParams(this.nodeId);
+        }
+        catch (error) {
+            logger.error("Failed to subscribe to MQTT updates", error);
+        }
+    }
+    /**
+     * Handles a normalized update from the subscription manager: applies it to the
+     * node's internal state (via {@link processNodeUpdate}) and re-broadcasts it on
+     * the process-wide node-updates bus for `user.subscribe(nodeUpdates)`.
+     *
+     * For MQTT the full shadow is carried in `metadata.shadow`, so internal
+     * bookkeeping (params + connectivity + config version) is unchanged. For a
+     * channel that only provides a param map, a minimal shadow is reconstructed.
+     *
+     * @param update - The normalized node update.
+     */
+    handleNodeUpdate(update) {
+        const shadow = update.metadata?.shadow ?? {
+            state: { reported: { params: update.payload } },
+        };
+        this.processNodeUpdate(shadow);
+        NodeUpdatesBus.emitNodeUpdate(update);
+    }
+    /**
+     * Applies a shadow update: devices/services params, connectivity, cache.
+     * If `ncfg_ver` changed, {@link ESPRMNeoNode#sync} → {@link applyNodeConfig}.
+     */
+    processNodeUpdate(shadow) {
+        const { params, connectivityStatus } = nodeTransform.extract(shadow);
+        if (Object.keys(params).length > 0) {
+            paramValues.applyParamValues(this, params);
+            this.config.params = paramValues.mergeParamMaps(this.config.params, params);
+            this.wireConfig.params = this.config.params;
+        }
+        this.applyConnectivityStatus(shadow, connectivityStatus);
+        ESPRMNeoStorage.ESPRMNeoStorage.setItem(constants.StorageKeys.NODE_CONFIG_PREFIX + this.nodeId, JSON.stringify({ ...this.wireConfig, node_id: this.nodeId }));
+        this.refreshConfigIfNcfgChanged(shadow);
+    }
+    /**
+     * Updates {@link connectivityStatus} and MQTT transport availability when the
+     * shadow reports `online`. Partial updates without `online` are ignored so
+     * an existing status is not cleared.
+     */
+    applyConnectivityStatus(shadow, connectivityStatus) {
+        if (shadow.state?.reported?.online === undefined)
+            return;
+        this.connectivityStatus = connectivityStatus;
+        if (connectivityStatus.isConnected) {
+            this.addTransport(transport.ESPTransportMode.mqtt, {
+                type: transport.ESPTransportMode.mqtt,
+                metadata: {},
+            });
+        }
+        else {
+            this.removeTransport(transport.ESPTransportMode.mqtt);
+        }
+    }
+    /** When cloud `ncfg_ver` changes, refetch config and persist the new marker. */
+    async refreshConfigIfNcfgChanged(shadow) {
+        try {
+            if (!(await nodeNcfgVersionHandler.hasNcfgVersionChanged(this.nodeId, shadow)))
+                return;
+            await this.sync();
+            await nodeNcfgVersionHandler.persistNcfgVersionMarker(this.nodeId, shadow);
+        }
+        catch (error) {
+            logger.error("Failed to refresh config on ncfg_ver change", error);
+        }
+    }
+}
+
+exports.ESPRMNeoNode = ESPRMNeoNode;
+//# sourceMappingURL=ESPRMNeoNode.js.map

package/dist/cjs/ESPRMNeoNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ESPRMNeoNode.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/ESPRMNeoSchedule.js

@@ -0,0 +1,66 @@
+'use strict';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Represents a schedule in the ESP Rainmaker Neo SDK.
+ * Provides instance methods for schedule operations.
+ */
+class ESPRMNeoSchedule {
+    id;
+    name;
+    nodeId;
+    groupId;
+    enabled;
+    triggers;
+    action;
+    validity;
+    node;
+    group;
+    constructor(schedule, nodeId, groupId, id, node, group) {
+        this.enabled = schedule.enabled;
+        this.triggers = schedule.triggers;
+        this.action = schedule.action;
+        this.validity = schedule.validity;
+        this.name = schedule.name;
+        this.nodeId = nodeId;
+        this.groupId = groupId;
+        this.node = node;
+        this.group = group;
+        this.id = id ?? schedule.id ?? ESPRMNeoSchedule.generateId();
+    }
+    /**
+     * Gets the node instance for this schedule.
+     * Returns the direct node reference when set, otherwise resolves it via the
+     * group. Returns `null` when neither path yields a node.
+     */
+    async getNode() {
+        if (this.node) {
+            return this.node;
+        }
+        if (this.group) {
+            try {
+                return await this.group.getNode(this.nodeId);
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    /**
+     * Generates a schedule id when the caller doesn't provide one.
+     * 4-char base36 tail (a-z, 0-9) — ~1.6M values per node. Duplicate ids
+     * inside a single node's list are still guarded against at create-time by
+     * {@link ESPRMNeoNode.createSchedule}.
+     */
+    static generateId() {
+        return `schedule_${Math.random().toString(36).slice(2, 6)}`;
+    }
+}
+
+exports.ESPRMNeoSchedule = ESPRMNeoSchedule;
+//# sourceMappingURL=ESPRMNeoSchedule.js.map

package/dist/cjs/ESPRMNeoSchedule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ESPRMNeoSchedule.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/ESPRMNeoService.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var ESPRMNeoServiceParam = require('./ESPRMNeoServiceParam.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Node-level service (not tied to a single device), e.g. time, local control.
+ * Holds a WeakRef to the parent node for delegating getParams/setParams.
+ */
+class ESPRMNeoService {
+    name;
+    type;
+    params;
+    _nodeRef;
+    constructor(data, nodeRef) {
+        this.name = data.name;
+        this.type = data.type ?? "";
+        this._nodeRef = nodeRef;
+        this.params = (data.params ?? []).map((p) => new ESPRMNeoServiceParam.ESPRMNeoServiceParam({
+            id: p.id,
+            type: p.type ?? p.id,
+            properties: p.properties ?? [],
+            dataType: p.dataType,
+            serviceName: data.name,
+            bounds: p.bounds,
+            validStrings: p.validStrings,
+        }, nodeRef));
+    }
+}
+
+exports.ESPRMNeoService = ESPRMNeoService;
+//# sourceMappingURL=ESPRMNeoService.js.map

package/dist/cjs/ESPRMNeoService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ESPRMNeoService.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/ESPRMNeoServiceParam.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var DelegatedTransportHandler = require('./services/ESPRMNeoHelpers/DelegatedTransportHandler.js');
+var constants = require('./utils/constants.js');
+var ESPAPICallValidationError = require('./utils/error/ESPAPICallValidationError.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Service parameter – one parameter of a node service (e.g. timezone).
+ * Holds a WeakRef to the parent node so writes can be dispatched via the best
+ * available transport (see {@link delegatedTransportHandler}).
+ */
+class ESPRMNeoServiceParam {
+    id;
+    type;
+    properties;
+    dataType;
+    serviceName;
+    bounds;
+    validStrings;
+    value;
+    _nodeRef;
+    constructor(data, nodeRef) {
+        this.id = data.id;
+        this.type = data.type ?? data.id;
+        this.properties = data.properties ?? [];
+        this.dataType = data.dataType;
+        this.serviceName = data.serviceName;
+        this.bounds = data.bounds;
+        this.validStrings = data.validStrings;
+        this.value = data.value;
+        this._nodeRef = nodeRef;
+    }
+    setValue(value) {
+        const node = this._nodeRef.deref();
+        if (!node) {
+            throw new ESPAPICallValidationError.ESPAPICallValidationError(constants.APICallValidationErrorCodes.MISSING_NODE_REF);
+        }
+        const payload = {
+            node_id: node.nodeId,
+            payload: { [this.serviceName]: { [this.id]: value } },
+        };
+        return (DelegatedTransportHandler.delegatedTransportHandler).call(node, (manager) => manager.setParam(payload, node));
+    }
+}
+
+exports.ESPRMNeoServiceParam = ESPRMNeoServiceParam;
+//# sourceMappingURL=ESPRMNeoServiceParam.js.map

package/dist/cjs/ESPRMNeoServiceParam.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ESPRMNeoServiceParam.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/ESPRMNeoSharingRequest.js

@@ -0,0 +1,33 @@
+'use strict';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Represents a sharing request in the ESP Rainmaker Neo SDK.
+ * Provides instance methods for sharing request operations.
+ */
+class ESPRMNeoSharingRequest {
+    sharingRequestId;
+    groupId;
+    subgroupId;
+    accessType;
+    /** Primary user information who sent the share invitation. */
+    primaryUserId;
+    primaryEmail;
+    primaryPhoneNumber;
+    constructor(data) {
+        this.sharingRequestId = data.sharing_request_id;
+        this.groupId = data.group_id;
+        this.subgroupId = data.subgroup_id;
+        this.accessType = data.access_type;
+        this.primaryUserId = data.primary_user_id ?? "";
+        this.primaryEmail = data.primary_email ?? "";
+        this.primaryPhoneNumber = data.primary_phone_number ?? "";
+    }
+}
+
+exports.ESPRMNeoSharingRequest = ESPRMNeoSharingRequest;
+//# sourceMappingURL=ESPRMNeoSharingRequest.js.map

package/dist/cjs/ESPRMNeoSharingRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ESPRMNeoSharingRequest.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/ESPRMNeoTrigger.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var triggerUtils = require('./utils/triggerUtils.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Represents a trigger in the ESP Rainmaker Neo SDK.
+ * Provides instance methods for trigger operations.
+ * Holds a WeakRef to the parent node, matching the pattern used by
+ * ESPRMNeoDevice / ESPRMNeoService / ESPRMNeoDeviceParam.
+ */
+class ESPRMNeoTrigger {
+    id;
+    nodeId;
+    groupId;
+    type;
+    enabled;
+    path;
+    operator;
+    value;
+    _nodeRef;
+    constructor(data, node) {
+        this.id = data.id;
+        this.type = data.type;
+        this.enabled = data.enabled;
+        this.path = data.path;
+        this.operator = data.operator;
+        this.value = data.value;
+        this.nodeId = node.nodeId;
+        this.groupId = node.groupId;
+        this._nodeRef = new WeakRef(node);
+    }
+    /** Parent node, if the weak reference is still alive. */
+    getNode() {
+        return this._nodeRef.deref();
+    }
+    /**
+     * Converts this trigger to a plain TriggerItem (for building API payloads).
+     */
+    toTriggerItem() {
+        return triggerUtils.triggerToItem(this);
+    }
+}
+
+exports.ESPRMNeoTrigger = ESPRMNeoTrigger;
+//# sourceMappingURL=ESPRMNeoTrigger.js.map

package/dist/cjs/ESPRMNeoTrigger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ESPRMNeoTrigger.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/ESPRMNeoUser.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var constants = require('./utils/constants.js');
+var ESPRMNeoStorage = require('./services/ESPRMNeoStorage/ESPRMNeoStorage.js');
+var ESPRMNeoAuth = require('./ESPRMNeoAuth.js');
+var ESPTokenError = require('./utils/error/ESPTokenError.js');
+var logger$1 = require('./utils/logger.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = new logger$1.Logger("ESPRMNeoUser");
+/**
+ * Represents an authenticated user in the ESP Rainmaker Neo system.
+ * Provides methods for user operations, device management, group management,
+ * and MQTT-based real-time communication.
+ *
+ */
+class ESPRMNeoUser {
+    /** Registered event subscriber callbacks, keyed by event (see {@link subscribe}). */
+    eventCallbacks = {};
+    /**
+     * Per-event teardown handles for backing sources started by {@link subscribe}
+     * (LAN discovery, node-updates bus, custom discovery). Kept so
+     * {@link unsubscribe} / {@link removeAllCallbacks} can stop them.
+     */
+    eventTeardowns = {};
+    /**
+     * Initializes the ESPRMNeoUser instance and persists the tokens to storage.
+     *
+     * @param tokens - Object containing the access token, id token, and refresh token.
+     */
+    constructor(tokens) {
+        ESPRMNeoStorage.ESPRMNeoStorage.setItem(constants.StorageKeys.ACCESSTOKEN, tokens.accessToken);
+        ESPRMNeoStorage.ESPRMNeoStorage.setItem(constants.StorageKeys.IDTOKEN, tokens.idToken);
+        ESPRMNeoStorage.ESPRMNeoStorage.setItem(constants.StorageKeys.REFRESHTOKEN, tokens.refreshToken);
+        logger.debug("User initialized");
+    }
+    /** Reads a token from storage, throwing when the user is not logged in. */
+    static async requireToken(storageKey, missingCode) {
+        const token = await ESPRMNeoStorage.ESPRMNeoStorage.getItem(storageKey);
+        if (!token) {
+            throw new ESPTokenError.ESPTokenError(missingCode);
+        }
+        return token;
+    }
+    /**
+     * Returns the current Cognito access token from storage.
+     * @throws {ESPTokenError} When no access token is stored (not logged in).
+     */
+    async getAccessToken() {
+        return ESPRMNeoUser.requireToken(constants.StorageKeys.ACCESSTOKEN, constants.TokenErrorCodes.MISSING_ACCESS_TOKEN);
+    }
+    /**
+     * Returns the current Cognito ID token from storage.
+     * @throws {ESPTokenError} When no ID token is stored (not logged in).
+     */
+    async getIdToken() {
+        return ESPRMNeoUser.requireToken(constants.StorageKeys.IDTOKEN, constants.TokenErrorCodes.MISSING_ID_TOKEN);
+    }
+    /**
+     * Returns the current Cognito refresh token from storage.
+     * @throws {ESPTokenError} When no refresh token is stored (not logged in).
+     */
+    async getRefreshToken() {
+        return ESPRMNeoUser.requireToken(constants.StorageKeys.REFRESHTOKEN, constants.TokenErrorCodes.MISSING_REFRESH_TOKEN);
+    }
+    /**
+     * Extends the current session using a refresh token.
+     */
+    static async extendSession(refreshToken) {
+        const response = await ESPRMNeoAuth.ESPRMNeoAuth.getRefreshedTokens(refreshToken);
+        await ESPRMNeoStorage.ESPRMNeoStorage.setItem(constants.StorageKeys.ACCESSTOKEN, response.accessToken);
+        await ESPRMNeoStorage.ESPRMNeoStorage.setItem(constants.StorageKeys.IDTOKEN, response.idToken);
+        await ESPRMNeoStorage.ESPRMNeoStorage.setItem(constants.StorageKeys.REFRESHTOKEN, response.refreshToken);
+    }
+}
+
+exports.ESPRMNeoUser = ESPRMNeoUser;
+//# sourceMappingURL=ESPRMNeoUser.js.map

package/dist/cjs/ESPRMNeoUser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ESPRMNeoUser.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}