@seamapi/http 0.12.0 → 0.14.0

package/README.md

@@ -211,6 +211,18 @@ const seam = new SeamHttp({
 await seam.locks.unlockDoor({ device_id })
 ```
 
+If you have already have an action attempt id
+and want to wait for it to resolve, simply use
+
+```ts
+await seam.actionAttempts.get(
+  { action_attempt_id },
+  {
+    waitForActionAttempt: true,
+  },
+)
+```
+
 Using the `waitForActionAttempt` option:
 
 - Polls the action attempt up to the `timeout`

package/connect.d.ts

@@ -1 +1,2 @@
 export * from './lib/seam/connect/index.js';
+export * from '@seamapi/url-search-params-serializer';

package/connect.js

@@ -1,2 +1,3 @@
 export * from './lib/seam/connect/index.js';
+export * from '@seamapi/url-search-params-serializer';
 //# sourceMappingURL=connect.js.map

package/connect.js.map

@@ -1 +1 @@
-{"version":3,"file":"connect.js","sourceRoot":"","sources":["src/connect.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAA"}
+{"version":3,"file":"connect.js","sourceRoot":"","sources":["src/connect.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAA;AAC3C,cAAc,uCAAuC,CAAA"}

package/dist/connect.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var axios = require('axios');
+var urlSearchParamsSerializer = require('@seamapi/url-search-params-serializer');
 var axiosBetterStacktrace = require('axios-better-stacktrace');
 var axiosRetry = require('axios-retry');
 
@@ -268,7 +269,8 @@ var getAuthHeaders = (options) => {
       "clientSessionToken,",
       "publishableKey,",
       "consoleSessionToken",
-      "or personalAccessToken"
+      "or personalAccessToken.",
+      "Attempted reading configuration from the environment, but the environment variable SEAM_API_KEY is not set."
     ].join(" ")
   );
 };
@@ -525,55 +527,9 @@ var getRequestId = (err) => {
     return "";
   return requestId;
 };
-
-// src/lib/params-serializer.ts
-var paramsSerializer = (params) => {
-  const searchParams = new URLSearchParams();
-  for (const [name, value] of Object.entries(params)) {
-    if (value == null)
-      continue;
-    if (Array.isArray(value)) {
-      if (value.length === 0)
-        searchParams.set(name, "");
-      if (value.length === 1 && value[0] === "") {
-        throw new UnserializableParamError(
-          name,
-          `is a single element array containing the empty string which is unsupported because it serializes to the empty array`
-        );
-      }
-      for (const v of value) {
-        searchParams.append(name, serialize(name, v));
-      }
-      continue;
-    }
-    searchParams.set(name, serialize(name, value));
-  }
-  searchParams.sort();
-  return searchParams.toString();
-};
-var serialize = (k, v) => {
-  if (typeof v === "string")
-    return v.toString();
-  if (typeof v === "number")
-    return v.toString();
-  if (typeof v === "bigint")
-    return v.toString();
-  if (typeof v === "boolean")
-    return v.toString();
-  throw new UnserializableParamError(k, `is a ${typeof v}`);
-};
-var UnserializableParamError = class extends Error {
-  constructor(name, message) {
-    super(`Could not serialize parameter: '${name}' ${message}`);
-    this.name = this.constructor.name;
-    Error.captureStackTrace(this, this.constructor);
-  }
-};
-
-// src/lib/seam/connect/client.ts
 var createClient = (options) => {
   const client = axios__default.default.create({
-    paramsSerializer,
+    paramsSerializer: urlSearchParamsSerializer.serializeUrlSearchParams,
     ...options.axiosOptions
   });
   axiosBetterStacktrace__default.default(axios__default.default);
@@ -2442,6 +2398,85 @@ var SeamHttpLocks = class _SeamHttpLocks {
   }
 };
 
+// src/lib/seam/connect/routes/networks.ts
+var SeamHttpNetworks = class _SeamHttpNetworks {
+  constructor(apiKeyOrOptions = {}) {
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
+  }
+  static fromClient(client, options = {}) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpNetworks(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpNetworks(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpNetworks(constructorOptions);
+  }
+  static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey);
+    const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
+    const client = createClient(clientOptions);
+    const clientSessions = SeamHttpClientSessions.fromClient(client);
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey
+    });
+    return _SeamHttpNetworks.fromClientSessionToken(token, options);
+  }
+  static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId };
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing consoleSessionToken or workspaceId"
+      );
+    }
+    return new _SeamHttpNetworks(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpNetworks(constructorOptions);
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/networks/get",
+      method: "post",
+      data: body
+    });
+    return data.network;
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/networks/list",
+      method: "post",
+      data: body
+    });
+    return data.networks;
+  }
+};
+
 // src/lib/seam/connect/routes/noise-sensors-noise-thresholds.ts
 var SeamHttpNoiseSensorsNoiseThresholds = class _SeamHttpNoiseSensorsNoiseThresholds {
   constructor(apiKeyOrOptions = {}) {
@@ -2614,6 +2649,77 @@ var SeamHttpNoiseSensors = class _SeamHttpNoiseSensors {
   }
 };
 
+// src/lib/seam/connect/routes/phones.ts
+var SeamHttpPhones = class _SeamHttpPhones {
+  constructor(apiKeyOrOptions = {}) {
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
+  }
+  static fromClient(client, options = {}) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpPhones(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpPhones(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpPhones(constructorOptions);
+  }
+  static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey);
+    const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
+    const client = createClient(clientOptions);
+    const clientSessions = SeamHttpClientSessions.fromClient(client);
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey
+    });
+    return _SeamHttpPhones.fromClientSessionToken(token, options);
+  }
+  static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId };
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing consoleSessionToken or workspaceId"
+      );
+    }
+    return new _SeamHttpPhones(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpPhones(constructorOptions);
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/phones/list",
+      method: "post",
+      data: body
+    });
+    return data.phones;
+  }
+};
+
 // src/lib/seam/connect/routes/thermostats-climate-setting-schedules.ts
 var SeamHttpThermostatsClimateSettingSchedules = class _SeamHttpThermostatsClimateSettingSchedules {
   constructor(apiKeyOrOptions = {}) {
@@ -2853,6 +2959,102 @@ var SeamHttpThermostats = class _SeamHttpThermostats {
   }
 };
 
+// src/lib/seam/connect/routes/user-identities-enrollment-automations.ts
+var SeamHttpUserIdentitiesEnrollmentAutomations = class _SeamHttpUserIdentitiesEnrollmentAutomations {
+  constructor(apiKeyOrOptions = {}) {
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
+  }
+  static fromClient(client, options = {}) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpUserIdentitiesEnrollmentAutomations(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpUserIdentitiesEnrollmentAutomations(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpUserIdentitiesEnrollmentAutomations(constructorOptions);
+  }
+  static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey);
+    const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
+    const client = createClient(clientOptions);
+    const clientSessions = SeamHttpClientSessions.fromClient(client);
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey
+    });
+    return _SeamHttpUserIdentitiesEnrollmentAutomations.fromClientSessionToken(
+      token,
+      options
+    );
+  }
+  static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId };
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing consoleSessionToken or workspaceId"
+      );
+    }
+    return new _SeamHttpUserIdentitiesEnrollmentAutomations(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpUserIdentitiesEnrollmentAutomations(constructorOptions);
+  }
+  async get(body) {
+    const { data } = await this.client.request(
+      {
+        url: "/user_identities/enrollment_automations/get",
+        method: "post",
+        data: body
+      }
+    );
+    return data.enrollment_automation;
+  }
+  async launch(body) {
+    const { data } = await this.client.request(
+      {
+        url: "/user_identities/enrollment_automations/launch",
+        method: "post",
+        data: body
+      }
+    );
+    return data.enrollment_automation;
+  }
+  async list(body) {
+    const { data } = await this.client.request(
+      {
+        url: "/user_identities/enrollment_automations/list",
+        method: "post",
+        data: body
+      }
+    );
+    return data.enrollment_automations;
+  }
+};
+
 // src/lib/seam/connect/routes/user-identities.ts
 var SeamHttpUserIdentities = class _SeamHttpUserIdentities {
   constructor(apiKeyOrOptions = {}) {
@@ -2914,6 +3116,12 @@ var SeamHttpUserIdentities = class _SeamHttpUserIdentities {
     }
     return new _SeamHttpUserIdentities(constructorOptions);
   }
+  get enrollmentAutomations() {
+    return SeamHttpUserIdentitiesEnrollmentAutomations.fromClient(
+      this.client,
+      this.defaults
+    );
+  }
   async addAcsUser(body) {
     await this.client.request({
       url: "/user_identities/add_acs_user",
@@ -2960,6 +3168,14 @@ var SeamHttpUserIdentities = class _SeamHttpUserIdentities {
     });
     return data.accessible_devices;
   }
+  async listAcsSystems(body) {
+    const { data } = await this.client.request({
+      url: "/user_identities/list_acs_systems",
+      method: "post",
+      data: body
+    });
+    return data.acs_systems;
+  }
   async listAcsUsers(body) {
     const { data } = await this.client.request({
       url: "/user_identities/list_acs_users",
@@ -3260,9 +3476,15 @@ var SeamHttp = class _SeamHttp {
   get locks() {
     return SeamHttpLocks.fromClient(this.client, this.defaults);
   }
+  get networks() {
+    return SeamHttpNetworks.fromClient(this.client, this.defaults);
+  }
   get noiseSensors() {
     return SeamHttpNoiseSensors.fromClient(this.client, this.defaults);
   }
+  get phones() {
+    return SeamHttpPhones.fromClient(this.client, this.defaults);
+  }
   get thermostats() {
     return SeamHttpThermostats.fromClient(this.client, this.defaults);
   }
@@ -3346,15 +3568,17 @@ exports.SeamHttpInvalidTokenError = SeamHttpInvalidTokenError;
 exports.SeamHttpLocks = SeamHttpLocks;
 exports.SeamHttpMultiWorkspace = SeamHttpMultiWorkspace;
 exports.SeamHttpMultiWorkspaceInvalidOptionsError = SeamHttpMultiWorkspaceInvalidOptionsError;
+exports.SeamHttpNetworks = SeamHttpNetworks;
 exports.SeamHttpNoiseSensors = SeamHttpNoiseSensors;
 exports.SeamHttpNoiseSensorsNoiseThresholds = SeamHttpNoiseSensorsNoiseThresholds;
+exports.SeamHttpPhones = SeamHttpPhones;
 exports.SeamHttpThermostats = SeamHttpThermostats;
 exports.SeamHttpThermostatsClimateSettingSchedules = SeamHttpThermostatsClimateSettingSchedules;
 exports.SeamHttpUnauthorizedError = SeamHttpUnauthorizedError;
 exports.SeamHttpUserIdentities = SeamHttpUserIdentities;
+exports.SeamHttpUserIdentitiesEnrollmentAutomations = SeamHttpUserIdentitiesEnrollmentAutomations;
 exports.SeamHttpWebhooks = SeamHttpWebhooks;
 exports.SeamHttpWorkspaces = SeamHttpWorkspaces;
-exports.UnserializableParamError = UnserializableParamError;
 exports.errorInterceptor = errorInterceptor;
 exports.getOpenapiSchema = getOpenapiSchema;
 exports.isApiKey = isApiKey;
@@ -3376,6 +3600,11 @@ exports.isSeamHttpOptionsWithClientSessionToken = isSeamHttpOptionsWithClientSes
 exports.isSeamHttpOptionsWithConsoleSessionToken = isSeamHttpOptionsWithConsoleSessionToken;
 exports.isSeamHttpOptionsWithPersonalAccessToken = isSeamHttpOptionsWithPersonalAccessToken;
 exports.isSeamHttpUnauthorizedError = isSeamHttpUnauthorizedError;
-exports.paramsSerializer = paramsSerializer;
+Object.keys(urlSearchParamsSerializer).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return urlSearchParamsSerializer[k]; }
+  });
+});
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=connect.cjs.map