@seamapi/http 0.1.0 → 0.2.0

package/src/lib/seam/connect/routes/acs-access-groups.ts

@@ -4,50 +4,53 @@
  */
 
 import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect'
-import type { Axios } from 'axios'
 import type { SetNonNullable } from 'type-fest'
 
-import { createAxiosClient } from 'lib/seam/connect/axios.js'
+import { warnOnInsecureuserIdentifierKey } from 'lib/seam/connect/auth.js'
+import { type Client, createClient } from 'lib/seam/connect/client.js'
 import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
-} from 'lib/seam/connect/client-options.js'
+} from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
+import { SeamHttpClientSessions } from './client-sessions.js'
+
 export class SeamHttpAcsAccessGroups {
-  client: Axios
+  client: Client
 
-  constructor(apiKeyOrOptions: string | SeamHttpOptions) {
-    const options = parseOptions(apiKeyOrOptions)
-    this.client = createAxiosClient(options)
+  constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions)
+    this.client = createClient(clientOptions)
   }
 
   static fromClient(
     client: SeamHttpOptionsWithClient['client'],
     options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
   ): SeamHttpAcsAccessGroups {
-    const opts = { ...options, client }
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing client')
     }
-    return new SeamHttpAcsAccessGroups(opts)
+    return new SeamHttpAcsAccessGroups(constructorOptions)
   }
 
   static fromApiKey(
     apiKey: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpAcsAccessGroups {
-    const opts = { ...options, apiKey }
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey }
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing apiKey')
     }
-    return new SeamHttpAcsAccessGroups(opts)
+    return new SeamHttpAcsAccessGroups(constructorOptions)
   }
 
   static fromClientSessionToken(
@@ -57,11 +60,26 @@ export class SeamHttpAcsAccessGroups {
       'clientSessionToken'
     > = {},
   ): SeamHttpAcsAccessGroups {
-    const opts = { ...options, clientSessionToken }
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken }
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
     }
-    return new SeamHttpAcsAccessGroups(opts)
+    return new SeamHttpAcsAccessGroups(constructorOptions)
+  }
+
+  static async fromPublishableKey(
+    publishableKey: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpAcsAccessGroups> {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey)
+    const clientOptions = parseOptions({ ...options, publishableKey })
+    const client = createClient(clientOptions)
+    const clientSessions = SeamHttpClientSessions.fromClient(client)
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey,
+    })
+    return SeamHttpAcsAccessGroups.fromClientSessionToken(token, options)
   }
 
   async addUser(body: AcsAccessGroupsAddUserBody): Promise<void> {
@@ -142,65 +160,56 @@ export class SeamHttpAcsAccessGroups {
   }
 }
 
-export type AcsAccessGroupsAddUserBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/access_groups/add_user'>>
->
+export type AcsAccessGroupsAddUserBody =
+  RouteRequestBody<'/acs/access_groups/add_user'>
 
 export type AcsAccessGroupsAddUserResponse = SetNonNullable<
   Required<RouteResponse<'/acs/access_groups/add_user'>>
 >
 
-export type AcsAccessGroupsCreateBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/access_groups/create'>>
->
+export type AcsAccessGroupsCreateBody =
+  RouteRequestBody<'/acs/access_groups/create'>
 
 export type AcsAccessGroupsCreateResponse = SetNonNullable<
   Required<RouteResponse<'/acs/access_groups/create'>>
 >
 
-export type AcsAccessGroupsDeleteBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/access_groups/delete'>>
->
+export type AcsAccessGroupsDeleteBody =
+  RouteRequestBody<'/acs/access_groups/delete'>
 
 export type AcsAccessGroupsDeleteResponse = SetNonNullable<
   Required<RouteResponse<'/acs/access_groups/delete'>>
 >
 
-export type AcsAccessGroupsGetBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/access_groups/get'>>
->
+export type AcsAccessGroupsGetBody = RouteRequestBody<'/acs/access_groups/get'>
 
 export type AcsAccessGroupsGetResponse = SetNonNullable<
   Required<RouteResponse<'/acs/access_groups/get'>>
 >
 
-export type AcsAccessGroupsListBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/access_groups/list'>>
->
+export type AcsAccessGroupsListBody =
+  RouteRequestBody<'/acs/access_groups/list'>
 
 export type AcsAccessGroupsListResponse = SetNonNullable<
   Required<RouteResponse<'/acs/access_groups/list'>>
 >
 
-export type AcsAccessGroupsListUsersBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/access_groups/list_users'>>
->
+export type AcsAccessGroupsListUsersBody =
+  RouteRequestBody<'/acs/access_groups/list_users'>
 
 export type AcsAccessGroupsListUsersResponse = SetNonNullable<
   Required<RouteResponse<'/acs/access_groups/list_users'>>
 >
 
-export type AcsAccessGroupsRemoveUserBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/access_groups/remove_user'>>
->
+export type AcsAccessGroupsRemoveUserBody =
+  RouteRequestBody<'/acs/access_groups/remove_user'>
 
 export type AcsAccessGroupsRemoveUserResponse = SetNonNullable<
   Required<RouteResponse<'/acs/access_groups/remove_user'>>
 >
 
-export type AcsAccessGroupsUpdateBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/access_groups/update'>>
->
+export type AcsAccessGroupsUpdateBody =
+  RouteRequestBody<'/acs/access_groups/update'>
 
 export type AcsAccessGroupsUpdateResponse = SetNonNullable<
   Required<RouteResponse<'/acs/access_groups/update'>>

package/src/lib/seam/connect/routes/acs-credentials.ts

@@ -4,50 +4,53 @@
  */
 
 import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect'
-import type { Axios } from 'axios'
 import type { SetNonNullable } from 'type-fest'
 
-import { createAxiosClient } from 'lib/seam/connect/axios.js'
+import { warnOnInsecureuserIdentifierKey } from 'lib/seam/connect/auth.js'
+import { type Client, createClient } from 'lib/seam/connect/client.js'
 import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
-} from 'lib/seam/connect/client-options.js'
+} from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
+import { SeamHttpClientSessions } from './client-sessions.js'
+
 export class SeamHttpAcsCredentials {
-  client: Axios
+  client: Client
 
-  constructor(apiKeyOrOptions: string | SeamHttpOptions) {
-    const options = parseOptions(apiKeyOrOptions)
-    this.client = createAxiosClient(options)
+  constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions)
+    this.client = createClient(clientOptions)
   }
 
   static fromClient(
     client: SeamHttpOptionsWithClient['client'],
     options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
   ): SeamHttpAcsCredentials {
-    const opts = { ...options, client }
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing client')
     }
-    return new SeamHttpAcsCredentials(opts)
+    return new SeamHttpAcsCredentials(constructorOptions)
   }
 
   static fromApiKey(
     apiKey: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpAcsCredentials {
-    const opts = { ...options, apiKey }
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey }
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing apiKey')
     }
-    return new SeamHttpAcsCredentials(opts)
+    return new SeamHttpAcsCredentials(constructorOptions)
   }
 
   static fromClientSessionToken(
@@ -57,11 +60,26 @@ export class SeamHttpAcsCredentials {
       'clientSessionToken'
     > = {},
   ): SeamHttpAcsCredentials {
-    const opts = { ...options, clientSessionToken }
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken }
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
     }
-    return new SeamHttpAcsCredentials(opts)
+    return new SeamHttpAcsCredentials(constructorOptions)
+  }
+
+  static async fromPublishableKey(
+    publishableKey: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpAcsCredentials> {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey)
+    const clientOptions = parseOptions({ ...options, publishableKey })
+    const client = createClient(clientOptions)
+    const clientSessions = SeamHttpClientSessions.fromClient(client)
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey,
+    })
+    return SeamHttpAcsCredentials.fromClientSessionToken(token, options)
   }
 
   async create(
@@ -106,33 +124,27 @@ export class SeamHttpAcsCredentials {
   }
 }
 
-export type AcsCredentialsCreateBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/credentials/create'>>
->
+export type AcsCredentialsCreateBody =
+  RouteRequestBody<'/acs/credentials/create'>
 
 export type AcsCredentialsCreateResponse = SetNonNullable<
   Required<RouteResponse<'/acs/credentials/create'>>
 >
 
-export type AcsCredentialsDeleteBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/credentials/delete'>>
->
+export type AcsCredentialsDeleteBody =
+  RouteRequestBody<'/acs/credentials/delete'>
 
 export type AcsCredentialsDeleteResponse = SetNonNullable<
   Required<RouteResponse<'/acs/credentials/delete'>>
 >
 
-export type AcsCredentialsGetBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/credentials/get'>>
->
+export type AcsCredentialsGetBody = RouteRequestBody<'/acs/credentials/get'>
 
 export type AcsCredentialsGetResponse = SetNonNullable<
   Required<RouteResponse<'/acs/credentials/get'>>
 >
 
-export type AcsCredentialsListBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/credentials/list'>>
->
+export type AcsCredentialsListBody = RouteRequestBody<'/acs/credentials/list'>
 
 export type AcsCredentialsListResponse = SetNonNullable<
   Required<RouteResponse<'/acs/credentials/list'>>

package/src/lib/seam/connect/routes/acs-systems.ts

@@ -3,55 +3,54 @@
  * Do not edit this file or add other files to this directory.
  */
 
-import type {
-  RouteRequestBody,
-  RouteRequestParams,
-  RouteResponse,
-} from '@seamapi/types/connect'
-import type { Axios } from 'axios'
+import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect'
 import type { SetNonNullable } from 'type-fest'
 
-import { createAxiosClient } from 'lib/seam/connect/axios.js'
+import { warnOnInsecureuserIdentifierKey } from 'lib/seam/connect/auth.js'
+import { type Client, createClient } from 'lib/seam/connect/client.js'
 import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
-} from 'lib/seam/connect/client-options.js'
+} from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
+import { SeamHttpClientSessions } from './client-sessions.js'
+
 export class SeamHttpAcsSystems {
-  client: Axios
+  client: Client
 
-  constructor(apiKeyOrOptions: string | SeamHttpOptions) {
-    const options = parseOptions(apiKeyOrOptions)
-    this.client = createAxiosClient(options)
+  constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions)
+    this.client = createClient(clientOptions)
   }
 
   static fromClient(
     client: SeamHttpOptionsWithClient['client'],
     options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
   ): SeamHttpAcsSystems {
-    const opts = { ...options, client }
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing client')
     }
-    return new SeamHttpAcsSystems(opts)
+    return new SeamHttpAcsSystems(constructorOptions)
   }
 
   static fromApiKey(
     apiKey: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpAcsSystems {
-    const opts = { ...options, apiKey }
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey }
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing apiKey')
     }
-    return new SeamHttpAcsSystems(opts)
+    return new SeamHttpAcsSystems(constructorOptions)
   }
 
   static fromClientSessionToken(
@@ -61,11 +60,26 @@ export class SeamHttpAcsSystems {
       'clientSessionToken'
     > = {},
   ): SeamHttpAcsSystems {
-    const opts = { ...options, clientSessionToken }
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken }
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
     }
-    return new SeamHttpAcsSystems(opts)
+    return new SeamHttpAcsSystems(constructorOptions)
+  }
+
+  static async fromPublishableKey(
+    publishableKey: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpAcsSystems> {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey)
+    const clientOptions = parseOptions({ ...options, publishableKey })
+    const client = createClient(clientOptions)
+    const clientSessions = SeamHttpClientSessions.fromClient(client)
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey,
+    })
+    return SeamHttpAcsSystems.fromClientSessionToken(token, options)
   }
 
   async get(
@@ -80,28 +94,24 @@ export class SeamHttpAcsSystems {
   }
 
   async list(
-    params?: AcsSystemsListParams,
+    body: AcsSystemsListBody,
   ): Promise<AcsSystemsListResponse['acs_systems']> {
     const { data } = await this.client.request<AcsSystemsListResponse>({
       url: '/acs/systems/list',
-      method: 'get',
-      params,
+      method: 'post',
+      data: body,
     })
     return data.acs_systems
   }
 }
 
-export type AcsSystemsGetBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/systems/get'>>
->
+export type AcsSystemsGetBody = RouteRequestBody<'/acs/systems/get'>
 
 export type AcsSystemsGetResponse = SetNonNullable<
   Required<RouteResponse<'/acs/systems/get'>>
 >
 
-export type AcsSystemsListParams = SetNonNullable<
-  Required<RouteRequestParams<'/acs/systems/list'>>
->
+export type AcsSystemsListBody = RouteRequestBody<'/acs/systems/list'>
 
 export type AcsSystemsListResponse = SetNonNullable<
   Required<RouteResponse<'/acs/systems/list'>>

package/src/lib/seam/connect/routes/acs-users.ts

@@ -4,50 +4,53 @@
  */
 
 import type { RouteRequestBody, RouteResponse } from '@seamapi/types/connect'
-import type { Axios } from 'axios'
 import type { SetNonNullable } from 'type-fest'
 
-import { createAxiosClient } from 'lib/seam/connect/axios.js'
+import { warnOnInsecureuserIdentifierKey } from 'lib/seam/connect/auth.js'
+import { type Client, createClient } from 'lib/seam/connect/client.js'
 import {
   isSeamHttpOptionsWithApiKey,
   isSeamHttpOptionsWithClient,
   isSeamHttpOptionsWithClientSessionToken,
+  type SeamHttpFromPublishableKeyOptions,
   SeamHttpInvalidOptionsError,
   type SeamHttpOptions,
   type SeamHttpOptionsWithApiKey,
   type SeamHttpOptionsWithClient,
   type SeamHttpOptionsWithClientSessionToken,
-} from 'lib/seam/connect/client-options.js'
+} from 'lib/seam/connect/options.js'
 import { parseOptions } from 'lib/seam/connect/parse-options.js'
 
+import { SeamHttpClientSessions } from './client-sessions.js'
+
 export class SeamHttpAcsUsers {
-  client: Axios
+  client: Client
 
-  constructor(apiKeyOrOptions: string | SeamHttpOptions) {
-    const options = parseOptions(apiKeyOrOptions)
-    this.client = createAxiosClient(options)
+  constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
+    const clientOptions = parseOptions(apiKeyOrOptions)
+    this.client = createClient(clientOptions)
   }
 
   static fromClient(
     client: SeamHttpOptionsWithClient['client'],
     options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
   ): SeamHttpAcsUsers {
-    const opts = { ...options, client }
-    if (!isSeamHttpOptionsWithClient(opts)) {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing client')
     }
-    return new SeamHttpAcsUsers(opts)
+    return new SeamHttpAcsUsers(constructorOptions)
   }
 
   static fromApiKey(
     apiKey: SeamHttpOptionsWithApiKey['apiKey'],
     options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
   ): SeamHttpAcsUsers {
-    const opts = { ...options, apiKey }
-    if (!isSeamHttpOptionsWithApiKey(opts)) {
+    const constructorOptions = { ...options, apiKey }
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing apiKey')
     }
-    return new SeamHttpAcsUsers(opts)
+    return new SeamHttpAcsUsers(constructorOptions)
   }
 
   static fromClientSessionToken(
@@ -57,11 +60,26 @@ export class SeamHttpAcsUsers {
       'clientSessionToken'
     > = {},
   ): SeamHttpAcsUsers {
-    const opts = { ...options, clientSessionToken }
-    if (!isSeamHttpOptionsWithClientSessionToken(opts)) {
+    const constructorOptions = { ...options, clientSessionToken }
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
       throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
     }
-    return new SeamHttpAcsUsers(opts)
+    return new SeamHttpAcsUsers(constructorOptions)
+  }
+
+  static async fromPublishableKey(
+    publishableKey: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpAcsUsers> {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey)
+    const clientOptions = parseOptions({ ...options, publishableKey })
+    const client = createClient(clientOptions)
+    const clientSessions = SeamHttpClientSessions.fromClient(client)
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey,
+    })
+    return SeamHttpAcsUsers.fromClientSessionToken(token, options)
   }
 
   async addToAccessGroup(body: AcsUsersAddToAccessGroupBody): Promise<void> {
@@ -121,6 +139,22 @@ export class SeamHttpAcsUsers {
     })
   }
 
+  async suspend(body: AcsUsersSuspendBody): Promise<void> {
+    await this.client.request<AcsUsersSuspendResponse>({
+      url: '/acs/users/suspend',
+      method: 'post',
+      data: body,
+    })
+  }
+
+  async unsuspend(body: AcsUsersUnsuspendBody): Promise<void> {
+    await this.client.request<AcsUsersUnsuspendResponse>({
+      url: '/acs/users/unsuspend',
+      method: 'post',
+      data: body,
+    })
+  }
+
   async update(body: AcsUsersUpdateBody): Promise<void> {
     await this.client.request<AcsUsersUpdateResponse>({
       url: '/acs/users/update',
@@ -130,58 +164,58 @@ export class SeamHttpAcsUsers {
   }
 }
 
-export type AcsUsersAddToAccessGroupBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/users/add_to_access_group'>>
->
+export type AcsUsersAddToAccessGroupBody =
+  RouteRequestBody<'/acs/users/add_to_access_group'>
 
 export type AcsUsersAddToAccessGroupResponse = SetNonNullable<
   Required<RouteResponse<'/acs/users/add_to_access_group'>>
 >
 
-export type AcsUsersCreateBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/users/create'>>
->
+export type AcsUsersCreateBody = RouteRequestBody<'/acs/users/create'>
 
 export type AcsUsersCreateResponse = SetNonNullable<
   Required<RouteResponse<'/acs/users/create'>>
 >
 
-export type AcsUsersDeleteBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/users/delete'>>
->
+export type AcsUsersDeleteBody = RouteRequestBody<'/acs/users/delete'>
 
 export type AcsUsersDeleteResponse = SetNonNullable<
   Required<RouteResponse<'/acs/users/delete'>>
 >
 
-export type AcsUsersGetBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/users/get'>>
->
+export type AcsUsersGetBody = RouteRequestBody<'/acs/users/get'>
 
 export type AcsUsersGetResponse = SetNonNullable<
   Required<RouteResponse<'/acs/users/get'>>
 >
 
-export type AcsUsersListBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/users/list'>>
->
+export type AcsUsersListBody = RouteRequestBody<'/acs/users/list'>
 
 export type AcsUsersListResponse = SetNonNullable<
   Required<RouteResponse<'/acs/users/list'>>
 >
 
-export type AcsUsersRemoveFromAccessGroupBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/users/remove_from_access_group'>>
->
+export type AcsUsersRemoveFromAccessGroupBody =
+  RouteRequestBody<'/acs/users/remove_from_access_group'>
 
 export type AcsUsersRemoveFromAccessGroupResponse = SetNonNullable<
   Required<RouteResponse<'/acs/users/remove_from_access_group'>>
 >
 
-export type AcsUsersUpdateBody = SetNonNullable<
-  Required<RouteRequestBody<'/acs/users/update'>>
+export type AcsUsersSuspendBody = RouteRequestBody<'/acs/users/suspend'>
+
+export type AcsUsersSuspendResponse = SetNonNullable<
+  Required<RouteResponse<'/acs/users/suspend'>>
+>
+
+export type AcsUsersUnsuspendBody = RouteRequestBody<'/acs/users/unsuspend'>
+
+export type AcsUsersUnsuspendResponse = SetNonNullable<
+  Required<RouteResponse<'/acs/users/unsuspend'>>
 >
 
+export type AcsUsersUpdateBody = RouteRequestBody<'/acs/users/update'>
+
 export type AcsUsersUpdateResponse = SetNonNullable<
   Required<RouteResponse<'/acs/users/update'>>
 >