@seamapi/http 0.5.0 → 0.7.0

package/src/lib/seam/connect/options.ts

@@ -1,5 +1,10 @@
 import type { Client, ClientOptions } from './client.js'
 
+export type SeamHttpMultiWorkspaceOptions =
+  | SeamHttpMultiWorkspaceOptionsWithClient
+  | SeamHttpMultiWorkspaceOptionsWithConsoleSessionToken
+  | SeamHttpMultiWorkspaceOptionsWithPersonalAccessToken
+
 export type SeamHttpOptions =
   | SeamHttpOptionsFromEnv
   | SeamHttpOptionsWithClient
@@ -17,6 +22,15 @@ export interface SeamHttpFromPublishableKeyOptions
 
 export interface SeamHttpOptionsFromEnv extends SeamHttpCommonOptions {}
 
+export interface SeamHttpMultiWorkspaceOptionsWithClient {
+  client: Client
+}
+
+export const isSeamHttpMultiWorkspaceOptionsWithClient = (
+  options: SeamHttpOptions,
+): options is SeamHttpMultiWorkspaceOptionsWithClient =>
+  isSeamHttpOptionsWithClient(options)
+
 export interface SeamHttpOptionsWithClient {
   client: Client
 }
@@ -102,24 +116,17 @@ export const isSeamHttpOptionsWithClientSessionToken = (
   return true
 }
 
-export interface SeamHttpOptionsWithConsoleSessionToken
+export interface SeamHttpMultiWorkspaceOptionsWithConsoleSessionToken
   extends SeamHttpCommonOptions {
   consoleSessionToken: string
-  workspaceId: string
 }
 
-export const isSeamHttpOptionsWithConsoleSessionToken = (
+export const isSeamHttpMultiWorkspaceOptionsWithConsoleSessionToken = (
   options: SeamHttpOptions,
-): options is SeamHttpOptionsWithConsoleSessionToken => {
+): options is SeamHttpMultiWorkspaceOptionsWithConsoleSessionToken => {
   if (!('consoleSessionToken' in options)) return false
   if (options.consoleSessionToken == null) return false
 
-  if (!('workspaceId' in options) || options.workspaceId == null) {
-    throw new SeamHttpInvalidOptionsError(
-      'Must pass a workspaceId when using a consoleSessionToken',
-    )
-  }
-
   if ('apiKey' in options && options.apiKey != null) {
     throw new SeamHttpInvalidOptionsError(
       'The apiKey option cannot be used with the consoleSessionToken option',
@@ -141,24 +148,39 @@ export const isSeamHttpOptionsWithConsoleSessionToken = (
   return true
 }
 
-export interface SeamHttpOptionsWithPersonalAccessToken
+export interface SeamHttpOptionsWithConsoleSessionToken
   extends SeamHttpCommonOptions {
-  personalAccessToken: string
+  consoleSessionToken: string
   workspaceId: string
 }
 
-export const isSeamHttpOptionsWithPersonalAccessToken = (
+export const isSeamHttpOptionsWithConsoleSessionToken = (
   options: SeamHttpOptions,
-): options is SeamHttpOptionsWithPersonalAccessToken => {
-  if (!('personalAccessToken' in options)) return false
-  if (options.personalAccessToken == null) return false
+): options is SeamHttpOptionsWithConsoleSessionToken => {
+  if (!isSeamHttpMultiWorkspaceOptionsWithConsoleSessionToken(options)) {
+    return false
+  }
 
   if (!('workspaceId' in options) || options.workspaceId == null) {
     throw new SeamHttpInvalidOptionsError(
-      'Must pass a workspaceId when using a personalAccessToken',
+      'Must pass a workspaceId when using a consoleSessionToken',
     )
   }
 
+  return true
+}
+
+export interface SeamHttpMultiWorkspaceOptionsWithPersonalAccessToken
+  extends SeamHttpCommonOptions {
+  personalAccessToken: string
+}
+
+export const isSeamHttpMultiWorkspaceOptionsWithPersonalAccessToken = (
+  options: SeamHttpOptions,
+): options is SeamHttpMultiWorkspaceOptionsWithPersonalAccessToken => {
+  if (!('personalAccessToken' in options)) return false
+  if (options.personalAccessToken == null) return false
+
   if ('apiKey' in options && options.apiKey != null) {
     throw new SeamHttpInvalidOptionsError(
       'The apiKey option cannot be used with the personalAccessToken option',
@@ -180,6 +202,28 @@ export const isSeamHttpOptionsWithPersonalAccessToken = (
   return true
 }
 
+export interface SeamHttpOptionsWithPersonalAccessToken
+  extends SeamHttpCommonOptions {
+  personalAccessToken: string
+  workspaceId: string
+}
+
+export const isSeamHttpOptionsWithPersonalAccessToken = (
+  options: SeamHttpOptions,
+): options is SeamHttpOptionsWithPersonalAccessToken => {
+  if (!isSeamHttpMultiWorkspaceOptionsWithPersonalAccessToken(options)) {
+    return false
+  }
+
+  if (!('workspaceId' in options) || options.workspaceId == null) {
+    throw new SeamHttpInvalidOptionsError(
+      'Must pass a workspaceId when using a personalAccessToken',
+    )
+  }
+
+  return true
+}
+
 export class SeamHttpInvalidOptionsError extends Error {
   constructor(message: string) {
     super(`SeamHttp received invalid options: ${message}`)
@@ -187,3 +231,5 @@ export class SeamHttpInvalidOptionsError extends Error {
     Error.captureStackTrace(this, this.constructor)
   }
 }
+
+export class SeamHttpMultiWorkspaceInvalidOptionsError extends SeamHttpInvalidOptionsError {}

package/src/lib/seam/connect/parse-options.ts

@@ -3,8 +3,10 @@ import version from 'lib/version.js'
 import { getAuthHeaders } from './auth.js'
 import type { ClientOptions } from './client.js'
 import {
+  isSeamHttpMultiWorkspaceOptionsWithClient,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  type SeamHttpMultiWorkspaceOptions,
   type SeamHttpOptions,
 } from './options.js'
 
@@ -15,7 +17,9 @@ const sdkHeaders = {
   'seam-sdk-version': version,
 }
 
-export type Options = SeamHttpOptions & { publishableKey?: string }
+export type Options =
+  | SeamHttpMultiWorkspaceOptions
+  | (SeamHttpOptions & { publishableKey?: string })
 
 export const parseOptions = (
   apiKeyOrOptions: string | Options,
@@ -23,6 +27,7 @@ export const parseOptions = (
   const options = getNormalizedOptions(apiKeyOrOptions)
 
   if (isSeamHttpOptionsWithClient(options)) return options
+  if (isSeamHttpMultiWorkspaceOptionsWithClient(options)) return options
 
   return {
     axiosOptions: {

package/src/lib/seam/connect/routes/acs-access-groups.ts

@@ -128,25 +128,6 @@ export class SeamHttpAcsAccessGroups {
     })
   }
 
-  async create(
-    body?: AcsAccessGroupsCreateBody,
-  ): Promise<AcsAccessGroupsCreateResponse['acs_access_group']> {
-    const { data } = await this.client.request<AcsAccessGroupsCreateResponse>({
-      url: '/acs/access_groups/create',
-      method: 'post',
-      data: body,
-    })
-    return data.acs_access_group
-  }
-
-  async delete(body?: AcsAccessGroupsDeleteBody): Promise<void> {
-    await this.client.request<AcsAccessGroupsDeleteResponse>({
-      url: '/acs/access_groups/delete',
-      method: 'post',
-      data: body,
-    })
-  }
-
   async get(
     body?: AcsAccessGroupsGetParams,
   ): Promise<AcsAccessGroupsGetResponse['acs_access_group']> {
@@ -188,14 +169,6 @@ export class SeamHttpAcsAccessGroups {
       data: body,
     })
   }
-
-  async update(body?: AcsAccessGroupsUpdateBody): Promise<void> {
-    await this.client.request<AcsAccessGroupsUpdateResponse>({
-      url: '/acs/access_groups/update',
-      method: 'post',
-      data: body,
-    })
-  }
 }
 
 export type AcsAccessGroupsAddUserBody =
@@ -205,20 +178,6 @@ export type AcsAccessGroupsAddUserResponse = SetNonNullable<
   Required<RouteResponse<'/acs/access_groups/add_user'>>
 >
 
-export type AcsAccessGroupsCreateBody =
-  RouteRequestBody<'/acs/access_groups/create'>
-
-export type AcsAccessGroupsCreateResponse = SetNonNullable<
-  Required<RouteResponse<'/acs/access_groups/create'>>
->
-
-export type AcsAccessGroupsDeleteBody =
-  RouteRequestBody<'/acs/access_groups/delete'>
-
-export type AcsAccessGroupsDeleteResponse = SetNonNullable<
-  Required<RouteResponse<'/acs/access_groups/delete'>>
->
-
 export type AcsAccessGroupsGetParams =
   RouteRequestBody<'/acs/access_groups/get'>
 
@@ -246,10 +205,3 @@ export type AcsAccessGroupsRemoveUserBody =
 export type AcsAccessGroupsRemoveUserResponse = SetNonNullable<
   Required<RouteResponse<'/acs/access_groups/remove_user'>>
 >
-
-export type AcsAccessGroupsUpdateBody =
-  RouteRequestBody<'/acs/access_groups/update'>
-
-export type AcsAccessGroupsUpdateResponse = SetNonNullable<
-  Required<RouteResponse<'/acs/access_groups/update'>>
->

package/src/lib/seam/connect/routes/acs-credentials.ts

@@ -120,6 +120,14 @@ export class SeamHttpAcsCredentials {
     return new SeamHttpAcsCredentials(constructorOptions)
   }
 
+  async assign(body?: AcsCredentialsAssignBody): Promise<void> {
+    await this.client.request<AcsCredentialsAssignResponse>({
+      url: '/acs/credentials/assign',
+      method: 'post',
+      data: body,
+    })
+  }
+
   async create(
     body?: AcsCredentialsCreateBody,
   ): Promise<AcsCredentialsCreateResponse['acs_credential']> {
@@ -160,8 +168,23 @@ export class SeamHttpAcsCredentials {
     })
     return data.acs_credentials
   }
+
+  async unassign(body?: AcsCredentialsUnassignBody): Promise<void> {
+    await this.client.request<AcsCredentialsUnassignResponse>({
+      url: '/acs/credentials/unassign',
+      method: 'post',
+      data: body,
+    })
+  }
 }
 
+export type AcsCredentialsAssignBody =
+  RouteRequestBody<'/acs/credentials/assign'>
+
+export type AcsCredentialsAssignResponse = SetNonNullable<
+  Required<RouteResponse<'/acs/credentials/assign'>>
+>
+
 export type AcsCredentialsCreateBody =
   RouteRequestBody<'/acs/credentials/create'>
 
@@ -187,3 +210,10 @@ export type AcsCredentialsListParams = RouteRequestBody<'/acs/credentials/list'>
 export type AcsCredentialsListResponse = SetNonNullable<
   Required<RouteResponse<'/acs/credentials/list'>>
 >
+
+export type AcsCredentialsUnassignBody =
+  RouteRequestBody<'/acs/credentials/unassign'>
+
+export type AcsCredentialsUnassignResponse = SetNonNullable<
+  Required<RouteResponse<'/acs/credentials/unassign'>>
+>

package/src/lib/seam/connect/routes/client-sessions.ts

@@ -182,6 +182,14 @@ export class SeamHttpClientSessions {
     })
     return data.client_sessions
   }
+
+  async revoke(body?: ClientSessionsRevokeBody): Promise<void> {
+    await this.client.request<ClientSessionsRevokeResponse>({
+      url: '/client_sessions/revoke',
+      method: 'post',
+      data: body,
+    })
+  }
 }
 
 export type ClientSessionsCreateBody =
@@ -223,3 +231,10 @@ export type ClientSessionsListParams = RouteRequestBody<'/client_sessions/list'>
 export type ClientSessionsListResponse = SetNonNullable<
   Required<RouteResponse<'/client_sessions/list'>>
 >
+
+export type ClientSessionsRevokeBody =
+  RouteRequestBody<'/client_sessions/revoke'>
+
+export type ClientSessionsRevokeResponse = SetNonNullable<
+  Required<RouteResponse<'/client_sessions/revoke'>>
+>

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/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/seam-http-multi-workspace.ts

@@ -0,0 +1,77 @@
+import { type Client, createClient } from './client.js'
+import {
+  isSeamHttpMultiWorkspaceOptionsWithClient,
+  isSeamHttpMultiWorkspaceOptionsWithConsoleSessionToken,
+  isSeamHttpMultiWorkspaceOptionsWithPersonalAccessToken,
+  SeamHttpMultiWorkspaceInvalidOptionsError,
+  type SeamHttpMultiWorkspaceOptions,
+  type SeamHttpMultiWorkspaceOptionsWithClient,
+  type SeamHttpMultiWorkspaceOptionsWithConsoleSessionToken,
+  type SeamHttpMultiWorkspaceOptionsWithPersonalAccessToken,
+} from './options.js'
+import { parseOptions } from './parse-options.js'
+import { SeamHttpWorkspaces } from './routes/index.js'
+
+export class SeamHttpMultiWorkspace {
+  client: Client
+
+  constructor(options: SeamHttpMultiWorkspaceOptions) {
+    const clientOptions = parseOptions(options)
+    this.client = createClient(clientOptions)
+  }
+
+  static fromClient(
+    client: SeamHttpMultiWorkspaceOptionsWithClient['client'],
+    options: Omit<SeamHttpMultiWorkspaceOptionsWithClient, 'client'> = {},
+  ): SeamHttpMultiWorkspace {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpMultiWorkspaceOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpMultiWorkspaceInvalidOptionsError('Missing client')
+    }
+    return new SeamHttpMultiWorkspace(constructorOptions)
+  }
+
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpMultiWorkspaceOptionsWithConsoleSessionToken['consoleSessionToken'],
+    options: Omit<
+      SeamHttpMultiWorkspaceOptionsWithConsoleSessionToken,
+      'consoleSessionToken'
+    > = {},
+  ): SeamHttpMultiWorkspace {
+    const constructorOptions = { ...options, consoleSessionToken }
+    if (
+      !isSeamHttpMultiWorkspaceOptionsWithConsoleSessionToken(
+        constructorOptions,
+      )
+    ) {
+      throw new SeamHttpMultiWorkspaceInvalidOptionsError(
+        'Missing consoleSessionToken',
+      )
+    }
+    return new SeamHttpMultiWorkspace(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpMultiWorkspaceOptionsWithPersonalAccessToken['personalAccessToken'],
+    options: Omit<
+      SeamHttpMultiWorkspaceOptionsWithPersonalAccessToken,
+      'personalAccessToken'
+    > = {},
+  ): SeamHttpMultiWorkspace {
+    const constructorOptions = { ...options, personalAccessToken }
+    if (
+      !isSeamHttpMultiWorkspaceOptionsWithPersonalAccessToken(
+        constructorOptions,
+      )
+    ) {
+      throw new SeamHttpMultiWorkspaceInvalidOptionsError(
+        'Missing personalAccessToken',
+      )
+    }
+    return new SeamHttpMultiWorkspace(constructorOptions)
+  }
+
+  get workspaces(): SeamHttpWorkspaces {
+    return SeamHttpWorkspaces.fromClient(this.client)
+  }
+}

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

@@ -28,6 +28,7 @@ import {
   SeamHttpLocks,
   SeamHttpNoiseSensors,
   SeamHttpThermostats,
+  SeamHttpUserIdentities,
   SeamHttpWebhooks,
   SeamHttpWorkspaces,
 } from './routes/index.js'
@@ -169,6 +170,10 @@ export class SeamHttp {
     return SeamHttpThermostats.fromClient(this.client)
   }
 
+  get userIdentities(): SeamHttpUserIdentities {
+    return SeamHttpUserIdentities.fromClient(this.client)
+  }
+
   get webhooks(): SeamHttpWebhooks {
     return SeamHttpWebhooks.fromClient(this.client)
   }

package/src/lib/version.ts

@@ -1,3 +1,3 @@
-const seamapiJavascriptHttpVersion = '0.5.0'
+const seamapiJavascriptHttpVersion = '0.7.0'
 
 export default seamapiJavascriptHttpVersion