@seamapi/http 0.1.0 → 0.2.0

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

@@ -4,50 +4,53 @@
  */
 
 import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect'
-import type { Axios } from 'axios'
 import type { SetNonNullable } from 'type-fest'
 
-import { createAxiosClient } from 'lib/seam/connect/axios.js'
+import { warnOnInsecureuserIdentifierKey } from 'lib/seam/connect/auth.js'
+import { type Client, createClient } from 'lib/seam/connect/client.js'
 import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
-} from 'lib/seam/connect/client-options.js'
+} from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
+import { SeamHttpClientSessions } from './client-sessions.js'
+
 export class SeamHttpDevicesUnmanaged {
-  client: Axios
+  client: Client
 
-  constructor(apiKeyOrOptions: string | SeamHttpOptions) {
-    const options = parseOptions(apiKeyOrOptions)
-    this.client = createAxiosClient(options)
+  constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions)
+    this.client = createClient(clientOptions)
   }
 
   static fromClient(
     client: SeamHttpOptionsWithClient['client'],
     options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
   ): SeamHttpDevicesUnmanaged {
-    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: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpDevicesUnmanaged {
-    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(
@@ -57,11 +60,26 @@ export class SeamHttpDevicesUnmanaged {
       'clientSessionToken'
     > = {},
   ): SeamHttpDevicesUnmanaged {
-    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: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpDevicesUnmanaged> {
+    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(
@@ -95,25 +113,21 @@ export class SeamHttpDevicesUnmanaged {
   }
 }
 
-export type DevicesUnmanagedGetBody = SetNonNullable<
-  Required<RouteRequestBody<'/devices/unmanaged/get'>>
->
+export type DevicesUnmanagedGetBody = RouteRequestBody<'/devices/unmanaged/get'>
 
 export type DevicesUnmanagedGetResponse = SetNonNullable<
   Required<RouteResponse<'/devices/unmanaged/get'>>
 >
 
-export type DevicesUnmanagedListBody = SetNonNullable<
-  Required<RouteRequestBody<'/devices/unmanaged/list'>>
->
+export type DevicesUnmanagedListBody =
+  RouteRequestBody<'/devices/unmanaged/list'>
 
 export type DevicesUnmanagedListResponse = SetNonNullable<
   Required<RouteResponse<'/devices/unmanaged/list'>>
 >
 
-export type DevicesUnmanagedUpdateBody = SetNonNullable<
-  Required<RouteRequestBody<'/devices/unmanaged/update'>>
->
+export type DevicesUnmanagedUpdateBody =
+  RouteRequestBody<'/devices/unmanaged/update'>
 
 export type DevicesUnmanagedUpdateResponse = SetNonNullable<
   Required<RouteResponse<'/devices/unmanaged/update'>>

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

@@ -4,52 +4,54 @@
  */
 
 import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect'
-import type { Axios } from 'axios'
 import type { SetNonNullable } from 'type-fest'
 
-import { createAxiosClient } from 'lib/seam/connect/axios.js'
+import { warnOnInsecureuserIdentifierKey } from 'lib/seam/connect/auth.js'
+import { type Client, createClient } from 'lib/seam/connect/client.js'
 import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
-} from 'lib/seam/connect/client-options.js'
+} from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
+import { SeamHttpClientSessions } from './client-sessions.js'
 import { SeamHttpDevicesUnmanaged } from './devices-unmanaged.js'
 
 export class SeamHttpDevices {
-  client: Axios
+  client: Client
 
-  constructor(apiKeyOrOptions: string | SeamHttpOptions) {
-    const options = parseOptions(apiKeyOrOptions)
-    this.client = createAxiosClient(options)
+  constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions)
+    this.client = createClient(clientOptions)
   }
 
   static fromClient(
     client: SeamHttpOptionsWithClient['client'],
     options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
   ): SeamHttpDevices {
-    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: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpDevices {
-    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(
@@ -59,11 +61,26 @@ export class SeamHttpDevices {
       'clientSessionToken'
     > = {},
   ): SeamHttpDevices {
-    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: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpDevices> {
+    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(): SeamHttpDevicesUnmanaged {
@@ -117,41 +134,32 @@ export class SeamHttpDevices {
   }
 }
 
-export type DevicesDeleteBody = SetNonNullable<
-  Required<RouteRequestBody<'/devices/delete'>>
->
+export type DevicesDeleteBody = RouteRequestBody<'/devices/delete'>
 
 export type DevicesDeleteResponse = SetNonNullable<
   Required<RouteResponse<'/devices/delete'>>
 >
 
-export type DevicesGetBody = SetNonNullable<
-  Required<RouteRequestBody<'/devices/get'>>
->
+export type DevicesGetBody = RouteRequestBody<'/devices/get'>
 
 export type DevicesGetResponse = SetNonNullable<
   Required<RouteResponse<'/devices/get'>>
 >
 
-export type DevicesListBody = SetNonNullable<
-  Required<RouteRequestBody<'/devices/list'>>
->
+export type DevicesListBody = RouteRequestBody<'/devices/list'>
 
 export type DevicesListResponse = SetNonNullable<
   Required<RouteResponse<'/devices/list'>>
 >
 
-export type DevicesListDeviceProvidersBody = SetNonNullable<
-  Required<RouteRequestBody<'/devices/list_device_providers'>>
->
+export type DevicesListDeviceProvidersBody =
+  RouteRequestBody<'/devices/list_device_providers'>
 
 export type DevicesListDeviceProvidersResponse = SetNonNullable<
   Required<RouteResponse<'/devices/list_device_providers'>>
 >
 
-export type DevicesUpdateBody = SetNonNullable<
-  Required<RouteRequestBody<'/devices/update'>>
->
+export type DevicesUpdateBody = RouteRequestBody<'/devices/update'>
 
 export type DevicesUpdateResponse = SetNonNullable<
   Required<RouteResponse<'/devices/update'>>

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

@@ -4,50 +4,53 @@
  */
 
 import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect'
-import type { Axios } from 'axios'
 import type { SetNonNullable } from 'type-fest'
 
-import { createAxiosClient } from 'lib/seam/connect/axios.js'
+import { warnOnInsecureuserIdentifierKey } from 'lib/seam/connect/auth.js'
+import { type Client, createClient } from 'lib/seam/connect/client.js'
 import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
-} from 'lib/seam/connect/client-options.js'
+} from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
+import { SeamHttpClientSessions } from './client-sessions.js'
+
 export class SeamHttpEvents {
-  client: Axios
+  client: Client
 
-  constructor(apiKeyOrOptions: string | SeamHttpOptions) {
-    const options = parseOptions(apiKeyOrOptions)
-    this.client = createAxiosClient(options)
+  constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions)
+    this.client = createClient(clientOptions)
   }
 
   static fromClient(
     client: SeamHttpOptionsWithClient['client'],
     options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
   ): SeamHttpEvents {
-    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: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpEvents {
-    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(
@@ -57,11 +60,26 @@ export class SeamHttpEvents {
       'clientSessionToken'
     > = {},
   ): SeamHttpEvents {
-    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: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpEvents> {
+    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: EventsGetBody): Promise<EventsGetResponse['event']> {
@@ -83,17 +101,13 @@ export class SeamHttpEvents {
   }
 }
 
-export type EventsGetBody = SetNonNullable<
-  Required<RouteRequestBody<'/events/get'>>
->
+export type EventsGetBody = RouteRequestBody<'/events/get'>
 
 export type EventsGetResponse = SetNonNullable<
   Required<RouteResponse<'/events/get'>>
 >
 
-export type EventsListBody = SetNonNullable<
-  Required<RouteRequestBody<'/events/list'>>
->
+export type EventsListBody = RouteRequestBody<'/events/list'>
 
 export type EventsListResponse = SetNonNullable<
   Required<RouteResponse<'/events/list'>>

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

@@ -4,50 +4,53 @@
  */
 
 import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect'
-import type { Axios } from 'axios'
 import type { SetNonNullable } from 'type-fest'
 
-import { createAxiosClient } from 'lib/seam/connect/axios.js'
+import { warnOnInsecureuserIdentifierKey } from 'lib/seam/connect/auth.js'
+import { type Client, createClient } from 'lib/seam/connect/client.js'
 import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
-} from 'lib/seam/connect/client-options.js'
+} from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
+import { SeamHttpClientSessions } from './client-sessions.js'
+
 export class SeamHttpLocks {
-  client: Axios
+  client: Client
 
-  constructor(apiKeyOrOptions: string | SeamHttpOptions) {
-    const options = parseOptions(apiKeyOrOptions)
-    this.client = createAxiosClient(options)
+  constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions)
+    this.client = createClient(clientOptions)
   }
 
   static fromClient(
     client: SeamHttpOptionsWithClient['client'],
     options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
   ): SeamHttpLocks {
-    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: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpLocks {
-    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(
@@ -57,11 +60,26 @@ export class SeamHttpLocks {
       'clientSessionToken'
     > = {},
   ): SeamHttpLocks {
-    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: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpLocks> {
+    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: LocksGetBody): Promise<LocksGetResponse['device']> {
@@ -105,33 +123,25 @@ export class SeamHttpLocks {
   }
 }
 
-export type LocksGetBody = SetNonNullable<
-  Required<RouteRequestBody<'/locks/get'>>
->
+export type LocksGetBody = RouteRequestBody<'/locks/get'>
 
 export type LocksGetResponse = SetNonNullable<
   Required<RouteResponse<'/locks/get'>>
 >
 
-export type LocksListBody = SetNonNullable<
-  Required<RouteRequestBody<'/locks/list'>>
->
+export type LocksListBody = RouteRequestBody<'/locks/list'>
 
 export type LocksListResponse = SetNonNullable<
   Required<RouteResponse<'/locks/list'>>
 >
 
-export type LocksLockDoorBody = SetNonNullable<
-  Required<RouteRequestBody<'/locks/lock_door'>>
->
+export type LocksLockDoorBody = RouteRequestBody<'/locks/lock_door'>
 
 export type LocksLockDoorResponse = SetNonNullable<
   Required<RouteResponse<'/locks/lock_door'>>
 >
 
-export type LocksUnlockDoorBody = SetNonNullable<
-  Required<RouteRequestBody<'/locks/unlock_door'>>
->
+export type LocksUnlockDoorBody = RouteRequestBody<'/locks/unlock_door'>
 
 export type LocksUnlockDoorResponse = SetNonNullable<
   Required<RouteResponse<'/locks/unlock_door'>>

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

@@ -4,50 +4,53 @@
  */
 
 import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect'
-import type { Axios } from 'axios'
 import type { SetNonNullable } from 'type-fest'
 
-import { createAxiosClient } from 'lib/seam/connect/axios.js'
+import { warnOnInsecureuserIdentifierKey } from 'lib/seam/connect/auth.js'
+import { type Client, createClient } from 'lib/seam/connect/client.js'
 import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
-} from 'lib/seam/connect/client-options.js'
+} from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
+import { SeamHttpClientSessions } from './client-sessions.js'
+
 export class SeamHttpNoiseSensorsNoiseThresholds {
-  client: Axios
+  client: Client
 
-  constructor(apiKeyOrOptions: string | SeamHttpOptions) {
-    const options = parseOptions(apiKeyOrOptions)
-    this.client = createAxiosClient(options)
+  constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions)
+    this.client = createClient(clientOptions)
   }
 
   static fromClient(
     client: SeamHttpOptionsWithClient['client'],
     options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
   ): SeamHttpNoiseSensorsNoiseThresholds {
-    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: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpNoiseSensorsNoiseThresholds {
-    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(
@@ -57,11 +60,29 @@ export class SeamHttpNoiseSensorsNoiseThresholds {
       'clientSessionToken'
     > = {},
   ): SeamHttpNoiseSensorsNoiseThresholds {
-    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: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpNoiseSensorsNoiseThresholds> {
+    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: NoiseSensorsNoiseThresholdsCreateBody): Promise<void> {
@@ -113,41 +134,36 @@ export class SeamHttpNoiseSensorsNoiseThresholds {
   }
 }
 
-export type NoiseSensorsNoiseThresholdsCreateBody = SetNonNullable<
-  Required<RouteRequestBody<'/noise_sensors/noise_thresholds/create'>>
->
+export type NoiseSensorsNoiseThresholdsCreateBody =
+  RouteRequestBody<'/noise_sensors/noise_thresholds/create'>
 
 export type NoiseSensorsNoiseThresholdsCreateResponse = SetNonNullable<
   Required<RouteResponse<'/noise_sensors/noise_thresholds/create'>>
 >
 
-export type NoiseSensorsNoiseThresholdsDeleteBody = SetNonNullable<
-  Required<RouteRequestBody<'/noise_sensors/noise_thresholds/delete'>>
->
+export type NoiseSensorsNoiseThresholdsDeleteBody =
+  RouteRequestBody<'/noise_sensors/noise_thresholds/delete'>
 
 export type NoiseSensorsNoiseThresholdsDeleteResponse = SetNonNullable<
   Required<RouteResponse<'/noise_sensors/noise_thresholds/delete'>>
 >
 
-export type NoiseSensorsNoiseThresholdsGetBody = SetNonNullable<
-  Required<RouteRequestBody<'/noise_sensors/noise_thresholds/get'>>
->
+export type NoiseSensorsNoiseThresholdsGetBody =
+  RouteRequestBody<'/noise_sensors/noise_thresholds/get'>
 
 export type NoiseSensorsNoiseThresholdsGetResponse = SetNonNullable<
   Required<RouteResponse<'/noise_sensors/noise_thresholds/get'>>
 >
 
-export type NoiseSensorsNoiseThresholdsListBody = SetNonNullable<
-  Required<RouteRequestBody<'/noise_sensors/noise_thresholds/list'>>
->
+export type NoiseSensorsNoiseThresholdsListBody =
+  RouteRequestBody<'/noise_sensors/noise_thresholds/list'>
 
 export type NoiseSensorsNoiseThresholdsListResponse = SetNonNullable<
   Required<RouteResponse<'/noise_sensors/noise_thresholds/list'>>
 >
 
-export type NoiseSensorsNoiseThresholdsUpdateBody = SetNonNullable<
-  Required<RouteRequestBody<'/noise_sensors/noise_thresholds/update'>>
->
+export type NoiseSensorsNoiseThresholdsUpdateBody =
+  RouteRequestBody<'/noise_sensors/noise_thresholds/update'>
 
 export type NoiseSensorsNoiseThresholdsUpdateResponse = SetNonNullable<
   Required<RouteResponse<'/noise_sensors/noise_thresholds/update'>>