@seamapi/http 0.4.0 → 0.6.0

package/dist/connect.cjs

@@ -119,6 +119,16 @@ var isSeamHttpOptionsWithApiKey = (options) => {
       "The clientSessionToken option cannot be used with the apiKey option"
     );
   }
+  if ("consoleSessionToken" in options && options.consoleSessionToken != null) {
+    throw new SeamHttpInvalidOptionsError(
+      "The consoleSessionToken option cannot be used with the apiKey option"
+    );
+  }
+  if ("personalAccessToken" in options && options.personalAccessToken != null) {
+    throw new SeamHttpInvalidOptionsError(
+      "The personalAccessToken option cannot be used with the apiKey option"
+    );
+  }
   return true;
 };
 var isSeamHttpOptionsWithClientSessionToken = (options) => {
@@ -128,7 +138,71 @@ var isSeamHttpOptionsWithClientSessionToken = (options) => {
     return false;
   if ("apiKey" in options && options.apiKey != null) {
     throw new SeamHttpInvalidOptionsError(
-      "The clientSessionToken option cannot be used with the apiKey option"
+      "The apiKey option cannot be used with the clientSessionToken option"
+    );
+  }
+  if ("consoleSessionToken" in options && options.consoleSessionToken != null) {
+    throw new SeamHttpInvalidOptionsError(
+      "The consoleSessionToken option cannot be used with the clientSessionToken option"
+    );
+  }
+  if ("personalAccessToken" in options && options.personalAccessToken != null) {
+    throw new SeamHttpInvalidOptionsError(
+      "The personalAccessToken option cannot be used with the clientSessionToken option"
+    );
+  }
+  return true;
+};
+var isSeamHttpOptionsWithConsoleSessionToken = (options) => {
+  if (!("consoleSessionToken" in options))
+    return false;
+  if (options.consoleSessionToken == null)
+    return false;
+  if (!("workspaceId" in options) || options.workspaceId == null) {
+    throw new SeamHttpInvalidOptionsError(
+      "Must pass a workspaceId when using a consoleSessionToken"
+    );
+  }
+  if ("apiKey" in options && options.apiKey != null) {
+    throw new SeamHttpInvalidOptionsError(
+      "The apiKey option cannot be used with the consoleSessionToken option"
+    );
+  }
+  if ("clientSessionToken" in options && options.clientSessionToken != null) {
+    throw new SeamHttpInvalidOptionsError(
+      "The clientSessionToken option cannot be used with the consoleSessionToken option"
+    );
+  }
+  if ("personalAccessToken" in options && options.personalAccessToken != null) {
+    throw new SeamHttpInvalidOptionsError(
+      "The personalAccessToken option cannot be used with the consoleSessionToken option"
+    );
+  }
+  return true;
+};
+var isSeamHttpOptionsWithPersonalAccessToken = (options) => {
+  if (!("personalAccessToken" in options))
+    return false;
+  if (options.personalAccessToken == null)
+    return false;
+  if (!("workspaceId" in options) || options.workspaceId == null) {
+    throw new SeamHttpInvalidOptionsError(
+      "Must pass a workspaceId when using a personalAccessToken"
+    );
+  }
+  if ("apiKey" in options && options.apiKey != null) {
+    throw new SeamHttpInvalidOptionsError(
+      "The apiKey option cannot be used with the personalAccessToken option"
+    );
+  }
+  if ("clientSessionToken" in options && options.clientSessionToken != null) {
+    throw new SeamHttpInvalidOptionsError(
+      "The clientSessionToken option cannot be used with the personalAccessToken option"
+    );
+  }
+  if ("consoleSessionToken" in options && options.consoleSessionToken != null) {
+    throw new SeamHttpInvalidOptionsError(
+      "The consoleSessionToken option cannot be used with the personalAccessToken option"
     );
   }
   return true;
@@ -152,8 +226,21 @@ var getAuthHeaders = (options) => {
   if (isSeamHttpOptionsWithClientSessionToken(options)) {
     return getAuthHeadersForClientSessionToken(options);
   }
+  if (isSeamHttpOptionsWithConsoleSessionToken(options)) {
+    return getAuthHeadersForConsoleSessionToken(options);
+  }
+  if (isSeamHttpOptionsWithPersonalAccessToken(options)) {
+    return getAuthHeadersForPersonalAccessToken(options);
+  }
   throw new SeamHttpInvalidOptionsError(
-    "Must specify an apiKey, clientSessionToken, or publishableKey"
+    [
+      "Must specify",
+      "an apiKey,",
+      "clientSessionToken,",
+      "publishableKey,",
+      "consoleSessionToken with a workspaceId",
+      "or personalAccessToken with a workspaceId"
+    ].join(" ")
   );
 };
 var getAuthHeadersForApiKey = ({
@@ -214,6 +301,64 @@ var getAuthHeadersForClientSessionToken = ({
     "client-session-token": clientSessionToken
   };
 };
+var getAuthHeadersForConsoleSessionToken = ({
+  consoleSessionToken,
+  workspaceId
+}) => {
+  if (isAccessToken(consoleSessionToken)) {
+    throw new SeamHttpInvalidTokenError(
+      "An Access Token cannot be used as a consoleSessionToken"
+    );
+  }
+  if (isClientSessionToken(consoleSessionToken)) {
+    throw new SeamHttpInvalidTokenError(
+      "A Client Session Token cannot be used as a consoleSessionToken"
+    );
+  }
+  if (isPublishableKey(consoleSessionToken)) {
+    throw new SeamHttpInvalidTokenError(
+      "A Publishable Key cannot be used as a consoleSessionToken"
+    );
+  }
+  if (!isJwt(consoleSessionToken)) {
+    throw new SeamHttpInvalidTokenError(
+      `Unknown or invalid consoleSessionToken format, expected a JWT which starts with ${jwtPrefix}`
+    );
+  }
+  return {
+    authorization: `Bearer ${consoleSessionToken}`,
+    "seam-workspace-id": workspaceId
+  };
+};
+var getAuthHeadersForPersonalAccessToken = ({
+  personalAccessToken,
+  workspaceId
+}) => {
+  if (isJwt(personalAccessToken)) {
+    throw new SeamHttpInvalidTokenError(
+      "A JWT cannot be used as a personalAccessToken"
+    );
+  }
+  if (isClientSessionToken(personalAccessToken)) {
+    throw new SeamHttpInvalidTokenError(
+      "A Client Session Token cannot be used as a personalAccessToken"
+    );
+  }
+  if (isPublishableKey(personalAccessToken)) {
+    throw new SeamHttpInvalidTokenError(
+      "A Publishable Key cannot be used as a personalAccessToken"
+    );
+  }
+  if (!isAccessToken(personalAccessToken)) {
+    throw new SeamHttpInvalidTokenError(
+      `Unknown or invalid personalAccessToken format, expected token to start with ${accessTokenPrefix}`
+    );
+  }
+  return {
+    authorization: `Bearer ${personalAccessToken}`,
+    "seam-workspace-id": workspaceId
+  };
+};
 var getAuthHeadersForPublishableKey = (publishableKey) => {
   if (isJwt(publishableKey)) {
     throw new SeamHttpInvalidTokenError(
@@ -260,11 +405,13 @@ var warnOnInsecureuserIdentifierKey = (userIdentifierKey) => {
   }
 };
 var tokenPrefix = "seam_";
+var accessTokenPrefix = "seam_at";
+var jwtPrefix = "ey";
 var clientSessionTokenPrefix = "seam_cst";
 var publishableKeyTokenPrefix = "seam_pk";
 var isClientSessionToken = (token) => token.startsWith(clientSessionTokenPrefix);
-var isAccessToken = (token) => token.startsWith("seam_at");
-var isJwt = (token) => token.startsWith("ey");
+var isAccessToken = (token) => token.startsWith(accessTokenPrefix);
+var isJwt = (token) => token.startsWith(jwtPrefix);
 var isSeamToken = (token) => token.startsWith(tokenPrefix);
 var isPublishableKey = (token) => token.startsWith(publishableKeyTokenPrefix);
 var isEmail = (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
@@ -423,6 +570,24 @@ var SeamHttpClientSessions = class _SeamHttpClientSessions {
     });
     return _SeamHttpClientSessions.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 _SeamHttpClientSessions(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpClientSessions(constructorOptions);
+  }
   async create(body) {
     const { data } = await this.client.request({
       url: "/client_sessions/create",
@@ -470,6 +635,13 @@ var SeamHttpClientSessions = class _SeamHttpClientSessions {
     });
     return data.client_sessions;
   }
+  async revoke(body) {
+    await this.client.request({
+      url: "/client_sessions/revoke",
+      method: "post",
+      data: body
+    });
+  }
 };
 
 // src/lib/seam/connect/routes/access-codes-unmanaged.ts
@@ -509,6 +681,24 @@ var SeamHttpAccessCodesUnmanaged = class _SeamHttpAccessCodesUnmanaged {
     });
     return _SeamHttpAccessCodesUnmanaged.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 _SeamHttpAccessCodesUnmanaged(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpAccessCodesUnmanaged(constructorOptions);
+  }
   async convertToManaged(body) {
     await this.client.request({
       url: "/access_codes/unmanaged/convert_to_managed",
@@ -587,6 +777,24 @@ var SeamHttpAccessCodes = class _SeamHttpAccessCodes {
     });
     return _SeamHttpAccessCodes.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 _SeamHttpAccessCodes(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpAccessCodes(constructorOptions);
+  }
   get unmanaged() {
     return SeamHttpAccessCodesUnmanaged.fromClient(this.client);
   }
@@ -693,24 +901,27 @@ var SeamHttpAcsAccessGroups = class _SeamHttpAcsAccessGroups {
     });
     return _SeamHttpAcsAccessGroups.fromClientSessionToken(token, options);
   }
-  async addUser(body) {
-    await this.client.request({
-      url: "/acs/access_groups/add_user",
-      method: "post",
-      data: body
-    });
+  static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId };
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing consoleSessionToken or workspaceId"
+      );
+    }
+    return new _SeamHttpAcsAccessGroups(constructorOptions);
   }
-  async create(body) {
-    const { data } = await this.client.request({
-      url: "/acs/access_groups/create",
-      method: "post",
-      data: body
-    });
-    return data.acs_access_group;
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpAcsAccessGroups(constructorOptions);
   }
-  async delete(body) {
+  async addUser(body) {
     await this.client.request({
-      url: "/acs/access_groups/delete",
+      url: "/acs/access_groups/add_user",
       method: "post",
       data: body
     });
@@ -746,13 +957,6 @@ var SeamHttpAcsAccessGroups = class _SeamHttpAcsAccessGroups {
       data: body
     });
   }
-  async update(body) {
-    await this.client.request({
-      url: "/acs/access_groups/update",
-      method: "post",
-      data: body
-    });
-  }
 };
 
 // src/lib/seam/connect/routes/acs-credentials.ts
@@ -792,6 +996,31 @@ var SeamHttpAcsCredentials = class _SeamHttpAcsCredentials {
     });
     return _SeamHttpAcsCredentials.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 _SeamHttpAcsCredentials(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpAcsCredentials(constructorOptions);
+  }
+  async assign(body) {
+    await this.client.request({
+      url: "/acs/credentials/assign",
+      method: "post",
+      data: body
+    });
+  }
   async create(body) {
     const { data } = await this.client.request({
       url: "/acs/credentials/create",
@@ -823,6 +1052,13 @@ var SeamHttpAcsCredentials = class _SeamHttpAcsCredentials {
     });
     return data.acs_credentials;
   }
+  async unassign(body) {
+    await this.client.request({
+      url: "/acs/credentials/unassign",
+      method: "post",
+      data: body
+    });
+  }
 };
 
 // src/lib/seam/connect/routes/acs-systems.ts
@@ -862,6 +1098,24 @@ var SeamHttpAcsSystems = class _SeamHttpAcsSystems {
     });
     return _SeamHttpAcsSystems.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 _SeamHttpAcsSystems(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpAcsSystems(constructorOptions);
+  }
   async get(body) {
     const { data } = await this.client.request({
       url: "/acs/systems/get",
@@ -917,6 +1171,24 @@ var SeamHttpAcsUsers = class _SeamHttpAcsUsers {
     });
     return _SeamHttpAcsUsers.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 _SeamHttpAcsUsers(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpAcsUsers(constructorOptions);
+  }
   async addToAccessGroup(body) {
     await this.client.request({
       url: "/acs/users/add_to_access_group",
@@ -1022,6 +1294,24 @@ var SeamHttpAcs = class _SeamHttpAcs {
     });
     return _SeamHttpAcs.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 _SeamHttpAcs(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpAcs(constructorOptions);
+  }
   get accessGroups() {
     return SeamHttpAcsAccessGroups.fromClient(this.client);
   }
@@ -1073,6 +1363,24 @@ var SeamHttpActionAttempts = class _SeamHttpActionAttempts {
     });
     return _SeamHttpActionAttempts.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 _SeamHttpActionAttempts(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpActionAttempts(constructorOptions);
+  }
   async get(body) {
     const { data } = await this.client.request({
       url: "/action_attempts/get",
@@ -1128,6 +1436,24 @@ var SeamHttpConnectWebviews = class _SeamHttpConnectWebviews {
     });
     return _SeamHttpConnectWebviews.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 _SeamHttpConnectWebviews(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpConnectWebviews(constructorOptions);
+  }
   async create(body) {
     const { data } = await this.client.request({
       url: "/connect_webviews/create",
@@ -1205,6 +1531,24 @@ var SeamHttpConnectedAccounts = class _SeamHttpConnectedAccounts {
     });
     return _SeamHttpConnectedAccounts.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 _SeamHttpConnectedAccounts(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpConnectedAccounts(constructorOptions);
+  }
   async delete(body) {
     await this.client.request({
       url: "/connected_accounts/delete",
@@ -1267,6 +1611,24 @@ var SeamHttpDevicesUnmanaged = class _SeamHttpDevicesUnmanaged {
     });
     return _SeamHttpDevicesUnmanaged.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 _SeamHttpDevicesUnmanaged(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpDevicesUnmanaged(constructorOptions);
+  }
   async get(body) {
     const { data } = await this.client.request({
       url: "/devices/unmanaged/get",
@@ -1329,6 +1691,24 @@ var SeamHttpDevices = class _SeamHttpDevices {
     });
     return _SeamHttpDevices.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 _SeamHttpDevices(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpDevices(constructorOptions);
+  }
   get unmanaged() {
     return SeamHttpDevicesUnmanaged.fromClient(this.client);
   }
@@ -1409,6 +1789,24 @@ var SeamHttpEvents = class _SeamHttpEvents {
     });
     return _SeamHttpEvents.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 _SeamHttpEvents(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpEvents(constructorOptions);
+  }
   async get(body) {
     const { data } = await this.client.request({
       url: "/events/get",
@@ -1464,6 +1862,24 @@ var SeamHttpLocks = class _SeamHttpLocks {
     });
     return _SeamHttpLocks.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 _SeamHttpLocks(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpLocks(constructorOptions);
+  }
   async get(body) {
     const { data } = await this.client.request({
       url: "/locks/get",
@@ -1538,6 +1954,24 @@ var SeamHttpNoiseSensorsNoiseThresholds = class _SeamHttpNoiseSensorsNoiseThresh
       options
     );
   }
+  static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId };
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing consoleSessionToken or workspaceId"
+      );
+    }
+    return new _SeamHttpNoiseSensorsNoiseThresholds(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpNoiseSensorsNoiseThresholds(constructorOptions);
+  }
   async create(body) {
     await this.client.request({
       url: "/noise_sensors/noise_thresholds/create",
@@ -1614,6 +2048,24 @@ var SeamHttpNoiseSensors = class _SeamHttpNoiseSensors {
     });
     return _SeamHttpNoiseSensors.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 _SeamHttpNoiseSensors(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpNoiseSensors(constructorOptions);
+  }
   get noiseThresholds() {
     return SeamHttpNoiseSensorsNoiseThresholds.fromClient(this.client);
   }
@@ -1659,6 +2111,24 @@ var SeamHttpThermostatsClimateSettingSchedules = class _SeamHttpThermostatsClima
       options
     );
   }
+  static fromConsoleSessionToken(consoleSessionToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId };
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing consoleSessionToken or workspaceId"
+      );
+    }
+    return new _SeamHttpThermostatsClimateSettingSchedules(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpThermostatsClimateSettingSchedules(constructorOptions);
+  }
   async create(body) {
     const { data } = await this.client.request(
       {
@@ -1744,6 +2214,24 @@ var SeamHttpThermostats = class _SeamHttpThermostats {
     });
     return _SeamHttpThermostats.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 _SeamHttpThermostats(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpThermostats(constructorOptions);
+  }
   get climateSettingSchedules() {
     return SeamHttpThermostatsClimateSettingSchedules.fromClient(this.client);
   }
@@ -1807,6 +2295,123 @@ var SeamHttpThermostats = class _SeamHttpThermostats {
   }
 };
 
+// src/lib/seam/connect/routes/user-identities.ts
+var SeamHttpUserIdentities = class _SeamHttpUserIdentities {
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
+  }
+  static fromClient(client, options = {}) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpUserIdentities(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpUserIdentities(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpUserIdentities(constructorOptions);
+  }
+  static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey);
+    const clientOptions = parseOptions({ ...options, publishableKey });
+    const client = createClient(clientOptions);
+    const clientSessions = SeamHttpClientSessions.fromClient(client);
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey
+    });
+    return _SeamHttpUserIdentities.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 _SeamHttpUserIdentities(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpUserIdentities(constructorOptions);
+  }
+  async addAcsUser(body) {
+    await this.client.request({
+      url: "/user_identities/add_acs_user",
+      method: "post",
+      data: body
+    });
+  }
+  async create(body) {
+    const { data } = await this.client.request({
+      url: "/user_identities/create",
+      method: "post",
+      data: body
+    });
+    return data.user_identity;
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/user_identities/get",
+      method: "post",
+      data: body
+    });
+    return data.user_identity;
+  }
+  async grantAccessToDevice(body) {
+    await this.client.request({
+      url: "/user_identities/grant_access_to_device",
+      method: "post",
+      data: body
+    });
+  }
+  async listAccessibleDevices(body) {
+    const { data } = await this.client.request({
+      url: "/user_identities/list_accessible_devices",
+      method: "post",
+      data: body
+    });
+    return data.accessible_devices;
+  }
+  async listAcsUsers(body) {
+    const { data } = await this.client.request({
+      url: "/user_identities/list_acs_users",
+      method: "post",
+      data: body
+    });
+    return data.acs_users;
+  }
+  async removeAcsUser(body) {
+    await this.client.request({
+      url: "/user_identities/remove_acs_user",
+      method: "post",
+      data: body
+    });
+  }
+  async revokeAccessToDevice(body) {
+    await this.client.request({
+      url: "/user_identities/revoke_access_to_device",
+      method: "post",
+      data: body
+    });
+  }
+};
+
 // src/lib/seam/connect/routes/webhooks.ts
 var SeamHttpWebhooks = class _SeamHttpWebhooks {
   constructor(apiKeyOrOptions = {}) {
@@ -1844,6 +2449,24 @@ var SeamHttpWebhooks = class _SeamHttpWebhooks {
     });
     return _SeamHttpWebhooks.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 _SeamHttpWebhooks(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpWebhooks(constructorOptions);
+  }
   async create(body) {
     const { data } = await this.client.request({
       url: "/webhooks/create",
@@ -1914,6 +2537,24 @@ var SeamHttpWorkspaces = class _SeamHttpWorkspaces {
     });
     return _SeamHttpWorkspaces.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 _SeamHttpWorkspaces(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttpWorkspaces(constructorOptions);
+  }
   async get(params) {
     const { data } = await this.client.request({
       url: "/workspaces/get",
@@ -1976,6 +2617,24 @@ var SeamHttp = class _SeamHttp {
     });
     return _SeamHttp.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 _SeamHttp(constructorOptions);
+  }
+  static fromPersonalAccessToken(personalAccessToken, workspaceId, options = {}) {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId };
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "Missing personalAccessToken or workspaceId"
+      );
+    }
+    return new _SeamHttp(constructorOptions);
+  }
   get accessCodes() {
     return SeamHttpAccessCodes.fromClient(this.client);
   }
@@ -2009,6 +2668,9 @@ var SeamHttp = class _SeamHttp {
   get thermostats() {
     return SeamHttpThermostats.fromClient(this.client);
   }
+  get userIdentities() {
+    return SeamHttpUserIdentities.fromClient(this.client);
+  }
   get webhooks() {
     return SeamHttpWebhooks.fromClient(this.client);
   }
@@ -2041,6 +2703,7 @@ exports.SeamHttpNoiseSensorsNoiseThresholds = SeamHttpNoiseSensorsNoiseThreshold
 exports.SeamHttpThermostats = SeamHttpThermostats;
 exports.SeamHttpThermostatsClimateSettingSchedules = SeamHttpThermostatsClimateSettingSchedules;
 exports.SeamHttpUnauthorizedError = SeamHttpUnauthorizedError;
+exports.SeamHttpUserIdentities = SeamHttpUserIdentities;
 exports.SeamHttpWebhooks = SeamHttpWebhooks;
 exports.SeamHttpWorkspaces = SeamHttpWorkspaces;
 exports.UnserializableParamError = UnserializableParamError;
@@ -2050,6 +2713,8 @@ exports.isSeamHttpInvalidInputError = isSeamHttpInvalidInputError;
 exports.isSeamHttpOptionsWithApiKey = isSeamHttpOptionsWithApiKey;
 exports.isSeamHttpOptionsWithClient = isSeamHttpOptionsWithClient;
 exports.isSeamHttpOptionsWithClientSessionToken = isSeamHttpOptionsWithClientSessionToken;
+exports.isSeamHttpOptionsWithConsoleSessionToken = isSeamHttpOptionsWithConsoleSessionToken;
+exports.isSeamHttpOptionsWithPersonalAccessToken = isSeamHttpOptionsWithPersonalAccessToken;
 exports.isSeamHttpUnauthorizedError = isSeamHttpUnauthorizedError;
 exports.paramsSerializer = paramsSerializer;
 //# sourceMappingURL=out.js.map