@seamapi/http 0.8.0 → 0.9.0

package/src/lib/seam/connect/routes/devices-unmanaged.ts

@@ -22,17 +22,23 @@ import {
   type SeamHttpOptionsWithClientSessionToken,
   type SeamHttpOptionsWithConsoleSessionToken,
   type SeamHttpOptionsWithPersonalAccessToken,
+  type SeamHttpRequestOptions,
 } from 'lib/seam/connect/options.js'
-import { parseOptions } from 'lib/seam/connect/parse-options.js'
+import {
+  limitToSeamHttpRequestOptions,
+  parseOptions,
+} from 'lib/seam/connect/parse-options.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 
 export class SeamHttpDevicesUnmanaged {
   client: Client
+  readonly defaults: Required<SeamHttpRequestOptions>
 
   constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
-    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(
@@ -78,6 +84,11 @@ export class SeamHttpDevicesUnmanaged {
   ): Promise<SeamHttpDevicesUnmanaged> {
     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({

package/src/lib/seam/connect/routes/devices.ts

@@ -22,18 +22,24 @@ import {
   type SeamHttpOptionsWithClientSessionToken,
   type SeamHttpOptionsWithConsoleSessionToken,
   type SeamHttpOptionsWithPersonalAccessToken,
+  type SeamHttpRequestOptions,
 } from 'lib/seam/connect/options.js'
-import { parseOptions } from 'lib/seam/connect/parse-options.js'
+import {
+  limitToSeamHttpRequestOptions,
+  parseOptions,
+} from 'lib/seam/connect/parse-options.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 import { SeamHttpDevicesUnmanaged } from './devices-unmanaged.js'
 
 export class SeamHttpDevices {
   client: Client
+  readonly defaults: Required<SeamHttpRequestOptions>
 
   constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
-    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(
@@ -79,6 +85,11 @@ export class SeamHttpDevices {
   ): Promise<SeamHttpDevices> {
     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({
@@ -122,7 +133,7 @@ export class SeamHttpDevices {
   }
 
   get unmanaged(): SeamHttpDevicesUnmanaged {
-    return SeamHttpDevicesUnmanaged.fromClient(this.client)
+    return SeamHttpDevicesUnmanaged.fromClient(this.client, this.defaults)
   }
 
   async delete(body?: DevicesDeleteBody): Promise<void> {

package/src/lib/seam/connect/routes/events.ts

@@ -22,17 +22,23 @@ import {
   type SeamHttpOptionsWithClientSessionToken,
   type SeamHttpOptionsWithConsoleSessionToken,
   type SeamHttpOptionsWithPersonalAccessToken,
+  type SeamHttpRequestOptions,
 } from 'lib/seam/connect/options.js'
-import { parseOptions } from 'lib/seam/connect/parse-options.js'
+import {
+  limitToSeamHttpRequestOptions,
+  parseOptions,
+} from 'lib/seam/connect/parse-options.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 
 export class SeamHttpEvents {
   client: Client
+  readonly defaults: Required<SeamHttpRequestOptions>
 
   constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
-    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(
@@ -78,6 +84,11 @@ export class SeamHttpEvents {
   ): Promise<SeamHttpEvents> {
     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({

package/src/lib/seam/connect/routes/locks.ts

@@ -22,22 +22,25 @@ import {
   type SeamHttpOptionsWithClientSessionToken,
   type SeamHttpOptionsWithConsoleSessionToken,
   type SeamHttpOptionsWithPersonalAccessToken,
+  type SeamHttpRequestOptions,
 } from 'lib/seam/connect/options.js'
-import { parseOptions } from 'lib/seam/connect/parse-options.js'
 import {
-  resolveActionAttempt,
-  type ResolveActionAttemptOptions,
-} from 'lib/seam/connect/resolve-action-attempt.js'
+  limitToSeamHttpRequestOptions,
+  parseOptions,
+} from 'lib/seam/connect/parse-options.js'
+import { resolveActionAttempt } from 'lib/seam/connect/resolve-action-attempt.js'
 
 import { SeamHttpActionAttempts } from './action-attempts.js'
 import { SeamHttpClientSessions } from './client-sessions.js'
 
 export class SeamHttpLocks {
   client: Client
+  readonly defaults: Required<SeamHttpRequestOptions>
 
   constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
-    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(
@@ -83,6 +86,11 @@ export class SeamHttpLocks {
   ): Promise<SeamHttpLocks> {
     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({
@@ -147,21 +155,22 @@ export class SeamHttpLocks {
 
   async lockDoor(
     body?: LocksLockDoorBody,
-    {
-      waitForActionAttempt = false,
-    }: {
-      waitForActionAttempt?: boolean | Partial<ResolveActionAttemptOptions>
-    } = {},
+    options: Pick<SeamHttpRequestOptions, 'waitForActionAttempt'> = {},
   ): Promise<LocksLockDoorResponse['action_attempt']> {
     const { data } = await this.client.request<LocksLockDoorResponse>({
       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,
       )
     }
@@ -170,21 +179,22 @@ export class SeamHttpLocks {
 
   async unlockDoor(
     body?: LocksUnlockDoorBody,
-    {
-      waitForActionAttempt = false,
-    }: {
-      waitForActionAttempt?: boolean | Partial<ResolveActionAttemptOptions>
-    } = {},
+    options: Pick<SeamHttpRequestOptions, 'waitForActionAttempt'> = {},
   ): Promise<LocksUnlockDoorResponse['action_attempt']> {
     const { data } = await this.client.request<LocksUnlockDoorResponse>({
       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,
       )
     }
@@ -214,9 +224,10 @@ export type LocksLockDoorResponse = SetNonNullable<
   Required<RouteResponse<'/locks/lock_door'>>
 >
 
-export interface LocksLockDoorOptions {
-  waitForActionAttempt?: boolean | Partial<ResolveActionAttemptOptions>
-}
+export type LocksLockDoorOptions = Pick<
+  SeamHttpRequestOptions,
+  'waitForActionAttempt'
+>
 
 export type LocksUnlockDoorBody = RouteRequestBody<'/locks/unlock_door'>
 
@@ -224,6 +235,7 @@ export type LocksUnlockDoorResponse = SetNonNullable<
   Required<RouteResponse<'/locks/unlock_door'>>
 >
 
-export interface LocksUnlockDoorOptions {
-  waitForActionAttempt?: boolean | Partial<ResolveActionAttemptOptions>
-}
+export type LocksUnlockDoorOptions = Pick<
+  SeamHttpRequestOptions,
+  'waitForActionAttempt'
+>

package/src/lib/seam/connect/routes/noise-sensors-noise-thresholds.ts

@@ -22,17 +22,23 @@ import {
   type SeamHttpOptionsWithClientSessionToken,
   type SeamHttpOptionsWithConsoleSessionToken,
   type SeamHttpOptionsWithPersonalAccessToken,
+  type SeamHttpRequestOptions,
 } from 'lib/seam/connect/options.js'
-import { parseOptions } from 'lib/seam/connect/parse-options.js'
+import {
+  limitToSeamHttpRequestOptions,
+  parseOptions,
+} from 'lib/seam/connect/parse-options.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 
 export class SeamHttpNoiseSensorsNoiseThresholds {
   client: Client
+  readonly defaults: Required<SeamHttpRequestOptions>
 
   constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
-    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(
@@ -78,6 +84,11 @@ export class SeamHttpNoiseSensorsNoiseThresholds {
   ): Promise<SeamHttpNoiseSensorsNoiseThresholds> {
     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({

package/src/lib/seam/connect/routes/noise-sensors.ts

@@ -19,18 +19,24 @@ import {
   type SeamHttpOptionsWithClientSessionToken,
   type SeamHttpOptionsWithConsoleSessionToken,
   type SeamHttpOptionsWithPersonalAccessToken,
+  type SeamHttpRequestOptions,
 } from 'lib/seam/connect/options.js'
-import { parseOptions } from 'lib/seam/connect/parse-options.js'
+import {
+  limitToSeamHttpRequestOptions,
+  parseOptions,
+} from 'lib/seam/connect/parse-options.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 import { SeamHttpNoiseSensorsNoiseThresholds } from './noise-sensors-noise-thresholds.js'
 
 export class SeamHttpNoiseSensors {
   client: Client
+  readonly defaults: Required<SeamHttpRequestOptions>
 
   constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
-    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(
@@ -76,6 +82,11 @@ export class SeamHttpNoiseSensors {
   ): Promise<SeamHttpNoiseSensors> {
     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({
@@ -119,6 +130,9 @@ export class SeamHttpNoiseSensors {
   }
 
   get noiseThresholds(): SeamHttpNoiseSensorsNoiseThresholds {
-    return SeamHttpNoiseSensorsNoiseThresholds.fromClient(this.client)
+    return SeamHttpNoiseSensorsNoiseThresholds.fromClient(
+      this.client,
+      this.defaults,
+    )
   }
 }

package/src/lib/seam/connect/routes/thermostats-climate-setting-schedules.ts

@@ -22,17 +22,23 @@ import {
   type SeamHttpOptionsWithClientSessionToken,
   type SeamHttpOptionsWithConsoleSessionToken,
   type SeamHttpOptionsWithPersonalAccessToken,
+  type SeamHttpRequestOptions,
 } from 'lib/seam/connect/options.js'
-import { parseOptions } from 'lib/seam/connect/parse-options.js'
+import {
+  limitToSeamHttpRequestOptions,
+  parseOptions,
+} from 'lib/seam/connect/parse-options.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 
 export class SeamHttpThermostatsClimateSettingSchedules {
   client: Client
+  readonly defaults: Required<SeamHttpRequestOptions>
 
   constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
-    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(
@@ -78,6 +84,11 @@ export class SeamHttpThermostatsClimateSettingSchedules {
   ): Promise<SeamHttpThermostatsClimateSettingSchedules> {
     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({

package/src/lib/seam/connect/routes/thermostats.ts

@@ -22,18 +22,24 @@ import {
   type SeamHttpOptionsWithClientSessionToken,
   type SeamHttpOptionsWithConsoleSessionToken,
   type SeamHttpOptionsWithPersonalAccessToken,
+  type SeamHttpRequestOptions,
 } from 'lib/seam/connect/options.js'
-import { parseOptions } from 'lib/seam/connect/parse-options.js'
+import {
+  limitToSeamHttpRequestOptions,
+  parseOptions,
+} from 'lib/seam/connect/parse-options.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 import { SeamHttpThermostatsClimateSettingSchedules } from './thermostats-climate-setting-schedules.js'
 
 export class SeamHttpThermostats {
   client: Client
+  readonly defaults: Required<SeamHttpRequestOptions>
 
   constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
-    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(
@@ -79,6 +85,11 @@ export class SeamHttpThermostats {
   ): Promise<SeamHttpThermostats> {
     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({
@@ -122,7 +133,10 @@ export class SeamHttpThermostats {
   }
 
   get climateSettingSchedules(): SeamHttpThermostatsClimateSettingSchedules {
-    return SeamHttpThermostatsClimateSettingSchedules.fromClient(this.client)
+    return SeamHttpThermostatsClimateSettingSchedules.fromClient(
+      this.client,
+      this.defaults,
+    )
   }
 
   async cool(body?: ThermostatsCoolBody): Promise<void> {

package/src/lib/seam/connect/routes/user-identities.ts

@@ -22,17 +22,23 @@ import {
   type SeamHttpOptionsWithClientSessionToken,
   type SeamHttpOptionsWithConsoleSessionToken,
   type SeamHttpOptionsWithPersonalAccessToken,
+  type SeamHttpRequestOptions,
 } from 'lib/seam/connect/options.js'
-import { parseOptions } from 'lib/seam/connect/parse-options.js'
+import {
+  limitToSeamHttpRequestOptions,
+  parseOptions,
+} from 'lib/seam/connect/parse-options.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 
 export class SeamHttpUserIdentities {
   client: Client
+  readonly defaults: Required<SeamHttpRequestOptions>
 
   constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
-    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(
@@ -78,6 +84,11 @@ export class SeamHttpUserIdentities {
   ): Promise<SeamHttpUserIdentities> {
     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({

package/src/lib/seam/connect/routes/webhooks.ts

@@ -26,17 +26,23 @@ import {
   type SeamHttpOptionsWithClientSessionToken,
   type SeamHttpOptionsWithConsoleSessionToken,
   type SeamHttpOptionsWithPersonalAccessToken,
+  type SeamHttpRequestOptions,
 } from 'lib/seam/connect/options.js'
-import { parseOptions } from 'lib/seam/connect/parse-options.js'
+import {
+  limitToSeamHttpRequestOptions,
+  parseOptions,
+} from 'lib/seam/connect/parse-options.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 
 export class SeamHttpWebhooks {
   client: Client
+  readonly defaults: Required<SeamHttpRequestOptions>
 
   constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
-    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(
@@ -82,6 +88,11 @@ export class SeamHttpWebhooks {
   ): Promise<SeamHttpWebhooks> {
     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({

package/src/lib/seam/connect/routes/workspaces.ts

@@ -26,17 +26,23 @@ import {
   type SeamHttpOptionsWithClientSessionToken,
   type SeamHttpOptionsWithConsoleSessionToken,
   type SeamHttpOptionsWithPersonalAccessToken,
+  type SeamHttpRequestOptions,
 } from 'lib/seam/connect/options.js'
-import { parseOptions } from 'lib/seam/connect/parse-options.js'
+import {
+  limitToSeamHttpRequestOptions,
+  parseOptions,
+} from 'lib/seam/connect/parse-options.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 
 export class SeamHttpWorkspaces {
   client: Client
+  readonly defaults: Required<SeamHttpRequestOptions>
 
   constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
-    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(
@@ -82,6 +88,11 @@ export class SeamHttpWorkspaces {
   ): Promise<SeamHttpWorkspaces> {
     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({

package/src/lib/seam/connect/seam-http-multi-workspace.ts

@@ -8,16 +8,19 @@ import {
   type SeamHttpMultiWorkspaceOptionsWithClient,
   type SeamHttpMultiWorkspaceOptionsWithConsoleSessionToken,
   type SeamHttpMultiWorkspaceOptionsWithPersonalAccessToken,
+  type SeamHttpRequestOptions,
 } from './options.js'
-import { parseOptions } from './parse-options.js'
+import { limitToSeamHttpRequestOptions, parseOptions } from './parse-options.js'
 import { SeamHttpWorkspaces } from './routes/index.js'
 
 export class SeamHttpMultiWorkspace {
   client: Client
+  readonly defaults: Required<SeamHttpRequestOptions>
 
   constructor(options: SeamHttpMultiWorkspaceOptions) {
-    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(
@@ -72,6 +75,6 @@ export class SeamHttpMultiWorkspace {
   }
 
   get workspaces(): SeamHttpWorkspaces {
-    return SeamHttpWorkspaces.fromClient(this.client)
+    return SeamHttpWorkspaces.fromClient(this.client, this.defaults)
   }
 }