@seamapi/http 0.0.2 → 0.1.0

package/dist/connect.cjs

@@ -6,31 +6,33 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var axios__default = /*#__PURE__*/_interopDefault(axios);
 
-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/axios.ts
 
 // src/lib/seam/connect/client-options.ts
+var isSeamHttpOptionsWithClient = (options) => {
+  if (!("client" in options))
+    return false;
+  if (options.client == null)
+    return false;
+  const keys = Object.keys(options).filter(
+    (k) => !["client", "enableLegacyMethodBehaivor"].includes(k)
+  );
+  if (keys.length > 0) {
+    throw new SeamHttpInvalidOptionsError(
+      `The client option cannot be used with any other option except enableLegacyMethodBehaivor, but received: ${keys.join(
+        ", "
+      )}`
+    );
+  }
+  return true;
+};
 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(
+    throw new SeamHttpInvalidOptionsError(
       "The clientSessionToken option cannot be used with the apiKey option."
     );
   }
@@ -39,14 +41,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(
+    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;
@@ -62,7 +66,7 @@ var getAuthHeaders = (options) => {
   if (isSeamHttpOptionsWithClientSessionToken(options)) {
     return getAuthHeadersForClientSessionToken(options);
   }
-  throw new InvalidSeamHttpOptionsError(
+  throw new SeamHttpInvalidOptionsError(
     "Must specify an apiKey or clientSessionToken"
   );
 };
@@ -70,17 +74,17 @@ var getAuthHeadersForApiKey = ({
   apiKey
 }) => {
   if (isClientSessionToken(apiKey)) {
-    throw new InvalidSeamTokenError(
+    throw new SeamHttpInvalidTokenError(
       "A Client Session Token cannot be used as an apiKey"
     );
   }
   if (isAccessToken(apiKey)) {
-    throw new InvalidSeamTokenError(
+    throw new SeamHttpInvalidTokenError(
       "An access token cannot be used as an apiKey"
     );
   }
   if (isJwt(apiKey) || !isSeamToken(apiKey)) {
-    throw new InvalidSeamTokenError(
+    throw new SeamHttpInvalidTokenError(
       `Unknown or invalid apiKey format, expected token to start with ${tokenPrefix}`
     );
   }
@@ -92,7 +96,7 @@ var getAuthHeadersForClientSessionToken = ({
   clientSessionToken
 }) => {
   if (!isClientSessionToken(clientSessionToken)) {
-    throw new InvalidSeamTokenError(
+    throw new SeamHttpInvalidTokenError(
       `Unknown or invalid clientSessionToken format, expected token to start with ${clientSessionTokenPrefix}`
     );
   }
@@ -101,7 +105,7 @@ var getAuthHeadersForClientSessionToken = ({
     "client-session-token": clientSessionToken
   };
 };
-var InvalidSeamTokenError = class extends Error {
+var SeamHttpInvalidTokenError = class extends Error {
   constructor(message) {
     super(`SeamHttp received an invalid token: ${message}`);
     this.name = this.constructor.name;
@@ -117,6 +121,8 @@ var isSeamToken = (token) => token.startsWith(tokenPrefix);
 
 // src/lib/seam/connect/axios.ts
 var createAxiosClient = (options) => {
+  if (isSeamHttpOptionsWithClient(options))
+    return options.client;
   return axios__default.default.create({
     baseURL: options.endpoint,
     withCredentials: isSeamHttpOptionsWithClientSessionToken(options),
@@ -130,8 +136,14 @@ var createAxiosClient = (options) => {
 };
 
 // src/lib/seam/connect/parse-options.ts
+var enableLegacyMethodBehaivorDefault = true;
 var parseOptions = (apiKeyOrOptions) => {
   const options = typeof apiKeyOrOptions === "string" ? { apiKey: apiKeyOrOptions } : apiKeyOrOptions;
+  if (isSeamHttpOptionsWithClient(options))
+    return {
+      ...options,
+      enableLegacyMethodBehaivor: options.enableLegacyMethodBehaivor ?? enableLegacyMethodBehaivorDefault
+    };
   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"];
   return {
@@ -139,80 +151,1393 @@ var parseOptions = (apiKeyOrOptions) => {
     ...apiKey != null ? { apiKey } : {},
     endpoint,
     axiosOptions: options.axiosOptions ?? {},
-    enableLegacyMethodBehaivor: false
+    enableLegacyMethodBehaivor: options.enableLegacyMethodBehaivor ?? enableLegacyMethodBehaivorDefault
   };
 };
 
-// src/lib/seam/connect/routes/workspaces.ts
-var WorkspacesHttp = class {
-  constructor(apiKeyOrOptionsOrClient) {
-    if (apiKeyOrOptionsOrClient instanceof axios.Axios) {
-      this.client = apiKeyOrOptionsOrClient;
-      return;
+// src/lib/seam/connect/routes/access-codes-unmanaged.ts
+var SeamHttpAccessCodesUnmanaged = class _SeamHttpAccessCodesUnmanaged {
+  constructor(apiKeyOrOptions) {
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpAccessCodesUnmanaged(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    const options = parseOptions(apiKeyOrOptionsOrClient);
+    return new _SeamHttpAccessCodesUnmanaged(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAccessCodesUnmanaged(opts);
+  }
+  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(
+      {
+        url: "/access_codes/unmanaged/get",
+        method: "post",
+        data: body
+      }
+    );
+    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 options = parseOptions(apiKeyOrOptions);
     this.client = createAxiosClient(options);
   }
-  async get(params = {}) {
-    const { data } = await this.client.get(
-      "/workspaces/get",
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpAccessCodes(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpAccessCodes(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAccessCodes(opts);
+  }
+  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(params) {
+    const { data } = await this.client.request(
       {
+        url: "/access_codes/generate_code",
+        method: "get",
         params
       }
     );
-    return data.workspace;
+    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 options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpAcsAccessGroups(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpAcsAccessGroups(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAcsAccessGroups(opts);
+  }
+  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 options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpAcsCredentials(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpAcsCredentials(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAcsCredentials(opts);
+  }
+  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 options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpAcsSystems(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpAcsSystems(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAcsSystems(opts);
+  }
+  async get(body) {
+    const { data } = await this.client.request({
+      url: "/acs/systems/get",
+      method: "post",
+      data: body
+    });
+    return data.acs_system;
+  }
+  async list(params) {
+    const { data } = await this.client.request({
+      url: "/acs/systems/list",
+      method: "get",
+      params
+    });
+    return data.acs_systems;
+  }
+};
+
+// src/lib/seam/connect/routes/acs-users.ts
+var SeamHttpAcsUsers = class _SeamHttpAcsUsers {
+  constructor(apiKeyOrOptions) {
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpAcsUsers(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpAcsUsers(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAcsUsers(opts);
+  }
+  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 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 options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpAcs(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpAcs(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpAcs(opts);
+  }
+  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 options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpActionAttempts(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpActionAttempts(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpActionAttempts(opts);
+  }
+  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/routes/client-sessions.ts
+var SeamHttpClientSessions = class _SeamHttpClientSessions {
+  constructor(apiKeyOrOptions) {
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpClientSessions(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpClientSessions(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpClientSessions(opts);
+  }
+  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 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/connect-webviews.ts
+var SeamHttpConnectWebviews = class _SeamHttpConnectWebviews {
+  constructor(apiKeyOrOptions) {
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpConnectWebviews(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpConnectWebviews(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpConnectWebviews(opts);
+  }
+  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(params) {
+    const { data } = await this.client.request({
+      url: "/connect_webviews/list",
+      method: "get",
+      params
+    });
+    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 options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpConnectedAccounts(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpConnectedAccounts(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpConnectedAccounts(opts);
+  }
+  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 options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpDevicesUnmanaged(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpDevicesUnmanaged(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpDevicesUnmanaged(opts);
+  }
+  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 options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpDevices(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpDevices(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpDevices(opts);
+  }
+  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 options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpEvents(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpEvents(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpEvents(opts);
+  }
+  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 options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpLocks(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpLocks(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpLocks(opts);
+  }
+  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 options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpNoiseSensorsNoiseThresholds(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpNoiseSensorsNoiseThresholds(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpNoiseSensorsNoiseThresholds(opts);
+  }
+  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/legacy/workspaces.ts
-var LegacyWorkspacesHttp = class extends WorkspacesHttp {
-  async get(params = {}) {
-    const { data } = await this.client.get(
-      "/workspaces/get",
+// src/lib/seam/connect/routes/noise-sensors.ts
+var SeamHttpNoiseSensors = class _SeamHttpNoiseSensors {
+  constructor(apiKeyOrOptions) {
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpNoiseSensors(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpNoiseSensors(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpNoiseSensors(opts);
+  }
+  get noiseThresholds() {
+    return SeamHttpNoiseSensorsNoiseThresholds.fromClient(this.client);
+  }
+};
+
+// src/lib/seam/connect/routes/thermostats-climate-setting-schedules.ts
+var SeamHttpThermostatsClimateSettingSchedules = class _SeamHttpThermostatsClimateSettingSchedules {
+  constructor(apiKeyOrOptions) {
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpThermostatsClimateSettingSchedules(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpThermostatsClimateSettingSchedules(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpThermostatsClimateSettingSchedules(opts);
+  }
+  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 options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpThermostats(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpThermostats(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpThermostats(opts);
+  }
+  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 options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpWebhooks(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpWebhooks(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpWebhooks(opts);
+  }
+  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 options = parseOptions(apiKeyOrOptions);
+    this.client = createAxiosClient(options);
+  }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttpWorkspaces(opts);
+  }
+  static fromApiKey(apiKey, options = {}) {
+    const opts = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
+    }
+    return new _SeamHttpWorkspaces(opts);
+  }
+  static fromClientSessionToken(clientSessionToken, options = {}) {
+    const opts = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
+    }
+    return new _SeamHttpWorkspaces(opts);
+  }
+  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 {
+var SeamHttp = class _SeamHttp {
+  // #legacy: boolean
   constructor(apiKeyOrOptions) {
-    __privateAdd(this, _legacy, void 0);
     const options = parseOptions(apiKeyOrOptions);
-    __privateSet(this, _legacy, options.enableLegacyMethodBehaivor);
     this.client = createAxiosClient(options);
   }
+  static fromClient(client, options = {}) {
+    const opts = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(opts)) {
+      throw new SeamHttpInvalidOptionsError("Missing client");
+    }
+    return new _SeamHttp(opts);
+  }
   static fromApiKey(apiKey, options = {}) {
     const opts = { ...options, apiKey };
     if (!isSeamHttpOptionsWithApiKey(opts)) {
-      throw new InvalidSeamHttpOptionsError("Missing apiKey");
+      throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
     return new _SeamHttp(opts);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
     const opts = { ...options, clientSessionToken };
     if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
-      throw new InvalidSeamHttpOptionsError("Missing clientSessionToken");
+      throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
     return new _SeamHttp(opts);
   }
-  // TODO
-  // static fromPublishableKey and deprecate getClientSessionToken
-  // TODO: Should we keep makeRequest?
-  // Better to implement error handling and wrapping in an error handler.
-  // makeRequest
+  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);
+  }
   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;
 //# sourceMappingURL=out.js.map