@seamapi/http 1.36.0 → 1.38.0

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

@@ -168,98 +168,168 @@ export class SeamHttpConnectedAccounts {
   }
 
   delete(
-    params?: ConnectedAccountsDeleteParams,
-  ): SeamHttpRequest<void, undefined> {
+    parameters?: ConnectedAccountsDeleteParameters,
+    options: ConnectedAccountsDeleteOptions = {},
+  ): ConnectedAccountsDeleteRequest {
     return new SeamHttpRequest(this, {
       pathname: '/connected_accounts/delete',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
   get(
-    params?: ConnectedAccountsGetParams,
-  ): SeamHttpRequest<ConnectedAccountsGetResponse, 'connected_account'> {
+    parameters?: ConnectedAccountsGetParameters,
+    options: ConnectedAccountsGetOptions = {},
+  ): ConnectedAccountsGetRequest {
     return new SeamHttpRequest(this, {
       pathname: '/connected_accounts/get',
       method: 'GET',
-      params,
+      params: parameters,
       responseKey: 'connected_account',
+      options,
     })
   }
 
   list(
-    params?: ConnectedAccountsListParams,
-  ): SeamHttpRequest<ConnectedAccountsListResponse, 'connected_accounts'> {
+    parameters?: ConnectedAccountsListParameters,
+    options: ConnectedAccountsListOptions = {},
+  ): ConnectedAccountsListRequest {
     return new SeamHttpRequest(this, {
       pathname: '/connected_accounts/list',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'connected_accounts',
+      options,
     })
   }
 
-  sync(body?: ConnectedAccountsSyncBody): SeamHttpRequest<void, undefined> {
+  sync(
+    parameters?: ConnectedAccountsSyncParameters,
+    options: ConnectedAccountsSyncOptions = {},
+  ): ConnectedAccountsSyncRequest {
     return new SeamHttpRequest(this, {
       pathname: '/connected_accounts/sync',
       method: 'POST',
-      body,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
-  update(body?: ConnectedAccountsUpdateBody): SeamHttpRequest<void, undefined> {
+  update(
+    parameters?: ConnectedAccountsUpdateParameters,
+    options: ConnectedAccountsUpdateOptions = {},
+  ): ConnectedAccountsUpdateRequest {
     return new SeamHttpRequest(this, {
       pathname: '/connected_accounts/update',
       method: 'POST',
-      body,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 }
 
-export type ConnectedAccountsDeleteParams =
+export type ConnectedAccountsDeleteParameters =
   RouteRequestBody<'/connected_accounts/delete'>
 
+/**
+ * @deprecated Use ConnectedAccountsDeleteParameters instead.
+ */
+export type ConnectedAccountsDeleteParams = ConnectedAccountsDeleteParameters
+
+/**
+ * @deprecated Use ConnectedAccountsDeleteRequest instead.
+ */
 export type ConnectedAccountsDeleteResponse = SetNonNullable<
   Required<RouteResponse<'/connected_accounts/delete'>>
 >
 
-export type ConnectedAccountsDeleteOptions = never
+export type ConnectedAccountsDeleteRequest = SeamHttpRequest<void, undefined>
 
-export type ConnectedAccountsGetParams =
+export type ConnectedAccountsDeleteOptions = Record<string, never>
+
+export type ConnectedAccountsGetParameters =
   RouteRequestParams<'/connected_accounts/get'>
 
+/**
+ * @deprecated Use ConnectedAccountsGetParameters instead.
+ */
+export type ConnectedAccountsGetParams = ConnectedAccountsGetParameters
+
+/**
+ * @deprecated Use ConnectedAccountsGetRequest instead.
+ */
 export type ConnectedAccountsGetResponse = SetNonNullable<
   Required<RouteResponse<'/connected_accounts/get'>>
 >
 
-export type ConnectedAccountsGetOptions = never
+export type ConnectedAccountsGetRequest = SeamHttpRequest<
+  ConnectedAccountsGetResponse,
+  'connected_account'
+>
+
+export type ConnectedAccountsGetOptions = Record<string, never>
 
-export type ConnectedAccountsListParams =
+export type ConnectedAccountsListParameters =
   RouteRequestBody<'/connected_accounts/list'>
 
+/**
+ * @deprecated Use ConnectedAccountsListParameters instead.
+ */
+export type ConnectedAccountsListParams = ConnectedAccountsListParameters
+
+/**
+ * @deprecated Use ConnectedAccountsListRequest instead.
+ */
 export type ConnectedAccountsListResponse = SetNonNullable<
   Required<RouteResponse<'/connected_accounts/list'>>
 >
 
-export type ConnectedAccountsListOptions = never
+export type ConnectedAccountsListRequest = SeamHttpRequest<
+  ConnectedAccountsListResponse,
+  'connected_accounts'
+>
+
+export type ConnectedAccountsListOptions = Record<string, never>
 
-export type ConnectedAccountsSyncBody =
+export type ConnectedAccountsSyncParameters =
   RouteRequestBody<'/connected_accounts/sync'>
 
+/**
+ * @deprecated Use ConnectedAccountsSyncParameters instead.
+ */
+export type ConnectedAccountsSyncBody = ConnectedAccountsSyncParameters
+
+/**
+ * @deprecated Use ConnectedAccountsSyncRequest instead.
+ */
 export type ConnectedAccountsSyncResponse = SetNonNullable<
   Required<RouteResponse<'/connected_accounts/sync'>>
 >
 
-export type ConnectedAccountsSyncOptions = never
+export type ConnectedAccountsSyncRequest = SeamHttpRequest<void, undefined>
 
-export type ConnectedAccountsUpdateBody =
+export type ConnectedAccountsSyncOptions = Record<string, never>
+
+export type ConnectedAccountsUpdateParameters =
   RouteRequestBody<'/connected_accounts/update'>
 
+/**
+ * @deprecated Use ConnectedAccountsUpdateParameters instead.
+ */
+export type ConnectedAccountsUpdateBody = ConnectedAccountsUpdateParameters
+
+/**
+ * @deprecated Use ConnectedAccountsUpdateRequest instead.
+ */
 export type ConnectedAccountsUpdateResponse = SetNonNullable<
   Required<RouteResponse<'/connected_accounts/update'>>
 >
 
-export type ConnectedAccountsUpdateOptions = never
+export type ConnectedAccountsUpdateRequest = SeamHttpRequest<void, undefined>
+
+export type ConnectedAccountsUpdateOptions = Record<string, never>

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

@@ -174,78 +174,168 @@ export class SeamHttpDevices {
     return SeamHttpDevicesUnmanaged.fromClient(this.client, this.defaults)
   }
 
+  delete(
+    parameters?: DevicesDeleteParameters,
+    options: DevicesDeleteOptions = {},
+  ): DevicesDeleteRequest {
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        'Cannot use undocumented API without isUndocumentedApiEnabled',
+      )
+    }
+    return new SeamHttpRequest(this, {
+      pathname: '/devices/delete',
+      method: 'POST',
+      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 DevicesGetParams = RouteRequestBody<'/devices/get'>
+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 DevicesDeleteRequest = SeamHttpRequest<void, undefined>
+
+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 DevicesListParams = RouteRequestBody<'/devices/list'>
+export type DevicesListParameters = 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 DevicesListDeviceProvidersOptions = Record<string, never>
 
-export type DevicesUpdateBody = RouteRequestBody<'/devices/update'>
+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>