@seamapi/http 0.8.1 → 0.9.1

package/dist/connect.cjs

@@ -10,6 +10,82 @@ var axios__default = /*#__PURE__*/_interopDefault(axios);
 var axiosBetterStacktrace__default = /*#__PURE__*/_interopDefault(axiosBetterStacktrace);
 var axiosRetry__default = /*#__PURE__*/_interopDefault(axiosRetry);
 
+// src/lib/version.ts
+var seamapiJavascriptHttpVersion = null;
+var version_default = seamapiJavascriptHttpVersion;
+
+// src/lib/seam/connect/parse-options.ts
+var defaultEndpoint = "https://connect.getseam.com";
+var sdkHeaders = {
+  "seam-sdk-name": "seamapi/javascript-http",
+  "seam-sdk-version": version_default
+};
+var parseOptions = (apiKeyOrOptions) => {
+  const options = getNormalizedOptions(apiKeyOrOptions);
+  if (isSeamHttpOptionsWithClient(options))
+    return options;
+  if (isSeamHttpMultiWorkspaceOptionsWithClient(options))
+    return options;
+  return {
+    ...options,
+    axiosOptions: {
+      baseURL: options.endpoint ?? getEndpointFromEnv() ?? defaultEndpoint,
+      withCredentials: isSeamHttpOptionsWithClientSessionToken(options),
+      ...options.axiosOptions,
+      headers: {
+        ...getAuthHeaders(options),
+        ...options.axiosOptions?.headers,
+        ...sdkHeaders
+      }
+    },
+    axiosRetryOptions: {
+      ...options.axiosRetryOptions
+    }
+  };
+};
+var getNormalizedOptions = (apiKeyOrOptions) => {
+  const options = typeof apiKeyOrOptions === "string" ? { apiKey: apiKeyOrOptions } : apiKeyOrOptions;
+  const requestOptions = {
+    waitForActionAttempt: options.waitForActionAttempt ?? false
+  };
+  if (isSeamHttpOptionsWithClient(options)) {
+    return {
+      ...options,
+      ...requestOptions
+    };
+  }
+  const apiKey = "apiKey" in options ? options.apiKey : getApiKeyFromEnv(options);
+  return {
+    ...options,
+    ...apiKey != null ? { apiKey } : {},
+    ...requestOptions
+  };
+};
+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;
+};
+var limitToSeamHttpRequestOptions = (options) => {
+  return Object.keys(options).filter(isSeamHttpRequestOption).reduce(
+    (obj, key) => ({
+      ...obj,
+      [key]: options[key]
+    }),
+    {}
+  );
+};
+var isSeamHttpRequestOption = (key) => {
+  const keys = {
+    waitForActionAttempt: true
+  };
+  return Object.keys(keys).includes(key);
+};
+
 // src/lib/seam/connect/options.ts
 var isSeamHttpMultiWorkspaceOptionsWithClient = (options) => isSeamHttpOptionsWithClient(options);
 var isSeamHttpOptionsWithClient = (options) => {
@@ -18,7 +94,7 @@ var isSeamHttpOptionsWithClient = (options) => {
   if (options.client == null)
     return false;
   const keys = Object.keys(options).filter((k) => k !== "client");
-  if (keys.length > 0) {
+  if (keys.filter((k) => !isSeamHttpRequestOption(k)).length > 0) {
     throw new SeamHttpInvalidOptionsError(
       `The client option cannot be used with any other option, but received: ${keys.join(
         ", "
@@ -557,8 +633,6 @@ var UnserializableParamError = class extends Error {
 
 // 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
@@ -573,63 +647,12 @@ var createClient = (options) => {
   return client;
 };
 
-// src/lib/version.ts
-var seamapiJavascriptHttpVersion = null;
-var version_default = seamapiJavascriptHttpVersion;
-
-// src/lib/seam/connect/parse-options.ts
-var defaultEndpoint = "https://connect.getseam.com";
-var sdkHeaders = {
-  "seam-sdk-name": "seamapi/javascript-http",
-  "seam-sdk-version": version_default
-};
-var parseOptions = (apiKeyOrOptions) => {
-  const options = getNormalizedOptions(apiKeyOrOptions);
-  if (isSeamHttpOptionsWithClient(options))
-    return options;
-  if (isSeamHttpMultiWorkspaceOptionsWithClient(options))
-    return options;
-  return {
-    axiosOptions: {
-      baseURL: options.endpoint ?? getEndpointFromEnv() ?? defaultEndpoint,
-      withCredentials: isSeamHttpOptionsWithClientSessionToken(options),
-      ...options.axiosOptions,
-      headers: {
-        ...getAuthHeaders(options),
-        ...options.axiosOptions?.headers,
-        ...sdkHeaders
-      }
-    },
-    axiosRetryOptions: {
-      ...options.axiosRetryOptions
-    }
-  };
-};
-var getNormalizedOptions = (apiKeyOrOptions) => {
-  const options = typeof apiKeyOrOptions === "string" ? { apiKey: apiKeyOrOptions } : apiKeyOrOptions;
-  if (isSeamHttpOptionsWithClient(options))
-    return options;
-  const apiKey = "apiKey" in options ? options.apiKey : getApiKeyFromEnv(options);
-  return {
-    ...options,
-    ...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);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -655,6 +678,11 @@ var SeamHttpClientSessions = class _SeamHttpClientSessions {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = _SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -739,8 +767,9 @@ var SeamHttpClientSessions = class _SeamHttpClientSessions {
 // src/lib/seam/connect/routes/access-codes-unmanaged.ts
 var SeamHttpAccessCodesUnmanaged = class _SeamHttpAccessCodesUnmanaged {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -766,6 +795,11 @@ var SeamHttpAccessCodesUnmanaged = class _SeamHttpAccessCodesUnmanaged {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -835,8 +869,9 @@ var SeamHttpAccessCodesUnmanaged = class _SeamHttpAccessCodesUnmanaged {
 // src/lib/seam/connect/routes/access-codes.ts
 var SeamHttpAccessCodes = class _SeamHttpAccessCodes {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -862,6 +897,11 @@ var SeamHttpAccessCodes = class _SeamHttpAccessCodes {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -888,7 +928,7 @@ var SeamHttpAccessCodes = class _SeamHttpAccessCodes {
     return new _SeamHttpAccessCodes(constructorOptions);
   }
   get unmanaged() {
-    return SeamHttpAccessCodesUnmanaged.fromClient(this.client);
+    return SeamHttpAccessCodesUnmanaged.fromClient(this.client, this.defaults);
   }
   async create(body) {
     const { data } = await this.client.request({
@@ -959,8 +999,9 @@ var SeamHttpAccessCodes = class _SeamHttpAccessCodes {
 // src/lib/seam/connect/routes/acs-access-groups.ts
 var SeamHttpAcsAccessGroups = class _SeamHttpAcsAccessGroups {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -986,6 +1027,11 @@ var SeamHttpAcsAccessGroups = class _SeamHttpAcsAccessGroups {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -1054,8 +1100,9 @@ var SeamHttpAcsAccessGroups = class _SeamHttpAcsAccessGroups {
 // src/lib/seam/connect/routes/acs-credentials.ts
 var SeamHttpAcsCredentials = class _SeamHttpAcsCredentials {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -1081,6 +1128,11 @@ var SeamHttpAcsCredentials = class _SeamHttpAcsCredentials {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -1156,8 +1208,9 @@ var SeamHttpAcsCredentials = class _SeamHttpAcsCredentials {
 // src/lib/seam/connect/routes/acs-systems.ts
 var SeamHttpAcsSystems = class _SeamHttpAcsSystems {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -1183,6 +1236,11 @@ var SeamHttpAcsSystems = class _SeamHttpAcsSystems {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -1229,8 +1287,9 @@ var SeamHttpAcsSystems = class _SeamHttpAcsSystems {
 // src/lib/seam/connect/routes/acs-users.ts
 var SeamHttpAcsUsers = class _SeamHttpAcsUsers {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -1256,6 +1315,11 @@ var SeamHttpAcsUsers = class _SeamHttpAcsUsers {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -1352,8 +1416,9 @@ var SeamHttpAcsUsers = class _SeamHttpAcsUsers {
 // src/lib/seam/connect/routes/acs.ts
 var SeamHttpAcs = class _SeamHttpAcs {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -1379,6 +1444,11 @@ var SeamHttpAcs = class _SeamHttpAcs {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -1405,24 +1475,25 @@ var SeamHttpAcs = class _SeamHttpAcs {
     return new _SeamHttpAcs(constructorOptions);
   }
   get accessGroups() {
-    return SeamHttpAcsAccessGroups.fromClient(this.client);
+    return SeamHttpAcsAccessGroups.fromClient(this.client, this.defaults);
   }
   get credentials() {
-    return SeamHttpAcsCredentials.fromClient(this.client);
+    return SeamHttpAcsCredentials.fromClient(this.client, this.defaults);
   }
   get systems() {
-    return SeamHttpAcsSystems.fromClient(this.client);
+    return SeamHttpAcsSystems.fromClient(this.client, this.defaults);
   }
   get users() {
-    return SeamHttpAcsUsers.fromClient(this.client);
+    return SeamHttpAcsUsers.fromClient(this.client, this.defaults);
   }
 };
 
 // src/lib/seam/connect/routes/action-attempts.ts
 var SeamHttpActionAttempts = class _SeamHttpActionAttempts {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -1448,6 +1519,11 @@ var SeamHttpActionAttempts = class _SeamHttpActionAttempts {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -1473,18 +1549,20 @@ var SeamHttpActionAttempts = class _SeamHttpActionAttempts {
     }
     return new _SeamHttpActionAttempts(constructorOptions);
   }
-  async get(body, {
-    waitForActionAttempt = false
-  } = {}) {
+  async get(body, options = {}) {
     const { data } = await this.client.request({
       url: "/action_attempts/get",
       method: "post",
       data: body
     });
-    if (waitForActionAttempt != null && waitForActionAttempt !== false) {
+    const waitForActionAttempt = options.waitForActionAttempt ?? this.defaults.waitForActionAttempt;
+    if (waitForActionAttempt !== false) {
       return await resolveActionAttempt(
         data.action_attempt,
-        _SeamHttpActionAttempts.fromClient(this.client),
+        _SeamHttpActionAttempts.fromClient(this.client, {
+          ...this.defaults,
+          waitForActionAttempt: false
+        }),
         typeof waitForActionAttempt === "boolean" ? {} : waitForActionAttempt
       );
     }
@@ -1503,8 +1581,9 @@ var SeamHttpActionAttempts = class _SeamHttpActionAttempts {
 // src/lib/seam/connect/routes/connect-webviews.ts
 var SeamHttpConnectWebviews = class _SeamHttpConnectWebviews {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -1530,6 +1609,11 @@ var SeamHttpConnectWebviews = class _SeamHttpConnectWebviews {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -1598,8 +1682,9 @@ var SeamHttpConnectWebviews = class _SeamHttpConnectWebviews {
 // src/lib/seam/connect/routes/connected-accounts.ts
 var SeamHttpConnectedAccounts = class _SeamHttpConnectedAccounts {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -1625,6 +1710,11 @@ var SeamHttpConnectedAccounts = class _SeamHttpConnectedAccounts {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -1678,8 +1768,9 @@ var SeamHttpConnectedAccounts = class _SeamHttpConnectedAccounts {
 // src/lib/seam/connect/routes/devices-unmanaged.ts
 var SeamHttpDevicesUnmanaged = class _SeamHttpDevicesUnmanaged {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -1705,6 +1796,11 @@ var SeamHttpDevicesUnmanaged = class _SeamHttpDevicesUnmanaged {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -1758,8 +1854,9 @@ var SeamHttpDevicesUnmanaged = class _SeamHttpDevicesUnmanaged {
 // src/lib/seam/connect/routes/devices.ts
 var SeamHttpDevices = class _SeamHttpDevices {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -1785,6 +1882,11 @@ var SeamHttpDevices = class _SeamHttpDevices {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -1811,7 +1913,7 @@ var SeamHttpDevices = class _SeamHttpDevices {
     return new _SeamHttpDevices(constructorOptions);
   }
   get unmanaged() {
-    return SeamHttpDevicesUnmanaged.fromClient(this.client);
+    return SeamHttpDevicesUnmanaged.fromClient(this.client, this.defaults);
   }
   async delete(body) {
     await this.client.request({
@@ -1856,8 +1958,9 @@ var SeamHttpDevices = class _SeamHttpDevices {
 // src/lib/seam/connect/routes/events.ts
 var SeamHttpEvents = class _SeamHttpEvents {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -1883,6 +1986,11 @@ var SeamHttpEvents = class _SeamHttpEvents {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -1929,8 +2037,9 @@ var SeamHttpEvents = class _SeamHttpEvents {
 // src/lib/seam/connect/routes/locks.ts
 var SeamHttpLocks = class _SeamHttpLocks {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -1956,6 +2065,11 @@ var SeamHttpLocks = class _SeamHttpLocks {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -1997,35 +2111,39 @@ var SeamHttpLocks = class _SeamHttpLocks {
     });
     return data.devices;
   }
-  async lockDoor(body, {
-    waitForActionAttempt = false
-  } = {}) {
+  async lockDoor(body, options = {}) {
     const { data } = await this.client.request({
       url: "/locks/lock_door",
       method: "post",
       data: body
     });
-    if (waitForActionAttempt != null && waitForActionAttempt !== false) {
+    const waitForActionAttempt = options.waitForActionAttempt ?? this.defaults.waitForActionAttempt;
+    if (waitForActionAttempt !== false) {
       return await resolveActionAttempt(
         data.action_attempt,
-        SeamHttpActionAttempts.fromClient(this.client),
+        SeamHttpActionAttempts.fromClient(this.client, {
+          ...this.defaults,
+          waitForActionAttempt: false
+        }),
         typeof waitForActionAttempt === "boolean" ? {} : waitForActionAttempt
       );
     }
     return data.action_attempt;
   }
-  async unlockDoor(body, {
-    waitForActionAttempt = false
-  } = {}) {
+  async unlockDoor(body, options = {}) {
     const { data } = await this.client.request({
       url: "/locks/unlock_door",
       method: "post",
       data: body
     });
-    if (waitForActionAttempt != null && waitForActionAttempt !== false) {
+    const waitForActionAttempt = options.waitForActionAttempt ?? this.defaults.waitForActionAttempt;
+    if (waitForActionAttempt !== false) {
       return await resolveActionAttempt(
         data.action_attempt,
-        SeamHttpActionAttempts.fromClient(this.client),
+        SeamHttpActionAttempts.fromClient(this.client, {
+          ...this.defaults,
+          waitForActionAttempt: false
+        }),
         typeof waitForActionAttempt === "boolean" ? {} : waitForActionAttempt
       );
     }
@@ -2036,8 +2154,9 @@ var SeamHttpLocks = class _SeamHttpLocks {
 // src/lib/seam/connect/routes/noise-sensors-noise-thresholds.ts
 var SeamHttpNoiseSensorsNoiseThresholds = class _SeamHttpNoiseSensorsNoiseThresholds {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -2063,6 +2182,11 @@ var SeamHttpNoiseSensorsNoiseThresholds = class _SeamHttpNoiseSensorsNoiseThresh
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -2133,8 +2257,9 @@ var SeamHttpNoiseSensorsNoiseThresholds = class _SeamHttpNoiseSensorsNoiseThresh
 // src/lib/seam/connect/routes/noise-sensors.ts
 var SeamHttpNoiseSensors = class _SeamHttpNoiseSensors {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -2160,6 +2285,11 @@ var SeamHttpNoiseSensors = class _SeamHttpNoiseSensors {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -2186,15 +2316,19 @@ var SeamHttpNoiseSensors = class _SeamHttpNoiseSensors {
     return new _SeamHttpNoiseSensors(constructorOptions);
   }
   get noiseThresholds() {
-    return SeamHttpNoiseSensorsNoiseThresholds.fromClient(this.client);
+    return SeamHttpNoiseSensorsNoiseThresholds.fromClient(
+      this.client,
+      this.defaults
+    );
   }
 };
 
 // src/lib/seam/connect/routes/thermostats-climate-setting-schedules.ts
 var SeamHttpThermostatsClimateSettingSchedules = class _SeamHttpThermostatsClimateSettingSchedules {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -2220,6 +2354,11 @@ var SeamHttpThermostatsClimateSettingSchedules = class _SeamHttpThermostatsClima
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -2299,8 +2438,9 @@ var SeamHttpThermostatsClimateSettingSchedules = class _SeamHttpThermostatsClima
 // src/lib/seam/connect/routes/thermostats.ts
 var SeamHttpThermostats = class _SeamHttpThermostats {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -2326,6 +2466,11 @@ var SeamHttpThermostats = class _SeamHttpThermostats {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -2352,7 +2497,10 @@ var SeamHttpThermostats = class _SeamHttpThermostats {
     return new _SeamHttpThermostats(constructorOptions);
   }
   get climateSettingSchedules() {
-    return SeamHttpThermostatsClimateSettingSchedules.fromClient(this.client);
+    return SeamHttpThermostatsClimateSettingSchedules.fromClient(
+      this.client,
+      this.defaults
+    );
   }
   async cool(body) {
     await this.client.request({
@@ -2417,8 +2565,9 @@ var SeamHttpThermostats = class _SeamHttpThermostats {
 // src/lib/seam/connect/routes/user-identities.ts
 var SeamHttpUserIdentities = class _SeamHttpUserIdentities {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -2444,6 +2593,11 @@ var SeamHttpUserIdentities = class _SeamHttpUserIdentities {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -2534,8 +2688,9 @@ var SeamHttpUserIdentities = class _SeamHttpUserIdentities {
 // src/lib/seam/connect/routes/webhooks.ts
 var SeamHttpWebhooks = class _SeamHttpWebhooks {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -2561,6 +2716,11 @@ var SeamHttpWebhooks = class _SeamHttpWebhooks {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -2622,8 +2782,9 @@ var SeamHttpWebhooks = class _SeamHttpWebhooks {
 // src/lib/seam/connect/routes/workspaces.ts
 var SeamHttpWorkspaces = class _SeamHttpWorkspaces {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -2649,6 +2810,11 @@ var SeamHttpWorkspaces = class _SeamHttpWorkspaces {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -2702,8 +2868,9 @@ var SeamHttpWorkspaces = class _SeamHttpWorkspaces {
 // src/lib/seam/connect/seam-http.ts
 var SeamHttp = class _SeamHttp {
   constructor(apiKeyOrOptions = {}) {
-    const clientOptions = parseOptions(apiKeyOrOptions);
-    this.client = createClient(clientOptions);
+    const options = parseOptions(apiKeyOrOptions);
+    this.client = "client" in options ? options.client : createClient(options);
+    this.defaults = limitToSeamHttpRequestOptions(options);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -2729,6 +2896,11 @@ var SeamHttp = class _SeamHttp {
   static async fromPublishableKey(publishableKey, userIdentifierKey, options = {}) {
     warnOnInsecureuserIdentifierKey(userIdentifierKey);
     const clientOptions = parseOptions({ ...options, publishableKey });
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        "The client option cannot be used with SeamHttp.fromPublishableKey"
+      );
+    }
     const client = createClient(clientOptions);
     const clientSessions = SeamHttpClientSessions.fromClient(client);
     const { token } = await clientSessions.getOrCreate({
@@ -2755,54 +2927,55 @@ var SeamHttp = class _SeamHttp {
     return new _SeamHttp(constructorOptions);
   }
   get accessCodes() {
-    return SeamHttpAccessCodes.fromClient(this.client);
+    return SeamHttpAccessCodes.fromClient(this.client, this.defaults);
   }
   get acs() {
-    return SeamHttpAcs.fromClient(this.client);
+    return SeamHttpAcs.fromClient(this.client, this.defaults);
   }
   get actionAttempts() {
-    return SeamHttpActionAttempts.fromClient(this.client);
+    return SeamHttpActionAttempts.fromClient(this.client, this.defaults);
   }
   get clientSessions() {
-    return SeamHttpClientSessions.fromClient(this.client);
+    return SeamHttpClientSessions.fromClient(this.client, this.defaults);
   }
   get connectedAccounts() {
-    return SeamHttpConnectedAccounts.fromClient(this.client);
+    return SeamHttpConnectedAccounts.fromClient(this.client, this.defaults);
   }
   get connectWebviews() {
-    return SeamHttpConnectWebviews.fromClient(this.client);
+    return SeamHttpConnectWebviews.fromClient(this.client, this.defaults);
   }
   get devices() {
-    return SeamHttpDevices.fromClient(this.client);
+    return SeamHttpDevices.fromClient(this.client, this.defaults);
   }
   get events() {
-    return SeamHttpEvents.fromClient(this.client);
+    return SeamHttpEvents.fromClient(this.client, this.defaults);
   }
   get locks() {
-    return SeamHttpLocks.fromClient(this.client);
+    return SeamHttpLocks.fromClient(this.client, this.defaults);
   }
   get noiseSensors() {
-    return SeamHttpNoiseSensors.fromClient(this.client);
+    return SeamHttpNoiseSensors.fromClient(this.client, this.defaults);
   }
   get thermostats() {
-    return SeamHttpThermostats.fromClient(this.client);
+    return SeamHttpThermostats.fromClient(this.client, this.defaults);
   }
   get userIdentities() {
-    return SeamHttpUserIdentities.fromClient(this.client);
+    return SeamHttpUserIdentities.fromClient(this.client, this.defaults);
   }
   get webhooks() {
-    return SeamHttpWebhooks.fromClient(this.client);
+    return SeamHttpWebhooks.fromClient(this.client, this.defaults);
   }
   get workspaces() {
-    return SeamHttpWorkspaces.fromClient(this.client);
+    return SeamHttpWorkspaces.fromClient(this.client, this.defaults);
   }
 };
 
 // src/lib/seam/connect/seam-http-multi-workspace.ts
 var SeamHttpMultiWorkspace = class _SeamHttpMultiWorkspace {
   constructor(options) {
-    const clientOptions = parseOptions(options);
-    this.client = createClient(clientOptions);
+    const opts = parseOptions(options);
+    this.client = "client" in opts ? opts.client : createClient(opts);
+    this.defaults = limitToSeamHttpRequestOptions(opts);
   }
   static fromClient(client, options = {}) {
     const constructorOptions = { ...options, client };
@@ -2834,7 +3007,7 @@ var SeamHttpMultiWorkspace = class _SeamHttpMultiWorkspace {
     return new _SeamHttpMultiWorkspace(constructorOptions);
   }
   get workspaces() {
-    return SeamHttpWorkspaces.fromClient(this.client);
+    return SeamHttpWorkspaces.fromClient(this.client, this.defaults);
   }
 };