@seamapi/http 1.37.0 → 1.38.1

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

@@ -174,7 +174,10 @@ export class SeamHttpDevices {
     return SeamHttpDevicesUnmanaged.fromClient(this.client, this.defaults)
   }
 
-  delete(params?: DevicesDeleteParams): SeamHttpRequest<void, undefined> {
+  delete(
+    parameters?: DevicesDeleteParameters,
+    options: DevicesDeleteOptions = {},
+  ): DevicesDeleteRequest {
     if (!this.defaults.isUndocumentedApiEnabled) {
       throw new Error(
         'Cannot use undocumented API without isUndocumentedApiEnabled',
@@ -183,91 +186,156 @@ export class SeamHttpDevices {
     return new SeamHttpRequest(this, {
       pathname: '/devices/delete',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
   get(
-    params?: DevicesGetParams,
-  ): SeamHttpRequest<DevicesGetResponse, 'device'> {
+    parameters?: DevicesGetParameters,
+    options: DevicesGetOptions = {},
+  ): DevicesGetRequest {
     return new SeamHttpRequest(this, {
       pathname: '/devices/get',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'device',
+      options,
     })
   }
 
   list(
-    params?: DevicesListParams,
-  ): SeamHttpRequest<DevicesListResponse, 'devices'> {
+    parameters?: DevicesListParameters,
+    options: DevicesListOptions = {},
+  ): DevicesListRequest {
     return new SeamHttpRequest(this, {
       pathname: '/devices/list',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'devices',
+      options,
     })
   }
 
   listDeviceProviders(
-    params?: DevicesListDeviceProvidersParams,
-  ): SeamHttpRequest<DevicesListDeviceProvidersResponse, 'device_providers'> {
+    parameters?: DevicesListDeviceProvidersParameters,
+    options: DevicesListDeviceProvidersOptions = {},
+  ): DevicesListDeviceProvidersRequest {
     return new SeamHttpRequest(this, {
       pathname: '/devices/list_device_providers',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'device_providers',
+      options,
     })
   }
 
-  update(body?: DevicesUpdateBody): SeamHttpRequest<void, undefined> {
+  update(
+    parameters?: DevicesUpdateParameters,
+    options: DevicesUpdateOptions = {},
+  ): DevicesUpdateRequest {
     return new SeamHttpRequest(this, {
       pathname: '/devices/update',
       method: 'PATCH',
-      body,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 }
 
-export type DevicesDeleteParams = RouteRequestBody<'/devices/delete'>
+export type DevicesDeleteParameters = RouteRequestBody<'/devices/delete'>
 
+/**
+ * @deprecated Use DevicesDeleteParameters instead.
+ */
+export type DevicesDeleteParams = DevicesDeleteParameters
+
+/**
+ * @deprecated Use DevicesDeleteRequest instead.
+ */
 export type DevicesDeleteResponse = SetNonNullable<
   Required<RouteResponse<'/devices/delete'>>
 >
 
-export type DevicesDeleteOptions = never
+export type DevicesDeleteRequest = SeamHttpRequest<void, undefined>
 
-export type DevicesGetParams = RouteRequestBody<'/devices/get'>
+export type DevicesDeleteOptions = Record<string, never>
+
+export type DevicesGetParameters = RouteRequestBody<'/devices/get'>
+
+/**
+ * @deprecated Use DevicesGetParameters instead.
+ */
+export type DevicesGetParams = DevicesGetParameters
 
+/**
+ * @deprecated Use DevicesGetRequest instead.
+ */
 export type DevicesGetResponse = SetNonNullable<
   Required<RouteResponse<'/devices/get'>>
 >
 
-export type DevicesGetOptions = never
+export type DevicesGetRequest = SeamHttpRequest<DevicesGetResponse, 'device'>
+
+export type DevicesGetOptions = Record<string, never>
+
+export type DevicesListParameters = RouteRequestBody<'/devices/list'>
 
-export type DevicesListParams = RouteRequestBody<'/devices/list'>
+/**
+ * @deprecated Use DevicesListParameters instead.
+ */
+export type DevicesListParams = DevicesListParameters
 
+/**
+ * @deprecated Use DevicesListRequest instead.
+ */
 export type DevicesListResponse = SetNonNullable<
   Required<RouteResponse<'/devices/list'>>
 >
 
-export type DevicesListOptions = never
+export type DevicesListRequest = SeamHttpRequest<DevicesListResponse, 'devices'>
 
-export type DevicesListDeviceProvidersParams =
+export type DevicesListOptions = Record<string, never>
+
+export type DevicesListDeviceProvidersParameters =
   RouteRequestBody<'/devices/list_device_providers'>
 
+/**
+ * @deprecated Use DevicesListDeviceProvidersParameters instead.
+ */
+export type DevicesListDeviceProvidersParams =
+  DevicesListDeviceProvidersParameters
+
+/**
+ * @deprecated Use DevicesListDeviceProvidersRequest instead.
+ */
 export type DevicesListDeviceProvidersResponse = SetNonNullable<
   Required<RouteResponse<'/devices/list_device_providers'>>
 >
 
-export type DevicesListDeviceProvidersOptions = never
+export type DevicesListDeviceProvidersRequest = SeamHttpRequest<
+  DevicesListDeviceProvidersResponse,
+  'device_providers'
+>
 
-export type DevicesUpdateBody = RouteRequestBody<'/devices/update'>
+export type DevicesListDeviceProvidersOptions = Record<string, never>
 
+export type DevicesUpdateParameters = RouteRequestBody<'/devices/update'>
+
+/**
+ * @deprecated Use DevicesUpdateParameters instead.
+ */
+export type DevicesUpdateBody = DevicesUpdateParameters
+
+/**
+ * @deprecated Use DevicesUpdateRequest instead.
+ */
 export type DevicesUpdateResponse = SetNonNullable<
   Required<RouteResponse<'/devices/update'>>
 >
 
-export type DevicesUpdateOptions = never
+export type DevicesUpdateRequest = SeamHttpRequest<void, undefined>
+
+export type DevicesUpdateOptions = Record<string, never>

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

@@ -163,61 +163,99 @@ export class SeamHttpDevicesSimulate {
     await clientSessions.get()
   }
 
-  connect(body?: DevicesSimulateConnectBody): SeamHttpRequest<void, undefined> {
+  connect(
+    parameters?: DevicesSimulateConnectParameters,
+    options: DevicesSimulateConnectOptions = {},
+  ): DevicesSimulateConnectRequest {
     return new SeamHttpRequest(this, {
       pathname: '/devices/simulate/connect',
       method: 'POST',
-      body,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
   disconnect(
-    body?: DevicesSimulateDisconnectBody,
-  ): SeamHttpRequest<void, undefined> {
+    parameters?: DevicesSimulateDisconnectParameters,
+    options: DevicesSimulateDisconnectOptions = {},
+  ): DevicesSimulateDisconnectRequest {
     return new SeamHttpRequest(this, {
       pathname: '/devices/simulate/disconnect',
       method: 'POST',
-      body,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
   remove(
-    params?: DevicesSimulateRemoveParams,
-  ): SeamHttpRequest<void, undefined> {
+    parameters?: DevicesSimulateRemoveParameters,
+    options: DevicesSimulateRemoveOptions = {},
+  ): DevicesSimulateRemoveRequest {
     return new SeamHttpRequest(this, {
       pathname: '/devices/simulate/remove',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 }
 
-export type DevicesSimulateConnectBody =
+export type DevicesSimulateConnectParameters =
   RouteRequestBody<'/devices/simulate/connect'>
 
+/**
+ * @deprecated Use DevicesSimulateConnectParameters instead.
+ */
+export type DevicesSimulateConnectBody = DevicesSimulateConnectParameters
+
+/**
+ * @deprecated Use DevicesSimulateConnectRequest instead.
+ */
 export type DevicesSimulateConnectResponse = SetNonNullable<
   Required<RouteResponse<'/devices/simulate/connect'>>
 >
 
-export type DevicesSimulateConnectOptions = never
+export type DevicesSimulateConnectRequest = SeamHttpRequest<void, undefined>
 
-export type DevicesSimulateDisconnectBody =
+export type DevicesSimulateConnectOptions = Record<string, never>
+
+export type DevicesSimulateDisconnectParameters =
   RouteRequestBody<'/devices/simulate/disconnect'>
 
+/**
+ * @deprecated Use DevicesSimulateDisconnectParameters instead.
+ */
+export type DevicesSimulateDisconnectBody = DevicesSimulateDisconnectParameters
+
+/**
+ * @deprecated Use DevicesSimulateDisconnectRequest instead.
+ */
 export type DevicesSimulateDisconnectResponse = SetNonNullable<
   Required<RouteResponse<'/devices/simulate/disconnect'>>
 >
 
-export type DevicesSimulateDisconnectOptions = never
+export type DevicesSimulateDisconnectRequest = SeamHttpRequest<void, undefined>
+
+export type DevicesSimulateDisconnectOptions = Record<string, never>
 
-export type DevicesSimulateRemoveParams =
+export type DevicesSimulateRemoveParameters =
   RouteRequestBody<'/devices/simulate/remove'>
 
+/**
+ * @deprecated Use DevicesSimulateRemoveParameters instead.
+ */
+export type DevicesSimulateRemoveParams = DevicesSimulateRemoveParameters
+
+/**
+ * @deprecated Use DevicesSimulateRemoveRequest instead.
+ */
 export type DevicesSimulateRemoveResponse = SetNonNullable<
   Required<RouteResponse<'/devices/simulate/remove'>>
 >
 
-export type DevicesSimulateRemoveOptions = never
+export type DevicesSimulateRemoveRequest = SeamHttpRequest<void, undefined>
+
+export type DevicesSimulateRemoveOptions = Record<string, never>

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

@@ -164,60 +164,104 @@ export class SeamHttpDevicesUnmanaged {
   }
 
   get(
-    params?: DevicesUnmanagedGetParams,
-  ): SeamHttpRequest<DevicesUnmanagedGetResponse, 'device'> {
+    parameters?: DevicesUnmanagedGetParameters,
+    options: DevicesUnmanagedGetOptions = {},
+  ): DevicesUnmanagedGetRequest {
     return new SeamHttpRequest(this, {
       pathname: '/devices/unmanaged/get',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'device',
+      options,
     })
   }
 
   list(
-    params?: DevicesUnmanagedListParams,
-  ): SeamHttpRequest<DevicesUnmanagedListResponse, 'devices'> {
+    parameters?: DevicesUnmanagedListParameters,
+    options: DevicesUnmanagedListOptions = {},
+  ): DevicesUnmanagedListRequest {
     return new SeamHttpRequest(this, {
       pathname: '/devices/unmanaged/list',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'devices',
+      options,
     })
   }
 
-  update(body?: DevicesUnmanagedUpdateBody): SeamHttpRequest<void, undefined> {
+  update(
+    parameters?: DevicesUnmanagedUpdateParameters,
+    options: DevicesUnmanagedUpdateOptions = {},
+  ): DevicesUnmanagedUpdateRequest {
     return new SeamHttpRequest(this, {
       pathname: '/devices/unmanaged/update',
       method: 'PATCH',
-      body,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 }
 
-export type DevicesUnmanagedGetParams =
+export type DevicesUnmanagedGetParameters =
   RouteRequestBody<'/devices/unmanaged/get'>
 
+/**
+ * @deprecated Use DevicesUnmanagedGetParameters instead.
+ */
+export type DevicesUnmanagedGetParams = DevicesUnmanagedGetParameters
+
+/**
+ * @deprecated Use DevicesUnmanagedGetRequest instead.
+ */
 export type DevicesUnmanagedGetResponse = SetNonNullable<
   Required<RouteResponse<'/devices/unmanaged/get'>>
 >
 
-export type DevicesUnmanagedGetOptions = never
+export type DevicesUnmanagedGetRequest = SeamHttpRequest<
+  DevicesUnmanagedGetResponse,
+  'device'
+>
 
-export type DevicesUnmanagedListParams =
+export type DevicesUnmanagedGetOptions = Record<string, never>
+
+export type DevicesUnmanagedListParameters =
   RouteRequestBody<'/devices/unmanaged/list'>
 
+/**
+ * @deprecated Use DevicesUnmanagedListParameters instead.
+ */
+export type DevicesUnmanagedListParams = DevicesUnmanagedListParameters
+
+/**
+ * @deprecated Use DevicesUnmanagedListRequest instead.
+ */
 export type DevicesUnmanagedListResponse = SetNonNullable<
   Required<RouteResponse<'/devices/unmanaged/list'>>
 >
 
-export type DevicesUnmanagedListOptions = never
+export type DevicesUnmanagedListRequest = SeamHttpRequest<
+  DevicesUnmanagedListResponse,
+  'devices'
+>
+
+export type DevicesUnmanagedListOptions = Record<string, never>
 
-export type DevicesUnmanagedUpdateBody =
+export type DevicesUnmanagedUpdateParameters =
   RouteRequestBody<'/devices/unmanaged/update'>
 
+/**
+ * @deprecated Use DevicesUnmanagedUpdateParameters instead.
+ */
+export type DevicesUnmanagedUpdateBody = DevicesUnmanagedUpdateParameters
+
+/**
+ * @deprecated Use DevicesUnmanagedUpdateRequest instead.
+ */
 export type DevicesUnmanagedUpdateResponse = SetNonNullable<
   Required<RouteResponse<'/devices/unmanaged/update'>>
 >
 
-export type DevicesUnmanagedUpdateOptions = never
+export type DevicesUnmanagedUpdateRequest = SeamHttpRequest<void, undefined>
+
+export type DevicesUnmanagedUpdateOptions = Record<string, never>

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

@@ -163,39 +163,65 @@ export class SeamHttpEvents {
     await clientSessions.get()
   }
 
-  get(params?: EventsGetParams): SeamHttpRequest<EventsGetResponse, 'event'> {
+  get(
+    parameters?: EventsGetParameters,
+    options: EventsGetOptions = {},
+  ): EventsGetRequest {
     return new SeamHttpRequest(this, {
       pathname: '/events/get',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'event',
+      options,
     })
   }
 
   list(
-    params?: EventsListParams,
-  ): SeamHttpRequest<EventsListResponse, 'events'> {
+    parameters?: EventsListParameters,
+    options: EventsListOptions = {},
+  ): EventsListRequest {
     return new SeamHttpRequest(this, {
       pathname: '/events/list',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'events',
+      options,
     })
   }
 }
 
-export type EventsGetParams = RouteRequestBody<'/events/get'>
+export type EventsGetParameters = RouteRequestBody<'/events/get'>
 
+/**
+ * @deprecated Use EventsGetParameters instead.
+ */
+export type EventsGetParams = EventsGetParameters
+
+/**
+ * @deprecated Use EventsGetRequest instead.
+ */
 export type EventsGetResponse = SetNonNullable<
   Required<RouteResponse<'/events/get'>>
 >
 
-export type EventsGetOptions = never
+export type EventsGetRequest = SeamHttpRequest<EventsGetResponse, 'event'>
+
+export type EventsGetOptions = Record<string, never>
 
-export type EventsListParams = RouteRequestBody<'/events/list'>
+export type EventsListParameters = RouteRequestBody<'/events/list'>
 
+/**
+ * @deprecated Use EventsListParameters instead.
+ */
+export type EventsListParams = EventsListParameters
+
+/**
+ * @deprecated Use EventsListRequest instead.
+ */
 export type EventsListResponse = SetNonNullable<
   Required<RouteResponse<'/events/list'>>
 >
 
-export type EventsListOptions = never
+export type EventsListRequest = SeamHttpRequest<EventsListResponse, 'events'>
+
+export type EventsListOptions = Record<string, never>

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

@@ -169,86 +169,138 @@ export class SeamHttpLocks {
     return SeamHttpLocksSimulate.fromClient(this.client, this.defaults)
   }
 
-  get(params?: LocksGetParams): SeamHttpRequest<LocksGetResponse, 'device'> {
+  get(
+    parameters?: LocksGetParameters,
+    options: LocksGetOptions = {},
+  ): LocksGetRequest {
     return new SeamHttpRequest(this, {
       pathname: '/locks/get',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'device',
+      options,
     })
   }
 
   list(
-    params?: LocksListParams,
-  ): SeamHttpRequest<LocksListResponse, 'devices'> {
+    parameters?: LocksListParameters,
+    options: LocksListOptions = {},
+  ): LocksListRequest {
     return new SeamHttpRequest(this, {
       pathname: '/locks/list',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'devices',
+      options,
     })
   }
 
   lockDoor(
-    body?: LocksLockDoorBody,
+    parameters?: LocksLockDoorParameters,
     options: LocksLockDoorOptions = {},
-  ): SeamHttpRequest<LocksLockDoorResponse, 'action_attempt'> {
+  ): LocksLockDoorRequest {
     return new SeamHttpRequest(this, {
       pathname: '/locks/lock_door',
       method: 'POST',
-      body,
+      body: parameters,
       responseKey: 'action_attempt',
       options,
     })
   }
 
   unlockDoor(
-    body?: LocksUnlockDoorBody,
+    parameters?: LocksUnlockDoorParameters,
     options: LocksUnlockDoorOptions = {},
-  ): SeamHttpRequest<LocksUnlockDoorResponse, 'action_attempt'> {
+  ): LocksUnlockDoorRequest {
     return new SeamHttpRequest(this, {
       pathname: '/locks/unlock_door',
       method: 'POST',
-      body,
+      body: parameters,
       responseKey: 'action_attempt',
       options,
     })
   }
 }
 
-export type LocksGetParams = RouteRequestBody<'/locks/get'>
+export type LocksGetParameters = RouteRequestBody<'/locks/get'>
 
+/**
+ * @deprecated Use LocksGetParameters instead.
+ */
+export type LocksGetParams = LocksGetParameters
+
+/**
+ * @deprecated Use LocksGetRequest instead.
+ */
 export type LocksGetResponse = SetNonNullable<
   Required<RouteResponse<'/locks/get'>>
 >
 
-export type LocksGetOptions = never
+export type LocksGetRequest = SeamHttpRequest<LocksGetResponse, 'device'>
 
-export type LocksListParams = RouteRequestBody<'/locks/list'>
+export type LocksGetOptions = Record<string, never>
 
+export type LocksListParameters = RouteRequestBody<'/locks/list'>
+
+/**
+ * @deprecated Use LocksListParameters instead.
+ */
+export type LocksListParams = LocksListParameters
+
+/**
+ * @deprecated Use LocksListRequest instead.
+ */
 export type LocksListResponse = SetNonNullable<
   Required<RouteResponse<'/locks/list'>>
 >
 
-export type LocksListOptions = never
+export type LocksListRequest = SeamHttpRequest<LocksListResponse, 'devices'>
+
+export type LocksListOptions = Record<string, never>
 
-export type LocksLockDoorBody = RouteRequestBody<'/locks/lock_door'>
+export type LocksLockDoorParameters = RouteRequestBody<'/locks/lock_door'>
 
+/**
+ * @deprecated Use LocksLockDoorParameters instead.
+ */
+export type LocksLockDoorBody = LocksLockDoorParameters
+
+/**
+ * @deprecated Use LocksLockDoorRequest instead.
+ */
 export type LocksLockDoorResponse = SetNonNullable<
   Required<RouteResponse<'/locks/lock_door'>>
 >
 
+export type LocksLockDoorRequest = SeamHttpRequest<
+  LocksLockDoorResponse,
+  'action_attempt'
+>
+
 export type LocksLockDoorOptions = Pick<
   SeamHttpRequestOptions,
   'waitForActionAttempt'
 >
 
-export type LocksUnlockDoorBody = RouteRequestBody<'/locks/unlock_door'>
+export type LocksUnlockDoorParameters = RouteRequestBody<'/locks/unlock_door'>
 
+/**
+ * @deprecated Use LocksUnlockDoorParameters instead.
+ */
+export type LocksUnlockDoorBody = LocksUnlockDoorParameters
+
+/**
+ * @deprecated Use LocksUnlockDoorRequest instead.
+ */
 export type LocksUnlockDoorResponse = SetNonNullable<
   Required<RouteResponse<'/locks/unlock_door'>>
 >
 
+export type LocksUnlockDoorRequest = SeamHttpRequest<
+  LocksUnlockDoorResponse,
+  'action_attempt'
+>
+
 export type LocksUnlockDoorOptions = Pick<
   SeamHttpRequestOptions,
   'waitForActionAttempt'