@seamapi/http 0.4.0 → 0.6.0

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

@@ -12,12 +12,16 @@ import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  isSeamHttpOptionsWithConsoleSessionToken,
+  isSeamHttpOptionsWithPersonalAccessToken,
   type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
+  type SeamHttpOptionsWithConsoleSessionToken,
+  type SeamHttpOptionsWithPersonalAccessToken,
 } from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
@@ -82,6 +86,40 @@ export class SeamHttpEvents {
     return SeamHttpEvents.fromClientSessionToken(token, options)
   }
 
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
+    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithConsoleSessionToken,
+      'consoleSessionToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpEvents {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing consoleSessionToken or workspaceId',
+      )
+    }
+    return new SeamHttpEvents(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
+    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithPersonalAccessToken,
+      'personalAccessToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpEvents {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId }
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing personalAccessToken or workspaceId',
+      )
+    }
+    return new SeamHttpEvents(constructorOptions)
+  }
+
   async get(body?: EventsGetParams): Promise<EventsGetResponse['event']> {
     const { data } = await this.client.request<EventsGetResponse>({
       url: '/events/get',

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

@@ -17,5 +17,6 @@ export * from './noise-sensors.js'
 export * from './noise-sensors-noise-thresholds.js'
 export * from './thermostats.js'
 export * from './thermostats-climate-setting-schedules.js'
+export * from './user-identities.js'
 export * from './webhooks.js'
 export * from './workspaces.js'

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

@@ -12,12 +12,16 @@ import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  isSeamHttpOptionsWithConsoleSessionToken,
+  isSeamHttpOptionsWithPersonalAccessToken,
   type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
+  type SeamHttpOptionsWithConsoleSessionToken,
+  type SeamHttpOptionsWithPersonalAccessToken,
 } from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
@@ -82,6 +86,40 @@ export class SeamHttpLocks {
     return SeamHttpLocks.fromClientSessionToken(token, options)
   }
 
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
+    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithConsoleSessionToken,
+      'consoleSessionToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpLocks {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing consoleSessionToken or workspaceId',
+      )
+    }
+    return new SeamHttpLocks(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
+    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithPersonalAccessToken,
+      'personalAccessToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpLocks {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId }
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing personalAccessToken or workspaceId',
+      )
+    }
+    return new SeamHttpLocks(constructorOptions)
+  }
+
   async get(body?: LocksGetParams): Promise<LocksGetResponse['device']> {
     const { data } = await this.client.request<LocksGetResponse>({
       url: '/locks/get',

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

@@ -12,12 +12,16 @@ import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  isSeamHttpOptionsWithConsoleSessionToken,
+  isSeamHttpOptionsWithPersonalAccessToken,
   type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
+  type SeamHttpOptionsWithConsoleSessionToken,
+  type SeamHttpOptionsWithPersonalAccessToken,
 } from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
@@ -85,6 +89,40 @@ export class SeamHttpNoiseSensorsNoiseThresholds {
     )
   }
 
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
+    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithConsoleSessionToken,
+      'consoleSessionToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpNoiseSensorsNoiseThresholds {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing consoleSessionToken or workspaceId',
+      )
+    }
+    return new SeamHttpNoiseSensorsNoiseThresholds(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
+    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithPersonalAccessToken,
+      'personalAccessToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpNoiseSensorsNoiseThresholds {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId }
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing personalAccessToken or workspaceId',
+      )
+    }
+    return new SeamHttpNoiseSensorsNoiseThresholds(constructorOptions)
+  }
+
   async create(body?: NoiseSensorsNoiseThresholdsCreateBody): Promise<void> {
     await this.client.request<NoiseSensorsNoiseThresholdsCreateResponse>({
       url: '/noise_sensors/noise_thresholds/create',

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

@@ -9,12 +9,16 @@ import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  isSeamHttpOptionsWithConsoleSessionToken,
+  isSeamHttpOptionsWithPersonalAccessToken,
   type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
+  type SeamHttpOptionsWithConsoleSessionToken,
+  type SeamHttpOptionsWithPersonalAccessToken,
 } from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
@@ -80,6 +84,40 @@ export class SeamHttpNoiseSensors {
     return SeamHttpNoiseSensors.fromClientSessionToken(token, options)
   }
 
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
+    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithConsoleSessionToken,
+      'consoleSessionToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpNoiseSensors {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing consoleSessionToken or workspaceId',
+      )
+    }
+    return new SeamHttpNoiseSensors(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
+    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithPersonalAccessToken,
+      'personalAccessToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpNoiseSensors {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId }
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing personalAccessToken or workspaceId',
+      )
+    }
+    return new SeamHttpNoiseSensors(constructorOptions)
+  }
+
   get noiseThresholds(): SeamHttpNoiseSensorsNoiseThresholds {
     return SeamHttpNoiseSensorsNoiseThresholds.fromClient(this.client)
   }

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

@@ -12,12 +12,16 @@ import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  isSeamHttpOptionsWithConsoleSessionToken,
+  isSeamHttpOptionsWithPersonalAccessToken,
   type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
+  type SeamHttpOptionsWithConsoleSessionToken,
+  type SeamHttpOptionsWithPersonalAccessToken,
 } from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
@@ -85,6 +89,40 @@ export class SeamHttpThermostatsClimateSettingSchedules {
     )
   }
 
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
+    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithConsoleSessionToken,
+      'consoleSessionToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpThermostatsClimateSettingSchedules {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing consoleSessionToken or workspaceId',
+      )
+    }
+    return new SeamHttpThermostatsClimateSettingSchedules(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
+    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithPersonalAccessToken,
+      'personalAccessToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpThermostatsClimateSettingSchedules {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId }
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing personalAccessToken or workspaceId',
+      )
+    }
+    return new SeamHttpThermostatsClimateSettingSchedules(constructorOptions)
+  }
+
   async create(
     body?: ThermostatsClimateSettingSchedulesCreateBody,
   ): Promise<

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

@@ -12,12 +12,16 @@ import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  isSeamHttpOptionsWithConsoleSessionToken,
+  isSeamHttpOptionsWithPersonalAccessToken,
   type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
+  type SeamHttpOptionsWithConsoleSessionToken,
+  type SeamHttpOptionsWithPersonalAccessToken,
 } from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
@@ -83,6 +87,40 @@ export class SeamHttpThermostats {
     return SeamHttpThermostats.fromClientSessionToken(token, options)
   }
 
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
+    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithConsoleSessionToken,
+      'consoleSessionToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpThermostats {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing consoleSessionToken or workspaceId',
+      )
+    }
+    return new SeamHttpThermostats(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
+    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithPersonalAccessToken,
+      'personalAccessToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpThermostats {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId }
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing personalAccessToken or workspaceId',
+      )
+    }
+    return new SeamHttpThermostats(constructorOptions)
+  }
+
   get climateSettingSchedules(): SeamHttpThermostatsClimateSettingSchedules {
     return SeamHttpThermostatsClimateSettingSchedules.fromClient(this.client)
   }

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

@@ -0,0 +1,261 @@
+/*
+ * Automatically generated by generate-routes.ts.
+ * Do not edit this file or add other files to this directory.
+ */
+
+import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect'
+import type { SetNonNullable } from 'type-fest'
+
+import { warnOnInsecureuserIdentifierKey } from 'lib/seam/connect/auth.js'
+import { type Client, createClient } from 'lib/seam/connect/client.js'
+import {
+  isSeamHttpOptionsWithApiKey,
+  isSeamHttpOptionsWithClient,
+  isSeamHttpOptionsWithClientSessionToken,
+  isSeamHttpOptionsWithConsoleSessionToken,
+  isSeamHttpOptionsWithPersonalAccessToken,
+  type SeamHttpFromPublishableKeyOptions,
+  SeamHttpInvalidOptionsError,
+  type SeamHttpOptions,
+  type SeamHttpOptionsWithApiKey,
+  type SeamHttpOptionsWithClient,
+  type SeamHttpOptionsWithClientSessionToken,
+  type SeamHttpOptionsWithConsoleSessionToken,
+  type SeamHttpOptionsWithPersonalAccessToken,
+} from 'lib/seam/connect/options.js'
+import { parseOptions } from 'lib/seam/connect/parse-options.js'
+
+import { SeamHttpClientSessions } from './client-sessions.js'
+
+export class SeamHttpUserIdentities {
+  client: Client
+
+  constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions)
+    this.client = createClient(clientOptions)
+  }
+
+  static fromClient(
+    client: SeamHttpOptionsWithClient['client'],
+    options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
+  ): SeamHttpUserIdentities {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError('Missing client')
+    }
+    return new SeamHttpUserIdentities(constructorOptions)
+  }
+
+  static fromApiKey(
+    apiKey: SeamHttpOptionsWithApiKey['apiKey'],
+    options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
+  ): SeamHttpUserIdentities {
+    const constructorOptions = { ...options, apiKey }
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError('Missing apiKey')
+    }
+    return new SeamHttpUserIdentities(constructorOptions)
+  }
+
+  static fromClientSessionToken(
+    clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'],
+    options: Omit<
+      SeamHttpOptionsWithClientSessionToken,
+      'clientSessionToken'
+    > = {},
+  ): SeamHttpUserIdentities {
+    const constructorOptions = { ...options, clientSessionToken }
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
+    }
+    return new SeamHttpUserIdentities(constructorOptions)
+  }
+
+  static async fromPublishableKey(
+    publishableKey: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpUserIdentities> {
+    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 SeamHttpUserIdentities.fromClientSessionToken(token, options)
+  }
+
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
+    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithConsoleSessionToken,
+      'consoleSessionToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpUserIdentities {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing consoleSessionToken or workspaceId',
+      )
+    }
+    return new SeamHttpUserIdentities(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
+    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithPersonalAccessToken,
+      'personalAccessToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpUserIdentities {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId }
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing personalAccessToken or workspaceId',
+      )
+    }
+    return new SeamHttpUserIdentities(constructorOptions)
+  }
+
+  async addAcsUser(body?: UserIdentitiesAddAcsUserBody): Promise<void> {
+    await this.client.request<UserIdentitiesAddAcsUserResponse>({
+      url: '/user_identities/add_acs_user',
+      method: 'post',
+      data: body,
+    })
+  }
+
+  async create(
+    body?: UserIdentitiesCreateBody,
+  ): Promise<UserIdentitiesCreateResponse['user_identity']> {
+    const { data } = await this.client.request<UserIdentitiesCreateResponse>({
+      url: '/user_identities/create',
+      method: 'post',
+      data: body,
+    })
+    return data.user_identity
+  }
+
+  async get(
+    body?: UserIdentitiesGetParams,
+  ): Promise<UserIdentitiesGetResponse['user_identity']> {
+    const { data } = await this.client.request<UserIdentitiesGetResponse>({
+      url: '/user_identities/get',
+      method: 'post',
+      data: body,
+    })
+    return data.user_identity
+  }
+
+  async grantAccessToDevice(
+    body?: UserIdentitiesGrantAccessToDeviceBody,
+  ): Promise<void> {
+    await this.client.request<UserIdentitiesGrantAccessToDeviceResponse>({
+      url: '/user_identities/grant_access_to_device',
+      method: 'post',
+      data: body,
+    })
+  }
+
+  async listAccessibleDevices(
+    body?: UserIdentitiesListAccessibleDevicesParams,
+  ): Promise<
+    UserIdentitiesListAccessibleDevicesResponse['accessible_devices']
+  > {
+    const { data } =
+      await this.client.request<UserIdentitiesListAccessibleDevicesResponse>({
+        url: '/user_identities/list_accessible_devices',
+        method: 'post',
+        data: body,
+      })
+    return data.accessible_devices
+  }
+
+  async listAcsUsers(
+    body?: UserIdentitiesListAcsUsersParams,
+  ): Promise<UserIdentitiesListAcsUsersResponse['acs_users']> {
+    const { data } =
+      await this.client.request<UserIdentitiesListAcsUsersResponse>({
+        url: '/user_identities/list_acs_users',
+        method: 'post',
+        data: body,
+      })
+    return data.acs_users
+  }
+
+  async removeAcsUser(body?: UserIdentitiesRemoveAcsUserBody): Promise<void> {
+    await this.client.request<UserIdentitiesRemoveAcsUserResponse>({
+      url: '/user_identities/remove_acs_user',
+      method: 'post',
+      data: body,
+    })
+  }
+
+  async revokeAccessToDevice(
+    body?: UserIdentitiesRevokeAccessToDeviceBody,
+  ): Promise<void> {
+    await this.client.request<UserIdentitiesRevokeAccessToDeviceResponse>({
+      url: '/user_identities/revoke_access_to_device',
+      method: 'post',
+      data: body,
+    })
+  }
+}
+
+export type UserIdentitiesAddAcsUserBody =
+  RouteRequestBody<'/user_identities/add_acs_user'>
+
+export type UserIdentitiesAddAcsUserResponse = SetNonNullable<
+  Required<RouteResponse<'/user_identities/add_acs_user'>>
+>
+
+export type UserIdentitiesCreateBody =
+  RouteRequestBody<'/user_identities/create'>
+
+export type UserIdentitiesCreateResponse = SetNonNullable<
+  Required<RouteResponse<'/user_identities/create'>>
+>
+
+export type UserIdentitiesGetParams = RouteRequestBody<'/user_identities/get'>
+
+export type UserIdentitiesGetResponse = SetNonNullable<
+  Required<RouteResponse<'/user_identities/get'>>
+>
+
+export type UserIdentitiesGrantAccessToDeviceBody =
+  RouteRequestBody<'/user_identities/grant_access_to_device'>
+
+export type UserIdentitiesGrantAccessToDeviceResponse = SetNonNullable<
+  Required<RouteResponse<'/user_identities/grant_access_to_device'>>
+>
+
+export type UserIdentitiesListAccessibleDevicesParams =
+  RouteRequestBody<'/user_identities/list_accessible_devices'>
+
+export type UserIdentitiesListAccessibleDevicesResponse = SetNonNullable<
+  Required<RouteResponse<'/user_identities/list_accessible_devices'>>
+>
+
+export type UserIdentitiesListAcsUsersParams =
+  RouteRequestBody<'/user_identities/list_acs_users'>
+
+export type UserIdentitiesListAcsUsersResponse = SetNonNullable<
+  Required<RouteResponse<'/user_identities/list_acs_users'>>
+>
+
+export type UserIdentitiesRemoveAcsUserBody =
+  RouteRequestBody<'/user_identities/remove_acs_user'>
+
+export type UserIdentitiesRemoveAcsUserResponse = SetNonNullable<
+  Required<RouteResponse<'/user_identities/remove_acs_user'>>
+>
+
+export type UserIdentitiesRevokeAccessToDeviceBody =
+  RouteRequestBody<'/user_identities/revoke_access_to_device'>
+
+export type UserIdentitiesRevokeAccessToDeviceResponse = SetNonNullable<
+  Required<RouteResponse<'/user_identities/revoke_access_to_device'>>
+>

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

@@ -16,12 +16,16 @@ import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  isSeamHttpOptionsWithConsoleSessionToken,
+  isSeamHttpOptionsWithPersonalAccessToken,
   type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
+  type SeamHttpOptionsWithConsoleSessionToken,
+  type SeamHttpOptionsWithPersonalAccessToken,
 } from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
@@ -86,6 +90,40 @@ export class SeamHttpWebhooks {
     return SeamHttpWebhooks.fromClientSessionToken(token, options)
   }
 
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
+    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithConsoleSessionToken,
+      'consoleSessionToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpWebhooks {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing consoleSessionToken or workspaceId',
+      )
+    }
+    return new SeamHttpWebhooks(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
+    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithPersonalAccessToken,
+      'personalAccessToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpWebhooks {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId }
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing personalAccessToken or workspaceId',
+      )
+    }
+    return new SeamHttpWebhooks(constructorOptions)
+  }
+
   async create(
     body?: WebhooksCreateBody,
   ): Promise<WebhooksCreateResponse['webhook']> {