@seamapi/http 1.36.0 → 1.38.0

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

@@ -37,16 +37,22 @@ import { SeamHttpAccessGrants } from './access-grants/index.js'
 import { SeamHttpAccessMethods } from './access-methods/index.js'
 import { SeamHttpAcs } from './acs/index.js'
 import { SeamHttpActionAttempts } from './action-attempts/index.js'
+import { SeamHttpBridges } from './bridges/index.js'
 import { SeamHttpClientSessions } from './client-sessions/index.js'
 import { SeamHttpConnectWebviews } from './connect-webviews/index.js'
 import { SeamHttpConnectedAccounts } from './connected-accounts/index.js'
 import { SeamHttpDevices } from './devices/index.js'
 import { SeamHttpEvents } from './events/index.js'
 import { SeamHttpLocks } from './locks/index.js'
+import { SeamHttpNetworks } from './networks/index.js'
 import { SeamHttpNoiseSensors } from './noise-sensors/index.js'
 import { SeamHttpPhones } from './phones/index.js'
 import { SeamHttpSpaces } from './spaces/index.js'
 import { SeamHttpThermostats } from './thermostats/index.js'
+import { SeamHttpUnstableAccessGrants } from './unstable-access-grants/index.js'
+import { SeamHttpUnstableAccessMethods } from './unstable-access-methods/index.js'
+import { SeamHttpUnstableLocations } from './unstable-locations/index.js'
+import { SeamHttpUnstablePartner } from './unstable-partner/index.js'
 import { SeamHttpUserIdentities } from './user-identities/index.js'
 import { SeamHttpWebhooks } from './webhooks/index.js'
 import { SeamHttpWorkspaces } from './workspaces/index.js'
@@ -198,6 +204,10 @@ export class SeamHttp {
     return SeamHttpActionAttempts.fromClient(this.client, this.defaults)
   }
 
+  get bridges(): SeamHttpBridges {
+    return SeamHttpBridges.fromClient(this.client, this.defaults)
+  }
+
   get clientSessions(): SeamHttpClientSessions {
     return SeamHttpClientSessions.fromClient(this.client, this.defaults)
   }
@@ -222,6 +232,10 @@ export class SeamHttp {
     return SeamHttpLocks.fromClient(this.client, this.defaults)
   }
 
+  get networks(): SeamHttpNetworks {
+    return SeamHttpNetworks.fromClient(this.client, this.defaults)
+  }
+
   get noiseSensors(): SeamHttpNoiseSensors {
     return SeamHttpNoiseSensors.fromClient(this.client, this.defaults)
   }
@@ -238,6 +252,22 @@ export class SeamHttp {
     return SeamHttpThermostats.fromClient(this.client, this.defaults)
   }
 
+  get unstableAccessGrants(): SeamHttpUnstableAccessGrants {
+    return SeamHttpUnstableAccessGrants.fromClient(this.client, this.defaults)
+  }
+
+  get unstableAccessMethods(): SeamHttpUnstableAccessMethods {
+    return SeamHttpUnstableAccessMethods.fromClient(this.client, this.defaults)
+  }
+
+  get unstableLocations(): SeamHttpUnstableLocations {
+    return SeamHttpUnstableLocations.fromClient(this.client, this.defaults)
+  }
+
+  get unstablePartner(): SeamHttpUnstablePartner {
+    return SeamHttpUnstablePartner.fromClient(this.client, this.defaults)
+  }
+
   get userIdentities(): SeamHttpUserIdentities {
     return SeamHttpUserIdentities.fromClient(this.client, this.defaults)
   }

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

@@ -168,170 +168,284 @@ export class SeamHttpSpaces {
   }
 
   addAcsEntrances(
-    body?: SpacesAddAcsEntrancesBody,
-  ): SeamHttpRequest<void, undefined> {
+    parameters?: SpacesAddAcsEntrancesParameters,
+    options: SpacesAddAcsEntrancesOptions = {},
+  ): SpacesAddAcsEntrancesRequest {
     return new SeamHttpRequest(this, {
       pathname: '/spaces/add_acs_entrances',
       method: 'PUT',
-      body,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
-  addDevices(body?: SpacesAddDevicesBody): SeamHttpRequest<void, undefined> {
+  addDevices(
+    parameters?: SpacesAddDevicesParameters,
+    options: SpacesAddDevicesOptions = {},
+  ): SpacesAddDevicesRequest {
     return new SeamHttpRequest(this, {
       pathname: '/spaces/add_devices',
       method: 'PUT',
-      body,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
   create(
-    body?: SpacesCreateBody,
-  ): SeamHttpRequest<SpacesCreateResponse, 'space'> {
+    parameters?: SpacesCreateParameters,
+    options: SpacesCreateOptions = {},
+  ): SpacesCreateRequest {
     return new SeamHttpRequest(this, {
       pathname: '/spaces/create',
       method: 'POST',
-      body,
+      body: parameters,
       responseKey: 'space',
+      options,
     })
   }
 
-  delete(params?: SpacesDeleteParams): SeamHttpRequest<void, undefined> {
+  delete(
+    parameters?: SpacesDeleteParameters,
+    options: SpacesDeleteOptions = {},
+  ): SpacesDeleteRequest {
     return new SeamHttpRequest(this, {
       pathname: '/spaces/delete',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
-  get(params?: SpacesGetParams): SeamHttpRequest<SpacesGetResponse, 'space'> {
+  get(
+    parameters?: SpacesGetParameters,
+    options: SpacesGetOptions = {},
+  ): SpacesGetRequest {
     return new SeamHttpRequest(this, {
       pathname: '/spaces/get',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'space',
+      options,
     })
   }
 
   list(
-    params?: SpacesListParams,
-  ): SeamHttpRequest<SpacesListResponse, 'spaces'> {
+    parameters?: SpacesListParameters,
+    options: SpacesListOptions = {},
+  ): SpacesListRequest {
     return new SeamHttpRequest(this, {
       pathname: '/spaces/list',
       method: 'GET',
-      params,
+      params: parameters,
       responseKey: 'spaces',
+      options,
     })
   }
 
   removeAcsEntrances(
-    params?: SpacesRemoveAcsEntrancesParams,
-  ): SeamHttpRequest<void, undefined> {
+    parameters?: SpacesRemoveAcsEntrancesParameters,
+    options: SpacesRemoveAcsEntrancesOptions = {},
+  ): SpacesRemoveAcsEntrancesRequest {
     return new SeamHttpRequest(this, {
       pathname: '/spaces/remove_acs_entrances',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
   removeDevices(
-    params?: SpacesRemoveDevicesParams,
-  ): SeamHttpRequest<void, undefined> {
+    parameters?: SpacesRemoveDevicesParameters,
+    options: SpacesRemoveDevicesOptions = {},
+  ): SpacesRemoveDevicesRequest {
     return new SeamHttpRequest(this, {
       pathname: '/spaces/remove_devices',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
   update(
-    body?: SpacesUpdateBody,
-  ): SeamHttpRequest<SpacesUpdateResponse, 'space'> {
+    parameters?: SpacesUpdateParameters,
+    options: SpacesUpdateOptions = {},
+  ): SpacesUpdateRequest {
     return new SeamHttpRequest(this, {
       pathname: '/spaces/update',
       method: 'PATCH',
-      body,
+      body: parameters,
       responseKey: 'space',
+      options,
     })
   }
 }
 
-export type SpacesAddAcsEntrancesBody =
+export type SpacesAddAcsEntrancesParameters =
   RouteRequestBody<'/spaces/add_acs_entrances'>
 
+/**
+ * @deprecated Use SpacesAddAcsEntrancesParameters instead.
+ */
+export type SpacesAddAcsEntrancesBody = SpacesAddAcsEntrancesParameters
+
+/**
+ * @deprecated Use SpacesAddAcsEntrancesRequest instead.
+ */
 export type SpacesAddAcsEntrancesResponse = SetNonNullable<
   Required<RouteResponse<'/spaces/add_acs_entrances'>>
 >
 
-export type SpacesAddAcsEntrancesOptions = never
+export type SpacesAddAcsEntrancesRequest = SeamHttpRequest<void, undefined>
 
-export type SpacesAddDevicesBody = RouteRequestBody<'/spaces/add_devices'>
+export type SpacesAddAcsEntrancesOptions = Record<string, never>
 
+export type SpacesAddDevicesParameters = RouteRequestBody<'/spaces/add_devices'>
+
+/**
+ * @deprecated Use SpacesAddDevicesParameters instead.
+ */
+export type SpacesAddDevicesBody = SpacesAddDevicesParameters
+
+/**
+ * @deprecated Use SpacesAddDevicesRequest instead.
+ */
 export type SpacesAddDevicesResponse = SetNonNullable<
   Required<RouteResponse<'/spaces/add_devices'>>
 >
 
-export type SpacesAddDevicesOptions = never
+export type SpacesAddDevicesRequest = SeamHttpRequest<void, undefined>
+
+export type SpacesAddDevicesOptions = Record<string, never>
+
+export type SpacesCreateParameters = RouteRequestBody<'/spaces/create'>
 
-export type SpacesCreateBody = RouteRequestBody<'/spaces/create'>
+/**
+ * @deprecated Use SpacesCreateParameters instead.
+ */
+export type SpacesCreateBody = SpacesCreateParameters
 
+/**
+ * @deprecated Use SpacesCreateRequest instead.
+ */
 export type SpacesCreateResponse = SetNonNullable<
   Required<RouteResponse<'/spaces/create'>>
 >
 
-export type SpacesCreateOptions = never
+export type SpacesCreateRequest = SeamHttpRequest<SpacesCreateResponse, 'space'>
+
+export type SpacesCreateOptions = Record<string, never>
 
-export type SpacesDeleteParams = RouteRequestBody<'/spaces/delete'>
+export type SpacesDeleteParameters = RouteRequestBody<'/spaces/delete'>
+
+/**
+ * @deprecated Use SpacesDeleteParameters instead.
+ */
+export type SpacesDeleteParams = SpacesDeleteParameters
 
+/**
+ * @deprecated Use SpacesDeleteRequest instead.
+ */
 export type SpacesDeleteResponse = SetNonNullable<
   Required<RouteResponse<'/spaces/delete'>>
 >
 
-export type SpacesDeleteOptions = never
+export type SpacesDeleteRequest = SeamHttpRequest<void, undefined>
+
+export type SpacesDeleteOptions = Record<string, never>
 
-export type SpacesGetParams = RouteRequestBody<'/spaces/get'>
+export type SpacesGetParameters = RouteRequestBody<'/spaces/get'>
+
+/**
+ * @deprecated Use SpacesGetParameters instead.
+ */
+export type SpacesGetParams = SpacesGetParameters
 
+/**
+ * @deprecated Use SpacesGetRequest instead.
+ */
 export type SpacesGetResponse = SetNonNullable<
   Required<RouteResponse<'/spaces/get'>>
 >
 
-export type SpacesGetOptions = never
+export type SpacesGetRequest = SeamHttpRequest<SpacesGetResponse, 'space'>
+
+export type SpacesGetOptions = Record<string, never>
 
-export type SpacesListParams = RouteRequestParams<'/spaces/list'>
+export type SpacesListParameters = RouteRequestParams<'/spaces/list'>
 
+/**
+ * @deprecated Use SpacesListParameters instead.
+ */
+export type SpacesListParams = SpacesListParameters
+
+/**
+ * @deprecated Use SpacesListRequest instead.
+ */
 export type SpacesListResponse = SetNonNullable<
   Required<RouteResponse<'/spaces/list'>>
 >
 
-export type SpacesListOptions = never
+export type SpacesListRequest = SeamHttpRequest<SpacesListResponse, 'spaces'>
 
-export type SpacesRemoveAcsEntrancesParams =
+export type SpacesListOptions = Record<string, never>
+
+export type SpacesRemoveAcsEntrancesParameters =
   RouteRequestBody<'/spaces/remove_acs_entrances'>
 
+/**
+ * @deprecated Use SpacesRemoveAcsEntrancesParameters instead.
+ */
+export type SpacesRemoveAcsEntrancesParams = SpacesRemoveAcsEntrancesParameters
+
+/**
+ * @deprecated Use SpacesRemoveAcsEntrancesRequest instead.
+ */
 export type SpacesRemoveAcsEntrancesResponse = SetNonNullable<
   Required<RouteResponse<'/spaces/remove_acs_entrances'>>
 >
 
-export type SpacesRemoveAcsEntrancesOptions = never
+export type SpacesRemoveAcsEntrancesRequest = SeamHttpRequest<void, undefined>
 
-export type SpacesRemoveDevicesParams =
+export type SpacesRemoveAcsEntrancesOptions = Record<string, never>
+
+export type SpacesRemoveDevicesParameters =
   RouteRequestBody<'/spaces/remove_devices'>
 
+/**
+ * @deprecated Use SpacesRemoveDevicesParameters instead.
+ */
+export type SpacesRemoveDevicesParams = SpacesRemoveDevicesParameters
+
+/**
+ * @deprecated Use SpacesRemoveDevicesRequest instead.
+ */
 export type SpacesRemoveDevicesResponse = SetNonNullable<
   Required<RouteResponse<'/spaces/remove_devices'>>
 >
 
-export type SpacesRemoveDevicesOptions = never
+export type SpacesRemoveDevicesRequest = SeamHttpRequest<void, undefined>
+
+export type SpacesRemoveDevicesOptions = Record<string, never>
 
-export type SpacesUpdateBody = RouteRequestBody<'/spaces/update'>
+export type SpacesUpdateParameters = RouteRequestBody<'/spaces/update'>
 
+/**
+ * @deprecated Use SpacesUpdateParameters instead.
+ */
+export type SpacesUpdateBody = SpacesUpdateParameters
+
+/**
+ * @deprecated Use SpacesUpdateRequest instead.
+ */
 export type SpacesUpdateResponse = SetNonNullable<
   Required<RouteResponse<'/spaces/update'>>
 >
 
-export type SpacesUpdateOptions = never
+export type SpacesUpdateRequest = SeamHttpRequest<SpacesUpdateResponse, 'space'>
+
+export type SpacesUpdateOptions = Record<string, never>

package/src/lib/seam/connect/routes/thermostats/daily-programs/daily-programs.ts

@@ -167,69 +167,112 @@ export class SeamHttpThermostatsDailyPrograms {
   }
 
   create(
-    body?: ThermostatsDailyProgramsCreateBody,
-  ): SeamHttpRequest<
-    ThermostatsDailyProgramsCreateResponse,
-    'thermostat_daily_program'
-  > {
+    parameters?: ThermostatsDailyProgramsCreateParameters,
+    options: ThermostatsDailyProgramsCreateOptions = {},
+  ): ThermostatsDailyProgramsCreateRequest {
     return new SeamHttpRequest(this, {
       pathname: '/thermostats/daily_programs/create',
       method: 'POST',
-      body,
+      body: parameters,
       responseKey: 'thermostat_daily_program',
+      options,
     })
   }
 
   delete(
-    params?: ThermostatsDailyProgramsDeleteParams,
-  ): SeamHttpRequest<void, undefined> {
+    parameters?: ThermostatsDailyProgramsDeleteParameters,
+    options: ThermostatsDailyProgramsDeleteOptions = {},
+  ): ThermostatsDailyProgramsDeleteRequest {
     return new SeamHttpRequest(this, {
       pathname: '/thermostats/daily_programs/delete',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
   update(
-    body?: ThermostatsDailyProgramsUpdateBody,
+    parameters?: ThermostatsDailyProgramsUpdateParameters,
     options: ThermostatsDailyProgramsUpdateOptions = {},
-  ): SeamHttpRequest<ThermostatsDailyProgramsUpdateResponse, 'action_attempt'> {
+  ): ThermostatsDailyProgramsUpdateRequest {
     return new SeamHttpRequest(this, {
       pathname: '/thermostats/daily_programs/update',
       method: 'PATCH',
-      body,
+      body: parameters,
       responseKey: 'action_attempt',
       options,
     })
   }
 }
 
-export type ThermostatsDailyProgramsCreateBody =
+export type ThermostatsDailyProgramsCreateParameters =
   RouteRequestBody<'/thermostats/daily_programs/create'>
 
+/**
+ * @deprecated Use ThermostatsDailyProgramsCreateParameters instead.
+ */
+export type ThermostatsDailyProgramsCreateBody =
+  ThermostatsDailyProgramsCreateParameters
+
+/**
+ * @deprecated Use ThermostatsDailyProgramsCreateRequest instead.
+ */
 export type ThermostatsDailyProgramsCreateResponse = SetNonNullable<
   Required<RouteResponse<'/thermostats/daily_programs/create'>>
 >
 
-export type ThermostatsDailyProgramsCreateOptions = never
+export type ThermostatsDailyProgramsCreateRequest = SeamHttpRequest<
+  ThermostatsDailyProgramsCreateResponse,
+  'thermostat_daily_program'
+>
 
-export type ThermostatsDailyProgramsDeleteParams =
+export type ThermostatsDailyProgramsCreateOptions = Record<string, never>
+
+export type ThermostatsDailyProgramsDeleteParameters =
   RouteRequestBody<'/thermostats/daily_programs/delete'>
 
+/**
+ * @deprecated Use ThermostatsDailyProgramsDeleteParameters instead.
+ */
+export type ThermostatsDailyProgramsDeleteParams =
+  ThermostatsDailyProgramsDeleteParameters
+
+/**
+ * @deprecated Use ThermostatsDailyProgramsDeleteRequest instead.
+ */
 export type ThermostatsDailyProgramsDeleteResponse = SetNonNullable<
   Required<RouteResponse<'/thermostats/daily_programs/delete'>>
 >
 
-export type ThermostatsDailyProgramsDeleteOptions = never
+export type ThermostatsDailyProgramsDeleteRequest = SeamHttpRequest<
+  void,
+  undefined
+>
+
+export type ThermostatsDailyProgramsDeleteOptions = Record<string, never>
 
-export type ThermostatsDailyProgramsUpdateBody =
+export type ThermostatsDailyProgramsUpdateParameters =
   RouteRequestBody<'/thermostats/daily_programs/update'>
 
+/**
+ * @deprecated Use ThermostatsDailyProgramsUpdateParameters instead.
+ */
+export type ThermostatsDailyProgramsUpdateBody =
+  ThermostatsDailyProgramsUpdateParameters
+
+/**
+ * @deprecated Use ThermostatsDailyProgramsUpdateRequest instead.
+ */
 export type ThermostatsDailyProgramsUpdateResponse = SetNonNullable<
   Required<RouteResponse<'/thermostats/daily_programs/update'>>
 >
 
+export type ThermostatsDailyProgramsUpdateRequest = SeamHttpRequest<
+  ThermostatsDailyProgramsUpdateResponse,
+  'action_attempt'
+>
+
 export type ThermostatsDailyProgramsUpdateOptions = Pick<
   SeamHttpRequestOptions,
   'waitForActionAttempt'