@seamapi/http 0.3.0 → 0.5.0

package/dist/connect.cjs

@@ -1,13 +1,98 @@
 'use strict';
 
 var axios = require('axios');
+var axiosBetterStacktrace = require('axios-better-stacktrace');
 var axiosRetry = require('axios-retry');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var axios__default = /*#__PURE__*/_interopDefault(axios);
+var axiosBetterStacktrace__default = /*#__PURE__*/_interopDefault(axiosBetterStacktrace);
 var axiosRetry__default = /*#__PURE__*/_interopDefault(axiosRetry);
 
+// src/lib/seam/connect/error-interceptor.ts
+
+// src/lib/seam/connect/seam-http-error.ts
+var SeamHttpApiError = class extends Error {
+  constructor(error, statusCode, requestId) {
+    const { type, message, data } = error;
+    super(message);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+    this.code = type;
+    this.statusCode = statusCode;
+    this.requestId = requestId;
+    if (data != null)
+      this.data = data;
+  }
+};
+var isSeamHttpApiError = (error) => {
+  return error instanceof SeamHttpApiError;
+};
+var SeamHttpUnauthorizedError = class extends SeamHttpApiError {
+  constructor(requestId) {
+    const type = "unauthorized";
+    const status = 401;
+    super({ type, message: "Unauthorized" }, status, requestId);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+    this.code = type;
+    this.statusCode = status;
+    this.requestId = requestId;
+  }
+};
+var isSeamHttpUnauthorizedError = (error) => {
+  return error instanceof SeamHttpUnauthorizedError;
+};
+var SeamHttpInvalidInputError = class extends SeamHttpApiError {
+  constructor(error, statusCode, requestId) {
+    super(error, statusCode, requestId);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+    this.code = "invalid_input";
+  }
+};
+var isSeamHttpInvalidInputError = (error) => {
+  return error instanceof SeamHttpInvalidInputError;
+};
+
+// src/lib/seam/connect/error-interceptor.ts
+var errorInterceptor = async (err) => {
+  if (!axios.isAxiosError(err))
+    throw err;
+  const { response } = err;
+  const status = response?.status;
+  const headers = response?.headers;
+  const requestId = headers?.["seam-request-id"] ?? "";
+  if (status == null)
+    throw err;
+  if (status === 401) {
+    throw new SeamHttpUnauthorizedError(requestId);
+  }
+  if (!isApiErrorResponse(response))
+    throw err;
+  const { type } = response.data.error;
+  const args = [response.data.error, status, requestId];
+  if (type === "invalid_input")
+    throw new SeamHttpInvalidInputError(...args);
+  throw new SeamHttpApiError(...args);
+};
+var isApiErrorResponse = (response) => {
+  if (response == null)
+    return false;
+  const { headers, data } = response;
+  if (headers == null)
+    return false;
+  const contentType = headers["content-type"];
+  if (typeof contentType === "string" && !contentType.startsWith("application/json")) {
+    return false;
+  }
+  if (typeof data === "object" && data != null) {
+    return "error" in data && typeof data.error === "object" && data.error != null && "type" in data.error && typeof data.error.type === "string";
+  }
+  return false;
+};
+
 // src/lib/seam/connect/options.ts
 var isSeamHttpOptionsWithClient = (options) => {
   if (!("client" in options))
@@ -34,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) => {
@@ -43,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;
@@ -67,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 = ({
@@ -129,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(
@@ -175,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);
@@ -241,11 +473,13 @@ var createClient = (options) => {
     paramsSerializer,
     ...options.axiosOptions
   });
+  axiosBetterStacktrace__default.default(axios__default.default);
   axiosRetry__default.default(client, {
     retries: 2,
     retryDelay: axiosRetry.exponentialDelay,
     ...options.axiosRetryOptions
   });
+  client.interceptors.response.use(void 0, errorInterceptor);
   return client;
 };
 
@@ -336,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",
@@ -422,6 +674,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",
@@ -500,6 +770,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);
   }
@@ -606,6 +894,24 @@ var SeamHttpAcsAccessGroups = class _SeamHttpAcsAccessGroups {
     });
     return _SeamHttpAcsAccessGroups.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 _SeamHttpAcsAccessGroups(constructorOptions);
+  }
+  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 addUser(body) {
     await this.client.request({
       url: "/acs/access_groups/add_user",
@@ -705,6 +1011,24 @@ 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 create(body) {
     const { data } = await this.client.request({
       url: "/acs/credentials/create",
@@ -775,6 +1099,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",
@@ -830,6 +1172,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",
@@ -935,6 +1295,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);
   }
@@ -986,6 +1364,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",
@@ -1041,6 +1437,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",
@@ -1118,6 +1532,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",
@@ -1180,6 +1612,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",
@@ -1242,6 +1692,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);
   }
@@ -1322,6 +1790,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",
@@ -1377,6 +1863,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",
@@ -1451,6 +1955,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",
@@ -1527,6 +2049,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);
   }
@@ -1572,6 +2112,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(
       {
@@ -1657,6 +2215,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);
   }
@@ -1757,6 +2333,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",
@@ -1827,6 +2421,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",
@@ -1889,6 +2501,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);
   }
@@ -1939,24 +2569,33 @@ exports.SeamHttpAcsCredentials = SeamHttpAcsCredentials;
 exports.SeamHttpAcsSystems = SeamHttpAcsSystems;
 exports.SeamHttpAcsUsers = SeamHttpAcsUsers;
 exports.SeamHttpActionAttempts = SeamHttpActionAttempts;
+exports.SeamHttpApiError = SeamHttpApiError;
 exports.SeamHttpClientSessions = SeamHttpClientSessions;
 exports.SeamHttpConnectWebviews = SeamHttpConnectWebviews;
 exports.SeamHttpConnectedAccounts = SeamHttpConnectedAccounts;
 exports.SeamHttpDevices = SeamHttpDevices;
 exports.SeamHttpDevicesUnmanaged = SeamHttpDevicesUnmanaged;
 exports.SeamHttpEvents = SeamHttpEvents;
+exports.SeamHttpInvalidInputError = SeamHttpInvalidInputError;
 exports.SeamHttpInvalidOptionsError = SeamHttpInvalidOptionsError;
 exports.SeamHttpLocks = SeamHttpLocks;
 exports.SeamHttpNoiseSensors = SeamHttpNoiseSensors;
 exports.SeamHttpNoiseSensorsNoiseThresholds = SeamHttpNoiseSensorsNoiseThresholds;
 exports.SeamHttpThermostats = SeamHttpThermostats;
 exports.SeamHttpThermostatsClimateSettingSchedules = SeamHttpThermostatsClimateSettingSchedules;
+exports.SeamHttpUnauthorizedError = SeamHttpUnauthorizedError;
 exports.SeamHttpWebhooks = SeamHttpWebhooks;
 exports.SeamHttpWorkspaces = SeamHttpWorkspaces;
 exports.UnserializableParamError = UnserializableParamError;
+exports.errorInterceptor = errorInterceptor;
+exports.isSeamHttpApiError = isSeamHttpApiError;
+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
 //# sourceMappingURL=connect.cjs.map