@seamapi/http 1.36.0 → 1.38.0

package/src/lib/seam/connect/routes/acs/entrances/entrances.ts

@@ -164,83 +164,138 @@ export class SeamHttpAcsEntrances {
   }
 
   get(
-    params?: AcsEntrancesGetParams,
-  ): SeamHttpRequest<AcsEntrancesGetResponse, 'acs_entrance'> {
+    parameters?: AcsEntrancesGetParameters,
+    options: AcsEntrancesGetOptions = {},
+  ): AcsEntrancesGetRequest {
     return new SeamHttpRequest(this, {
       pathname: '/acs/entrances/get',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'acs_entrance',
+      options,
     })
   }
 
   grantAccess(
-    body?: AcsEntrancesGrantAccessBody,
-  ): SeamHttpRequest<void, undefined> {
+    parameters?: AcsEntrancesGrantAccessParameters,
+    options: AcsEntrancesGrantAccessOptions = {},
+  ): AcsEntrancesGrantAccessRequest {
     return new SeamHttpRequest(this, {
       pathname: '/acs/entrances/grant_access',
       method: 'POST',
-      body,
+      body: parameters,
       responseKey: undefined,
+      options,
     })
   }
 
   list(
-    params?: AcsEntrancesListParams,
-  ): SeamHttpRequest<AcsEntrancesListResponse, 'acs_entrances'> {
+    parameters?: AcsEntrancesListParameters,
+    options: AcsEntrancesListOptions = {},
+  ): AcsEntrancesListRequest {
     return new SeamHttpRequest(this, {
       pathname: '/acs/entrances/list',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'acs_entrances',
+      options,
     })
   }
 
   listCredentialsWithAccess(
-    params?: AcsEntrancesListCredentialsWithAccessParams,
-  ): SeamHttpRequest<
-    AcsEntrancesListCredentialsWithAccessResponse,
-    'acs_credentials'
-  > {
+    parameters?: AcsEntrancesListCredentialsWithAccessParameters,
+    options: AcsEntrancesListCredentialsWithAccessOptions = {},
+  ): AcsEntrancesListCredentialsWithAccessRequest {
     return new SeamHttpRequest(this, {
       pathname: '/acs/entrances/list_credentials_with_access',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'acs_credentials',
+      options,
     })
   }
 }
 
-export type AcsEntrancesGetParams = RouteRequestBody<'/acs/entrances/get'>
+export type AcsEntrancesGetParameters = RouteRequestBody<'/acs/entrances/get'>
 
+/**
+ * @deprecated Use AcsEntrancesGetParameters instead.
+ */
+export type AcsEntrancesGetParams = AcsEntrancesGetParameters
+
+/**
+ * @deprecated Use AcsEntrancesGetRequest instead.
+ */
 export type AcsEntrancesGetResponse = SetNonNullable<
   Required<RouteResponse<'/acs/entrances/get'>>
 >
 
-export type AcsEntrancesGetOptions = never
+export type AcsEntrancesGetRequest = SeamHttpRequest<
+  AcsEntrancesGetResponse,
+  'acs_entrance'
+>
+
+export type AcsEntrancesGetOptions = Record<string, never>
 
-export type AcsEntrancesGrantAccessBody =
+export type AcsEntrancesGrantAccessParameters =
   RouteRequestBody<'/acs/entrances/grant_access'>
 
+/**
+ * @deprecated Use AcsEntrancesGrantAccessParameters instead.
+ */
+export type AcsEntrancesGrantAccessBody = AcsEntrancesGrantAccessParameters
+
+/**
+ * @deprecated Use AcsEntrancesGrantAccessRequest instead.
+ */
 export type AcsEntrancesGrantAccessResponse = SetNonNullable<
   Required<RouteResponse<'/acs/entrances/grant_access'>>
 >
 
-export type AcsEntrancesGrantAccessOptions = never
+export type AcsEntrancesGrantAccessRequest = SeamHttpRequest<void, undefined>
+
+export type AcsEntrancesGrantAccessOptions = Record<string, never>
 
-export type AcsEntrancesListParams = RouteRequestBody<'/acs/entrances/list'>
+export type AcsEntrancesListParameters = RouteRequestBody<'/acs/entrances/list'>
+
+/**
+ * @deprecated Use AcsEntrancesListParameters instead.
+ */
+export type AcsEntrancesListParams = AcsEntrancesListParameters
 
+/**
+ * @deprecated Use AcsEntrancesListRequest instead.
+ */
 export type AcsEntrancesListResponse = SetNonNullable<
   Required<RouteResponse<'/acs/entrances/list'>>
 >
 
-export type AcsEntrancesListOptions = never
+export type AcsEntrancesListRequest = SeamHttpRequest<
+  AcsEntrancesListResponse,
+  'acs_entrances'
+>
 
-export type AcsEntrancesListCredentialsWithAccessParams =
+export type AcsEntrancesListOptions = Record<string, never>
+
+export type AcsEntrancesListCredentialsWithAccessParameters =
   RouteRequestBody<'/acs/entrances/list_credentials_with_access'>
 
+/**
+ * @deprecated Use AcsEntrancesListCredentialsWithAccessParameters instead.
+ */
+export type AcsEntrancesListCredentialsWithAccessParams =
+  AcsEntrancesListCredentialsWithAccessParameters
+
+/**
+ * @deprecated Use AcsEntrancesListCredentialsWithAccessRequest instead.
+ */
 export type AcsEntrancesListCredentialsWithAccessResponse = SetNonNullable<
   Required<RouteResponse<'/acs/entrances/list_credentials_with_access'>>
 >
 
-export type AcsEntrancesListCredentialsWithAccessOptions = never
+export type AcsEntrancesListCredentialsWithAccessRequest = SeamHttpRequest<
+  AcsEntrancesListCredentialsWithAccessResponse,
+  'acs_credentials'
+>
+
+export type AcsEntrancesListCredentialsWithAccessOptions = Record<string, never>

package/src/lib/seam/connect/routes/acs/index.ts

@@ -5,6 +5,8 @@
 
 export * from './access-groups/index.js'
 export * from './acs.js'
+export * from './credential-pools/index.js'
+export * from './credential-provisioning-automations/index.js'
 export * from './credentials/index.js'
 export * from './encoders/index.js'
 export * from './entrances/index.js'

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

@@ -164,61 +164,99 @@ export class SeamHttpAcsSystems {
   }
 
   get(
-    params?: AcsSystemsGetParams,
-  ): SeamHttpRequest<AcsSystemsGetResponse, 'acs_system'> {
+    parameters?: AcsSystemsGetParameters,
+    options: AcsSystemsGetOptions = {},
+  ): AcsSystemsGetRequest {
     return new SeamHttpRequest(this, {
       pathname: '/acs/systems/get',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'acs_system',
+      options,
     })
   }
 
   list(
-    params?: AcsSystemsListParams,
-  ): SeamHttpRequest<AcsSystemsListResponse, 'acs_systems'> {
+    parameters?: AcsSystemsListParameters,
+    options: AcsSystemsListOptions = {},
+  ): AcsSystemsListRequest {
     return new SeamHttpRequest(this, {
       pathname: '/acs/systems/list',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'acs_systems',
+      options,
     })
   }
 
   listCompatibleCredentialManagerAcsSystems(
-    params?: AcsSystemsListCompatibleCredentialManagerAcsSystemsParams,
-  ): SeamHttpRequest<
-    AcsSystemsListCompatibleCredentialManagerAcsSystemsResponse,
-    'acs_systems'
-  > {
+    parameters?: AcsSystemsListCompatibleCredentialManagerAcsSystemsParameters,
+    options: AcsSystemsListCompatibleCredentialManagerAcsSystemsOptions = {},
+  ): AcsSystemsListCompatibleCredentialManagerAcsSystemsRequest {
     return new SeamHttpRequest(this, {
       pathname: '/acs/systems/list_compatible_credential_manager_acs_systems',
       method: 'POST',
-      body: params,
+      body: parameters,
       responseKey: 'acs_systems',
+      options,
     })
   }
 }
 
-export type AcsSystemsGetParams = RouteRequestBody<'/acs/systems/get'>
+export type AcsSystemsGetParameters = RouteRequestBody<'/acs/systems/get'>
+
+/**
+ * @deprecated Use AcsSystemsGetParameters instead.
+ */
+export type AcsSystemsGetParams = AcsSystemsGetParameters
 
+/**
+ * @deprecated Use AcsSystemsGetRequest instead.
+ */
 export type AcsSystemsGetResponse = SetNonNullable<
   Required<RouteResponse<'/acs/systems/get'>>
 >
 
-export type AcsSystemsGetOptions = never
+export type AcsSystemsGetRequest = SeamHttpRequest<
+  AcsSystemsGetResponse,
+  'acs_system'
+>
 
-export type AcsSystemsListParams = RouteRequestBody<'/acs/systems/list'>
+export type AcsSystemsGetOptions = Record<string, never>
 
+export type AcsSystemsListParameters = RouteRequestBody<'/acs/systems/list'>
+
+/**
+ * @deprecated Use AcsSystemsListParameters instead.
+ */
+export type AcsSystemsListParams = AcsSystemsListParameters
+
+/**
+ * @deprecated Use AcsSystemsListRequest instead.
+ */
 export type AcsSystemsListResponse = SetNonNullable<
   Required<RouteResponse<'/acs/systems/list'>>
 >
 
-export type AcsSystemsListOptions = never
+export type AcsSystemsListRequest = SeamHttpRequest<
+  AcsSystemsListResponse,
+  'acs_systems'
+>
+
+export type AcsSystemsListOptions = Record<string, never>
 
-export type AcsSystemsListCompatibleCredentialManagerAcsSystemsParams =
+export type AcsSystemsListCompatibleCredentialManagerAcsSystemsParameters =
   RouteRequestBody<'/acs/systems/list_compatible_credential_manager_acs_systems'>
 
+/**
+ * @deprecated Use AcsSystemsListCompatibleCredentialManagerAcsSystemsParameters instead.
+ */
+export type AcsSystemsListCompatibleCredentialManagerAcsSystemsParams =
+  AcsSystemsListCompatibleCredentialManagerAcsSystemsParameters
+
+/**
+ * @deprecated Use AcsSystemsListCompatibleCredentialManagerAcsSystemsRequest instead.
+ */
 export type AcsSystemsListCompatibleCredentialManagerAcsSystemsResponse =
   SetNonNullable<
     Required<
@@ -226,4 +264,13 @@ export type AcsSystemsListCompatibleCredentialManagerAcsSystemsResponse =
     >
   >
 
-export type AcsSystemsListCompatibleCredentialManagerAcsSystemsOptions = never
+export type AcsSystemsListCompatibleCredentialManagerAcsSystemsRequest =
+  SeamHttpRequest<
+    AcsSystemsListCompatibleCredentialManagerAcsSystemsResponse,
+    'acs_systems'
+  >
+
+export type AcsSystemsListCompatibleCredentialManagerAcsSystemsOptions = Record<
+  string,
+  never
+>

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

@@ -3,4 +3,5 @@
  * Do not edit this file or add other files to this directory.
  */
 
+export * from './unmanaged/index.js'
 export * from './users.js'

package/src/lib/seam/connect/routes/acs/users/unmanaged/index.ts

@@ -0,0 +1,6 @@
+/*
+ * Automatically generated by codegen/smith.ts.
+ * Do not edit this file or add other files to this directory.
+ */
+
+export * from './unmanaged.js'

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

@@ -0,0 +1,250 @@
+/*
+ * Automatically generated by codegen/smith.ts.
+ * Do not edit this file or add other files to this directory.
+ */
+
+import type { RouteRequestBody, 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'
+
+export class SeamHttpAcsUsersUnmanaged {
+  client: Client
+  readonly defaults: Required<SeamHttpRequestOptions>
+  readonly ltsVersion = seamApiLtsVersion
+  static ltsVersion = seamApiLtsVersion
+
+  constructor(apiKeyOrOptions: string | SeamHttpOptions = {}) {
+    const options = parseOptions(apiKeyOrOptions)
+    if (!options.isUndocumentedApiEnabled) {
+      throw new Error(
+        'Cannot use undocumented API without isUndocumentedApiEnabled',
+      )
+    }
+    this.client = 'client' in options ? options.client : createClient(options)
+    this.defaults = limitToSeamHttpRequestOptions(options)
+  }
+
+  static fromClient(
+    client: SeamHttpOptionsWithClient['client'],
+    options: Omit<SeamHttpOptionsWithClient, 'client'> = {},
+  ): SeamHttpAcsUsersUnmanaged {
+    const constructorOptions = { ...options, client }
+    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError('Missing client')
+    }
+    return new SeamHttpAcsUsersUnmanaged(constructorOptions)
+  }
+
+  static fromApiKey(
+    apiKey: SeamHttpOptionsWithApiKey['apiKey'],
+    options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
+  ): SeamHttpAcsUsersUnmanaged {
+    const constructorOptions = { ...options, apiKey }
+    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError('Missing apiKey')
+    }
+    return new SeamHttpAcsUsersUnmanaged(constructorOptions)
+  }
+
+  static fromClientSessionToken(
+    clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'],
+    options: Omit<
+      SeamHttpOptionsWithClientSessionToken,
+      'clientSessionToken'
+    > = {},
+  ): SeamHttpAcsUsersUnmanaged {
+    const constructorOptions = { ...options, clientSessionToken }
+    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
+    }
+    return new SeamHttpAcsUsersUnmanaged(constructorOptions)
+  }
+
+  static async fromPublishableKey(
+    publishableKey: string,
+    userIdentifierKey: string,
+    options: SeamHttpFromPublishableKeyOptions = {},
+  ): Promise<SeamHttpAcsUsersUnmanaged> {
+    warnOnInsecureuserIdentifierKey(userIdentifierKey)
+    const clientOptions = parseOptions({ ...options, publishableKey })
+    if (isSeamHttpOptionsWithClient(clientOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'The client option cannot be used with SeamHttpAcsUsersUnmanaged.fromPublishableKey',
+      )
+    }
+    const client = createClient(clientOptions)
+    const clientSessions = SeamHttpClientSessions.fromClient(client)
+    const { token } = await clientSessions.getOrCreate({
+      user_identifier_key: userIdentifierKey,
+    })
+    return SeamHttpAcsUsersUnmanaged.fromClientSessionToken(token, options)
+  }
+
+  static fromConsoleSessionToken(
+    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
+    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithConsoleSessionToken,
+      'consoleSessionToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpAcsUsersUnmanaged {
+    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
+    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing consoleSessionToken or workspaceId',
+      )
+    }
+    return new SeamHttpAcsUsersUnmanaged(constructorOptions)
+  }
+
+  static fromPersonalAccessToken(
+    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
+    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
+    options: Omit<
+      SeamHttpOptionsWithPersonalAccessToken,
+      'personalAccessToken' | 'workspaceId'
+    > = {},
+  ): SeamHttpAcsUsersUnmanaged {
+    const constructorOptions = { ...options, personalAccessToken, workspaceId }
+    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
+      throw new SeamHttpInvalidOptionsError(
+        'Missing personalAccessToken or workspaceId',
+      )
+    }
+    return new SeamHttpAcsUsersUnmanaged(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(
+    parameters?: AcsUsersUnmanagedGetParameters,
+    options: AcsUsersUnmanagedGetOptions = {},
+  ): AcsUsersUnmanagedGetRequest {
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        'Cannot use undocumented API without isUndocumentedApiEnabled',
+      )
+    }
+    return new SeamHttpRequest(this, {
+      pathname: '/acs/users/unmanaged/get',
+      method: 'POST',
+      body: parameters,
+      responseKey: 'acs_user',
+      options,
+    })
+  }
+
+  list(
+    parameters?: AcsUsersUnmanagedListParameters,
+    options: AcsUsersUnmanagedListOptions = {},
+  ): AcsUsersUnmanagedListRequest {
+    if (!this.defaults.isUndocumentedApiEnabled) {
+      throw new Error(
+        'Cannot use undocumented API without isUndocumentedApiEnabled',
+      )
+    }
+    return new SeamHttpRequest(this, {
+      pathname: '/acs/users/unmanaged/list',
+      method: 'POST',
+      body: parameters,
+      responseKey: 'acs_users',
+      options,
+    })
+  }
+}
+
+export type AcsUsersUnmanagedGetParameters =
+  RouteRequestBody<'/acs/users/unmanaged/get'>
+
+/**
+ * @deprecated Use AcsUsersUnmanagedGetParameters instead.
+ */
+export type AcsUsersUnmanagedGetParams = AcsUsersUnmanagedGetParameters
+
+/**
+ * @deprecated Use AcsUsersUnmanagedGetRequest instead.
+ */
+export type AcsUsersUnmanagedGetResponse = SetNonNullable<
+  Required<RouteResponse<'/acs/users/unmanaged/get'>>
+>
+
+export type AcsUsersUnmanagedGetRequest = SeamHttpRequest<
+  AcsUsersUnmanagedGetResponse,
+  'acs_user'
+>
+
+export type AcsUsersUnmanagedGetOptions = Record<string, never>
+
+export type AcsUsersUnmanagedListParameters =
+  RouteRequestBody<'/acs/users/unmanaged/list'>
+
+/**
+ * @deprecated Use AcsUsersUnmanagedListParameters instead.
+ */
+export type AcsUsersUnmanagedListParams = AcsUsersUnmanagedListParameters
+
+/**
+ * @deprecated Use AcsUsersUnmanagedListRequest instead.
+ */
+export type AcsUsersUnmanagedListResponse = SetNonNullable<
+  Required<RouteResponse<'/acs/users/unmanaged/list'>>
+>
+
+export type AcsUsersUnmanagedListRequest = SeamHttpRequest<
+  AcsUsersUnmanagedListResponse,
+  'acs_users'
+>
+
+export type AcsUsersUnmanagedListOptions = Record<string, never>