/*
 * Automatically generated by codegen/smith.ts.
 * Do not edit this file or add other files to this directory.
 */

import { seamApiLtsVersion } from 'lib/lts-version.js'
import {
  getAuthHeadersForClientSessionToken,
  warnOnInsecureuserIdentifierKey,
} from 'lib/seam/connect/auth.js'
import { type Client, createClient } from 'lib/seam/connect/client.js'
import {
  isSeamHttpOptionsWithApiKey,
  isSeamHttpOptionsWithClient,
  isSeamHttpOptionsWithClientSessionToken,
  isSeamHttpOptionsWithConsoleSessionToken,
  isSeamHttpOptionsWithPersonalAccessToken,
  type SeamHttpFromPublishableKeyOptions,
  SeamHttpInvalidOptionsError,
  type SeamHttpOptions,
  type SeamHttpOptionsWithApiKey,
  type SeamHttpOptionsWithClient,
  type SeamHttpOptionsWithClientSessionToken,
  type SeamHttpOptionsWithConsoleSessionToken,
  type SeamHttpOptionsWithPersonalAccessToken,
  type SeamHttpRequestOptions,
} from 'lib/seam/connect/options.js'
import {
  limitToSeamHttpRequestOptions,
  parseOptions,
} from 'lib/seam/connect/parse-options.js'
import type { AcsEntrance } from 'lib/seam/connect/resources/acs-entrance.js'
import type { AcsSystem } from 'lib/seam/connect/resources/acs-system.js'
import type { AcsUser } from 'lib/seam/connect/resources/acs-user.js'
import type { Device } from 'lib/seam/connect/resources/device.js'
import type { InstantKey } from 'lib/seam/connect/resources/instant-key.js'
import type { UserIdentity } from 'lib/seam/connect/resources/user-identity.js'
import { SeamHttpClientSessions } from 'lib/seam/connect/routes/client-sessions/index.js'
import { SeamHttpRequest } from 'lib/seam/connect/seam-http-request.js'
import { SeamPaginator } from 'lib/seam/connect/seam-paginator.js'

import { SeamHttpUserIdentitiesUnmanaged } from './unmanaged/index.js'

export class SeamHttpUserIdentities {
  client: Client
  readonly defaults: Required<SeamHttpRequestOptions>
  readonly ltsVersion = seamApiLtsVersion
  static ltsVersion = seamApiLtsVersion

  constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
    const options = parseOptions(apiKeyOrOptions)
    this.client = 'client' in options ? options.client : createClient(options)
    this.defaults = limitToSeamHttpRequestOptions(options)
  }

  static fromClient(
    client: SeamHttpOptionsWithClient['client'],
    options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
  ): SeamHttpUserIdentities {
    const constructorOptions = { ...options, client }
    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
      throw new SeamHttpInvalidOptionsError('Missing client')
    }
    return new SeamHttpUserIdentities(constructorOptions)
  }

  static fromApiKey(
    apiKey: SeamHttpOptionsWithApiKey['apiKey'],
    options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
  ): SeamHttpUserIdentities {
    const constructorOptions = { ...options, apiKey }
    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
      throw new SeamHttpInvalidOptionsError('Missing apiKey')
    }
    return new SeamHttpUserIdentities(constructorOptions)
  }

  static fromClientSessionToken(
    clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'],
    options: Omit<
      SeamHttpOptionsWithClientSessionToken,
      'clientSessionToken'
    > = {},
  ): SeamHttpUserIdentities {
    const constructorOptions = { ...options, clientSessionToken }
    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
      throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
    }
    return new SeamHttpUserIdentities(constructorOptions)
  }

  static async fromPublishableKey(
    publishableKey: string,
    userIdentifierKey: string,
    options: SeamHttpFromPublishableKeyOptions = {},
  ): Promise<SeamHttpUserIdentities> {
    warnOnInsecureuserIdentifierKey(userIdentifierKey)
    const clientOptions = parseOptions({ ...options, publishableKey })
    if (isSeamHttpOptionsWithClient(clientOptions)) {
      throw new SeamHttpInvalidOptionsError(
        'The client option cannot be used with SeamHttpUserIdentities.fromPublishableKey',
      )
    }
    const client = createClient(clientOptions)
    const clientSessions = SeamHttpClientSessions.fromClient(client)
    const { token } = await clientSessions.getOrCreate({
      user_identifier_key: userIdentifierKey,
    })
    return SeamHttpUserIdentities.fromClientSessionToken(token, options)
  }

  static fromConsoleSessionToken(
    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
    options: Omit<
      SeamHttpOptionsWithConsoleSessionToken,
      'consoleSessionToken' | 'workspaceId'
    > = {},
  ): SeamHttpUserIdentities {
    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
      throw new SeamHttpInvalidOptionsError(
        'Missing consoleSessionToken or workspaceId',
      )
    }
    return new SeamHttpUserIdentities(constructorOptions)
  }

  static fromPersonalAccessToken(
    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
    options: Omit<
      SeamHttpOptionsWithPersonalAccessToken,
      'personalAccessToken' | 'workspaceId'
    > = {},
  ): SeamHttpUserIdentities {
    const constructorOptions = { ...options, personalAccessToken, workspaceId }
    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
      throw new SeamHttpInvalidOptionsError(
        'Missing personalAccessToken or workspaceId',
      )
    }
    return new SeamHttpUserIdentities(constructorOptions)
  }

  createPaginator<const TResponse, const TResponseKey extends keyof TResponse>(
    request: SeamHttpRequest<TResponse, TResponseKey>,
  ): SeamPaginator<TResponse, TResponseKey> {
    return new SeamPaginator<TResponse, TResponseKey>(this, request)
  }

  async updateClientSessionToken(
    clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'],
  ): Promise<void> {
    const { headers } = this.client.defaults
    const authHeaders = getAuthHeadersForClientSessionToken({
      clientSessionToken,
    })
    for (const key of Object.keys(authHeaders)) {
      if (headers[key] == null) {
        throw new Error(
          'Cannot update a clientSessionToken on a client created without a clientSessionToken',
        )
      }
    }
    this.client.defaults.headers = { ...headers, ...authHeaders }
    const clientSessions = SeamHttpClientSessions.fromClient(this.client)
    await clientSessions.get()
  }

  get unmanaged(): SeamHttpUserIdentitiesUnmanaged {
    return SeamHttpUserIdentitiesUnmanaged.fromClient(
      this.client,
      this.defaults,
    )
  }

  /**
   * Adds a specified [access system user](https://docs.seam.co/low-level-apis/access-systems/user-management) to a specified [user identity](https://docs.seam.co/capability-guides/mobile-access/managing-mobile-app-user-accounts-with-user-identities#what-is-a-user-identity).
   *
   * You must specify either `user_identity_id` or `user_identity_key` to identify the user identity.
   *
   * If `user_identity_key` is provided, but the user identity doesn't exist, a new user identity will be created automatically using information from the ACS user.
   */
  addAcsUser(
    parameters: UserIdentitiesAddAcsUserParameters,
    options: UserIdentitiesAddAcsUserOptions = {},
  ): UserIdentitiesAddAcsUserRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/add_acs_user',
      method: 'PUT',
      body: parameters,
      responseKey: undefined,
      options,
    })
  }

  /**
   * Creates a new [user identity](https://docs.seam.co/capability-guides/mobile-access/managing-mobile-app-user-accounts-with-user-identities#what-is-a-user-identity).
   */
  create(
    parameters?: UserIdentitiesCreateParameters,
    options: UserIdentitiesCreateOptions = {},
  ): UserIdentitiesCreateRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/create',
      method: 'POST',
      body: parameters,
      responseKey: 'user_identity',
      options,
    })
  }

  /**
   * Deletes a specified [user identity](https://docs.seam.co/capability-guides/mobile-access/managing-mobile-app-user-accounts-with-user-identities#what-is-a-user-identity). This deletes the user identity and all associated resources, including any [credentials](https://docs.seam.co/api/acs/credentials), [acs users](https://docs.seam.co/api/acs/users) and [client sessions](https://docs.seam.co/api/client_sessions).
   */
  delete(
    parameters: UserIdentitiesDeleteParameters,
    options: UserIdentitiesDeleteOptions = {},
  ): UserIdentitiesDeleteRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/delete',
      method: 'POST',
      body: parameters,
      responseKey: undefined,
      options,
    })
  }

  /**
   * Generates a new [instant key](https://docs.seam.co/capability-guides/instant-keys) for a specified [user identity](https://docs.seam.co/capability-guides/mobile-access/managing-mobile-app-user-accounts-with-user-identities#what-is-a-user-identity).
   */
  generateInstantKey(
    parameters: UserIdentitiesGenerateInstantKeyParameters,
    options: UserIdentitiesGenerateInstantKeyOptions = {},
  ): UserIdentitiesGenerateInstantKeyRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/generate_instant_key',
      method: 'POST',
      body: parameters,
      responseKey: 'instant_key',
      options,
    })
  }

  /**
   * Returns a specified [user identity](https://docs.seam.co/capability-guides/mobile-access/managing-mobile-app-user-accounts-with-user-identities#what-is-a-user-identity).
   */
  get(
    parameters?: UserIdentitiesGetParameters,
    options: UserIdentitiesGetOptions = {},
  ): UserIdentitiesGetRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/get',
      method: 'GET',
      params: parameters,
      responseKey: 'user_identity',
      options,
    })
  }

  /**
   * Grants a specified [user identity](https://docs.seam.co/capability-guides/mobile-access/managing-mobile-app-user-accounts-with-user-identities#what-is-a-user-identity) access to a specified [device](https://docs.seam.co/core-concepts/devices/).
   */
  grantAccessToDevice(
    parameters: UserIdentitiesGrantAccessToDeviceParameters,
    options: UserIdentitiesGrantAccessToDeviceOptions = {},
  ): UserIdentitiesGrantAccessToDeviceRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/grant_access_to_device',
      method: 'PUT',
      body: parameters,
      responseKey: undefined,
      options,
    })
  }

  /**
   * Returns a list of all [user identities](https://docs.seam.co/capability-guides/mobile-access/managing-mobile-app-user-accounts-with-user-identities#what-is-a-user-identity).
   */
  list(
    parameters?: UserIdentitiesListParameters,
    options: UserIdentitiesListOptions = {},
  ): UserIdentitiesListRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/list',
      method: 'POST',
      body: parameters,
      responseKey: 'user_identities',
      options,
    })
  }

  /**
   * Returns a list of all [devices](https://docs.seam.co/core-concepts/devices) associated with a specified [user identity](https://docs.seam.co/capability-guides/mobile-access/managing-mobile-app-user-accounts-with-user-identities#what-is-a-user-identity). This includes devices derived from the access grants assigned to the user identity and devices directly linked to the user identity.
   */
  listAccessibleDevices(
    parameters: UserIdentitiesListAccessibleDevicesParameters,
    options: UserIdentitiesListAccessibleDevicesOptions = {},
  ): UserIdentitiesListAccessibleDevicesRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/list_accessible_devices',
      method: 'POST',
      body: parameters,
      responseKey: 'devices',
      options,
    })
  }

  /**
   * Returns a list of all [ACS entrances](https://docs.seam.co/api/acs/entrances) accessible to a specified [user identity](https://docs.seam.co/capability-guides/mobile-access/managing-mobile-app-user-accounts-with-user-identities#what-is-a-user-identity). This includes entrances derived from the access grants assigned to the user identity and entrances accessible through ACS users linked to the user identity.
   */
  listAccessibleEntrances(
    parameters: UserIdentitiesListAccessibleEntrancesParameters,
    options: UserIdentitiesListAccessibleEntrancesOptions = {},
  ): UserIdentitiesListAccessibleEntrancesRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/list_accessible_entrances',
      method: 'POST',
      body: parameters,
      responseKey: 'acs_entrances',
      options,
    })
  }

  /**
   * Returns a list of all [access systems](https://docs.seam.co/low-level-apis/access-systems) associated with a specified [user identity](https://docs.seam.co/capability-guides/mobile-access/managing-mobile-app-user-accounts-with-user-identities#what-is-a-user-identity).
   */
  listAcsSystems(
    parameters: UserIdentitiesListAcsSystemsParameters,
    options: UserIdentitiesListAcsSystemsOptions = {},
  ): UserIdentitiesListAcsSystemsRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/list_acs_systems',
      method: 'POST',
      body: parameters,
      responseKey: 'acs_systems',
      options,
    })
  }

  /**
   * Returns a list of all [access system users](https://docs.seam.co/low-level-apis/access-systems/user-management) assigned to a specified [user identity](https://docs.seam.co/capability-guides/mobile-access/managing-mobile-app-user-accounts-with-user-identities#what-is-a-user-identity).
   */
  listAcsUsers(
    parameters: UserIdentitiesListAcsUsersParameters,
    options: UserIdentitiesListAcsUsersOptions = {},
  ): UserIdentitiesListAcsUsersRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/list_acs_users',
      method: 'POST',
      body: parameters,
      responseKey: 'acs_users',
      options,
    })
  }

  /**
   * Removes a specified [access system user](https://docs.seam.co/low-level-apis/access-systems/user-management) from a specified [user identity](https://docs.seam.co/capability-guides/mobile-access/managing-mobile-app-user-accounts-with-user-identities#what-is-a-user-identity).
   */
  removeAcsUser(
    parameters: UserIdentitiesRemoveAcsUserParameters,
    options: UserIdentitiesRemoveAcsUserOptions = {},
  ): UserIdentitiesRemoveAcsUserRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/remove_acs_user',
      method: 'POST',
      body: parameters,
      responseKey: undefined,
      options,
    })
  }

  /**
   * Revokes access to a specified [device](https://docs.seam.co/core-concepts/devices/) from a specified [user identity](https://docs.seam.co/capability-guides/mobile-access/managing-mobile-app-user-accounts-with-user-identities#what-is-a-user-identity).
   */
  revokeAccessToDevice(
    parameters: UserIdentitiesRevokeAccessToDeviceParameters,
    options: UserIdentitiesRevokeAccessToDeviceOptions = {},
  ): UserIdentitiesRevokeAccessToDeviceRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/revoke_access_to_device',
      method: 'POST',
      body: parameters,
      responseKey: undefined,
      options,
    })
  }

  /**
   * Updates a specified [user identity](https://docs.seam.co/capability-guides/mobile-access/managing-mobile-app-user-accounts-with-user-identities#what-is-a-user-identity).
   */
  update(
    parameters: UserIdentitiesUpdateParameters,
    options: UserIdentitiesUpdateOptions = {},
  ): UserIdentitiesUpdateRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/update',
      method: 'PATCH',
      body: parameters,
      responseKey: undefined,
      options,
    })
  }
}

export type UserIdentitiesAddAcsUserParameters = {
  /**
   * ID of the access system user that you want to add to the user identity.
   */
  acs_user_id: string

  /**
   * ID of the user identity to which you want to add an access system user.
   */
  user_identity_id?: string | undefined
  /**
   * Key of the user identity to which you want to add an access system user.
   */
  user_identity_key?: string | undefined
}

/**
 * @deprecated Use UserIdentitiesAddAcsUserRequest instead.
 */
export type UserIdentitiesAddAcsUserResponse = void

export type UserIdentitiesAddAcsUserRequest = SeamHttpRequest<void, undefined>

export interface UserIdentitiesAddAcsUserOptions {}

export type UserIdentitiesCreateParameters = {
  /**
   * List of access system IDs to associate with the new user identity through access system users. If there's no user with the same email address or phone number in the specified access systems, a new access system user is created. If there is an existing user with the same email or phone number in the specified access systems, the user is linked to the user identity.
   */
  acs_system_ids?: Array<string> | undefined
  /**
   * Unique email address for the new user identity.
   */
  email_address?: string | undefined
  /**
   * Full name of the user associated with the new user identity.
   */
  full_name?: string | undefined
  /**
   * Unique phone number for the new user identity in E.164 format (for example, +15555550100).
   */
  phone_number?: string | undefined
  /**
   * Unique key for the new user identity.
   */
  user_identity_key?: string | undefined
}

/**
 * @deprecated Use UserIdentitiesCreateRequest instead.
 */
export type UserIdentitiesCreateResponse = { user_identity: UserIdentity }

export type UserIdentitiesCreateRequest = SeamHttpRequest<
  UserIdentitiesCreateResponse,
  'user_identity'
>

export interface UserIdentitiesCreateOptions {}

export type UserIdentitiesDeleteParameters = {
  /**
   * ID of the user identity that you want to delete.
   */
  user_identity_id: string
}

/**
 * @deprecated Use UserIdentitiesDeleteRequest instead.
 */
export type UserIdentitiesDeleteResponse = void

export type UserIdentitiesDeleteRequest = SeamHttpRequest<void, undefined>

export interface UserIdentitiesDeleteOptions {}

export type UserIdentitiesGenerateInstantKeyParameters = {
  customization_profile_id?: string | undefined
  /**
   * Maximum number of times the instant key can be used. Default: 1.
   */
  max_use_count?: number | undefined
  /**
   * ID of the user identity for which you want to generate an instant key.
   */
  user_identity_id: string
}

/**
 * @deprecated Use UserIdentitiesGenerateInstantKeyRequest instead.
 */
export type UserIdentitiesGenerateInstantKeyResponse = {
  instant_key: InstantKey
}

export type UserIdentitiesGenerateInstantKeyRequest = SeamHttpRequest<
  UserIdentitiesGenerateInstantKeyResponse,
  'instant_key'
>

export interface UserIdentitiesGenerateInstantKeyOptions {}

export type UserIdentitiesGetParameters = {
  /**
   * ID of the user identity that you want to get.
   */
  user_identity_id?: string | undefined

  user_identity_key?: string | undefined
}

/**
 * @deprecated Use UserIdentitiesGetRequest instead.
 */
export type UserIdentitiesGetResponse = { user_identity: UserIdentity }

export type UserIdentitiesGetRequest = SeamHttpRequest<
  UserIdentitiesGetResponse,
  'user_identity'
>

export interface UserIdentitiesGetOptions {}

export type UserIdentitiesGrantAccessToDeviceParameters = {
  /**
   * ID of the managed device to which you want to grant access to the user identity.
   */
  device_id: string

  /**
   * ID of the user identity that you want to grant access to a device.
   */
  user_identity_id: string
}

/**
 * @deprecated Use UserIdentitiesGrantAccessToDeviceRequest instead.
 */
export type UserIdentitiesGrantAccessToDeviceResponse = void

export type UserIdentitiesGrantAccessToDeviceRequest = SeamHttpRequest<
  void,
  undefined
>

export interface UserIdentitiesGrantAccessToDeviceOptions {}

export type UserIdentitiesListParameters = {
  /**
   * Timestamp by which to limit returned user identities. Returns user identities created before this timestamp.
   */
  created_before?: string | undefined
  /**
   * `acs_system_id` of the credential manager by which you want to filter the list of user identities.
   */
  credential_manager_acs_system_id?: string | undefined
  /**
   * Maximum number of records to return per page.
   */
  limit?: number | undefined
  /**
   * Identifies the specific page of results to return, obtained from the previous page's `next_page_cursor`.
   */
  page_cursor?: string | undefined
  /**
   * String for which to search. Filters returned user identities to include all records that satisfy a partial match using `full_name`, `phone_number`, `email_address` or `user_identity_id`.
   */
  search?: string | undefined
  /**
   * Array of user identity IDs by which to filter the list of user identities.
   */
  user_identity_ids?: Array<string> | undefined
}

/**
 * @deprecated Use UserIdentitiesListRequest instead.
 */
export type UserIdentitiesListResponse = {
  user_identities: Array<UserIdentity>
}

export type UserIdentitiesListRequest = SeamHttpRequest<
  UserIdentitiesListResponse,
  'user_identities'
>

export interface UserIdentitiesListOptions {}

export type UserIdentitiesListAccessibleDevicesParameters = {
  /**
   * ID of the user identity for which you want to retrieve all accessible devices.
   */
  user_identity_id: string
}

/**
 * @deprecated Use UserIdentitiesListAccessibleDevicesRequest instead.
 */
export type UserIdentitiesListAccessibleDevicesResponse = {
  devices: Array<Device>
}

export type UserIdentitiesListAccessibleDevicesRequest = SeamHttpRequest<
  UserIdentitiesListAccessibleDevicesResponse,
  'devices'
>

export interface UserIdentitiesListAccessibleDevicesOptions {}

export type UserIdentitiesListAccessibleEntrancesParameters = {
  /**
   * ID of the user identity for which you want to retrieve all accessible entrances.
   */
  user_identity_id: string
}

/**
 * @deprecated Use UserIdentitiesListAccessibleEntrancesRequest instead.
 */
export type UserIdentitiesListAccessibleEntrancesResponse = {
  acs_entrances: Array<AcsEntrance>
}

export type UserIdentitiesListAccessibleEntrancesRequest = SeamHttpRequest<
  UserIdentitiesListAccessibleEntrancesResponse,
  'acs_entrances'
>

export interface UserIdentitiesListAccessibleEntrancesOptions {}

export type UserIdentitiesListAcsSystemsParameters = {
  /**
   * ID of the user identity for which you want to retrieve all access systems.
   */
  user_identity_id: string
}

/**
 * @deprecated Use UserIdentitiesListAcsSystemsRequest instead.
 */
export type UserIdentitiesListAcsSystemsResponse = {
  acs_systems: Array<AcsSystem>
}

export type UserIdentitiesListAcsSystemsRequest = SeamHttpRequest<
  UserIdentitiesListAcsSystemsResponse,
  'acs_systems'
>

export interface UserIdentitiesListAcsSystemsOptions {}

export type UserIdentitiesListAcsUsersParameters = {
  /**
   * ID of the user identity for which you want to retrieve all access system users.
   */
  user_identity_id: string
}

/**
 * @deprecated Use UserIdentitiesListAcsUsersRequest instead.
 */
export type UserIdentitiesListAcsUsersResponse = { acs_users: Array<AcsUser> }

export type UserIdentitiesListAcsUsersRequest = SeamHttpRequest<
  UserIdentitiesListAcsUsersResponse,
  'acs_users'
>

export interface UserIdentitiesListAcsUsersOptions {}

export type UserIdentitiesRemoveAcsUserParameters = {
  /**
   * ID of the access system user that you want to remove from the user identity..
   */
  acs_user_id: string

  /**
   * ID of the user identity from which you want to remove an access system user.
   */
  user_identity_id: string
}

/**
 * @deprecated Use UserIdentitiesRemoveAcsUserRequest instead.
 */
export type UserIdentitiesRemoveAcsUserResponse = void

export type UserIdentitiesRemoveAcsUserRequest = SeamHttpRequest<
  void,
  undefined
>

export interface UserIdentitiesRemoveAcsUserOptions {}

export type UserIdentitiesRevokeAccessToDeviceParameters = {
  /**
   * ID of the managed device to which you want to revoke access from the user identity.
   */
  device_id: string

  /**
   * ID of the user identity from which you want to revoke access to a device.
   */
  user_identity_id: string
}

/**
 * @deprecated Use UserIdentitiesRevokeAccessToDeviceRequest instead.
 */
export type UserIdentitiesRevokeAccessToDeviceResponse = void

export type UserIdentitiesRevokeAccessToDeviceRequest = SeamHttpRequest<
  void,
  undefined
>

export interface UserIdentitiesRevokeAccessToDeviceOptions {}

export type UserIdentitiesUpdateParameters = {
  /**
   * Unique email address for the user identity.
   */
  email_address?: string | undefined
  /**
   * Full name of the user associated with the user identity.
   */
  full_name?: string | undefined
  /**
   * Unique phone number for the user identity.
   */
  phone_number?: string | undefined
  /**
   * ID of the user identity that you want to update.
   */
  user_identity_id: string

  /**
   * Unique key for the user identity.
   */
  user_identity_key?: string | undefined
}

/**
 * @deprecated Use UserIdentitiesUpdateRequest instead.
 */
export type UserIdentitiesUpdateResponse = void

export type UserIdentitiesUpdateRequest = SeamHttpRequest<void, undefined>

export interface UserIdentitiesUpdateOptions {}