@seamapi/http 0.24.0 → 0.25.1

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

@@ -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,11 +154,12 @@ export class SeamHttpDevicesSimulate {
     await clientSessions.get()
   }
 
-  async remove(body?: DevicesSimulateRemoveBody): Promise<void> {
-    await this.client.request<DevicesSimulateRemoveResponse>({
-      url: '/devices/simulate/remove',
+  remove(body?: DevicesSimulateRemoveBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/devices/simulate/remove',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 }

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,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'
 import { SeamHttpDevicesSimulate } from './devices-simulate.js'
@@ -163,54 +164,52 @@ export class SeamHttpDevices {
     return SeamHttpDevicesSimulate.fromClient(this.client, this.defaults)
   }
 
-  async delete(body?: DevicesDeleteBody): Promise<void> {
-    await this.client.request<DevicesDeleteResponse>({
-      url: '/devices/delete',
+  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/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
   }
 }
 

package/src/lib/seam/connect/routes/networks.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,26 +154,26 @@ export class SeamHttpNetworks {
     await clientSessions.get()
   }
 
-  async get(body?: NetworksGetParams): Promise<NetworksGetResponse['network']> {
-    const { data } = await this.client.request<NetworksGetResponse>({
-      url: '/networks/get',
+  get(
+    body?: NetworksGetParams,
+  ): SeamHttpRequest<NetworksGetResponse, 'network'> {
+    return new SeamHttpRequest(this, {
+      path: '/networks/get',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'network',
     })
-
-    return data.network
   }
 
-  async list(
+  list(
     body?: NetworksListParams,
-  ): Promise<NetworksListResponse['networks']> {
-    const { data } = await this.client.request<NetworksListResponse>({
-      url: '/networks/list',
+  ): SeamHttpRequest<NetworksListResponse, 'networks'> {
+    return new SeamHttpRequest(this, {
+      path: '/networks/list',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'networks',
     })
-
-    return data.networks
   }
 }