@espressif/rainmaker-neo-base-sdk 1.0.0

package/dist/types/utils/nodeTransform.d.ts

@@ -0,0 +1,66 @@
+import { ESPRMNeoAttributeInterface, ESPRMNeoAttributeAPI, ESPRMNeoParamAPI, ESPRMNeoDeviceAPI, ESPRMNeoServiceAPI, ESPRMNeoExtractedShadow, ESPRMNeoShadowDocument, ESPRMNeoNodeInfoAPI, ESPRMNeoNodeInfoInterface } from "../types/node";
+/**
+ * Transforms a raw API attribute to the shape used by {@link ESPRMNeoDevice}.
+ */
+export declare function transformApiAttributeForNodeDevice(attr: ESPRMNeoAttributeAPI): ESPRMNeoAttributeInterface;
+/**
+ * Transforms a raw API param to device param input for {@link ESPRMNeoDevice}.
+ * Tolerates both the API shape (snake_case) and the legacy cached runtime
+ * shape (camelCase, see {@link ESPRMNeoCachedParamShape}).
+ */
+export declare function transformApiParamForNodeDevice(p: ESPRMNeoParamAPI): {
+    id: string;
+    type: string;
+    properties: string[];
+    dataType: string;
+    uiType?: string;
+    bounds?: ESPRMNeoParamAPI["bounds"];
+    validStrings?: string[];
+};
+/**
+ * Transforms a raw API param to service param input for {@link ESPRMNeoService}.
+ * Tolerates both the API shape (snake_case) and the legacy cached runtime
+ * shape (camelCase, see {@link ESPRMNeoCachedParamShape}).
+ */
+export declare function transformApiParamForNodeService(p: ESPRMNeoParamAPI): {
+    id: string;
+    type: string;
+    properties: string[];
+    dataType: string;
+    bounds?: ESPRMNeoParamAPI["bounds"];
+    validStrings?: string[];
+};
+/**
+ * Builds the first constructor argument for {@link ESPRMNeoDevice} from API data.
+ * Trusts the wire/API shape (`id`, `type`, …) — callers pass cloud or cache
+ * config already resolved before {@link ESPRMNeoNode} construction.
+ */
+export declare function transformNodeDevice(d: ESPRMNeoDeviceAPI): {
+    name: string;
+    displayName: string;
+    type: string;
+    primary: string;
+    attributes?: ESPRMNeoAttributeInterface[];
+    params: ReturnType<typeof transformApiParamForNodeDevice>[];
+};
+/**
+ * Builds the first constructor argument for {@link ESPRMNeoService} from API data.
+ * Trusts the wire/API shape (`id`, `type`, …) — same as {@link transformNodeDevice}.
+ */
+export declare function transformNodeService(s: ESPRMNeoServiceAPI): {
+    name: string;
+    type: string;
+    params: ReturnType<typeof transformApiParamForNodeService>[];
+};
+/**
+ * Transforms a raw node config `info` block ({@link ESPRMNeoNodeInfoAPI}) to
+ * {@link ESPRMNeoNodeInfoInterface}. The mapped `firmwareVersion` is added
+ * alongside the raw wire keys (`fw_version` is kept via the spread), so
+ * re-transforming an already-transformed object is a no-op.
+ * Returns `undefined` when `raw` is missing or not an object.
+ */
+export declare function transformNodeInfo(raw?: ESPRMNeoNodeInfoAPI | null): (ESPRMNeoNodeInfoInterface & ESPRMNeoNodeInfoAPI) | undefined;
+/**
+ * Params and connectivity from a shadow / reported-state JSON payload.
+ */
+export declare function extract(json: ESPRMNeoShadowDocument): ESPRMNeoExtractedShadow;

package/dist/types/utils/nodeUtils.d.ts

@@ -0,0 +1,36 @@
+import { ESPRMNeoGroup } from "../ESPRMNeoGroup";
+import { ESPRMNeoNode } from "../ESPRMNeoNode";
+import { NodeConfigAPI } from "../types/output";
+/** Sorted subgroup IDs under this group that contain `nodeId`. */
+export declare function collectSubgroupIdsForNode(group: ESPRMNeoGroup, nodeId: string): string[];
+/** Read node config from local storage. Returns null on miss or corrupt data. */
+export declare function readLocalNodeConfig(nodeId: string): Promise<NodeConfigAPI | null>;
+/** Best-effort persist of node config to local storage. */
+export declare function writeLocalNodeConfig(nodeId: string, config: NodeConfigAPI): Promise<void>;
+/** Best-effort removal of node config from local storage. */
+export declare function removeLocalNodeConfig(nodeId: string): Promise<void>;
+/**
+ * Best-effort clear of the ncfg version marker.
+ * Safe even when the node remains associated to another group — the marker
+ * will re-baseline on the next shadow update.
+ */
+export declare function clearLocalNcfgVersionMarker(nodeId: string): Promise<void>;
+/**
+ * Best-effort cleanup of local node config cache + ncfg version marker.
+ * Safe even when the node remains associated to another group.
+ */
+export declare function clearLocalNodeCache(nodeId: string): Promise<void>;
+/**
+ * Fetch node config from the cloud.
+ *
+ * Config is always served on the root-group route — the subgroup variant
+ * (`…/subgroups/{sgid}/nodes/{nid}/config`) does not exist in the backend
+ * (verified against the backend source: the gateway defines only PUT/DELETE on
+ * subgroup nodes). Subgroup-scoped users still pass the access check here
+ * because the user↔group mapping is keyed on the root group id.
+ */
+export declare function fetchCloudNodeConfigForNode(groupId: string, nodeId: string): Promise<NodeConfigAPI>;
+/** Fetch node config from the cloud and best-effort write it to local storage. */
+export declare function fetchCloudNodeConfig(group: ESPRMNeoGroup, nodeId: string): Promise<NodeConfigAPI>;
+/** Wrap a resolved config in an ESPRMNeoNode for this group context. */
+export declare function toNeoNode(group: ESPRMNeoGroup, config: NodeConfigAPI, nodeId: string): ESPRMNeoNode;

package/dist/types/utils/normalizeApiResponse.d.ts

@@ -0,0 +1,6 @@
+import type { SuccessResponse } from "../types/output";
+/**
+ * Normalizes API success payloads to {@link SuccessResponse}.
+ * Expects `{ message }` from the backend or an empty body on success.
+ */
+export declare function normalizeApiResponse(response: unknown, fallback?: SuccessResponse): SuccessResponse;

package/dist/types/utils/paramValues.d.ts

@@ -0,0 +1,30 @@
+/** Minimal param shape needed to apply live values. */
+export interface ParamWithValue {
+    id: string;
+    value?: unknown;
+}
+/** Named device/service host with params that can receive live values. */
+export interface NodeParamEntity {
+    name: string;
+    params: ParamWithValue[];
+}
+/** Device/service host used when applying a full params snapshot. */
+export interface NodeParamHost {
+    devices: NodeParamEntity[];
+    services: NodeParamEntity[];
+}
+/**
+ * Writes values from a map onto matching param instances.
+ * Params whose id is absent from the map are left unchanged.
+ */
+export declare function applyValuesToParams(params: ParamWithValue[], values: unknown): void;
+/**
+ * Writes a params snapshot (`entityName → { paramId → value }`) onto matching
+ * device/service param instances.
+ */
+export declare function applyParamValues(node: NodeParamHost, values: Record<string, unknown>): void;
+/**
+ * Deep-merges an incoming params map onto a previous one (per entity name).
+ * Partial updates (e.g. only `Switch.Power`) keep sibling entities/params.
+ */
+export declare function mergeParamMaps(previous: unknown, incoming: Record<string, unknown>): Record<string, unknown>;

package/dist/types/utils/scheduleUtils.d.ts

@@ -0,0 +1,14 @@
+import { ESPRMNeoNode } from "../ESPRMNeoNode";
+import { ESPRMNeoSchedule } from "../ESPRMNeoSchedule";
+import { ScheduleItem } from "../types/schedule";
+/**
+ * Fetches the current schedule list for a node as ScheduleItem[].
+ * Always hits the cloud — the schedules API is replace-all and has no
+ * version marker, so the SDK does not cache to avoid silent overwrites
+ * when another session edits the same list.
+ */
+export declare function getScheduleItemsForNode(node: ESPRMNeoNode): Promise<ScheduleItem[]>;
+/**
+ * Converts an ESPRMNeoSchedule instance to ScheduleItem (for building payloads).
+ */
+export declare function scheduleToItem(s: ESPRMNeoSchedule): ScheduleItem;

package/dist/types/utils/shadowUtils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Constructs a shadow name based on group ID and subgroups
+ * @param groupId The group ID
+ * @param subgroups Array of subgroup IDs
+ * @returns The constructed shadow name
+ */
+export declare function constructShadowName(groupId: string, subgroups?: string[]): string;
+/**
+ * Constructs a shadow topic for a device
+ * @param nodeId The node ID
+ * @param groupId The group ID
+ * @param subgroups Array of subgroup IDs
+ * @returns The constructed shadow topic
+ */
+export declare function constructShadowTopic(nodeId: string, groupId: string, subgroups: string[]): string;
+/**
+ * Constructs a device parameters topic
+ * @param nodeId The node ID
+ * @param groupId The group ID
+ * @param subgroups Array of subgroup IDs
+ * @returns The constructed parameters topic
+ */
+export declare function constructDeviceParamsTopic(nodeId: string, groupId: string, subgroups: string[]): string;
+/**
+ * Generates a digest for parameters to detect changes
+ * @param params The parameters object
+ * @returns A digest string representing the parameters
+ */
+export declare function generateParamsDigest(params: Record<string, any>): string;

package/dist/types/utils/triggerUtils.d.ts

@@ -0,0 +1,32 @@
+import { ESPRMNeoNode } from "../ESPRMNeoNode";
+import { TriggerItem, TriggerOperator } from "../types/trigger";
+/**
+ * Converts a trigger-like object to TriggerItem (for building payloads).
+ */
+export declare function triggerToItem(t: {
+    id: string;
+    type: string;
+    enabled?: boolean;
+    path: string;
+    operator: TriggerOperator;
+    value: unknown;
+}): TriggerItem;
+/**
+ * Fetches the current trigger list for a node as TriggerItem[].
+ * Always hits the cloud — the triggers API is replace-all.
+ */
+export declare function getTriggerItemsForNode(node: ESPRMNeoNode): Promise<TriggerItem[]>;
+/**
+ * Merges defined update fields onto a base TriggerItem without writing
+ * `undefined` over existing values.
+ */
+export declare function mergeTriggerItem(base: TriggerItem, updates: Partial<TriggerItem>): TriggerItem;
+/**
+ * Copies defined update fields onto a live trigger instance.
+ */
+export declare function applyTriggerUpdates(target: {
+    path: string;
+    enabled?: boolean;
+    operator: TriggerOperator;
+    value: unknown;
+}, updates: Partial<TriggerItem>): void;

package/dist/types/utils/tsDataUtils.d.ts

@@ -0,0 +1,70 @@
+import type { ESPRMNeoNode } from "../ESPRMNeoNode";
+import type { ESPRMNeoTSAggregateEntry, ESPRMNeoTSAggregateEntryAPI, ESPRMNeoTSAggregationWindow, ESPRMNeoTSDataOptions, ESPRMNeoTSDataPoint, ESPRMNeoTSDataPointAPI } from "../types/tsData";
+/** Param property flag marking a param as time-series capable (node config). */
+export declare const TIME_SERIES_PROPERTY = "time_series";
+/**
+ * Backend query identity of a time-series param: the `key`
+ * (`"<device_id>.<param_id>"`) and `data_type` every timeseries endpoint
+ * requires. A `data_type` mismatch silently returns no data, so it is read
+ * from the param metadata unless explicitly overridden via options.
+ */
+export interface TSParamIdentity {
+    key: string;
+    dataType: string;
+}
+/**
+ * Returns the explicit query identity from options when the caller provided
+ * one, bypassing any node-config lookup. This is the escape hatch for data
+ * models the default lookup cannot resolve (e.g. Matter attributes).
+ *
+ * @throws {ESPAPICallValidationError} If `options.key` is set without `options.dataType`.
+ */
+export declare function tsParamIdentityFromOptions(options?: ESPRMNeoTSDataOptions): TSParamIdentity | undefined;
+/**
+ * Builds the backend query identity from a device param's own metadata
+ * (used by the param-level methods, where `this` IS the param).
+ *
+ * @throws {ESPAPICallValidationError} If no data type can be determined.
+ */
+export declare function tsParamIdentityFromParam(param: {
+    id: string;
+    deviceName: string;
+    dataType?: string;
+    properties?: string[];
+}, options?: ESPRMNeoTSDataOptions): TSParamIdentity;
+/**
+ * Resolves the backend query identity for a device param by looking it up in
+ * the node's config (used by the node-level methods).
+ *
+ * @throws {ESPAPICallValidationError} If the param is not found on the node's config.
+ */
+export declare function resolveTSParamIdentity(node: ESPRMNeoNode, deviceName: string, paramId: string, options?: ESPRMNeoTSDataOptions): TSParamIdentity;
+/**
+ * Resolves the aggregation window from options.
+ *
+ * @throws {ESPAPICallValidationError} If no valid window is provided.
+ */
+export declare function resolveTSWindow(options?: ESPRMNeoTSDataOptions): ESPRMNeoTSAggregationWindow;
+/**
+ * Builds a URL query string from the given params, skipping undefined values.
+ */
+export declare function buildTSQueryString(params: Record<string, string | number | undefined>): string;
+/**
+ * Maps a raw API sample into an {@link ESPRMNeoTSDataPoint}.
+ * The backend emits `key`; older swagger examples show `name` — both accepted.
+ */
+export declare function transformTSDataPoint(point: ESPRMNeoTSDataPointAPI): ESPRMNeoTSDataPoint;
+/**
+ * Maps a raw API aggregate entry into an {@link ESPRMNeoTSAggregateEntry}.
+ *
+ * The backend emits two entry shapes:
+ * - **Nested** (`windows: {hourly: {...}, ...}`) — only the current-aggregates
+ *   query with no `window` param (all windows at once).
+ * - **Flat** — historical `date`/`start_date`+`end_date` queries and the
+ *   current-single-window query put the stats directly on the entry
+ *   (`{date, window_start, count, average, ...}`), with no `windows` map.
+ *
+ * Flat entries are nested under `requestedWindow` so consumers always read
+ * `entry.windows[window]` regardless of query mode.
+ */
+export declare function transformTSAggregateEntry(entry: ESPRMNeoTSAggregateEntryAPI, requestedWindow?: ESPRMNeoTSAggregationWindow): ESPRMNeoTSAggregateEntry;

package/dist/types/utils/userUtils.d.ts

@@ -0,0 +1,11 @@
+export declare function errorDetail(error: unknown): string;
+/** Runs an action without letting failures abort the caller. */
+export declare function failSafe(step: string, action: () => void | Promise<void>): Promise<void>;
+/** Best-effort `POST /v1/user/auth/signout` when an access token is present. */
+export declare function invalidateServerSession(): Promise<void>;
+/** Removes access, id, and refresh tokens from storage. */
+export declare function clearTokens(): Promise<void>;
+/**
+ * Clears ncfg version markers and every cached node config they referenced.
+ */
+export declare function clearNodeConfigCache(): Promise<void>;

package/dist/types/utils/validator/ConfigValidator.d.ts

@@ -0,0 +1,99 @@
+import { ESPRMNeoBaseConfig } from "../../types/input";
+/**
+ * A class that validates configuration objects for the ESP RainMaker Neo SDK.
+ *
+ * This class provides methods to ensure that the provided configuration
+ * adheres to the required structure and rules for URLs, versions, and other fields.
+ */
+export declare class ConfigValidator {
+    /**
+     * Validates the given authentication configuration.
+     *
+     * @param config - The authentication configuration object to validate.
+     * @throws {ESPConfigError} If the configuration is invalid.
+     */
+    static validateConfig(config: ESPRMNeoBaseConfig): void;
+    /**
+     * Validates that the provided configuration object is valid.
+     *
+     * @param config - The configuration object to validate.
+     * @throws {ESPConfigError} If the configuration object is invalid.
+     */
+    private static validateConfigObject;
+    /**
+     * Validates the base URL of the configuration.
+     *
+     * @param baseUrl - The base URL to validate.
+     * @throws {ESPConfigError} If the base URL is invalid or empty.
+     */
+    private static validateBaseUrl;
+    /**
+     * Validates the User/auth API base URL of the configuration.
+     *
+     * @param userApiBase - The User API base URL to validate.
+     * @throws {ESPConfigError} If the User API base URL is invalid or empty.
+     */
+    private static validateUserApiBase;
+    /**
+     * Validates the AWS region.
+     *
+     * @param region - The AWS region to validate.
+     * @throws {ESPConfigError} If the region is invalid or empty.
+     */
+    private static validateRegion;
+    /**
+     * Validates the IoT endpoint (used for MQTT and SigV4-signed connections).
+     * Accepts either a hostname (e.g. `xxxxx-ats.iot.region.amazonaws.com`) or a
+     * full `wss://…/mqtt` URL; both forms are normalised downstream.
+     *
+     * @param iotEndpoint - The IoT endpoint string to validate.
+     * @throws {ESPConfigError} If the endpoint is missing or empty.
+     */
+    private static validateIotEndpoint;
+    /**
+     * Validates that an adapter is an object and implements every method in
+     * {@link requiredMethods}. Throws with {@link errorCode} on the first
+     * missing method.
+     */
+    private static validateAdapterShape;
+    /**
+     * Validates the custom storage adapter if provided.
+     *
+     * @param adapter - The custom storage adapter to validate. Optional.
+     * @throws {ESPConfigError} If the adapter is provided but does not implement
+     *   the {@link ESPStorageAdapter} contract.
+     */
+    private static validateCustomStorageAdapter;
+    /**
+     * Validates the MQTT adapter if provided.
+     *
+     * @param adapter - The MQTT adapter to validate. Optional.
+     * @throws {ESPConfigError} If the adapter is provided but does not implement
+     *   the {@link MQTTTransport} contract.
+     */
+    private static validateMQTTAdapter;
+    /**
+     * Validates the provisioning adapter if provided.
+     *
+     * @param adapter - The provisioning adapter to validate. Optional.
+     * @throws {ESPConfigError} If the adapter is provided but does not implement
+     *   the {@link ESPProvisionAdapterInterface} contract.
+     */
+    private static validateProvisionAdapter;
+    /**
+     * Validates the local control adapter if provided.
+     *
+     * @param adapter - The local control adapter to validate. Optional.
+     * @throws {ESPConfigError} If the adapter is provided but does not implement
+     *   the {@link ESPLocalControlAdapterInterface} contract.
+     */
+    private static validateLocalControlAdapter;
+    /**
+     * Validates the local discovery adapter if provided.
+     *
+     * @param adapter - The local discovery adapter to validate. Optional.
+     * @throws {ESPConfigError} If the adapter is provided but does not implement
+     *   the {@link ESPLocalDiscoveryAdapterInterface} contract.
+     */
+    private static validateLocalDiscoveryAdapter;
+}

package/dist/types/utils/validator/ScheduleValidator.d.ts

@@ -0,0 +1,23 @@
+import { ScheduleItem } from "../../types/schedule";
+/**
+ * Validates schedule payloads used by group/node schedule APIs.
+ */
+export declare class ScheduleValidator {
+    /**
+     * Validates the `nodeSchedules` argument for `createSchedule`.
+     *
+     * @param nodeSchedules - Per-node schedule batches to validate.
+     * @throws {ESPAPICallValidationError} If the payload shape is invalid.
+     */
+    static validateNodeSchedules(nodeSchedules: Array<{
+        nodeId: string;
+        schedules: ScheduleItem[];
+    }>): void;
+    /**
+     * Validates a single schedule item.
+     *
+     * @param item - The schedule item to validate.
+     * @throws {ESPAPICallValidationError} If required fields are missing or invalid.
+     */
+    static validateScheduleItem(item: ScheduleItem): void;
+}

package/dist/types/utils/validator/validators.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Checks if a string is not empty.
+ * @param value - The string to check.
+ * @returns True if the string is not empty, false otherwise.
+ */
+export declare const isNonEmptyString: (value: any) => boolean;
+/**
+ * Validates if a given string is a valid URL.
+ * @param url - The URL string to validate.
+ * @returns True if the URL is valid, false otherwise.
+ */
+export declare const isValidUrl: (url: string) => boolean;
+/**
+ * Checks if a value is a valid object (not null and type object).
+ * @param value - The value to check.
+ * @returns True if the value is a valid object, false otherwise.
+ */
+export declare const isValidObject: (value: any) => boolean;

package/dist/types/utils/waitForNodeOnline.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Waits for a RainMakerNeo node to report `online: true` in its AWS IoT Device Shadow.
+ *
+ * Typical use: after provisioning WiFi credentials, the device joins the network and
+ * connects to the cloud. There is no dedicated "online" MQTT topic — connectivity is
+ * published as `state.reported.online` inside shadow update messages on the named
+ * shadow `params-{groupId}` (firmware writes this after getGroupInfo; cloud presence
+ * only clears online on disconnect).
+ *
+ * Matches app_sim `_wait_node_online`: subscribe first, then poll shadow GET on an
+ * interval until `reported.online === true` (or a live MQTT update arrives). GET may
+ * 404 while the shadow does not exist yet — that is expected and ignored.
+ *
+ * This helper registers a **temporary** subscription via {@link NodeMQTTOrchestrator},
+ * resolves when online is detected, then unsubscribes (and unregisters only if it
+ * created the binding) so a later {@link ESPRMNeoNode} attach does not lose listeners.
+ */
+import { ESPRMNeoUser } from "../ESPRMNeoUser";
+/** Default max wait after WiFi provisioning before rejecting (2 minutes). */
+export declare const DEFAULT_NODE_ONLINE_TIMEOUT_MS = 120000;
+/** Interval between shadow GET polls while waiting (matches app_sim). */
+export declare const DEFAULT_NODE_ONLINE_POLL_INTERVAL_MS = 5000;
+export interface WaitForNodeOnlineParams {
+    nodeId: string;
+    /** Group the node was associated with during provisioning (drives shadow name). */
+    groupId: string;
+    /** Logged-in user; used to connect MQTT if not already connected. */
+    user: ESPRMNeoUser;
+    timeoutMs?: number;
+    /** Shadow GET poll interval. Default: {@link DEFAULT_NODE_ONLINE_POLL_INTERVAL_MS}. */
+    pollIntervalMs?: number;
+}
+/**
+ * Detects online status from a shadow MQTT payload or getShadow state slice.
+ *
+ * Live MQTT messages use `{ state: { reported: { online: true } } }`.
+ * {@link NodeMQTTOrchestrator.getShadow} returns `{ reported: { online: true } }`.
+ */
+export declare function isNodeOnlineFromShadowPayload(payload: unknown): boolean;
+/**
+ * Subscribes to shadow MQTT for `nodeId`, polls getShadow on an interval, resolves
+ * when `online: true`, then unsubscribes and unregisters the temporary node binding
+ * (if owned).
+ *
+ * @throws {ESPProvError} If `timeoutMs` elapses without the node reporting online.
+ * @throws {Error} If MQTT connection or subscription fails.
+ */
+export declare function waitForNodeOnline({ nodeId, groupId, user, timeoutMs, pollIntervalMs, }: WaitForNodeOnlineParams): Promise<void>;

package/package.json

@@ -0,0 +1,116 @@
+{
+  "name": "@espressif/rainmaker-neo-base-sdk",
+  "description": "ESP RainMaker Neo TypeScript SDK for JS-based apps — Cognito auth, MQTT control, device provisioning, groups, and real-time node updates.",
+  "version": "1.0.0",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
+  "author": "Espressif Systems (Shanghai) CO LTD",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/espressif/esp-rainmaker-neo-app-sdk-ts.git"
+  },
+  "homepage": "https://github.com/espressif/esp-rainmaker-neo-app-sdk-ts#readme",
+  "bugs": {
+    "url": "https://github.com/espressif/esp-rainmaker-neo-app-sdk-ts/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && rollup -c rollup.config.mjs",
+    "test": "jest --selectProjects unit",
+    "test:watch": "jest --selectProjects unit --watch",
+    "test:coverage": "jest --selectProjects unit --coverage",
+    "test:integration": "jest --selectProjects integration",
+    "test:contract": "jest --selectProjects contract",
+    "test:workflow": "jest --selectProjects workflow",
+    "test:adapter": "jest --selectProjects adapter",
+    "test:all": "jest --selectProjects unit contract workflow adapter integration",
+    "test:closed": "RMNEO_CLOSED_WORLD=1 jest --selectProjects unit contract workflow adapter",
+    "openapi:sync": "node scripts/sync-openapi.mjs",
+    "openapi:sync:check": "node scripts/sync-openapi.mjs --check",
+    "schema:gen": "node test-utils/schema-generator/generate.mjs",
+    "schema:selftest": "node --test test-utils/schema-generator/openapiToJsonSchema.test.mjs scripts/lib/spec-source.test.mjs",
+    "schema:verify": "node test-utils/schema-generator/generate.mjs && git diff --exit-code -I \"fingerprintsGeneratedAt\" contracts/openapi/generated contracts/openapi/manifest.json",
+    "typecheck": "tsc -p tsconfig.test.json --noEmit",
+    "contracts:drift-check": "node scripts/check-contract-drift.mjs",
+    "contracts:coverage-check": "node scripts/check-tracking-coverage.mjs",
+    "contracts:build": "npm run openapi:sync && npm run schema:gen",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "eslint src __tests__ --ext .ts",
+    "genDocs": "rm -rf docs && typedoc"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "esp",
+    "esp-rainmaker",
+    "esp-rainmaker-neo-sdk",
+    "esp-rainmaker-app-sdk",
+    "esp-device-provisioning",
+    "esp-device-control",
+    "esp-mqtt-communication",
+    "esp-aws-iot-core",
+    "esp-cognito-auth",
+    "react-native",
+    "typescript",
+    "iot",
+    "esp32",
+    "device-management",
+    "real-time-communication",
+    "wifi-provisioning",
+    "aws-cognito",
+    "mqtt"
+  ],
+  "dependencies": {
+    "google-protobuf": "^3.21.2"
+  },
+  "devDependencies": {
+    "@apidevtools/swagger-parser": "^10.1.1",
+    "@react-native-async-storage/async-storage": "^2.2.0",
+    "@rollup/plugin-commonjs": "^29.0.0",
+    "@rollup/plugin-json": "^6.1.0",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@types/google-protobuf": "^3.15.12",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.17.24",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "ajv": "^8.20.0",
+    "ajv-formats": "^3.0.1",
+    "crypto-js": "^4.2.0",
+    "dotenv": "^16.4.5",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
+    "jest-junit": "^16.0.0",
+    "js-yaml": "^5.2.1",
+    "prettier": "^3.0.0",
+    "rollup": "^4.55.1",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "text-encoding": "^0.7.0",
+    "ts-jest": "^29.1.2",
+    "typedoc": "^0.27.6",
+    "typescript": "^5.8.2",
+    "whatwg-fetch": "^3.6.20"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=8.0.0"
+  }
+}