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

import type {
  RouteRequestBody,
  RouteRequestParams,
  RouteResponse,
} from '@seamapi/types/connect'

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 { 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 type { SetNonNullable } from 'lib/types.js'

import { SeamHttpUserIdentitiesEnrollmentAutomations } from './enrollment-automations/index.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 enrollmentAutomations(): SeamHttpUserIdentitiesEnrollmentAutomations {
    return SeamHttpUserIdentitiesEnrollmentAutomations.fromClient(
      this.client,
      this.defaults,
    )
  }

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

  addAcsUser(
    parameters?: UserIdentitiesAddAcsUserParameters,
    options: UserIdentitiesAddAcsUserOptions = {},
  ): UserIdentitiesAddAcsUserRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/add_acs_user',
      method: 'PUT',
      body: parameters,
      responseKey: undefined,
      options,
    })
  }

  create(
    parameters?: UserIdentitiesCreateParameters,
    options: UserIdentitiesCreateOptions = {},
  ): UserIdentitiesCreateRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/create',
      method: 'POST',
      body: parameters,
      responseKey: 'user_identity',
      options,
    })
  }

  delete(
    parameters?: UserIdentitiesDeleteParameters,
    options: UserIdentitiesDeleteOptions = {},
  ): UserIdentitiesDeleteRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/delete',
      method: 'POST',
      body: parameters,
      responseKey: undefined,
      options,
    })
  }

  generateInstantKey(
    parameters?: UserIdentitiesGenerateInstantKeyParameters,
    options: UserIdentitiesGenerateInstantKeyOptions = {},
  ): UserIdentitiesGenerateInstantKeyRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/generate_instant_key',
      method: 'POST',
      body: parameters,
      responseKey: 'instant_key',
      options,
    })
  }

  get(
    parameters?: UserIdentitiesGetParameters,
    options: UserIdentitiesGetOptions = {},
  ): UserIdentitiesGetRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/get',
      method: 'GET',
      params: parameters,
      responseKey: 'user_identity',
      options,
    })
  }

  grantAccessToDevice(
    parameters?: UserIdentitiesGrantAccessToDeviceParameters,
    options: UserIdentitiesGrantAccessToDeviceOptions = {},
  ): UserIdentitiesGrantAccessToDeviceRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/grant_access_to_device',
      method: 'PUT',
      body: parameters,
      responseKey: undefined,
      options,
    })
  }

  list(
    parameters?: UserIdentitiesListParameters,
    options: UserIdentitiesListOptions = {},
  ): UserIdentitiesListRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/list',
      method: 'POST',
      body: parameters,
      responseKey: 'user_identities',
      options,
    })
  }

  listAccessibleDevices(
    parameters?: UserIdentitiesListAccessibleDevicesParameters,
    options: UserIdentitiesListAccessibleDevicesOptions = {},
  ): UserIdentitiesListAccessibleDevicesRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/list_accessible_devices',
      method: 'POST',
      body: parameters,
      responseKey: 'devices',
      options,
    })
  }

  listAccessibleEntrances(
    parameters?: UserIdentitiesListAccessibleEntrancesParameters,
    options: UserIdentitiesListAccessibleEntrancesOptions = {},
  ): UserIdentitiesListAccessibleEntrancesRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/list_accessible_entrances',
      method: 'POST',
      body: parameters,
      responseKey: 'acs_entrances',
      options,
    })
  }

  listAcsSystems(
    parameters?: UserIdentitiesListAcsSystemsParameters,
    options: UserIdentitiesListAcsSystemsOptions = {},
  ): UserIdentitiesListAcsSystemsRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/list_acs_systems',
      method: 'POST',
      body: parameters,
      responseKey: 'acs_systems',
      options,
    })
  }

  listAcsUsers(
    parameters?: UserIdentitiesListAcsUsersParameters,
    options: UserIdentitiesListAcsUsersOptions = {},
  ): UserIdentitiesListAcsUsersRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/list_acs_users',
      method: 'POST',
      body: parameters,
      responseKey: 'acs_users',
      options,
    })
  }

  removeAcsUser(
    parameters?: UserIdentitiesRemoveAcsUserParameters,
    options: UserIdentitiesRemoveAcsUserOptions = {},
  ): UserIdentitiesRemoveAcsUserRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/remove_acs_user',
      method: 'POST',
      body: parameters,
      responseKey: undefined,
      options,
    })
  }

  revokeAccessToDevice(
    parameters?: UserIdentitiesRevokeAccessToDeviceParameters,
    options: UserIdentitiesRevokeAccessToDeviceOptions = {},
  ): UserIdentitiesRevokeAccessToDeviceRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/revoke_access_to_device',
      method: 'POST',
      body: parameters,
      responseKey: undefined,
      options,
    })
  }

  update(
    parameters?: UserIdentitiesUpdateParameters,
    options: UserIdentitiesUpdateOptions = {},
  ): UserIdentitiesUpdateRequest {
    return new SeamHttpRequest(this, {
      pathname: '/user_identities/update',
      method: 'PATCH',
      body: parameters,
      responseKey: undefined,
      options,
    })
  }
}

export type UserIdentitiesAddAcsUserParameters =
  RouteRequestBody<'/user_identities/add_acs_user'>

/**
 * @deprecated Use UserIdentitiesAddAcsUserParameters instead.
 */
export type UserIdentitiesAddAcsUserBody = UserIdentitiesAddAcsUserParameters

/**
 * @deprecated Use UserIdentitiesAddAcsUserRequest instead.
 */
export type UserIdentitiesAddAcsUserResponse = SetNonNullable<
  Required<RouteResponse<'/user_identities/add_acs_user'>>
>

export type UserIdentitiesAddAcsUserRequest = SeamHttpRequest<void, undefined>

export interface UserIdentitiesAddAcsUserOptions {}

export type UserIdentitiesCreateParameters =
  RouteRequestBody<'/user_identities/create'>

/**
 * @deprecated Use UserIdentitiesCreateParameters instead.
 */
export type UserIdentitiesCreateBody = UserIdentitiesCreateParameters

/**
 * @deprecated Use UserIdentitiesCreateRequest instead.
 */
export type UserIdentitiesCreateResponse = SetNonNullable<
  Required<RouteResponse<'/user_identities/create'>>
>

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

export interface UserIdentitiesCreateOptions {}

export type UserIdentitiesDeleteParameters =
  RouteRequestBody<'/user_identities/delete'>

/**
 * @deprecated Use UserIdentitiesDeleteParameters instead.
 */
export type UserIdentitiesDeleteParams = UserIdentitiesDeleteParameters

/**
 * @deprecated Use UserIdentitiesDeleteRequest instead.
 */
export type UserIdentitiesDeleteResponse = SetNonNullable<
  Required<RouteResponse<'/user_identities/delete'>>
>

export type UserIdentitiesDeleteRequest = SeamHttpRequest<void, undefined>

export interface UserIdentitiesDeleteOptions {}

export type UserIdentitiesGenerateInstantKeyParameters =
  RouteRequestBody<'/user_identities/generate_instant_key'>

/**
 * @deprecated Use UserIdentitiesGenerateInstantKeyParameters instead.
 */
export type UserIdentitiesGenerateInstantKeyBody =
  UserIdentitiesGenerateInstantKeyParameters

/**
 * @deprecated Use UserIdentitiesGenerateInstantKeyRequest instead.
 */
export type UserIdentitiesGenerateInstantKeyResponse = SetNonNullable<
  Required<RouteResponse<'/user_identities/generate_instant_key'>>
>

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

export interface UserIdentitiesGenerateInstantKeyOptions {}

export type UserIdentitiesGetParameters =
  RouteRequestParams<'/user_identities/get'>

/**
 * @deprecated Use UserIdentitiesGetParameters instead.
 */
export type UserIdentitiesGetParams = UserIdentitiesGetParameters

/**
 * @deprecated Use UserIdentitiesGetRequest instead.
 */
export type UserIdentitiesGetResponse = SetNonNullable<
  Required<RouteResponse<'/user_identities/get'>>
>

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

export interface UserIdentitiesGetOptions {}

export type UserIdentitiesGrantAccessToDeviceParameters =
  RouteRequestBody<'/user_identities/grant_access_to_device'>

/**
 * @deprecated Use UserIdentitiesGrantAccessToDeviceParameters instead.
 */
export type UserIdentitiesGrantAccessToDeviceBody =
  UserIdentitiesGrantAccessToDeviceParameters

/**
 * @deprecated Use UserIdentitiesGrantAccessToDeviceRequest instead.
 */
export type UserIdentitiesGrantAccessToDeviceResponse = SetNonNullable<
  Required<RouteResponse<'/user_identities/grant_access_to_device'>>
>

export type UserIdentitiesGrantAccessToDeviceRequest = SeamHttpRequest<
  void,
  undefined
>

export interface UserIdentitiesGrantAccessToDeviceOptions {}

export type UserIdentitiesListParameters =
  RouteRequestBody<'/user_identities/list'>

/**
 * @deprecated Use UserIdentitiesListParameters instead.
 */
export type UserIdentitiesListParams = UserIdentitiesListParameters

/**
 * @deprecated Use UserIdentitiesListRequest instead.
 */
export type UserIdentitiesListResponse = SetNonNullable<
  Required<RouteResponse<'/user_identities/list'>>
>

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

export interface UserIdentitiesListOptions {}

export type UserIdentitiesListAccessibleDevicesParameters =
  RouteRequestBody<'/user_identities/list_accessible_devices'>

/**
 * @deprecated Use UserIdentitiesListAccessibleDevicesParameters instead.
 */
export type UserIdentitiesListAccessibleDevicesParams =
  UserIdentitiesListAccessibleDevicesParameters

/**
 * @deprecated Use UserIdentitiesListAccessibleDevicesRequest instead.
 */
export type UserIdentitiesListAccessibleDevicesResponse = SetNonNullable<
  Required<RouteResponse<'/user_identities/list_accessible_devices'>>
>

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

export interface UserIdentitiesListAccessibleDevicesOptions {}

export type UserIdentitiesListAccessibleEntrancesParameters =
  RouteRequestBody<'/user_identities/list_accessible_entrances'>

/**
 * @deprecated Use UserIdentitiesListAccessibleEntrancesParameters instead.
 */
export type UserIdentitiesListAccessibleEntrancesParams =
  UserIdentitiesListAccessibleEntrancesParameters

/**
 * @deprecated Use UserIdentitiesListAccessibleEntrancesRequest instead.
 */
export type UserIdentitiesListAccessibleEntrancesResponse = SetNonNullable<
  Required<RouteResponse<'/user_identities/list_accessible_entrances'>>
>

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

export interface UserIdentitiesListAccessibleEntrancesOptions {}

export type UserIdentitiesListAcsSystemsParameters =
  RouteRequestBody<'/user_identities/list_acs_systems'>

/**
 * @deprecated Use UserIdentitiesListAcsSystemsParameters instead.
 */
export type UserIdentitiesListAcsSystemsParams =
  UserIdentitiesListAcsSystemsParameters

/**
 * @deprecated Use UserIdentitiesListAcsSystemsRequest instead.
 */
export type UserIdentitiesListAcsSystemsResponse = SetNonNullable<
  Required<RouteResponse<'/user_identities/list_acs_systems'>>
>

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

export interface UserIdentitiesListAcsSystemsOptions {}

export type UserIdentitiesListAcsUsersParameters =
  RouteRequestBody<'/user_identities/list_acs_users'>

/**
 * @deprecated Use UserIdentitiesListAcsUsersParameters instead.
 */
export type UserIdentitiesListAcsUsersParams =
  UserIdentitiesListAcsUsersParameters

/**
 * @deprecated Use UserIdentitiesListAcsUsersRequest instead.
 */
export type UserIdentitiesListAcsUsersResponse = SetNonNullable<
  Required<RouteResponse<'/user_identities/list_acs_users'>>
>

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

export interface UserIdentitiesListAcsUsersOptions {}

export type UserIdentitiesRemoveAcsUserParameters =
  RouteRequestBody<'/user_identities/remove_acs_user'>

/**
 * @deprecated Use UserIdentitiesRemoveAcsUserParameters instead.
 */
export type UserIdentitiesRemoveAcsUserParams =
  UserIdentitiesRemoveAcsUserParameters

/**
 * @deprecated Use UserIdentitiesRemoveAcsUserRequest instead.
 */
export type UserIdentitiesRemoveAcsUserResponse = SetNonNullable<
  Required<RouteResponse<'/user_identities/remove_acs_user'>>
>

export type UserIdentitiesRemoveAcsUserRequest = SeamHttpRequest<
  void,
  undefined
>

export interface UserIdentitiesRemoveAcsUserOptions {}

export type UserIdentitiesRevokeAccessToDeviceParameters =
  RouteRequestBody<'/user_identities/revoke_access_to_device'>

/**
 * @deprecated Use UserIdentitiesRevokeAccessToDeviceParameters instead.
 */
export type UserIdentitiesRevokeAccessToDeviceParams =
  UserIdentitiesRevokeAccessToDeviceParameters

/**
 * @deprecated Use UserIdentitiesRevokeAccessToDeviceRequest instead.
 */
export type UserIdentitiesRevokeAccessToDeviceResponse = SetNonNullable<
  Required<RouteResponse<'/user_identities/revoke_access_to_device'>>
>

export type UserIdentitiesRevokeAccessToDeviceRequest = SeamHttpRequest<
  void,
  undefined
>

export interface UserIdentitiesRevokeAccessToDeviceOptions {}

export type UserIdentitiesUpdateParameters =
  RouteRequestBody<'/user_identities/update'>

/**
 * @deprecated Use UserIdentitiesUpdateParameters instead.
 */
export type UserIdentitiesUpdateBody = UserIdentitiesUpdateParameters

/**
 * @deprecated Use UserIdentitiesUpdateRequest instead.
 */
export type UserIdentitiesUpdateResponse = SetNonNullable<
  Required<RouteResponse<'/user_identities/update'>>
>

export type UserIdentitiesUpdateRequest = SeamHttpRequest<void, undefined>

export interface UserIdentitiesUpdateOptions {}