@seamapi/http 0.24.0 → 0.25.0

package/src/lib/seam/connect/routes/acs-credentials.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,84 +154,79 @@ export class SeamHttpAcsCredentials {
     await clientSessions.get()
   }
 
-  async assign(
+  assign(
     body?: AcsCredentialsAssignBody,
-  ): Promise<AcsCredentialsAssignResponse['acs_credential']> {
-    const { data } = await this.client.request<AcsCredentialsAssignResponse>({
-      url: '/acs/credentials/assign',
+  ): SeamHttpRequest<AcsCredentialsAssignResponse, 'acs_credential'> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/credentials/assign',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'acs_credential',
     })
-
-    return data.acs_credential
   }
 
-  async create(
+  create(
     body?: AcsCredentialsCreateBody,
-  ): Promise<AcsCredentialsCreateResponse['acs_credential']> {
-    const { data } = await this.client.request<AcsCredentialsCreateResponse>({
-      url: '/acs/credentials/create',
+  ): SeamHttpRequest<AcsCredentialsCreateResponse, 'acs_credential'> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/credentials/create',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'acs_credential',
     })
-
-    return data.acs_credential
   }
 
-  async delete(body?: AcsCredentialsDeleteBody): Promise<void> {
-    await this.client.request<AcsCredentialsDeleteResponse>({
-      url: '/acs/credentials/delete',
+  delete(body?: AcsCredentialsDeleteBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/credentials/delete',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async get(
+  get(
     body?: AcsCredentialsGetParams,
-  ): Promise<AcsCredentialsGetResponse['acs_credential']> {
-    const { data } = await this.client.request<AcsCredentialsGetResponse>({
-      url: '/acs/credentials/get',
+  ): SeamHttpRequest<AcsCredentialsGetResponse, 'acs_credential'> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/credentials/get',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'acs_credential',
     })
-
-    return data.acs_credential
   }
 
-  async list(
+  list(
     body?: AcsCredentialsListParams,
-  ): Promise<AcsCredentialsListResponse['acs_credentials']> {
-    const { data } = await this.client.request<AcsCredentialsListResponse>({
-      url: '/acs/credentials/list',
+  ): SeamHttpRequest<AcsCredentialsListResponse, 'acs_credentials'> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/credentials/list',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'acs_credentials',
     })
-
-    return data.acs_credentials
   }
 
-  async unassign(
+  unassign(
     body?: AcsCredentialsUnassignBody,
-  ): Promise<AcsCredentialsUnassignResponse['acs_credential']> {
-    const { data } = await this.client.request<AcsCredentialsUnassignResponse>({
-      url: '/acs/credentials/unassign',
+  ): SeamHttpRequest<AcsCredentialsUnassignResponse, 'acs_credential'> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/credentials/unassign',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'acs_credential',
     })
-
-    return data.acs_credential
   }
 
-  async update(
+  update(
     body?: AcsCredentialsUpdateBody,
-  ): Promise<AcsCredentialsUpdateResponse['acs_credential']> {
-    const { data } = await this.client.request<AcsCredentialsUpdateResponse>({
-      url: '/acs/credentials/update',
+  ): SeamHttpRequest<AcsCredentialsUpdateResponse, 'acs_credential'> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/credentials/update',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'acs_credential',
     })
-
-    return data.acs_credential
   }
 }
 

package/src/lib/seam/connect/routes/acs-entrances.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,49 +154,51 @@ export class SeamHttpAcsEntrances {
     await clientSessions.get()
   }
 
-  async get(
+  get(
     body?: AcsEntrancesGetParams,
-  ): Promise<AcsEntrancesGetResponse['acs_entrance']> {
-    const { data } = await this.client.request<AcsEntrancesGetResponse>({
-      url: '/acs/entrances/get',
+  ): SeamHttpRequest<AcsEntrancesGetResponse, 'acs_entrance'> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/entrances/get',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'acs_entrance',
     })
-
-    return data.acs_entrance
   }
 
-  async grantAccess(body?: AcsEntrancesGrantAccessBody): Promise<void> {
-    await this.client.request<AcsEntrancesGrantAccessResponse>({
-      url: '/acs/entrances/grant_access',
+  grantAccess(
+    body?: AcsEntrancesGrantAccessBody,
+  ): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/entrances/grant_access',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async list(
+  list(
     body?: AcsEntrancesListParams,
-  ): Promise<AcsEntrancesListResponse['acs_entrances']> {
-    const { data } = await this.client.request<AcsEntrancesListResponse>({
-      url: '/acs/entrances/list',
+  ): SeamHttpRequest<AcsEntrancesListResponse, 'acs_entrances'> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/entrances/list',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'acs_entrances',
     })
-
-    return data.acs_entrances
   }
 
-  async listCredentialsWithAccess(
+  listCredentialsWithAccess(
     body?: AcsEntrancesListCredentialsWithAccessParams,
-  ): Promise<AcsEntrancesListCredentialsWithAccessResponse['acs_credentials']> {
-    const { data } =
-      await this.client.request<AcsEntrancesListCredentialsWithAccessResponse>({
-        url: '/acs/entrances/list_credentials_with_access',
-        method: 'post',
-        data: body,
-      })
-
-    return data.acs_credentials
+  ): SeamHttpRequest<
+    AcsEntrancesListCredentialsWithAccessResponse,
+    'acs_credentials'
+  > {
+    return new SeamHttpRequest(this, {
+      path: '/acs/entrances/list_credentials_with_access',
+      method: 'post',
+      body,
+      responseKey: 'acs_credentials',
+    })
   }
 }
 

package/src/lib/seam/connect/routes/acs-systems.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,28 +154,26 @@ export class SeamHttpAcsSystems {
     await clientSessions.get()
   }
 
-  async get(
+  get(
     body?: AcsSystemsGetParams,
-  ): Promise<AcsSystemsGetResponse['acs_system']> {
-    const { data } = await this.client.request<AcsSystemsGetResponse>({
-      url: '/acs/systems/get',
+  ): SeamHttpRequest<AcsSystemsGetResponse, 'acs_system'> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/systems/get',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'acs_system',
     })
-
-    return data.acs_system
   }
 
-  async list(
+  list(
     body?: AcsSystemsListParams,
-  ): Promise<AcsSystemsListResponse['acs_systems']> {
-    const { data } = await this.client.request<AcsSystemsListResponse>({
-      url: '/acs/systems/list',
+  ): SeamHttpRequest<AcsSystemsListResponse, 'acs_systems'> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/systems/list',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'acs_systems',
     })
-
-    return data.acs_systems
   }
 }
 

package/src/lib/seam/connect/routes/acs-users.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,112 +154,116 @@ export class SeamHttpAcsUsers {
     await clientSessions.get()
   }
 
-  async addToAccessGroup(body?: AcsUsersAddToAccessGroupBody): Promise<void> {
-    await this.client.request<AcsUsersAddToAccessGroupResponse>({
-      url: '/acs/users/add_to_access_group',
+  addToAccessGroup(
+    body?: AcsUsersAddToAccessGroupBody,
+  ): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/users/add_to_access_group',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async create(
+  create(
     body?: AcsUsersCreateBody,
-  ): Promise<AcsUsersCreateResponse['acs_user']> {
-    const { data } = await this.client.request<AcsUsersCreateResponse>({
-      url: '/acs/users/create',
+  ): SeamHttpRequest<AcsUsersCreateResponse, 'acs_user'> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/users/create',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'acs_user',
     })
-
-    return data.acs_user
   }
 
-  async delete(body?: AcsUsersDeleteBody): Promise<void> {
-    await this.client.request<AcsUsersDeleteResponse>({
-      url: '/acs/users/delete',
+  delete(body?: AcsUsersDeleteBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/users/delete',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async get(
+  get(
     body?: AcsUsersGetParams,
-  ): Promise<AcsUsersGetResponse['acs_user']> {
-    const { data } = await this.client.request<AcsUsersGetResponse>({
-      url: '/acs/users/get',
+  ): SeamHttpRequest<AcsUsersGetResponse, 'acs_user'> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/users/get',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'acs_user',
     })
-
-    return data.acs_user
   }
 
-  async list(
+  list(
     body?: AcsUsersListParams,
-  ): Promise<AcsUsersListResponse['acs_users']> {
-    const { data } = await this.client.request<AcsUsersListResponse>({
-      url: '/acs/users/list',
+  ): SeamHttpRequest<AcsUsersListResponse, 'acs_users'> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/users/list',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'acs_users',
     })
-
-    return data.acs_users
   }
 
-  async listAccessibleEntrances(
+  listAccessibleEntrances(
     body?: AcsUsersListAccessibleEntrancesParams,
-  ): Promise<AcsUsersListAccessibleEntrancesResponse['acs_entrances']> {
-    const { data } =
-      await this.client.request<AcsUsersListAccessibleEntrancesResponse>({
-        url: '/acs/users/list_accessible_entrances',
-        method: 'post',
-        data: body,
-      })
-
-    return data.acs_entrances
+  ): SeamHttpRequest<AcsUsersListAccessibleEntrancesResponse, 'acs_entrances'> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/users/list_accessible_entrances',
+      method: 'post',
+      body,
+      responseKey: 'acs_entrances',
+    })
   }
 
-  async removeFromAccessGroup(
+  removeFromAccessGroup(
     body?: AcsUsersRemoveFromAccessGroupBody,
-  ): Promise<void> {
-    await this.client.request<AcsUsersRemoveFromAccessGroupResponse>({
-      url: '/acs/users/remove_from_access_group',
+  ): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/users/remove_from_access_group',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async revokeAccessToAllEntrances(
+  revokeAccessToAllEntrances(
     body?: AcsUsersRevokeAccessToAllEntrancesBody,
-  ): Promise<void> {
-    await this.client.request<AcsUsersRevokeAccessToAllEntrancesResponse>({
-      url: '/acs/users/revoke_access_to_all_entrances',
+  ): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/users/revoke_access_to_all_entrances',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async suspend(body?: AcsUsersSuspendBody): Promise<void> {
-    await this.client.request<AcsUsersSuspendResponse>({
-      url: '/acs/users/suspend',
+  suspend(body?: AcsUsersSuspendBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/users/suspend',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async unsuspend(body?: AcsUsersUnsuspendBody): Promise<void> {
-    await this.client.request<AcsUsersUnsuspendResponse>({
-      url: '/acs/users/unsuspend',
+  unsuspend(body?: AcsUsersUnsuspendBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/users/unsuspend',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async update(body?: AcsUsersUpdateBody): Promise<void> {
-    await this.client.request<AcsUsersUpdateResponse>({
-      url: '/acs/users/update',
+  update(body?: AcsUsersUpdateBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/acs/users/update',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 }

package/src/lib/seam/connect/routes/action-attempts.ts

@@ -31,7 +31,7 @@ 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 { SeamHttpClientSessions } from './client-sessions.js'
 
@@ -154,40 +154,28 @@ export class SeamHttpActionAttempts {
     await clientSessions.get()
   }
 
-  async get(
+  get(
     body?: ActionAttemptsGetParams,
     options: Pick<SeamHttpRequestOptions, 'waitForActionAttempt'> = {},
-  ): Promise<ActionAttemptsGetResponse['action_attempt']> {
-    const { data } = await this.client.request<ActionAttemptsGetResponse>({
-      url: '/action_attempts/get',
+  ): SeamHttpRequest<ActionAttemptsGetResponse, 'action_attempt'> {
+    return new SeamHttpRequest(this, {
+      path: '/action_attempts/get',
       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 list(
+  list(
     body?: ActionAttemptsListParams,
-  ): Promise<ActionAttemptsListResponse['action_attempts']> {
-    const { data } = await this.client.request<ActionAttemptsListResponse>({
-      url: '/action_attempts/list',
+  ): SeamHttpRequest<ActionAttemptsListResponse, 'action_attempts'> {
+    return new SeamHttpRequest(this, {
+      path: '/action_attempts/list',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'action_attempts',
     })
-
-    return data.action_attempts
   }
 }
 

package/src/lib/seam/connect/routes/client-sessions.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'
 
 export class SeamHttpClientSessions {
   client: Client
@@ -151,81 +152,76 @@ export class SeamHttpClientSessions {
     await clientSessions.get()
   }
 
-  async create(
+  create(
     body?: ClientSessionsCreateBody,
-  ): Promise<ClientSessionsCreateResponse['client_session']> {
-    const { data } = await this.client.request<ClientSessionsCreateResponse>({
-      url: '/client_sessions/create',
+  ): SeamHttpRequest<ClientSessionsCreateResponse, 'client_session'> {
+    return new SeamHttpRequest(this, {
+      path: '/client_sessions/create',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'client_session',
     })
-
-    return data.client_session
   }
 
-  async delete(body?: ClientSessionsDeleteBody): Promise<void> {
-    await this.client.request<ClientSessionsDeleteResponse>({
-      url: '/client_sessions/delete',
+  delete(body?: ClientSessionsDeleteBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/client_sessions/delete',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 
-  async get(
+  get(
     body?: ClientSessionsGetParams,
-  ): Promise<ClientSessionsGetResponse['client_session']> {
-    const { data } = await this.client.request<ClientSessionsGetResponse>({
-      url: '/client_sessions/get',
+  ): SeamHttpRequest<ClientSessionsGetResponse, 'client_session'> {
+    return new SeamHttpRequest(this, {
+      path: '/client_sessions/get',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'client_session',
     })
-
-    return data.client_session
   }
 
-  async getOrCreate(
+  getOrCreate(
     body?: ClientSessionsGetOrCreateBody,
-  ): Promise<ClientSessionsGetOrCreateResponse['client_session']> {
-    const { data } =
-      await this.client.request<ClientSessionsGetOrCreateResponse>({
-        url: '/client_sessions/get_or_create',
-        method: 'post',
-        data: body,
-      })
-
-    return data.client_session
+  ): SeamHttpRequest<ClientSessionsGetOrCreateResponse, 'client_session'> {
+    return new SeamHttpRequest(this, {
+      path: '/client_sessions/get_or_create',
+      method: 'post',
+      body,
+      responseKey: 'client_session',
+    })
   }
 
-  async grantAccess(
+  grantAccess(
     body?: ClientSessionsGrantAccessBody,
-  ): Promise<ClientSessionsGrantAccessResponse['client_session']> {
-    const { data } =
-      await this.client.request<ClientSessionsGrantAccessResponse>({
-        url: '/client_sessions/grant_access',
-        method: 'post',
-        data: body,
-      })
-
-    return data.client_session
+  ): SeamHttpRequest<ClientSessionsGrantAccessResponse, 'client_session'> {
+    return new SeamHttpRequest(this, {
+      path: '/client_sessions/grant_access',
+      method: 'post',
+      body,
+      responseKey: 'client_session',
+    })
   }
 
-  async list(
+  list(
     body?: ClientSessionsListParams,
-  ): Promise<ClientSessionsListResponse['client_sessions']> {
-    const { data } = await this.client.request<ClientSessionsListResponse>({
-      url: '/client_sessions/list',
+  ): SeamHttpRequest<ClientSessionsListResponse, 'client_sessions'> {
+    return new SeamHttpRequest(this, {
+      path: '/client_sessions/list',
       method: 'post',
-      data: body,
+      body,
+      responseKey: 'client_sessions',
     })
-
-    return data.client_sessions
   }
 
-  async revoke(body?: ClientSessionsRevokeBody): Promise<void> {
-    await this.client.request<ClientSessionsRevokeResponse>({
-      url: '/client_sessions/revoke',
+  revoke(body?: ClientSessionsRevokeBody): SeamHttpRequest<void, undefined> {
+    return new SeamHttpRequest(this, {
+      path: '/client_sessions/revoke',
       method: 'post',
-      data: body,
+      body,
+      responseKey: undefined,
     })
   }
 }