@seamapi/http 0.1.0 → 0.2.0

package/dist/connect.cjs

@@ -1,25 +1,23 @@
 '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);
 
-// src/lib/seam/connect/axios.ts
-
-// src/lib/seam/connect/client-options.ts
+// 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) => !["client", "enableLegacyMethodBehaivor"].includes(k)
-  );
+  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 except enableLegacyMethodBehaivor, but received: ${keys.join(
+      `The client option cannot be used with any other option, but received: ${keys.join(
         ", "
       )}`
     );
@@ -33,7 +31,7 @@ var isSeamHttpOptionsWithApiKey = (options) => {
     return false;
   if ("clientSessionToken" in options && options.clientSessionToken != null) {
     throw new SeamHttpInvalidOptionsError(
-      "The clientSessionToken option cannot be used with the apiKey option."
+      "The clientSessionToken option cannot be used with the apiKey option"
     );
   }
   return true;
@@ -45,7 +43,7 @@ var isSeamHttpOptionsWithClientSessionToken = (options) => {
     return false;
   if ("apiKey" in options && options.apiKey != null) {
     throw new SeamHttpInvalidOptionsError(
-      "The clientSessionToken option cannot be used with the apiKey option."
+      "The clientSessionToken option cannot be used with the apiKey option"
     );
   }
   return true;
@@ -60,6 +58,9 @@ var SeamHttpInvalidOptionsError = 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);
   }
@@ -67,7 +68,7 @@ var getAuthHeaders = (options) => {
     return getAuthHeadersForClientSessionToken(options);
   }
   throw new SeamHttpInvalidOptionsError(
-    "Must specify an apiKey or clientSessionToken"
+    "Must specify an apiKey, clientSessionToken, or publishableKey"
   );
 };
 var getAuthHeadersForApiKey = ({
@@ -78,12 +79,20 @@ var getAuthHeadersForApiKey = ({
       "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 SeamHttpInvalidTokenError(
-      "An access token cannot be used as an apiKey"
+      "An Access Token cannot be used as an apiKey"
     );
   }
-  if (isJwt(apiKey) || !isSeamToken(apiKey)) {
+  if (isPublishableKey(apiKey)) {
+    throw new SeamHttpInvalidTokenError(
+      "A Publishable Key cannot be used as an apiKey"
+    );
+  }
+  if (!isSeamToken(apiKey)) {
     throw new SeamHttpInvalidTokenError(
       `Unknown or invalid apiKey format, expected token to start with ${tokenPrefix}`
     );
@@ -95,6 +104,21 @@ 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 SeamHttpInvalidTokenError(
       `Unknown or invalid clientSessionToken format, expected token to start with ${clientSessionTokenPrefix}`
@@ -105,6 +129,31 @@ var getAuthHeadersForClientSessionToken = ({
     "client-session-token": clientSessionToken
   };
 };
+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}`);
@@ -112,75 +161,257 @@ var SeamHttpInvalidTokenError = class extends Error {
     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) => {
-  if (isSeamHttpOptionsWithClient(options))
-    return options.client;
-  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 enableLegacyMethodBehaivorDefault = true;
+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;
   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 options;
+  const apiKey = "apiKey" in options ? options.apiKey : getApiKeyFromEnv(options);
   return {
     ...options,
-    ...apiKey != null ? { apiKey } : {},
-    endpoint,
-    axiosOptions: options.axiosOptions ?? {},
-    enableLegacyMethodBehaivor: options.enableLegacyMethodBehaivor ?? enableLegacyMethodBehaivorDefault
+    ...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/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 options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpAccessCodesUnmanaged(opts);
+    return new _SeamHttpAccessCodesUnmanaged(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpAccessCodesUnmanaged(opts);
+    return new _SeamHttpAccessCodesUnmanaged(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpAccessCodesUnmanaged(opts);
+    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({
@@ -225,30 +456,40 @@ var SeamHttpAccessCodesUnmanaged = class _SeamHttpAccessCodesUnmanaged {
 
 // src/lib/seam/connect/routes/access-codes.ts
 var SeamHttpAccessCodes = class _SeamHttpAccessCodes {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpAccessCodes(opts);
+    return new _SeamHttpAccessCodes(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpAccessCodes(opts);
+    return new _SeamHttpAccessCodes(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpAccessCodes(opts);
+    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);
@@ -276,12 +517,12 @@ var SeamHttpAccessCodes = class _SeamHttpAccessCodes {
       data: body
     });
   }
-  async generateCode(params) {
+  async generateCode(body) {
     const { data } = await this.client.request(
       {
         url: "/access_codes/generate_code",
-        method: "get",
-        params
+        method: "post",
+        data: body
       }
     );
     return data.generated_code;
@@ -321,30 +562,40 @@ var SeamHttpAccessCodes = class _SeamHttpAccessCodes {
 
 // src/lib/seam/connect/routes/acs-access-groups.ts
 var SeamHttpAcsAccessGroups = class _SeamHttpAcsAccessGroups {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpAcsAccessGroups(opts);
+    return new _SeamHttpAcsAccessGroups(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpAcsAccessGroups(opts);
+    return new _SeamHttpAcsAccessGroups(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpAcsAccessGroups(opts);
+    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({
@@ -410,30 +661,40 @@ var SeamHttpAcsAccessGroups = class _SeamHttpAcsAccessGroups {
 
 // src/lib/seam/connect/routes/acs-credentials.ts
 var SeamHttpAcsCredentials = class _SeamHttpAcsCredentials {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpAcsCredentials(opts);
+    return new _SeamHttpAcsCredentials(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpAcsCredentials(opts);
+    return new _SeamHttpAcsCredentials(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpAcsCredentials(opts);
+    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({
@@ -470,30 +731,40 @@ var SeamHttpAcsCredentials = class _SeamHttpAcsCredentials {
 
 // src/lib/seam/connect/routes/acs-systems.ts
 var SeamHttpAcsSystems = class _SeamHttpAcsSystems {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpAcsSystems(opts);
+    return new _SeamHttpAcsSystems(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpAcsSystems(opts);
+    return new _SeamHttpAcsSystems(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpAcsSystems(opts);
+    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({
@@ -503,11 +774,11 @@ var SeamHttpAcsSystems = class _SeamHttpAcsSystems {
     });
     return data.acs_system;
   }
-  async list(params) {
+  async list(body) {
     const { data } = await this.client.request({
       url: "/acs/systems/list",
-      method: "get",
-      params
+      method: "post",
+      data: body
     });
     return data.acs_systems;
   }
@@ -515,30 +786,40 @@ var SeamHttpAcsSystems = class _SeamHttpAcsSystems {
 
 // src/lib/seam/connect/routes/acs-users.ts
 var SeamHttpAcsUsers = class _SeamHttpAcsUsers {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpAcsUsers(opts);
+    return new _SeamHttpAcsUsers(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpAcsUsers(opts);
+    return new _SeamHttpAcsUsers(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpAcsUsers(opts);
+    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({
@@ -585,6 +866,20 @@ var SeamHttpAcsUsers = class _SeamHttpAcsUsers {
       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",
@@ -596,30 +891,40 @@ var SeamHttpAcsUsers = class _SeamHttpAcsUsers {
 
 // src/lib/seam/connect/routes/acs.ts
 var SeamHttpAcs = class _SeamHttpAcs {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpAcs(opts);
+    return new _SeamHttpAcs(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpAcs(opts);
+    return new _SeamHttpAcs(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpAcs(opts);
+    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);
@@ -637,30 +942,40 @@ var SeamHttpAcs = class _SeamHttpAcs {
 
 // src/lib/seam/connect/routes/action-attempts.ts
 var SeamHttpActionAttempts = class _SeamHttpActionAttempts {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpActionAttempts(opts);
+    return new _SeamHttpActionAttempts(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpActionAttempts(opts);
+    return new _SeamHttpActionAttempts(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpActionAttempts(opts);
+    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({
@@ -680,100 +995,42 @@ var SeamHttpActionAttempts = class _SeamHttpActionAttempts {
   }
 };
 
-// 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);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpConnectWebviews(opts);
+    return new _SeamHttpConnectWebviews(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpConnectWebviews(opts);
+    return new _SeamHttpConnectWebviews(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpConnectWebviews(opts);
+    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({
@@ -798,11 +1055,11 @@ var SeamHttpConnectWebviews = class _SeamHttpConnectWebviews {
     });
     return data.connect_webview;
   }
-  async list(params) {
+  async list(body) {
     const { data } = await this.client.request({
       url: "/connect_webviews/list",
-      method: "get",
-      params
+      method: "post",
+      data: body
     });
     return data.connect_webviews;
   }
@@ -817,30 +1074,40 @@ var SeamHttpConnectWebviews = class _SeamHttpConnectWebviews {
 
 // src/lib/seam/connect/routes/connected-accounts.ts
 var SeamHttpConnectedAccounts = class _SeamHttpConnectedAccounts {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpConnectedAccounts(opts);
+    return new _SeamHttpConnectedAccounts(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpConnectedAccounts(opts);
+    return new _SeamHttpConnectedAccounts(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpConnectedAccounts(opts);
+    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({
@@ -869,30 +1136,40 @@ var SeamHttpConnectedAccounts = class _SeamHttpConnectedAccounts {
 
 // src/lib/seam/connect/routes/devices-unmanaged.ts
 var SeamHttpDevicesUnmanaged = class _SeamHttpDevicesUnmanaged {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpDevicesUnmanaged(opts);
+    return new _SeamHttpDevicesUnmanaged(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpDevicesUnmanaged(opts);
+    return new _SeamHttpDevicesUnmanaged(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpDevicesUnmanaged(opts);
+    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({
@@ -921,30 +1198,40 @@ var SeamHttpDevicesUnmanaged = class _SeamHttpDevicesUnmanaged {
 
 // src/lib/seam/connect/routes/devices.ts
 var SeamHttpDevices = class _SeamHttpDevices {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpDevices(opts);
+    return new _SeamHttpDevices(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpDevices(opts);
+    return new _SeamHttpDevices(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpDevices(opts);
+    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);
@@ -991,30 +1278,40 @@ var SeamHttpDevices = class _SeamHttpDevices {
 
 // src/lib/seam/connect/routes/events.ts
 var SeamHttpEvents = class _SeamHttpEvents {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpEvents(opts);
+    return new _SeamHttpEvents(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpEvents(opts);
+    return new _SeamHttpEvents(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpEvents(opts);
+    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({
@@ -1036,30 +1333,40 @@ var SeamHttpEvents = class _SeamHttpEvents {
 
 // src/lib/seam/connect/routes/locks.ts
 var SeamHttpLocks = class _SeamHttpLocks {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpLocks(opts);
+    return new _SeamHttpLocks(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpLocks(opts);
+    return new _SeamHttpLocks(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpLocks(opts);
+    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({
@@ -1097,30 +1404,43 @@ var SeamHttpLocks = class _SeamHttpLocks {
 
 // src/lib/seam/connect/routes/noise-sensors-noise-thresholds.ts
 var SeamHttpNoiseSensorsNoiseThresholds = class _SeamHttpNoiseSensorsNoiseThresholds {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpNoiseSensorsNoiseThresholds(opts);
+    return new _SeamHttpNoiseSensorsNoiseThresholds(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpNoiseSensorsNoiseThresholds(opts);
+    return new _SeamHttpNoiseSensorsNoiseThresholds(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpNoiseSensorsNoiseThresholds(opts);
+    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({
@@ -1163,30 +1483,40 @@ var SeamHttpNoiseSensorsNoiseThresholds = class _SeamHttpNoiseSensorsNoiseThresh
 
 // src/lib/seam/connect/routes/noise-sensors.ts
 var SeamHttpNoiseSensors = class _SeamHttpNoiseSensors {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpNoiseSensors(opts);
+    return new _SeamHttpNoiseSensors(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpNoiseSensors(opts);
+    return new _SeamHttpNoiseSensors(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpNoiseSensors(opts);
+    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);
@@ -1195,30 +1525,43 @@ var SeamHttpNoiseSensors = class _SeamHttpNoiseSensors {
 
 // src/lib/seam/connect/routes/thermostats-climate-setting-schedules.ts
 var SeamHttpThermostatsClimateSettingSchedules = class _SeamHttpThermostatsClimateSettingSchedules {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpThermostatsClimateSettingSchedules(opts);
+    return new _SeamHttpThermostatsClimateSettingSchedules(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpThermostatsClimateSettingSchedules(opts);
+    return new _SeamHttpThermostatsClimateSettingSchedules(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpThermostatsClimateSettingSchedules(opts);
+    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(
@@ -1270,30 +1613,40 @@ var SeamHttpThermostatsClimateSettingSchedules = class _SeamHttpThermostatsClima
 
 // src/lib/seam/connect/routes/thermostats.ts
 var SeamHttpThermostats = class _SeamHttpThermostats {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpThermostats(opts);
+    return new _SeamHttpThermostats(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpThermostats(opts);
+    return new _SeamHttpThermostats(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpThermostats(opts);
+    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);
@@ -1360,30 +1713,40 @@ var SeamHttpThermostats = class _SeamHttpThermostats {
 
 // src/lib/seam/connect/routes/webhooks.ts
 var SeamHttpWebhooks = class _SeamHttpWebhooks {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpWebhooks(opts);
+    return new _SeamHttpWebhooks(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpWebhooks(opts);
+    return new _SeamHttpWebhooks(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpWebhooks(opts);
+    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({
@@ -1420,30 +1783,40 @@ var SeamHttpWebhooks = class _SeamHttpWebhooks {
 
 // src/lib/seam/connect/routes/workspaces.ts
 var SeamHttpWorkspaces = class _SeamHttpWorkspaces {
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttpWorkspaces(opts);
+    return new _SeamHttpWorkspaces(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey };
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing apiKey");
     }
-    return new _SeamHttpWorkspaces(opts);
+    return new _SeamHttpWorkspaces(constructorOptions);
   }
   static fromClientSessionToken(clientSessionToken, options = {}) {
-    const opts = { ...options, clientSessionToken };
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken };
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing clientSessionToken");
     }
-    return new _SeamHttpWorkspaces(opts);
+    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({
@@ -1470,33 +1843,42 @@ var SeamHttpWorkspaces = class _SeamHttpWorkspaces {
   }
 };
 
-// src/lib/seam/connect/client.ts
+// src/lib/seam/connect/seam-http.ts
 var SeamHttp = class _SeamHttp {
-  // #legacy: boolean
-  constructor(apiKeyOrOptions) {
-    const options = parseOptions(apiKeyOrOptions);
-    this.client = createAxiosClient(options);
+  constructor(apiKeyOrOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions);
+    this.client = createClient(clientOptions);
   }
   static fromClient(client, options = {}) {
-    const opts = { ...options, client };
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client };
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError("Missing client");
     }
-    return new _SeamHttp(opts);
+    return new _SeamHttp(constructorOptions);
   }
   static fromApiKey(apiKey, options = {}) {
-    const opts = { ...options, apiKey };
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    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)) {
+    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);
@@ -1540,5 +1922,9 @@ var SeamHttp = class _SeamHttp {
 };
 
 exports.SeamHttp = SeamHttp;
+exports.SeamHttpInvalidOptionsError = SeamHttpInvalidOptionsError;
+exports.isSeamHttpOptionsWithApiKey = isSeamHttpOptionsWithApiKey;
+exports.isSeamHttpOptionsWithClient = isSeamHttpOptionsWithClient;
+exports.isSeamHttpOptionsWithClientSessionToken = isSeamHttpOptionsWithClientSessionToken;
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=connect.cjs.map