@seamapi/http 0.23.0 → 0.25.0

package/src/lib/seam/connect/routes/connect-webviews.ts

@@ -35,6 +35,7 @@ import {
   limitToSeamHttpRequestOptions,
   parseOptions,
 } from 'lib/seam/connect/parse-options.js'
+import { SeamHttpRequest } from 'lib/seam/connect/seam-http-request.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 
@@ -157,55 +158,54 @@ export class SeamHttpConnectWebviews {
     await clientSessions.get()
   }
 
-  async create(
+  create(
     body?: ConnectWebviewsCreateBody,
-  ): Promise<ConnectWebviewsCreateResponse['connect_webview']> {
-    const { data } = await this.client.request<ConnectWebviewsCreateResponse>({
-      url: '/connect_webviews/create',
+  ): SeamHttpRequest<ConnectWebviewsCreateResponse, 'connect_webview'> {
+    return new SeamHttpRequest(this, {
+      path: '/connect_webviews/create',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'connect_webview',
     })
-
-    return data.connect_webview
   }
 
-  async delete(body?: ConnectWebviewsDeleteBody): Promise<void> {
-    await this.client.request<ConnectWebviewsDeleteResponse>({
-      url: '/connect_webviews/delete',
+  delete(body?: ConnectWebviewsDeleteBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/connect_webviews/delete',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async get(
+  get(
     body?: ConnectWebviewsGetParams,
-  ): Promise<ConnectWebviewsGetResponse['connect_webview']> {
-    const { data } = await this.client.request<ConnectWebviewsGetResponse>({
-      url: '/connect_webviews/get',
+  ): SeamHttpRequest<ConnectWebviewsGetResponse, 'connect_webview'> {
+    return new SeamHttpRequest(this, {
+      path: '/connect_webviews/get',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'connect_webview',
     })
-
-    return data.connect_webview
   }
 
-  async list(
+  list(
     body?: ConnectWebviewsListParams,
-  ): Promise<ConnectWebviewsListResponse['connect_webviews']> {
-    const { data } = await this.client.request<ConnectWebviewsListResponse>({
-      url: '/connect_webviews/list',
+  ): SeamHttpRequest<ConnectWebviewsListResponse, 'connect_webviews'> {
+    return new SeamHttpRequest(this, {
+      path: '/connect_webviews/list',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'connect_webviews',
     })
-
-    return data.connect_webviews
   }
 
-  async view(params?: ConnectWebviewsViewParams): Promise<void> {
-    await this.client.request<ConnectWebviewsViewResponse>({
-      url: '/connect_webviews/view',
+  view(params?: ConnectWebviewsViewParams): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/connect_webviews/view',
       method: 'get',
       params,
+      responseKey: undefined,
     })
   }
 }

package/src/lib/seam/connect/routes/connected-accounts.ts

@@ -31,6 +31,7 @@ import {
   limitToSeamHttpRequestOptions,
   parseOptions,
 } from 'lib/seam/connect/parse-options.js'
+import { SeamHttpRequest } from 'lib/seam/connect/seam-http-request.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 
@@ -153,50 +154,46 @@ export class SeamHttpConnectedAccounts {
     await clientSessions.get()
   }
 
-  async delete(body?: ConnectedAccountsDeleteBody): Promise<void> {
-    await this.client.request<ConnectedAccountsDeleteResponse>({
-      url: '/connected_accounts/delete',
+  delete(body?: ConnectedAccountsDeleteBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/connected_accounts/delete',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async get(
+  get(
     body?: ConnectedAccountsGetParams,
-  ): Promise<ConnectedAccountsGetResponse['connected_account']> {
-    const { data } = await this.client.request<ConnectedAccountsGetResponse>({
-      url: '/connected_accounts/get',
+  ): SeamHttpRequest<ConnectedAccountsGetResponse, 'connected_account'> {
+    return new SeamHttpRequest(this, {
+      path: '/connected_accounts/get',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'connected_account',
     })
-
-    return data.connected_account
   }
 
-  async list(
+  list(
     body?: ConnectedAccountsListParams,
-  ): Promise<ConnectedAccountsListResponse['connected_accounts']> {
-    const { data } = await this.client.request<ConnectedAccountsListResponse>({
-      url: '/connected_accounts/list',
+  ): SeamHttpRequest<ConnectedAccountsListResponse, 'connected_accounts'> {
+    return new SeamHttpRequest(this, {
+      path: '/connected_accounts/list',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'connected_accounts',
     })
-
-    return data.connected_accounts
   }
 
-  async update(
+  update(
     body?: ConnectedAccountsUpdateBody,
-  ): Promise<ConnectedAccountsUpdateResponse['connected_account']> {
-    const { data } = await this.client.request<ConnectedAccountsUpdateResponse>(
-      {
-        url: '/connected_accounts/update',
-        method: 'post',
-        data: body,
-      },
-    )
-
-    return data.connected_account
+  ): SeamHttpRequest<ConnectedAccountsUpdateResponse, 'connected_account'> {
+    return new SeamHttpRequest(this, {
+      path: '/connected_accounts/update',
+      method: 'post',
+      body,
+      responseKey: 'connected_account',
+    })
   }
 }
 

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

@@ -0,0 +1,174 @@
+/*
+ * 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 {
+  getAuthHeadersForClientSessionToken,
+  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,
+  type SeamHttpRequestOptions,
+} from 'lib/seam/connect/options.js'
+import {
+  limitToSeamHttpRequestOptions,
+  parseOptions,
+} from 'lib/seam/connect/parse-options.js'
+import { SeamHttpRequest } from 'lib/seam/connect/seam-http-request.js'
+
+import { SeamHttpClientSessions } from './client-sessions.js'
+
+export class SeamHttpDevicesSimulate {
+  client: Client
+  readonly defaults: Required<SeamHttpRequestOptions>
+
+  constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
+    const options = parseOptions(apiKeyOrOptions)
+    this.client = 'client' in options ? options.client : createClient(options)
+    this.defaults = limitToSeamHttpRequestOptions(options)
+  }
+
+  static fromClient(
+    client: SeamHttpOptionsWithClient['client'],
+    options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
+  ): SeamHttpDevicesSimulate {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError('Missing client')
+    }
+    return new SeamHttpDevicesSimulate(constructorOptions)
+  }
+
+  static fromApiKey(
+    apiKey: SeamHttpOptionsWithApiKey['apiKey'],
+    options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
+  ): SeamHttpDevicesSimulate {
+    const constructorOptions = { ...options, apiKey }
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError('Missing apiKey')
+    }
+    return new SeamHttpDevicesSimulate(constructorOptions)
+  }
+
+  static fromClientSessionToken(
+    clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'],
+    options: Omit<
+      SeamHttpOptionsWithClientSessionToken,
+      'clientSessionToken'
+    > = {},
+  ): SeamHttpDevicesSimulate {
+    const constructorOptions = { ...options, clientSessionToken }
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
+    }
+    return new SeamHttpDevicesSimulate(constructorOptions)
+  }
+
+  static async fromPublishableKey(
+    publishableKey: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpDevicesSimulate> {
+    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({
+      user_identifier_key: userIdentifierKey,
+    })
+    return SeamHttpDevicesSimulate.fromClientSessionToken(token, options)
+  }
+
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
+    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithConsoleSessionToken,
+      'consoleSessionToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpDevicesSimulate {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing consoleSessionToken or workspaceId',
+      )
+    }
+    return new SeamHttpDevicesSimulate(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
+    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithPersonalAccessToken,
+      'personalAccessToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpDevicesSimulate {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId }
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing personalAccessToken or workspaceId',
+      )
+    }
+    return new SeamHttpDevicesSimulate(constructorOptions)
+  }
+
+  async updateClientSessionToken(
+    clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'],
+  ): Promise<void> {
+    const { headers } = this.client.defaults
+    const authHeaders = getAuthHeadersForClientSessionToken({
+      clientSessionToken,
+    })
+    for (const key of Object.keys(authHeaders)) {
+      if (headers[key] == null) {
+        throw new Error(
+          'Cannot update a clientSessionToken on a client created without a clientSessionToken',
+        )
+      }
+    }
+    this.client.defaults.headers = { ...headers, ...authHeaders }
+    const clientSessions = SeamHttpClientSessions.fromClient(this.client)
+    await clientSessions.get()
+  }
+
+  remove(body?: DevicesSimulateRemoveBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/devices/simulate/remove',
+      method: 'post',
+      body,
+      responseKey: undefined,
+    })
+  }
+}
+
+export type DevicesSimulateRemoveBody =
+  RouteRequestBody<'/devices/simulate/remove'>
+
+export type DevicesSimulateRemoveResponse = SetNonNullable<
+  Required<RouteResponse<'/devices/simulate/remove'>>
+>
+
+export type DevicesSimulateRemoveOptions = never

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

@@ -31,6 +31,7 @@ import {
   limitToSeamHttpRequestOptions,
   parseOptions,
 } from 'lib/seam/connect/parse-options.js'
+import { SeamHttpRequest } from 'lib/seam/connect/seam-http-request.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 
@@ -153,35 +154,34 @@ export class SeamHttpDevicesUnmanaged {
     await clientSessions.get()
   }
 
-  async get(
+  get(
     body?: DevicesUnmanagedGetParams,
-  ): Promise<DevicesUnmanagedGetResponse['device']> {
-    const { data } = await this.client.request<DevicesUnmanagedGetResponse>({
-      url: '/devices/unmanaged/get',
+  ): SeamHttpRequest<DevicesUnmanagedGetResponse, 'device'> {
+    return new SeamHttpRequest(this, {
+      path: '/devices/unmanaged/get',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'device',
     })
-
-    return data.device
   }
 
-  async list(
+  list(
     body?: DevicesUnmanagedListParams,
-  ): Promise<DevicesUnmanagedListResponse['devices']> {
-    const { data } = await this.client.request<DevicesUnmanagedListResponse>({
-      url: '/devices/unmanaged/list',
+  ): SeamHttpRequest<DevicesUnmanagedListResponse, 'devices'> {
+    return new SeamHttpRequest(this, {
+      path: '/devices/unmanaged/list',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'devices',
     })
-
-    return data.devices
   }
 
-  async update(body?: DevicesUnmanagedUpdateBody): Promise<void> {
-    await this.client.request<DevicesUnmanagedUpdateResponse>({
-      url: '/devices/unmanaged/update',
+  update(body?: DevicesUnmanagedUpdateBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/devices/unmanaged/update',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 }

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

@@ -31,8 +31,10 @@ import {
   limitToSeamHttpRequestOptions,
   parseOptions,
 } from 'lib/seam/connect/parse-options.js'
+import { SeamHttpRequest } from 'lib/seam/connect/seam-http-request.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
+import { SeamHttpDevicesSimulate } from './devices-simulate.js'
 import { SeamHttpDevicesUnmanaged } from './devices-unmanaged.js'
 
 export class SeamHttpDevices {
@@ -158,54 +160,56 @@ export class SeamHttpDevices {
     return SeamHttpDevicesUnmanaged.fromClient(this.client, this.defaults)
   }
 
-  async delete(body?: DevicesDeleteBody): Promise<void> {
-    await this.client.request<DevicesDeleteResponse>({
-      url: '/devices/delete',
+  get simulate(): SeamHttpDevicesSimulate {
+    return SeamHttpDevicesSimulate.fromClient(this.client, this.defaults)
+  }
+
+  delete(body?: DevicesDeleteBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/devices/delete',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async get(body?: DevicesGetParams): Promise<DevicesGetResponse['device']> {
-    const { data } = await this.client.request<DevicesGetResponse>({
-      url: '/devices/get',
+  get(body?: DevicesGetParams): SeamHttpRequest<DevicesGetResponse, 'device'> {
+    return new SeamHttpRequest(this, {
+      path: '/devices/get',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'device',
     })
-
-    return data.device
   }
 
-  async list(
+  list(
     body?: DevicesListParams,
-  ): Promise<DevicesListResponse['devices']> {
-    const { data } = await this.client.request<DevicesListResponse>({
-      url: '/devices/list',
+  ): SeamHttpRequest<DevicesListResponse, 'devices'> {
+    return new SeamHttpRequest(this, {
+      path: '/devices/list',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'devices',
     })
-
-    return data.devices
   }
 
-  async listDeviceProviders(
+  listDeviceProviders(
     body?: DevicesListDeviceProvidersParams,
-  ): Promise<DevicesListDeviceProvidersResponse['device_providers']> {
-    const { data } =
-      await this.client.request<DevicesListDeviceProvidersResponse>({
-        url: '/devices/list_device_providers',
-        method: 'post',
-        data: body,
-      })
-
-    return data.device_providers
+  ): SeamHttpRequest<DevicesListDeviceProvidersResponse, 'device_providers'> {
+    return new SeamHttpRequest(this, {
+      path: '/devices/list_device_providers',
+      method: 'post',
+      body,
+      responseKey: 'device_providers',
+    })
   }
 
-  async update(body?: DevicesUpdateBody): Promise<void> {
-    await this.client.request<DevicesUpdateResponse>({
-      url: '/devices/update',
+  update(body?: DevicesUpdateBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/devices/update',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 }

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

@@ -31,6 +31,7 @@ import {
   limitToSeamHttpRequestOptions,
   parseOptions,
 } from 'lib/seam/connect/parse-options.js'
+import { SeamHttpRequest } from 'lib/seam/connect/seam-http-request.js'
 
 import { SeamHttpClientSessions } from './client-sessions.js'
 
@@ -153,24 +154,22 @@ export class SeamHttpEvents {
     await clientSessions.get()
   }
 
-  async get(body?: EventsGetParams): Promise<EventsGetResponse['event']> {
-    const { data } = await this.client.request<EventsGetResponse>({
-      url: '/events/get',
+  get(body?: EventsGetParams): SeamHttpRequest<EventsGetResponse, 'event'> {
+    return new SeamHttpRequest(this, {
+      path: '/events/get',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'event',
     })
-
-    return data.event
   }
 
-  async list(body?: EventsListParams): Promise<EventsListResponse['events']> {
-    const { data } = await this.client.request<EventsListResponse>({
-      url: '/events/list',
+  list(body?: EventsListParams): SeamHttpRequest<EventsListResponse, 'events'> {
+    return new SeamHttpRequest(this, {
+      path: '/events/list',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'events',
     })
-
-    return data.events
   }
 }
 

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

@@ -13,6 +13,7 @@ export * from './client-sessions.js'
 export * from './connect-webviews.js'
 export * from './connected-accounts.js'
 export * from './devices.js'
+export * from './devices-simulate.js'
 export * from './devices-unmanaged.js'
 export * from './events.js'
 export * from './locks.js'

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

@@ -31,9 +31,8 @@ import {
   limitToSeamHttpRequestOptions,
   parseOptions,
 } from 'lib/seam/connect/parse-options.js'
-import { resolveActionAttempt } from 'lib/seam/connect/resolve-action-attempt.js'
+import { SeamHttpRequest } from 'lib/seam/connect/seam-http-request.js'
 
-import { SeamHttpActionAttempts } from './action-attempts.js'
 import { SeamHttpClientSessions } from './client-sessions.js'
 
 export class SeamHttpLocks {
@@ -155,72 +154,48 @@ export class SeamHttpLocks {
     await clientSessions.get()
   }
 
-  async get(body?: LocksGetParams): Promise<LocksGetResponse['device']> {
-    const { data } = await this.client.request<LocksGetResponse>({
-      url: '/locks/get',
+  get(body?: LocksGetParams): SeamHttpRequest<LocksGetResponse, 'device'> {
+    return new SeamHttpRequest(this, {
+      path: '/locks/get',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'device',
     })
-
-    return data.device
   }
 
-  async list(body?: LocksListParams): Promise<LocksListResponse['devices']> {
-    const { data } = await this.client.request<LocksListResponse>({
-      url: '/locks/list',
+  list(body?: LocksListParams): SeamHttpRequest<LocksListResponse, 'devices'> {
+    return new SeamHttpRequest(this, {
+      path: '/locks/list',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'devices',
     })
-
-    return data.devices
   }
 
-  async lockDoor(
+  lockDoor(
     body?: LocksLockDoorBody,
     options: Pick<SeamHttpRequestOptions, 'waitForActionAttempt'> = {},
-  ): Promise<LocksLockDoorResponse['action_attempt']> {
-    const { data } = await this.client.request<LocksLockDoorResponse>({
-      url: '/locks/lock_door',
+  ): SeamHttpRequest<LocksLockDoorResponse, 'action_attempt'> {
+    return new SeamHttpRequest(this, {
+      path: '/locks/lock_door',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'action_attempt',
+      options,
     })
-    const waitForActionAttempt =
-      options.waitForActionAttempt ?? this.defaults.waitForActionAttempt
-    if (waitForActionAttempt !== false) {
-      return await resolveActionAttempt(
-        data.action_attempt,
-        SeamHttpActionAttempts.fromClient(this.client, {
-          ...this.defaults,
-          waitForActionAttempt: false,
-        }),
-        typeof waitForActionAttempt === 'boolean' ? {} : waitForActionAttempt,
-      )
-    }
-    return data.action_attempt
   }
 
-  async unlockDoor(
+  unlockDoor(
     body?: LocksUnlockDoorBody,
     options: Pick<SeamHttpRequestOptions, 'waitForActionAttempt'> = {},
-  ): Promise<LocksUnlockDoorResponse['action_attempt']> {
-    const { data } = await this.client.request<LocksUnlockDoorResponse>({
-      url: '/locks/unlock_door',
+  ): SeamHttpRequest<LocksUnlockDoorResponse, 'action_attempt'> {
+    return new SeamHttpRequest(this, {
+      path: '/locks/unlock_door',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'action_attempt',
+      options,
     })
-    const waitForActionAttempt =
-      options.waitForActionAttempt ?? this.defaults.waitForActionAttempt
-    if (waitForActionAttempt !== false) {
-      return await resolveActionAttempt(
-        data.action_attempt,
-        SeamHttpActionAttempts.fromClient(this.client, {
-          ...this.defaults,
-          waitForActionAttempt: false,
-        }),
-        typeof waitForActionAttempt === 'boolean' ? {} : waitForActionAttempt,
-      )
-    }
-    return data.action_attempt
   }
 }