@espressif/rainmaker-neo-base-sdk 1.0.0

package/dist/cjs/services/NodeUpdatesBus.js

@@ -0,0 +1,53 @@
+'use strict';
+
+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("NodeUpdatesBus");
+/**
+ * Process-wide fan-out of normalized node parameter updates.
+ *
+ * Each {@link ESPRMNeoNode} feeds every update it receives (from whichever
+ * subscription channel served it) into this bus, and `user.subscribe(
+ * ESPRMNeoEventType.nodeUpdates, cb)` registers `cb` here. This gives consumers a
+ * single "subscribe to all node param updates" entry point that mirrors the base
+ * RainMaker SDK's `nodeUpdates` event — but actually wired, rather than the
+ * reference SDK's manual-`subscribeToAllNodes` placeholder.
+ */
+const listeners = new Set();
+/**
+ * Registers a listener for all node updates.
+ *
+ * @param listener - Invoked with each {@link ESPNodeUpdateData}.
+ * @returns An unsubscribe function that removes the listener.
+ */
+function subscribeNodeUpdates(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+/**
+ * Emits a node update to every registered listener. Listener errors are isolated
+ * so one bad subscriber cannot break delivery to the others.
+ *
+ * @param update - The normalized update to broadcast.
+ */
+function emitNodeUpdate(update) {
+    listeners.forEach((listener) => {
+        try {
+            listener(update);
+        }
+        catch (error) {
+            logger.error("nodeUpdates listener threw", error);
+        }
+    });
+}
+
+exports.emitNodeUpdate = emitNodeUpdate;
+exports.subscribeNodeUpdates = subscribeNodeUpdates;
+//# sourceMappingURL=NodeUpdatesBus.js.map

package/dist/cjs/services/NodeUpdatesBus.js.map

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

package/dist/cjs/types/discovery.js

@@ -0,0 +1,29 @@
+'use strict';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Discovery protocol / domain identifiers.
+ */
+exports.ESPDiscoveryProtocol = void 0;
+(function (ESPDiscoveryProtocol) {
+    ESPDiscoveryProtocol["local"] = "local";
+})(exports.ESPDiscoveryProtocol || (exports.ESPDiscoveryProtocol = {}));
+/**
+ * Events an app can subscribe to via {@link ESPRMNeoUser.subscribe}.
+ */
+exports.ESPRMNeoEventType = void 0;
+(function (ESPRMNeoEventType) {
+    /** Local (mDNS / LAN) node discovery. */
+    ESPRMNeoEventType["localDiscovery"] = "com.espressif.event.localDiscovery";
+    /**
+     * All-node parameter updates. Subscribers receive an `ESPNodeUpdateData` for
+     * every node param change, from whichever subscription channel served the
+     * node. Backed by the process-wide node-updates bus.
+     */
+    ESPRMNeoEventType["nodeUpdates"] = "com.espressif.event.nodeUpdates";
+})(exports.ESPRMNeoEventType || (exports.ESPRMNeoEventType = {}));
+//# sourceMappingURL=discovery.js.map

package/dist/cjs/types/discovery.js.map

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

package/dist/cjs/types/provision.js

@@ -0,0 +1,64 @@
+'use strict';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Represents the types of transport mechanisms available.
+ */
+exports.ESPTransport = void 0;
+(function (ESPTransport) {
+    ESPTransport["ble"] = "ble";
+    ESPTransport["softap"] = "softap";
+})(exports.ESPTransport || (exports.ESPTransport = {}));
+/**
+ * Represents the levels of security available.
+ */
+exports.ESPSecurity = void 0;
+(function (ESPSecurity) {
+    ESPSecurity[ESPSecurity["unsecure"] = 0] = "unsecure";
+    ESPSecurity[ESPSecurity["secure"] = 1] = "secure";
+    ESPSecurity[ESPSecurity["secure2"] = 2] = "secure2";
+})(exports.ESPSecurity || (exports.ESPSecurity = {}));
+/**
+ * Represents the status of the connection.
+ */
+exports.ESPConnectStatus = void 0;
+(function (ESPConnectStatus) {
+    ESPConnectStatus[ESPConnectStatus["connected"] = 0] = "connected";
+    ESPConnectStatus[ESPConnectStatus["failedToConnect"] = 1] = "failedToConnect";
+    ESPConnectStatus[ESPConnectStatus["disconnected"] = 2] = "disconnected";
+})(exports.ESPConnectStatus || (exports.ESPConnectStatus = {}));
+/**
+ * Represents the status of the provisioning process.
+ */
+exports.ESPProvisionStatus = void 0;
+(function (ESPProvisionStatus) {
+    ESPProvisionStatus[ESPProvisionStatus["success"] = 0] = "success";
+    ESPProvisionStatus[ESPProvisionStatus["failure"] = 1] = "failure";
+})(exports.ESPProvisionStatus || (exports.ESPProvisionStatus = {}));
+/**
+ * Represents the status of the provisioning response.
+ */
+exports.ESPProvResponseStatus = void 0;
+(function (ESPProvResponseStatus) {
+    ESPProvResponseStatus["onProgress"] = "onProgress";
+    ESPProvResponseStatus["succeed"] = "succeed";
+})(exports.ESPProvResponseStatus || (exports.ESPProvResponseStatus = {}));
+/**
+ * Represents the status of a claiming operation.
+ */
+exports.ESPClaimStatus = void 0;
+(function (ESPClaimStatus) {
+    /** Claiming in progress */
+    ESPClaimStatus["inProgress"] = "inProgress";
+    /** Claiming succeeded */
+    ESPClaimStatus["success"] = "success";
+    /** Claiming failed */
+    ESPClaimStatus["failed"] = "failed";
+    /** Claiming was aborted */
+    ESPClaimStatus["aborted"] = "aborted";
+})(exports.ESPClaimStatus || (exports.ESPClaimStatus = {}));
+//# sourceMappingURL=provision.js.map

package/dist/cjs/types/provision.js.map

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

package/dist/cjs/types/subscription.js

@@ -0,0 +1,20 @@
+'use strict';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Resolves the canonical node id from a {@link NodeLike} (`id` preferred,
+ * falling back to `nodeId`).
+ *
+ * @param node - The node-like object.
+ * @returns The node id, or `undefined` if neither field is set.
+ */
+function resolveNodeId(node) {
+    return node.id ?? node.nodeId;
+}
+
+exports.resolveNodeId = resolveNodeId;
+//# sourceMappingURL=subscription.js.map

package/dist/cjs/types/subscription.js.map

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

package/dist/cjs/types/transport.js

@@ -0,0 +1,32 @@
+'use strict';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Defines the transport mode for ESP node communication.
+ *
+ * The transport mode specifies whether communication is done locally (LAN /
+ * local-control) or through MQTT (the RainMaker Neo cloud channel: AWS IoT
+ * shadow / RainMaker user params topic).
+ */
+exports.ESPTransportMode = void 0;
+(function (ESPTransportMode) {
+    /** Communication is handled locally over the LAN, without cloud intervention. */
+    ESPTransportMode["local"] = "local";
+    /** Communication is routed through MQTT (RainMaker Neo cloud: AWS shadow). */
+    ESPTransportMode["mqtt"] = "mqtt";
+})(exports.ESPTransportMode || (exports.ESPTransportMode = {}));
+/**
+ * Default transport priority order used when neither the node nor the SDK base
+ * has an explicit order configured: local control first, MQTT (cloud) fallback.
+ */
+const DEFAULT_TRANSPORT_ORDER = [
+    exports.ESPTransportMode.local,
+    exports.ESPTransportMode.mqtt,
+];
+
+exports.DEFAULT_TRANSPORT_ORDER = DEFAULT_TRANSPORT_ORDER;
+//# sourceMappingURL=transport.js.map

package/dist/cjs/types/transport.js.map

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

package/dist/cjs/utils/authUtils.js

@@ -0,0 +1,28 @@
+'use strict';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Returns true when `username` looks like an E.164 phone number (leading `+`).
+ * Used by sign-up / confirm flows to choose `phone_number` vs `email`.
+ */
+function isPhoneUsername(username) {
+    return username.startsWith("+");
+}
+/**
+ * Maps a username to the signup/verify identity fields expected by the User API.
+ *
+ * Phone usernames (leading `+`) become `phone_number`; everything else becomes `email`.
+ */
+function signupIdentityFromUsername(username) {
+    return isPhoneUsername(username)
+        ? { phone_number: username }
+        : { email: username };
+}
+
+exports.isPhoneUsername = isPhoneUsername;
+exports.signupIdentityFromUsername = signupIdentityFromUsername;
+//# sourceMappingURL=authUtils.js.map

package/dist/cjs/utils/authUtils.js.map

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

package/dist/cjs/utils/awsShadowTopics.js

@@ -0,0 +1,154 @@
+'use strict';
+
+var common = require('./common.js');
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * AWS IoT Shadow topic and payload helpers for MQTT orchestrator.
+ * Handles topic construction, parsing, and state extraction from shadow messages.
+ */
+/** Topic format: $aws/things/NODE_ID/shadow/name/SHADOW_NAME/... */
+const TOPIC_PARTS = {
+    PREFIX: "$aws/things",
+    NODE_ID_INDEX: 2,
+};
+/**
+ * Builds the base shadow topic path for a node.
+ *
+ * @param nodeId - The device/node identifier
+ * @param shadowName - The named shadow (e.g. params-groupId-subgroupId)
+ * @returns Topic path: $aws/things/{nodeId}/shadow/name/{shadowName}
+ */
+function buildShadowBase(nodeId, shadowName) {
+    return `${TOPIC_PARTS.PREFIX}/${nodeId}/shadow/name/${shadowName}`;
+}
+/**
+ * Suffixes for group-wide shadow subscriptions (RainMakerNeo User MQTT API + GET).
+ * Wildcard thing name: `$aws/things/+/shadow/name/{shadowName}{suffix}`.
+ *
+ * RECEIVE (API 1.0.0): update/documents, update/delta, update/accepted, update/rejected.
+ * GET (request/response): get/accepted, get/rejected.
+ */
+const SHADOW_GROUP_SUFFIXES = [
+    "/update/documents",
+    "/update/delta",
+    "/update/accepted",
+    "/update/rejected",
+    "/get/accepted",
+    "/get/rejected",
+];
+/**
+ * Builds all wildcard topics for a named shadow (any thing / node id).
+ */
+function buildShadowGroupWildcardTopics(shadowName) {
+    return SHADOW_GROUP_SUFFIXES.map((suffix) => `${TOPIC_PARTS.PREFIX}/+/shadow/name/${shadowName}${suffix}`);
+}
+/**
+ * RainMaker user params channel (publish / optional subscribe).
+ * @see rainmaker/nodes/{nodeId}/user/{shadowName}/params
+ */
+function buildRainMakerUserParamsTopic(nodeId, shadowName) {
+    return `rainmaker/nodes/${nodeId}/user/${shadowName}/params`;
+}
+/**
+ * RainMaker **group control** topic (multicast to all nodes in a group or subgroup).
+ *
+ * - Broadcast (all devices in the group):
+ *   `rainmaker/nodes/groups/<groupId>/control`
+ * - Single subgroup:
+ *   `rainmaker/nodes/groups/<groupId>/subgroups/<subgroupId>/control`
+ *
+ * @param groupId - Primary group id (`pgrp`)
+ * @param subgroupId - Optional subgroup id; when set, targets that subgroup only
+ */
+function buildGroupControlParamsTopic(groupId, subgroupId) {
+    if (subgroupId) {
+        return `rainmaker/nodes/groups/${groupId}/subgroups/${subgroupId}/control`;
+    }
+    return `rainmaker/nodes/groups/${groupId}/control`;
+}
+/**
+ * Extracts device params from a shadow GET/accepted document.
+ * Prefers `state.reported.params` when present; otherwise `state.reported`.
+ * Always returns an object (`{}` when absent / non-object).
+ */
+function getReportedParamsFromShadowDocument(parsed) {
+    const reported = common.asObject(parsed?.state?.reported);
+    return "params" in reported ? common.asObject(reported.params) : reported;
+}
+/**
+ * Normalizes a live shadow MQTT payload for param listeners.
+ *
+ * - `/update/documents`: returns `current` (full shadow doc with previous+current
+ *   envelope unwrapped so callers see the usual `{ state, metadata, version }` shape).
+ * - Other topics: returns the parsed payload as received.
+ * Always returns an object (`{}` when absent / non-object).
+ */
+function getReportedParamsFromShadowLiveMessage(topic, parsed) {
+    if (topic.endsWith("/update/documents")) {
+        return common.asObject(parsed?.current);
+    }
+    return common.asObject(parsed);
+}
+/**
+ * Extracts the nodeId from an AWS IoT shadow topic.
+ * Topic format: $aws/things/NODE_ID/shadow/name/SHADOW_NAME/...
+ *
+ * @param topic - The MQTT topic string
+ * @returns The nodeId, or null if topic format is invalid
+ */
+function extractNodeIdFromTopic(topic) {
+    const parts = topic.split("/");
+    return parts[TOPIC_PARTS.NODE_ID_INDEX] ?? null;
+}
+/**
+ * Safely parses a shadow message buffer to JSON.
+ *
+ * @param message - Raw MQTT payload buffer
+ * @returns Parsed shadow document, or null on parse error
+ */
+function parseShadowMessage(message) {
+    try {
+        return JSON.parse(message.toString());
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Extracts the full state object from a parsed shadow payload.
+ *
+ * @param parsed - Parsed shadow document (or null)
+ * @returns The state object (reported + desired), or `{}` when absent / non-object
+ */
+function getStateFromPayload(parsed) {
+    if (parsed == null)
+        return common.asObject(parsed);
+    const payload = parsed;
+    return common.asObject(payload.state ?? parsed);
+}
+/**
+ * Builds the JSON payload for a shadow update (desired state).
+ *
+ * @param desiredParams - The desired state parameters to set
+ * @returns JSON string for MQTT publish
+ */
+function buildShadowUpdatePayload(desiredParams) {
+    return JSON.stringify({ state: { desired: desiredParams } });
+}
+
+exports.buildGroupControlParamsTopic = buildGroupControlParamsTopic;
+exports.buildRainMakerUserParamsTopic = buildRainMakerUserParamsTopic;
+exports.buildShadowBase = buildShadowBase;
+exports.buildShadowGroupWildcardTopics = buildShadowGroupWildcardTopics;
+exports.buildShadowUpdatePayload = buildShadowUpdatePayload;
+exports.extractNodeIdFromTopic = extractNodeIdFromTopic;
+exports.getReportedParamsFromShadowDocument = getReportedParamsFromShadowDocument;
+exports.getReportedParamsFromShadowLiveMessage = getReportedParamsFromShadowLiveMessage;
+exports.getStateFromPayload = getStateFromPayload;
+exports.parseShadowMessage = parseShadowMessage;
+//# sourceMappingURL=awsShadowTopics.js.map

package/dist/cjs/utils/awsShadowTopics.js.map

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

package/dist/cjs/utils/awsSigv4Utils.js

@@ -0,0 +1,143 @@
+'use strict';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Generates the full AWS SigV4 Authorization header for HTTP requests.
+ * Consolidates canonical request, string-to-sign, signature calculation, and header building.
+ */
+function generateSigV4AuthHeader(params) {
+    const { accessKey, secretKey, timestamp, dateStamp, region, service, method, canonicalURI, canonicalQueryString, requestHeaders, signedHeaders, payloadHash, } = params;
+    const canonicalRequest = buildCanonicalRequest(method, canonicalURI, canonicalQueryString, requestHeaders, signedHeaders, payloadHash);
+    const stringToSign = buildStringToSign(timestamp, dateStamp, region, service, canonicalRequest);
+    const signature = calculateSignature(secretKey, dateStamp, region, service, stringToSign);
+    return createAuthorizationHeader(accessKey, dateStamp, region, service, signature, signedHeaders);
+}
+function buildCanonicalRequest(httpMethod, canonicalURI, canonicalQueryString, canonicalHeaders, signedHeaders, payloadHash) {
+    const sortedHeaders = Object.entries(canonicalHeaders).sort(([a], [b]) => a.localeCompare(b));
+    const canonicalHeadersString = sortedHeaders
+        .map(([key, value]) => `${key}:${value}\n`)
+        .join("");
+    return [
+        httpMethod,
+        canonicalURI,
+        canonicalQueryString,
+        canonicalHeadersString,
+        signedHeaders,
+        payloadHash,
+    ].join("\n");
+}
+function buildStringToSign(timestamp, dateStamp, regionName, serviceName, canonicalRequest) {
+    const scope = `${dateStamp}/${regionName}/${serviceName}/aws4_request`;
+    const hashedRequest = crypto
+        .createHash("sha256")
+        .update(canonicalRequest)
+        .digest("hex");
+    return ["AWS4-HMAC-SHA256", timestamp, scope, hashedRequest].join("\n");
+}
+function calculateSignature(secretKey, dateStamp, regionName, serviceName, stringToSign) {
+    const kSecret = `AWS4${secretKey}`;
+    const kDate = hmac(kSecret, dateStamp);
+    const kRegion = hmac(kDate, regionName);
+    const kService = hmac(kRegion, serviceName);
+    const kSigning = hmac(kService, "aws4_request");
+    return hmac(kSigning, stringToSign, "hex");
+}
+/**
+ * Builds the AWS Signature Version 4 Authorization header value for HTTP requests.
+ */
+function createAuthorizationHeader(accessKey, dateStamp, regionName, serviceName, signature, signedHeaders) {
+    return `AWS4-HMAC-SHA256 Credential=${accessKey}/${dateStamp}/${regionName}/${serviceName}/aws4_request, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+}
+function sha256HexUtf8(data) {
+    return crypto.createHash("sha256").update(data, "utf8").digest("hex");
+}
+function awsUriEncodeComponent(s) {
+    return encodeURIComponent(s).replace(/[!'()*]/g, (c) => {
+        const code = c.charCodeAt(0);
+        return `%${code.toString(16).toUpperCase().padStart(2, "0")}`;
+    });
+}
+/**
+ * Builds the SigV4 canonical query string from parsed query parameters: each
+ * name and value URI-encoded (RFC 3986, including `!'()*`), pairs sorted by
+ * encoded name then encoded value (code-point order, per the SigV4 spec).
+ *
+ * API Gateway canonicalizes the incoming query string this way before
+ * verifying the signature, so signing the raw (unsorted) query string breaks
+ * every request whose parameters are not already in sorted order.
+ */
+function buildCanonicalQueryString(searchParams) {
+    const pairs = [];
+    searchParams.forEach((value, name) => {
+        pairs.push([awsUriEncodeComponent(name), awsUriEncodeComponent(value)]);
+    });
+    pairs.sort(([nameA, valueA], [nameB, valueB]) => {
+        if (nameA !== nameB)
+            return nameA < nameB ? -1 : 1;
+        if (valueA !== valueB)
+            return valueA < valueB ? -1 : 1;
+        return 0;
+    });
+    return pairs.map(([name, value]) => `${name}=${value}`).join("&");
+}
+/**
+ * Builds a presigned `wss://` URL for AWS IoT Core MQTT over WebSocket using
+ * query-string SigV4 (service `iotdevicegateway`, signed headers: `host`).
+ *
+ * Same signing flow as HTTP SigV4 in this module (`calculateSignature`, canonical request layout).
+ */
+function generateIotDeviceGatewayMqttSignedUrl(params) {
+    const { accessKey, secretKey, sessionToken, host, awsRegion, expiresSeconds = 86400, canonicalUri = "/mqtt", } = params;
+    const now = new Date();
+    const amzdate = now.toISOString().replace(/[:-]|\.\d{3}/g, "");
+    const datestamp = amzdate.slice(0, 8);
+    const service = "iotdevicegateway";
+    const credentialScope = `${datestamp}/${awsRegion}/${service}/aws4_request`;
+    const queryPairs = [
+        ["X-Amz-Algorithm", "AWS4-HMAC-SHA256"],
+        ["X-Amz-Credential", `${accessKey}/${credentialScope}`],
+        ["X-Amz-Date", amzdate],
+        ["X-Amz-Expires", String(expiresSeconds)],
+        ["X-Amz-SignedHeaders", "host"],
+    ];
+    if (sessionToken) {
+        queryPairs.push(["X-Amz-Security-Token", sessionToken]);
+    }
+    queryPairs.sort((a, b) => a[0].localeCompare(b[0]));
+    const canonicalQuerystring = queryPairs
+        .map(([k, v]) => `${awsUriEncodeComponent(k)}=${awsUriEncodeComponent(v)}`)
+        .join("&");
+    const canonicalHeaders = `host:${host}\n`;
+    const signedHeaders = "host";
+    const payloadHash = sha256HexUtf8("");
+    const canonicalRequest = [
+        "GET",
+        canonicalUri,
+        canonicalQuerystring,
+        canonicalHeaders,
+        signedHeaders,
+        payloadHash,
+    ].join("\n");
+    const stringToSign = [
+        "AWS4-HMAC-SHA256",
+        amzdate,
+        credentialScope,
+        sha256HexUtf8(canonicalRequest),
+    ].join("\n");
+    const signature = calculateSignature(secretKey, datestamp, awsRegion, service, stringToSign);
+    return `wss://${host}${canonicalUri}?${canonicalQuerystring}&X-Amz-Signature=${signature}`;
+}
+function hmac(key, data, encoding) {
+    const h = crypto.createHmac("sha256", key).update(data);
+    return encoding ? h.digest(encoding) : h.digest();
+}
+
+exports.buildCanonicalQueryString = buildCanonicalQueryString;
+exports.createAuthorizationHeader = createAuthorizationHeader;
+exports.generateIotDeviceGatewayMqttSignedUrl = generateIotDeviceGatewayMqttSignedUrl;
+exports.generateSigV4AuthHeader = generateSigV4AuthHeader;
+//# sourceMappingURL=awsSigv4Utils.js.map

package/dist/cjs/utils/awsSigv4Utils.js.map

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