@seamapi/http 0.0.2 → 0.2.0

package/dist/connect.cjs

@@ -1,37 +1,37 @@
 'use strict';
 
 var axios = require('axios');
+var axiosRetry = require('axios-retry');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var axios__default = /*#__PURE__*/_interopDefault(axios);
+var axiosRetry__default = /*#__PURE__*/_interopDefault(axiosRetry);
 
-var __accessCheck = (obj, member, msg) => {
-  if (!member.has(obj))
-    throw TypeError("Cannot " + msg);
-};
-var __privateGet = (obj, member, getter) => {
-  __accessCheck(obj, member, "read from private field");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-var __privateAdd = (obj, member, value) => {
-  if (member.has(obj))
-    throw TypeError("Cannot add the same private member more than once");
-  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-};
-var __privateSet = (obj, member, value, setter) => {
-  __accessCheck(obj, member, "write to private field");
-  setter ? setter.call(obj, value) : member.set(obj, value);
-  return value;
+// src/lib/seam/connect/options.ts
+var isSeamHttpOptionsWithClient = (options) => {
+  if (!("client" in options))
+    return false;
+  if (options.client == null)
+    return false;
+  const keys = Object.keys(options).filter((k) => k !== "client");
+  if (keys.length > 0) {
+    throw new SeamHttpInvalidOptionsError(
+      `The client option cannot be used with any other option, but received: ${keys.join(
+        ", "
+      )}`
+    );
+  }
+  return true;
 };
-
-// src/lib/seam/connect/client-options.ts
 var isSeamHttpOptionsWithApiKey = (options) => {
   if (!("apiKey" in options))
     return false;
+  if (options.apiKey == null)
+    return false;
   if ("clientSessionToken" in options && options.clientSessionToken != null) {
-    throw new InvalidSeamHttpOptionsError(
-      "The clientSessionToken option cannot be used with the apiKey option."
+    throw new SeamHttpInvalidOptionsError(
+      "The clientSessionToken option cannot be used with the apiKey option"
     );
   }
   return true;
@@ -39,14 +39,16 @@ var isSeamHttpOptionsWithApiKey = (options) => {
 var isSeamHttpOptionsWithClientSessionToken = (options) => {
   if (!("clientSessionToken" in options))
     return false;
+  if (options.clientSessionToken == null)
+    return false;
   if ("apiKey" in options && options.apiKey != null) {
-    throw new InvalidSeamHttpOptionsError(
-      "The clientSessionToken option cannot be used with the apiKey option."
+    throw new SeamHttpInvalidOptionsError(
+      "The clientSessionToken option cannot be used with the apiKey option"
     );
   }
   return true;
 };
-var InvalidSeamHttpOptionsError = class extends Error {
+var SeamHttpInvalidOptionsError = class extends Error {
   constructor(message) {
     super(`SeamHttp received invalid options: ${message}`);
     this.name = this.constructor.name;
@@ -56,31 +58,42 @@ var InvalidSeamHttpOptionsError = class extends Error {
 
 // src/lib/seam/connect/auth.ts
 var getAuthHeaders = (options) => {
+  if ("publishableKey" in options) {
+    return getAuthHeadersForPublishableKey(options.publishableKey);
+  }
   if (isSeamHttpOptionsWithApiKey(options)) {
     return getAuthHeadersForApiKey(options);
   }
   if (isSeamHttpOptionsWithClientSessionToken(options)) {
     return getAuthHeadersForClientSessionToken(options);
   }
-  throw new InvalidSeamHttpOptionsError(
-    "Must specify an apiKey or clientSessionToken"
+  throw new SeamHttpInvalidOptionsError(
+    "Must specify an apiKey, clientSessionToken, or publishableKey"
   );
 };
 var getAuthHeadersForApiKey = ({
   apiKey
 }) => {
   if (isClientSessionToken(apiKey)) {
-    throw new InvalidSeamTokenError(
+    throw new SeamHttpInvalidTokenError(
       "A Client Session Token cannot be used as an apiKey"
     );
   }
+  if (isJwt(apiKey)) {
+    throw new SeamHttpInvalidTokenError("A JWT cannot be used as an apiKey");
+  }
   if (isAccessToken(apiKey)) {
-    throw new InvalidSeamTokenError(
-      "An access token cannot be used as an apiKey"
+    throw new SeamHttpInvalidTokenError(
+      "An Access Token cannot be used as an apiKey"
+    );
+  }
+  if (isPublishableKey(apiKey)) {
+    throw new SeamHttpInvalidTokenError(
+      "A Publishable Key cannot be used as an apiKey"
     );
   }
-  if (isJwt(apiKey) || !isSeamToken(apiKey)) {
-    throw new InvalidSeamTokenError(
+  if (!isSeamToken(apiKey)) {
+    throw new SeamHttpInvalidTokenError(
       `Unknown or invalid apiKey format, expected token to start with ${tokenPrefix}`
     );
   }
@@ -91,8 +104,23 @@ var getAuthHeadersForApiKey = ({
 var getAuthHeadersForClientSessionToken = ({
   clientSessionToken
 }) => {
+  if (isJwt(clientSessionToken)) {
+    throw new SeamHttpInvalidTokenError(
+      "A JWT cannot be used as a clientSessionToken"
+    );
+  }
+  if (isAccessToken(clientSessionToken)) {
+    throw new SeamHttpInvalidTokenError(
+      "An Access Token cannot be used as a clientSessionToken"
+    );
+  }
+  if (isPublishableKey(clientSessionToken)) {
+    throw new SeamHttpInvalidTokenError(
+      "A Publishable Key cannot be used as a clientSessionToken"
+    );
+  }
   if (!isClientSessionToken(clientSessionToken)) {
-    throw new InvalidSeamTokenError(
+    throw new SeamHttpInvalidTokenError(
       `Unknown or invalid clientSessionToken format, expected token to start with ${clientSessionTokenPrefix}`
     );
   }
@@ -101,119 +129,1802 @@ var getAuthHeadersForClientSessionToken = ({
     "client-session-token": clientSessionToken
   };
 };
-var InvalidSeamTokenError = class extends Error {
+var getAuthHeadersForPublishableKey = (publishableKey) => {
+  if (isJwt(publishableKey)) {
+    throw new SeamHttpInvalidTokenError(
+      "A JWT cannot be used as a publishableKey"
+    );
+  }
+  if (isAccessToken(publishableKey)) {
+    throw new SeamHttpInvalidTokenError(
+      "An Access Token cannot be used as a publishableKey"
+    );
+  }
+  if (isClientSessionToken(publishableKey)) {
+    throw new SeamHttpInvalidTokenError(
+      "A Client Session Token Key cannot be used as a publishableKey"
+    );
+  }
+  if (!isPublishableKey(publishableKey)) {
+    throw new SeamHttpInvalidTokenError(
+      `Unknown or invalid publishableKey format, expected token to start with ${publishableKeyTokenPrefix}`
+    );
+  }
+  return {
+    "seam-publishable-key": publishableKey
+  };
+};
+var SeamHttpInvalidTokenError = class extends Error {
   constructor(message) {
     super(`SeamHttp received an invalid token: ${message}`);
     this.name = this.constructor.name;
     Error.captureStackTrace(this, this.constructor);
   }
 };
+var warnOnInsecureuserIdentifierKey = (userIdentifierKey) => {
+  if (isEmail(userIdentifierKey)) {
+    console.warn(
+      ...[
+        "Using an email for the userIdentifierKey is insecure and may return an error in the future!",
+        "This is insecure because an email is common knowledge or easily guessed.",
+        "Use something with sufficient entropy known only to the owner of the client session.",
+        "For help choosing a user identifier key see",
+        "https://docs.seam.co/latest/seam-components/overview/get-started-with-client-side-components#3-select-a-user-identifier-key"
+      ]
+    );
+  }
+};
 var tokenPrefix = "seam_";
 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 isSeamToken = (token) => token.startsWith(tokenPrefix);
+var isPublishableKey = (token) => token.startsWith(publishableKeyTokenPrefix);
+var isEmail = (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
 
-// src/lib/seam/connect/axios.ts
-var createAxiosClient = (options) => {
-  return axios__default.default.create({
-    baseURL: options.endpoint,
-    withCredentials: isSeamHttpOptionsWithClientSessionToken(options),
-    ...options.axiosOptions,
-    headers: {
-      ...getAuthHeaders(options),
-      ...options.axiosOptions.headers
-      // TODO: User-Agent
+// 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) {
+        throwIfUnserializable(name, v);
+        searchParams.append(name, v);
+      }
+      continue;
     }
+    throwIfUnserializable(name, value);
+    searchParams.set(name, value);
+  }
+  searchParams.sort();
+  return searchParams.toString();
+};
+var throwIfUnserializable = (k, v) => {
+  if (v == null) {
+    throw new UnserializableParamError(k, `is ${v} or contains ${v}`);
+  }
+  if (typeof v === "function") {
+    throw new UnserializableParamError(
+      k,
+      "is a function or contains a function"
+    );
+  }
+  if (typeof v === "object") {
+    throw new UnserializableParamError(k, "is an object or contains an object");
+  }
+};
+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) => {
+  if (options.client != null)
+    return options.client;
+  const client = axios__default.default.create({
+    paramsSerializer,
+    ...options.axiosOptions
+  });
+  axiosRetry__default.default(client, {
+    retries: 2,
+    retryDelay: axiosRetry.exponentialDelay,
+    ...options.axiosRetryOptions
   });
+  return client;
 };
 
 // src/lib/seam/connect/parse-options.ts
+var defaultEndpoint = "https://connect.getseam.com";
 var parseOptions = (apiKeyOrOptions) => {
+  const options = getNormalizedOptions(apiKeyOrOptions);
+  if (isSeamHttpOptionsWithClient(options))
+    return options;
+  return {
+    axiosOptions: {
+      baseURL: options.endpoint ?? getEndpointFromEnv() ?? defaultEndpoint,
+      withCredentials: isSeamHttpOptionsWithClientSessionToken(options),
+      ...options.axiosOptions,
+      headers: {
+        ...getAuthHeaders(options),
+        ...options.axiosOptions?.headers
+      }
+    },
+    axiosRetryOptions: {
+      ...options.axiosRetryOptions
+    }
+  };
+};
+var getNormalizedOptions = (apiKeyOrOptions) => {
   const options = typeof apiKeyOrOptions === "string" ? { apiKey: apiKeyOrOptions } : apiKeyOrOptions;
-  const endpoint = options.endpoint ?? globalThis.process?.env?.["SEAM_ENDPOINT"] ?? globalThis.process?.env?.["SEAM_API_URL"] ?? "https://connect.getseam.com";
-  const apiKey = "apiKey" in options ? options.apiKey : globalThis.process?.env?.["SEAM_API_KEY"];
+  if (isSeamHttpOptionsWithClient(options))
+    return options;
+  const apiKey = "apiKey" in options ? options.apiKey : getApiKeyFromEnv(options);
   return {
     ...options,
-    ...apiKey != null ? { apiKey } : {},
-    endpoint,
-    axiosOptions: options.axiosOptions ?? {},
-    enableLegacyMethodBehaivor: false
+    ...apiKey != null ? { apiKey } : {}
   };
 };
+var getApiKeyFromEnv = (options) => {
+  if ("clientSessionToken" in options && options.clientSessionToken != null) {
+    return null;
+  }
+  return globalThis.process?.env?.SEAM_API_KEY;
+};
+var getEndpointFromEnv = () => {
+  return globalThis.process?.env?.SEAM_ENDPOINT ?? globalThis.process?.env?.SEAM_API_URL;
+};
 
-// src/lib/seam/connect/routes/workspaces.ts
-var WorkspacesHttp = class {
-  constructor(apiKeyOrOptionsOrClient) {
-    if (apiKeyOrOptionsOrClient instanceof axios.Axios) {
-      this.client = apiKeyOrOptionsOrClient;
-      return;
-    }
-    const options = parseOptions(apiKeyOrOptionsOrClient);
-    this.client = createAxiosClient(options);
-  }
-  async get(params = {}) {
-    const { data } = await this.client.get(
-      "/workspaces/get",
+// src/lib/seam/connect/routes/client-sessions.ts
+var SeamHttpClientSessions = class _SeamHttpClientSessions {
+  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 _SeamHttpClientSessions(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpClientSessions(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpClientSessions(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 _SeamHttpClientSessions.fromClientSessionToken(token, options);
+  }
+  async create(body) {
+    const { data } = await this.client.request({
+      url: "/client_sessions/create",
+      method: "post",
+      data: body
+    });
+    return data.client_session;
+  }
+  async delete(body) {
+    await this.client.request({
+      url: "/client_sessions/delete",
+      method: "post",
+      data: body
+    });
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/client_sessions/get",
+      method: "post",
+      data: body
+    });
+    return data.client_session;
+  }
+  async getOrCreate(body) {
+    const { data } = await this.client.request({
+      url: "/client_sessions/get_or_create",
+      method: "post",
+      data: body
+    });
+    return data.client_session;
+  }
+  async grantAccess(body) {
+    const { data } = await this.client.request({
+      url: "/client_sessions/grant_access",
+      method: "post",
+      data: body
+    });
+    return data.client_session;
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/client_sessions/list",
+      method: "post",
+      data: body
+    });
+    return data.client_sessions;
+  }
+};
+
+// src/lib/seam/connect/routes/access-codes-unmanaged.ts
+var SeamHttpAccessCodesUnmanaged = class _SeamHttpAccessCodesUnmanaged {
+  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 _SeamHttpAccessCodesUnmanaged(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpAccessCodesUnmanaged(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAccessCodesUnmanaged(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 _SeamHttpAccessCodesUnmanaged.fromClientSessionToken(token, options);
+  }
+  async convertToManaged(body) {
+    await this.client.request({
+      url: "/access_codes/unmanaged/convert_to_managed",
+      method: "post",
+      data: body
+    });
+  }
+  async delete(body) {
+    await this.client.request({
+      url: "/access_codes/unmanaged/delete",
+      method: "post",
+      data: body
+    });
+  }
+  async get(body) {
+    const { data } = await this.client.request(
       {
-        params
+        url: "/access_codes/unmanaged/get",
+        method: "post",
+        data: body
       }
     );
-    return data.workspace;
+    return data.access_code;
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/access_codes/unmanaged/list",
+      method: "post",
+      data: body
+    });
+    return data.access_codes;
+  }
+  async update(body) {
+    await this.client.request({
+      url: "/access_codes/unmanaged/update",
+      method: "post",
+      data: body
+    });
+  }
+};
+
+// src/lib/seam/connect/routes/access-codes.ts
+var SeamHttpAccessCodes = class _SeamHttpAccessCodes {
+  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 _SeamHttpAccessCodes(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpAccessCodes(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAccessCodes(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 _SeamHttpAccessCodes.fromClientSessionToken(token, options);
+  }
+  get unmanaged() {
+    return SeamHttpAccessCodesUnmanaged.fromClient(this.client);
+  }
+  async create(body) {
+    const { data } = await this.client.request({
+      url: "/access_codes/create",
+      method: "post",
+      data: body
+    });
+    return data.access_code;
+  }
+  async createMultiple(body) {
+    const { data } = await this.client.request({
+      url: "/access_codes/create_multiple",
+      method: "post",
+      data: body
+    });
+    return data.access_codes;
+  }
+  async delete(body) {
+    await this.client.request({
+      url: "/access_codes/delete",
+      method: "post",
+      data: body
+    });
+  }
+  async generateCode(body) {
+    const { data } = await this.client.request(
+      {
+        url: "/access_codes/generate_code",
+        method: "post",
+        data: body
+      }
+    );
+    return data.generated_code;
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/access_codes/get",
+      method: "post",
+      data: body
+    });
+    return data.access_code;
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/access_codes/list",
+      method: "post",
+      data: body
+    });
+    return data.access_codes;
+  }
+  async pullBackupAccessCode(body) {
+    const { data } = await this.client.request({
+      url: "/access_codes/pull_backup_access_code",
+      method: "post",
+      data: body
+    });
+    return data.backup_access_code;
+  }
+  async update(body) {
+    await this.client.request({
+      url: "/access_codes/update",
+      method: "post",
+      data: body
+    });
+  }
+};
+
+// src/lib/seam/connect/routes/acs-access-groups.ts
+var SeamHttpAcsAccessGroups = class _SeamHttpAcsAccessGroups {
+  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 _SeamHttpAcsAccessGroups(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpAcsAccessGroups(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAcsAccessGroups(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 _SeamHttpAcsAccessGroups.fromClientSessionToken(token, options);
+  }
+  async addUser(body) {
+    await this.client.request({
+      url: "/acs/access_groups/add_user",
+      method: "post",
+      data: body
+    });
+  }
+  async create(body) {
+    const { data } = await this.client.request({
+      url: "/acs/access_groups/create",
+      method: "post",
+      data: body
+    });
+    return data.acs_access_group;
+  }
+  async delete(body) {
+    await this.client.request({
+      url: "/acs/access_groups/delete",
+      method: "post",
+      data: body
+    });
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/acs/access_groups/get",
+      method: "post",
+      data: body
+    });
+    return data.acs_access_group;
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/acs/access_groups/list",
+      method: "post",
+      data: body
+    });
+    return data.acs_access_groups;
+  }
+  async listUsers(body) {
+    const { data } = await this.client.request({
+      url: "/acs/access_groups/list_users",
+      method: "post",
+      data: body
+    });
+    return data.acs_users;
+  }
+  async removeUser(body) {
+    await this.client.request({
+      url: "/acs/access_groups/remove_user",
+      method: "post",
+      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
+var SeamHttpAcsCredentials = class _SeamHttpAcsCredentials {
+  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 _SeamHttpAcsCredentials(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpAcsCredentials(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAcsCredentials(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 _SeamHttpAcsCredentials.fromClientSessionToken(token, options);
+  }
+  async create(body) {
+    const { data } = await this.client.request({
+      url: "/acs/credentials/create",
+      method: "post",
+      data: body
+    });
+    return data.acs_credential;
+  }
+  async delete(body) {
+    await this.client.request({
+      url: "/acs/credentials/delete",
+      method: "post",
+      data: body
+    });
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/acs/credentials/get",
+      method: "post",
+      data: body
+    });
+    return data.acs_credential;
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/acs/credentials/list",
+      method: "post",
+      data: body
+    });
+    return data.acs_credentials;
+  }
+};
+
+// src/lib/seam/connect/routes/acs-systems.ts
+var SeamHttpAcsSystems = class _SeamHttpAcsSystems {
+  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 _SeamHttpAcsSystems(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpAcsSystems(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAcsSystems(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 _SeamHttpAcsSystems.fromClientSessionToken(token, options);
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/acs/systems/get",
+      method: "post",
+      data: body
+    });
+    return data.acs_system;
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/acs/systems/list",
+      method: "post",
+      data: body
+    });
+    return data.acs_systems;
+  }
+};
+
+// src/lib/seam/connect/routes/acs-users.ts
+var SeamHttpAcsUsers = class _SeamHttpAcsUsers {
+  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 _SeamHttpAcsUsers(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpAcsUsers(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAcsUsers(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 _SeamHttpAcsUsers.fromClientSessionToken(token, options);
+  }
+  async addToAccessGroup(body) {
+    await this.client.request({
+      url: "/acs/users/add_to_access_group",
+      method: "post",
+      data: body
+    });
+  }
+  async create(body) {
+    const { data } = await this.client.request({
+      url: "/acs/users/create",
+      method: "post",
+      data: body
+    });
+    return data.acs_user;
+  }
+  async delete(body) {
+    await this.client.request({
+      url: "/acs/users/delete",
+      method: "post",
+      data: body
+    });
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/acs/users/get",
+      method: "post",
+      data: body
+    });
+    return data.acs_user;
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/acs/users/list",
+      method: "post",
+      data: body
+    });
+    return data.acs_users;
+  }
+  async removeFromAccessGroup(body) {
+    await this.client.request({
+      url: "/acs/users/remove_from_access_group",
+      method: "post",
+      data: body
+    });
+  }
+  async suspend(body) {
+    await this.client.request({
+      url: "/acs/users/suspend",
+      method: "post",
+      data: body
+    });
+  }
+  async unsuspend(body) {
+    await this.client.request({
+      url: "/acs/users/unsuspend",
+      method: "post",
+      data: body
+    });
+  }
+  async update(body) {
+    await this.client.request({
+      url: "/acs/users/update",
+      method: "post",
+      data: body
+    });
+  }
+};
+
+// src/lib/seam/connect/routes/acs.ts
+var SeamHttpAcs = class _SeamHttpAcs {
+  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 _SeamHttpAcs(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpAcs(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAcs(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 _SeamHttpAcs.fromClientSessionToken(token, options);
+  }
+  get accessGroups() {
+    return SeamHttpAcsAccessGroups.fromClient(this.client);
+  }
+  get credentials() {
+    return SeamHttpAcsCredentials.fromClient(this.client);
+  }
+  get systems() {
+    return SeamHttpAcsSystems.fromClient(this.client);
+  }
+  get users() {
+    return SeamHttpAcsUsers.fromClient(this.client);
+  }
+};
+
+// src/lib/seam/connect/routes/action-attempts.ts
+var SeamHttpActionAttempts = class _SeamHttpActionAttempts {
+  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 _SeamHttpActionAttempts(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpActionAttempts(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpActionAttempts(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 _SeamHttpActionAttempts.fromClientSessionToken(token, options);
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/action_attempts/get",
+      method: "post",
+      data: body
+    });
+    return data.action_attempt;
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/action_attempts/list",
+      method: "post",
+      data: body
+    });
+    return data.action_attempts;
   }
 };
 
-// src/lib/seam/connect/legacy/workspaces.ts
-var LegacyWorkspacesHttp = class extends WorkspacesHttp {
-  async get(params = {}) {
-    const { data } = await this.client.get(
-      "/workspaces/get",
+// src/lib/seam/connect/routes/connect-webviews.ts
+var SeamHttpConnectWebviews = class _SeamHttpConnectWebviews {
+  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 _SeamHttpConnectWebviews(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpConnectWebviews(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpConnectWebviews(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 _SeamHttpConnectWebviews.fromClientSessionToken(token, options);
+  }
+  async create(body) {
+    const { data } = await this.client.request({
+      url: "/connect_webviews/create",
+      method: "post",
+      data: body
+    });
+    return data.connect_webview;
+  }
+  async delete(body) {
+    await this.client.request({
+      url: "/connect_webviews/delete",
+      method: "post",
+      data: body
+    });
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/connect_webviews/get",
+      method: "post",
+      data: body
+    });
+    return data.connect_webview;
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/connect_webviews/list",
+      method: "post",
+      data: body
+    });
+    return data.connect_webviews;
+  }
+  async view(params) {
+    await this.client.request({
+      url: "/connect_webviews/view",
+      method: "get",
+      params
+    });
+  }
+};
+
+// src/lib/seam/connect/routes/connected-accounts.ts
+var SeamHttpConnectedAccounts = class _SeamHttpConnectedAccounts {
+  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 _SeamHttpConnectedAccounts(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpConnectedAccounts(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpConnectedAccounts(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 _SeamHttpConnectedAccounts.fromClientSessionToken(token, options);
+  }
+  async delete(body) {
+    await this.client.request({
+      url: "/connected_accounts/delete",
+      method: "post",
+      data: body
+    });
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/connected_accounts/get",
+      method: "post",
+      data: body
+    });
+    return data.connected_account;
+  }
+  async list(params) {
+    const { data } = await this.client.request({
+      url: "/connected_accounts/list",
+      method: "get",
+      params
+    });
+    return data.connected_accounts;
+  }
+};
+
+// src/lib/seam/connect/routes/devices-unmanaged.ts
+var SeamHttpDevicesUnmanaged = class _SeamHttpDevicesUnmanaged {
+  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 _SeamHttpDevicesUnmanaged(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpDevicesUnmanaged(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpDevicesUnmanaged(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 _SeamHttpDevicesUnmanaged.fromClientSessionToken(token, options);
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/devices/unmanaged/get",
+      method: "post",
+      data: body
+    });
+    return data.device;
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/devices/unmanaged/list",
+      method: "post",
+      data: body
+    });
+    return data.devices;
+  }
+  async update(body) {
+    await this.client.request({
+      url: "/devices/unmanaged/update",
+      method: "post",
+      data: body
+    });
+  }
+};
+
+// src/lib/seam/connect/routes/devices.ts
+var SeamHttpDevices = class _SeamHttpDevices {
+  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 _SeamHttpDevices(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpDevices(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpDevices(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 _SeamHttpDevices.fromClientSessionToken(token, options);
+  }
+  get unmanaged() {
+    return SeamHttpDevicesUnmanaged.fromClient(this.client);
+  }
+  async delete(body) {
+    await this.client.request({
+      url: "/devices/delete",
+      method: "post",
+      data: body
+    });
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/devices/get",
+      method: "post",
+      data: body
+    });
+    return data.device;
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/devices/list",
+      method: "post",
+      data: body
+    });
+    return data.devices;
+  }
+  async listDeviceProviders(body) {
+    const { data } = await this.client.request({
+      url: "/devices/list_device_providers",
+      method: "post",
+      data: body
+    });
+    return data.device_providers;
+  }
+  async update(body) {
+    await this.client.request({
+      url: "/devices/update",
+      method: "post",
+      data: body
+    });
+  }
+};
+
+// src/lib/seam/connect/routes/events.ts
+var SeamHttpEvents = class _SeamHttpEvents {
+  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 _SeamHttpEvents(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpEvents(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpEvents(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 _SeamHttpEvents.fromClientSessionToken(token, options);
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/events/get",
+      method: "post",
+      data: body
+    });
+    return data.event;
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/events/list",
+      method: "post",
+      data: body
+    });
+    return data.events;
+  }
+};
+
+// src/lib/seam/connect/routes/locks.ts
+var SeamHttpLocks = class _SeamHttpLocks {
+  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 _SeamHttpLocks(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpLocks(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpLocks(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 _SeamHttpLocks.fromClientSessionToken(token, options);
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/locks/get",
+      method: "post",
+      data: body
+    });
+    return data.device;
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/locks/list",
+      method: "post",
+      data: body
+    });
+    return data.devices;
+  }
+  async lockDoor(body) {
+    const { data } = await this.client.request({
+      url: "/locks/lock_door",
+      method: "post",
+      data: body
+    });
+    return data.action_attempt;
+  }
+  async unlockDoor(body) {
+    const { data } = await this.client.request({
+      url: "/locks/unlock_door",
+      method: "post",
+      data: body
+    });
+    return data.action_attempt;
+  }
+};
+
+// src/lib/seam/connect/routes/noise-sensors-noise-thresholds.ts
+var SeamHttpNoiseSensorsNoiseThresholds = class _SeamHttpNoiseSensorsNoiseThresholds {
+  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 _SeamHttpNoiseSensorsNoiseThresholds(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpNoiseSensorsNoiseThresholds(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpNoiseSensorsNoiseThresholds(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 _SeamHttpNoiseSensorsNoiseThresholds.fromClientSessionToken(
+      token,
+      options
+    );
+  }
+  async create(body) {
+    await this.client.request({
+      url: "/noise_sensors/noise_thresholds/create",
+      method: "post",
+      data: body
+    });
+  }
+  async delete(body) {
+    await this.client.request({
+      url: "/noise_sensors/noise_thresholds/delete",
+      method: "post",
+      data: body
+    });
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/noise_sensors/noise_thresholds/get",
+      method: "post",
+      data: body
+    });
+    return data.noise_threshold;
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/noise_sensors/noise_thresholds/list",
+      method: "post",
+      data: body
+    });
+    return data.noise_thresholds;
+  }
+  async update(body) {
+    await this.client.request({
+      url: "/noise_sensors/noise_thresholds/update",
+      method: "post",
+      data: body
+    });
+  }
+};
+
+// src/lib/seam/connect/routes/noise-sensors.ts
+var SeamHttpNoiseSensors = class _SeamHttpNoiseSensors {
+  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 _SeamHttpNoiseSensors(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpNoiseSensors(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpNoiseSensors(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 _SeamHttpNoiseSensors.fromClientSessionToken(token, options);
+  }
+  get noiseThresholds() {
+    return SeamHttpNoiseSensorsNoiseThresholds.fromClient(this.client);
+  }
+};
+
+// src/lib/seam/connect/routes/thermostats-climate-setting-schedules.ts
+var SeamHttpThermostatsClimateSettingSchedules = class _SeamHttpThermostatsClimateSettingSchedules {
+  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 _SeamHttpThermostatsClimateSettingSchedules(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpThermostatsClimateSettingSchedules(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpThermostatsClimateSettingSchedules(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 _SeamHttpThermostatsClimateSettingSchedules.fromClientSessionToken(
+      token,
+      options
+    );
+  }
+  async create(body) {
+    const { data } = await this.client.request(
       {
-        params
+        url: "/thermostats/climate_setting_schedules/create",
+        method: "post",
+        data: body
       }
     );
+    return data.climate_setting_schedule;
+  }
+  async delete(body) {
+    await this.client.request(
+      {
+        url: "/thermostats/climate_setting_schedules/delete",
+        method: "post",
+        data: body
+      }
+    );
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/thermostats/climate_setting_schedules/get",
+      method: "post",
+      data: body
+    });
+    return data.climate_setting_schedule;
+  }
+  async list(body) {
+    const { data } = await this.client.request(
+      {
+        url: "/thermostats/climate_setting_schedules/list",
+        method: "post",
+        data: body
+      }
+    );
+    return data.climate_setting_schedules;
+  }
+  async update(body) {
+    await this.client.request(
+      {
+        url: "/thermostats/climate_setting_schedules/update",
+        method: "post",
+        data: body
+      }
+    );
+  }
+};
+
+// src/lib/seam/connect/routes/thermostats.ts
+var SeamHttpThermostats = class _SeamHttpThermostats {
+  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 _SeamHttpThermostats(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpThermostats(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpThermostats(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 _SeamHttpThermostats.fromClientSessionToken(token, options);
+  }
+  get climateSettingSchedules() {
+    return SeamHttpThermostatsClimateSettingSchedules.fromClient(this.client);
+  }
+  async cool(body) {
+    await this.client.request({
+      url: "/thermostats/cool",
+      method: "post",
+      data: body
+    });
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/thermostats/get",
+      method: "post",
+      data: body
+    });
+    return data.thermostat;
+  }
+  async heat(body) {
+    await this.client.request({
+      url: "/thermostats/heat",
+      method: "post",
+      data: body
+    });
+  }
+  async heatCool(body) {
+    await this.client.request({
+      url: "/thermostats/heat_cool",
+      method: "post",
+      data: body
+    });
+  }
+  async list(body) {
+    const { data } = await this.client.request({
+      url: "/thermostats/list",
+      method: "post",
+      data: body
+    });
+    return data.thermostats;
+  }
+  async off(body) {
+    await this.client.request({
+      url: "/thermostats/off",
+      method: "post",
+      data: body
+    });
+  }
+  async setFanMode(body) {
+    await this.client.request({
+      url: "/thermostats/set_fan_mode",
+      method: "post",
+      data: body
+    });
+  }
+  async update(body) {
+    await this.client.request({
+      url: "/thermostats/update",
+      method: "post",
+      data: body
+    });
+  }
+};
+
+// src/lib/seam/connect/routes/webhooks.ts
+var SeamHttpWebhooks = class _SeamHttpWebhooks {
+  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 _SeamHttpWebhooks(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpWebhooks(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpWebhooks(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 _SeamHttpWebhooks.fromClientSessionToken(token, options);
+  }
+  async create(body) {
+    const { data } = await this.client.request({
+      url: "/webhooks/create",
+      method: "post",
+      data: body
+    });
+    return data.webhook;
+  }
+  async delete(body) {
+    await this.client.request({
+      url: "/webhooks/delete",
+      method: "post",
+      data: body
+    });
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/webhooks/get",
+      method: "post",
+      data: body
+    });
+    return data.webhook;
+  }
+  async list(params) {
+    const { data } = await this.client.request({
+      url: "/webhooks/list",
+      method: "get",
+      params
+    });
+    return data.webhooks;
+  }
+};
+
+// src/lib/seam/connect/routes/workspaces.ts
+var SeamHttpWorkspaces = class _SeamHttpWorkspaces {
+  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 _SeamHttpWorkspaces(constructorOptions);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpWorkspaces(constructorOptions);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpWorkspaces(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 _SeamHttpWorkspaces.fromClientSessionToken(token, options);
+  }
+  async get(params) {
+    const { data } = await this.client.request({
+      url: "/workspaces/get",
+      method: "get",
+      params
+    });
     return data.workspace;
   }
+  async list(params) {
+    const { data } = await this.client.request({
+      url: "/workspaces/list",
+      method: "get",
+      params
+    });
+    return data.workspaces;
+  }
+  async resetSandbox(body) {
+    await this.client.request({
+      url: "/workspaces/reset_sandbox",
+      method: "post",
+      data: body
+    });
+  }
 };
 
-// src/lib/seam/connect/client.ts
-var _legacy;
-var _SeamHttp = class _SeamHttp {
-  constructor(apiKeyOrOptions) {
-    __privateAdd(this, _legacy, void 0);
-    const options = parseOptions(apiKeyOrOptions);
-    __privateSet(this, _legacy, options.enableLegacyMethodBehaivor);
-    this.client = createAxiosClient(options);
+// src/lib/seam/connect/seam-http.ts
+var SeamHttp = class _SeamHttp {
+  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 _SeamHttp(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
-      throw new InvalidSeamHttpOptionsError("Missing apiKey");
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttp(opts);
+    return new _SeamHttp(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
-      throw new InvalidSeamHttpOptionsError("Missing clientSessionToken");
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttp(opts);
+    return new _SeamHttp(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 _SeamHttp.fromClientSessionToken(token, options);
+  }
+  get accessCodes() {
+    return SeamHttpAccessCodes.fromClient(this.client);
+  }
+  get acs() {
+    return SeamHttpAcs.fromClient(this.client);
+  }
+  get actionAttempts() {
+    return SeamHttpActionAttempts.fromClient(this.client);
+  }
+  get clientSessions() {
+    return SeamHttpClientSessions.fromClient(this.client);
+  }
+  get connectedAccounts() {
+    return SeamHttpConnectedAccounts.fromClient(this.client);
+  }
+  get connectWebviews() {
+    return SeamHttpConnectWebviews.fromClient(this.client);
+  }
+  get devices() {
+    return SeamHttpDevices.fromClient(this.client);
+  }
+  get events() {
+    return SeamHttpEvents.fromClient(this.client);
+  }
+  get locks() {
+    return SeamHttpLocks.fromClient(this.client);
+  }
+  get noiseSensors() {
+    return SeamHttpNoiseSensors.fromClient(this.client);
+  }
+  get thermostats() {
+    return SeamHttpThermostats.fromClient(this.client);
+  }
+  get webhooks() {
+    return SeamHttpWebhooks.fromClient(this.client);
   }
-  // TODO
-  // static fromPublishableKey and deprecate getClientSessionToken
-  // TODO: Should we keep makeRequest?
-  // Better to implement error handling and wrapping in an error handler.
-  // makeRequest
   get workspaces() {
-    if (__privateGet(this, _legacy))
-      return new LegacyWorkspacesHttp(this.client);
-    return new WorkspacesHttp(this.client);
+    return SeamHttpWorkspaces.fromClient(this.client);
   }
 };
-_legacy = new WeakMap();
-var SeamHttp = _SeamHttp;
 
 exports.SeamHttp = SeamHttp;
+exports.SeamHttpInvalidOptionsError = SeamHttpInvalidOptionsError;
+exports.isSeamHttpOptionsWithApiKey = isSeamHttpOptionsWithApiKey;
+exports.isSeamHttpOptionsWithClient = isSeamHttpOptionsWithClient;
+exports.isSeamHttpOptionsWithClientSessionToken = isSeamHttpOptionsWithClientSessionToken;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=connect.cjs.map