@seamapi/http 2.1.0 → 2.3.0

package/src/lib/seam/connect/routes/seam-http-endpoints.ts

@@ -1,3761 +0,0 @@
-/*
- * 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 { SeamHttpRequest } from 'lib/seam/connect/seam-http-request.js'
-import { SeamPaginator } from 'lib/seam/connect/seam-paginator.js'
-
-import {
-  type AccessCodesCreateMultipleOptions,
-  type AccessCodesCreateMultipleParameters,
-  type AccessCodesCreateMultipleRequest,
-  type AccessCodesCreateOptions,
-  type AccessCodesCreateParameters,
-  type AccessCodesCreateRequest,
-  type AccessCodesDeleteOptions,
-  type AccessCodesDeleteParameters,
-  type AccessCodesDeleteRequest,
-  type AccessCodesGenerateCodeOptions,
-  type AccessCodesGenerateCodeParameters,
-  type AccessCodesGenerateCodeRequest,
-  type AccessCodesGetOptions,
-  type AccessCodesGetParameters,
-  type AccessCodesGetRequest,
-  type AccessCodesListOptions,
-  type AccessCodesListParameters,
-  type AccessCodesListRequest,
-  type AccessCodesPullBackupAccessCodeOptions,
-  type AccessCodesPullBackupAccessCodeParameters,
-  type AccessCodesPullBackupAccessCodeRequest,
-  type AccessCodesReportDeviceConstraintsOptions,
-  type AccessCodesReportDeviceConstraintsParameters,
-  type AccessCodesReportDeviceConstraintsRequest,
-  type AccessCodesUpdateMultipleOptions,
-  type AccessCodesUpdateMultipleParameters,
-  type AccessCodesUpdateMultipleRequest,
-  type AccessCodesUpdateOptions,
-  type AccessCodesUpdateParameters,
-  type AccessCodesUpdateRequest,
-  SeamHttpAccessCodes,
-} from './access-codes/index.js'
-import {
-  type AccessCodesSimulateCreateUnmanagedAccessCodeOptions,
-  type AccessCodesSimulateCreateUnmanagedAccessCodeParameters,
-  type AccessCodesSimulateCreateUnmanagedAccessCodeRequest,
-  SeamHttpAccessCodesSimulate,
-} from './access-codes/simulate/index.js'
-import {
-  type AccessCodesUnmanagedConvertToManagedOptions,
-  type AccessCodesUnmanagedConvertToManagedParameters,
-  type AccessCodesUnmanagedConvertToManagedRequest,
-  type AccessCodesUnmanagedDeleteOptions,
-  type AccessCodesUnmanagedDeleteParameters,
-  type AccessCodesUnmanagedDeleteRequest,
-  type AccessCodesUnmanagedGetOptions,
-  type AccessCodesUnmanagedGetParameters,
-  type AccessCodesUnmanagedGetRequest,
-  type AccessCodesUnmanagedListOptions,
-  type AccessCodesUnmanagedListParameters,
-  type AccessCodesUnmanagedListRequest,
-  type AccessCodesUnmanagedUpdateOptions,
-  type AccessCodesUnmanagedUpdateParameters,
-  type AccessCodesUnmanagedUpdateRequest,
-  SeamHttpAccessCodesUnmanaged,
-} from './access-codes/unmanaged/index.js'
-import {
-  type AccessGrantsCreateOptions,
-  type AccessGrantsCreateParameters,
-  type AccessGrantsCreateRequest,
-  type AccessGrantsDeleteOptions,
-  type AccessGrantsDeleteParameters,
-  type AccessGrantsDeleteRequest,
-  type AccessGrantsGetOptions,
-  type AccessGrantsGetParameters,
-  type AccessGrantsGetRelatedOptions,
-  type AccessGrantsGetRelatedParameters,
-  type AccessGrantsGetRelatedRequest,
-  type AccessGrantsGetRequest,
-  type AccessGrantsListOptions,
-  type AccessGrantsListParameters,
-  type AccessGrantsListRequest,
-  type AccessGrantsRequestAccessMethodsOptions,
-  type AccessGrantsRequestAccessMethodsParameters,
-  type AccessGrantsRequestAccessMethodsRequest,
-  type AccessGrantsUpdateOptions,
-  type AccessGrantsUpdateParameters,
-  type AccessGrantsUpdateRequest,
-  SeamHttpAccessGrants,
-} from './access-grants/index.js'
-import {
-  type AccessGrantsUnmanagedGetOptions,
-  type AccessGrantsUnmanagedGetParameters,
-  type AccessGrantsUnmanagedGetRequest,
-  type AccessGrantsUnmanagedListOptions,
-  type AccessGrantsUnmanagedListParameters,
-  type AccessGrantsUnmanagedListRequest,
-  type AccessGrantsUnmanagedUpdateOptions,
-  type AccessGrantsUnmanagedUpdateParameters,
-  type AccessGrantsUnmanagedUpdateRequest,
-  SeamHttpAccessGrantsUnmanaged,
-} from './access-grants/unmanaged/index.js'
-import {
-  type AccessMethodsAssignCardOptions,
-  type AccessMethodsAssignCardParameters,
-  type AccessMethodsAssignCardRequest,
-  type AccessMethodsDeleteOptions,
-  type AccessMethodsDeleteParameters,
-  type AccessMethodsDeleteRequest,
-  type AccessMethodsEncodeOptions,
-  type AccessMethodsEncodeParameters,
-  type AccessMethodsEncodeRequest,
-  type AccessMethodsGetOptions,
-  type AccessMethodsGetParameters,
-  type AccessMethodsGetRelatedOptions,
-  type AccessMethodsGetRelatedParameters,
-  type AccessMethodsGetRelatedRequest,
-  type AccessMethodsGetRequest,
-  type AccessMethodsListOptions,
-  type AccessMethodsListParameters,
-  type AccessMethodsListRequest,
-  type AccessMethodsUnlockDoorOptions,
-  type AccessMethodsUnlockDoorParameters,
-  type AccessMethodsUnlockDoorRequest,
-  SeamHttpAccessMethods,
-} from './access-methods/index.js'
-import {
-  type AccessMethodsUnmanagedGetOptions,
-  type AccessMethodsUnmanagedGetParameters,
-  type AccessMethodsUnmanagedGetRequest,
-  type AccessMethodsUnmanagedListOptions,
-  type AccessMethodsUnmanagedListParameters,
-  type AccessMethodsUnmanagedListRequest,
-  SeamHttpAccessMethodsUnmanaged,
-} from './access-methods/unmanaged/index.js'
-import {
-  type AcsAccessGroupsAddUserOptions,
-  type AcsAccessGroupsAddUserParameters,
-  type AcsAccessGroupsAddUserRequest,
-  type AcsAccessGroupsDeleteOptions,
-  type AcsAccessGroupsDeleteParameters,
-  type AcsAccessGroupsDeleteRequest,
-  type AcsAccessGroupsGetOptions,
-  type AcsAccessGroupsGetParameters,
-  type AcsAccessGroupsGetRequest,
-  type AcsAccessGroupsListAccessibleEntrancesOptions,
-  type AcsAccessGroupsListAccessibleEntrancesParameters,
-  type AcsAccessGroupsListAccessibleEntrancesRequest,
-  type AcsAccessGroupsListOptions,
-  type AcsAccessGroupsListParameters,
-  type AcsAccessGroupsListRequest,
-  type AcsAccessGroupsListUsersOptions,
-  type AcsAccessGroupsListUsersParameters,
-  type AcsAccessGroupsListUsersRequest,
-  type AcsAccessGroupsRemoveUserOptions,
-  type AcsAccessGroupsRemoveUserParameters,
-  type AcsAccessGroupsRemoveUserRequest,
-  SeamHttpAcsAccessGroups,
-} from './acs/access-groups/index.js'
-import {
-  type AcsCredentialsAssignOptions,
-  type AcsCredentialsAssignParameters,
-  type AcsCredentialsAssignRequest,
-  type AcsCredentialsCreateOptions,
-  type AcsCredentialsCreateParameters,
-  type AcsCredentialsCreateRequest,
-  type AcsCredentialsDeleteOptions,
-  type AcsCredentialsDeleteParameters,
-  type AcsCredentialsDeleteRequest,
-  type AcsCredentialsGetOptions,
-  type AcsCredentialsGetParameters,
-  type AcsCredentialsGetRequest,
-  type AcsCredentialsListAccessibleEntrancesOptions,
-  type AcsCredentialsListAccessibleEntrancesParameters,
-  type AcsCredentialsListAccessibleEntrancesRequest,
-  type AcsCredentialsListOptions,
-  type AcsCredentialsListParameters,
-  type AcsCredentialsListRequest,
-  type AcsCredentialsUnassignOptions,
-  type AcsCredentialsUnassignParameters,
-  type AcsCredentialsUnassignRequest,
-  type AcsCredentialsUpdateOptions,
-  type AcsCredentialsUpdateParameters,
-  type AcsCredentialsUpdateRequest,
-  SeamHttpAcsCredentials,
-} from './acs/credentials/index.js'
-import {
-  type AcsEncodersEncodeCredentialOptions,
-  type AcsEncodersEncodeCredentialParameters,
-  type AcsEncodersEncodeCredentialRequest,
-  type AcsEncodersGetOptions,
-  type AcsEncodersGetParameters,
-  type AcsEncodersGetRequest,
-  type AcsEncodersListOptions,
-  type AcsEncodersListParameters,
-  type AcsEncodersListRequest,
-  type AcsEncodersScanCredentialOptions,
-  type AcsEncodersScanCredentialParameters,
-  type AcsEncodersScanCredentialRequest,
-  type AcsEncodersScanToAssignCredentialOptions,
-  type AcsEncodersScanToAssignCredentialParameters,
-  type AcsEncodersScanToAssignCredentialRequest,
-  SeamHttpAcsEncoders,
-} from './acs/encoders/index.js'
-import {
-  type AcsEncodersSimulateNextCredentialEncodeWillFailOptions,
-  type AcsEncodersSimulateNextCredentialEncodeWillFailParameters,
-  type AcsEncodersSimulateNextCredentialEncodeWillFailRequest,
-  type AcsEncodersSimulateNextCredentialEncodeWillSucceedOptions,
-  type AcsEncodersSimulateNextCredentialEncodeWillSucceedParameters,
-  type AcsEncodersSimulateNextCredentialEncodeWillSucceedRequest,
-  type AcsEncodersSimulateNextCredentialScanWillFailOptions,
-  type AcsEncodersSimulateNextCredentialScanWillFailParameters,
-  type AcsEncodersSimulateNextCredentialScanWillFailRequest,
-  type AcsEncodersSimulateNextCredentialScanWillSucceedOptions,
-  type AcsEncodersSimulateNextCredentialScanWillSucceedParameters,
-  type AcsEncodersSimulateNextCredentialScanWillSucceedRequest,
-  SeamHttpAcsEncodersSimulate,
-} from './acs/encoders/simulate/index.js'
-import {
-  type AcsEntrancesGetOptions,
-  type AcsEntrancesGetParameters,
-  type AcsEntrancesGetRequest,
-  type AcsEntrancesGrantAccessOptions,
-  type AcsEntrancesGrantAccessParameters,
-  type AcsEntrancesGrantAccessRequest,
-  type AcsEntrancesListCredentialsWithAccessOptions,
-  type AcsEntrancesListCredentialsWithAccessParameters,
-  type AcsEntrancesListCredentialsWithAccessRequest,
-  type AcsEntrancesListOptions,
-  type AcsEntrancesListParameters,
-  type AcsEntrancesListRequest,
-  type AcsEntrancesUnlockOptions,
-  type AcsEntrancesUnlockParameters,
-  type AcsEntrancesUnlockRequest,
-  SeamHttpAcsEntrances,
-} from './acs/entrances/index.js'
-import {
-  type AcsSystemsGetOptions,
-  type AcsSystemsGetParameters,
-  type AcsSystemsGetRequest,
-  type AcsSystemsListCompatibleCredentialManagerAcsSystemsOptions,
-  type AcsSystemsListCompatibleCredentialManagerAcsSystemsParameters,
-  type AcsSystemsListCompatibleCredentialManagerAcsSystemsRequest,
-  type AcsSystemsListOptions,
-  type AcsSystemsListParameters,
-  type AcsSystemsListRequest,
-  type AcsSystemsReportDevicesOptions,
-  type AcsSystemsReportDevicesParameters,
-  type AcsSystemsReportDevicesRequest,
-  SeamHttpAcsSystems,
-} from './acs/systems/index.js'
-import {
-  type AcsUsersAddToAccessGroupOptions,
-  type AcsUsersAddToAccessGroupParameters,
-  type AcsUsersAddToAccessGroupRequest,
-  type AcsUsersCreateOptions,
-  type AcsUsersCreateParameters,
-  type AcsUsersCreateRequest,
-  type AcsUsersDeleteOptions,
-  type AcsUsersDeleteParameters,
-  type AcsUsersDeleteRequest,
-  type AcsUsersGetOptions,
-  type AcsUsersGetParameters,
-  type AcsUsersGetRequest,
-  type AcsUsersListAccessibleEntrancesOptions,
-  type AcsUsersListAccessibleEntrancesParameters,
-  type AcsUsersListAccessibleEntrancesRequest,
-  type AcsUsersListOptions,
-  type AcsUsersListParameters,
-  type AcsUsersListRequest,
-  type AcsUsersRemoveFromAccessGroupOptions,
-  type AcsUsersRemoveFromAccessGroupParameters,
-  type AcsUsersRemoveFromAccessGroupRequest,
-  type AcsUsersRevokeAccessToAllEntrancesOptions,
-  type AcsUsersRevokeAccessToAllEntrancesParameters,
-  type AcsUsersRevokeAccessToAllEntrancesRequest,
-  type AcsUsersSuspendOptions,
-  type AcsUsersSuspendParameters,
-  type AcsUsersSuspendRequest,
-  type AcsUsersUnsuspendOptions,
-  type AcsUsersUnsuspendParameters,
-  type AcsUsersUnsuspendRequest,
-  type AcsUsersUpdateOptions,
-  type AcsUsersUpdateParameters,
-  type AcsUsersUpdateRequest,
-  SeamHttpAcsUsers,
-} from './acs/users/index.js'
-import {
-  type ActionAttemptsGetOptions,
-  type ActionAttemptsGetParameters,
-  type ActionAttemptsGetRequest,
-  type ActionAttemptsListOptions,
-  type ActionAttemptsListParameters,
-  type ActionAttemptsListRequest,
-  SeamHttpActionAttempts,
-} from './action-attempts/index.js'
-import {
-  type ClientSessionsCreateOptions,
-  type ClientSessionsCreateParameters,
-  type ClientSessionsCreateRequest,
-  type ClientSessionsDeleteOptions,
-  type ClientSessionsDeleteParameters,
-  type ClientSessionsDeleteRequest,
-  type ClientSessionsGetOptions,
-  type ClientSessionsGetOrCreateOptions,
-  type ClientSessionsGetOrCreateParameters,
-  type ClientSessionsGetOrCreateRequest,
-  type ClientSessionsGetParameters,
-  type ClientSessionsGetRequest,
-  type ClientSessionsGrantAccessOptions,
-  type ClientSessionsGrantAccessParameters,
-  type ClientSessionsGrantAccessRequest,
-  type ClientSessionsListOptions,
-  type ClientSessionsListParameters,
-  type ClientSessionsListRequest,
-  type ClientSessionsRevokeOptions,
-  type ClientSessionsRevokeParameters,
-  type ClientSessionsRevokeRequest,
-  SeamHttpClientSessions,
-} from './client-sessions/index.js'
-import {
-  type ConnectWebviewsCreateOptions,
-  type ConnectWebviewsCreateParameters,
-  type ConnectWebviewsCreateRequest,
-  type ConnectWebviewsDeleteOptions,
-  type ConnectWebviewsDeleteParameters,
-  type ConnectWebviewsDeleteRequest,
-  type ConnectWebviewsGetOptions,
-  type ConnectWebviewsGetParameters,
-  type ConnectWebviewsGetRequest,
-  type ConnectWebviewsListOptions,
-  type ConnectWebviewsListParameters,
-  type ConnectWebviewsListRequest,
-  SeamHttpConnectWebviews,
-} from './connect-webviews/index.js'
-import {
-  type ConnectedAccountsDeleteOptions,
-  type ConnectedAccountsDeleteParameters,
-  type ConnectedAccountsDeleteRequest,
-  type ConnectedAccountsGetOptions,
-  type ConnectedAccountsGetParameters,
-  type ConnectedAccountsGetRequest,
-  type ConnectedAccountsListOptions,
-  type ConnectedAccountsListParameters,
-  type ConnectedAccountsListRequest,
-  type ConnectedAccountsSyncOptions,
-  type ConnectedAccountsSyncParameters,
-  type ConnectedAccountsSyncRequest,
-  type ConnectedAccountsUpdateOptions,
-  type ConnectedAccountsUpdateParameters,
-  type ConnectedAccountsUpdateRequest,
-  SeamHttpConnectedAccounts,
-} from './connected-accounts/index.js'
-import {
-  type ConnectedAccountsSimulateDisconnectOptions,
-  type ConnectedAccountsSimulateDisconnectParameters,
-  type ConnectedAccountsSimulateDisconnectRequest,
-  SeamHttpConnectedAccountsSimulate,
-} from './connected-accounts/simulate/index.js'
-import {
-  type CustomersCreatePortalOptions,
-  type CustomersCreatePortalParameters,
-  type CustomersCreatePortalRequest,
-  type CustomersDeleteDataOptions,
-  type CustomersDeleteDataParameters,
-  type CustomersDeleteDataRequest,
-  type CustomersPushDataOptions,
-  type CustomersPushDataParameters,
-  type CustomersPushDataRequest,
-  SeamHttpCustomers,
-} from './customers/index.js'
-import {
-  type DevicesGetOptions,
-  type DevicesGetParameters,
-  type DevicesGetRequest,
-  type DevicesListDeviceProvidersOptions,
-  type DevicesListDeviceProvidersParameters,
-  type DevicesListDeviceProvidersRequest,
-  type DevicesListOptions,
-  type DevicesListParameters,
-  type DevicesListRequest,
-  type DevicesReportProviderMetadataOptions,
-  type DevicesReportProviderMetadataParameters,
-  type DevicesReportProviderMetadataRequest,
-  type DevicesUpdateOptions,
-  type DevicesUpdateParameters,
-  type DevicesUpdateRequest,
-  SeamHttpDevices,
-} from './devices/index.js'
-import {
-  type DevicesSimulateConnectOptions,
-  type DevicesSimulateConnectParameters,
-  type DevicesSimulateConnectRequest,
-  type DevicesSimulateConnectToHubOptions,
-  type DevicesSimulateConnectToHubParameters,
-  type DevicesSimulateConnectToHubRequest,
-  type DevicesSimulateDisconnectFromHubOptions,
-  type DevicesSimulateDisconnectFromHubParameters,
-  type DevicesSimulateDisconnectFromHubRequest,
-  type DevicesSimulateDisconnectOptions,
-  type DevicesSimulateDisconnectParameters,
-  type DevicesSimulateDisconnectRequest,
-  type DevicesSimulatePaidSubscriptionOptions,
-  type DevicesSimulatePaidSubscriptionParameters,
-  type DevicesSimulatePaidSubscriptionRequest,
-  type DevicesSimulateRemoveOptions,
-  type DevicesSimulateRemoveParameters,
-  type DevicesSimulateRemoveRequest,
-  SeamHttpDevicesSimulate,
-} from './devices/simulate/index.js'
-import {
-  type DevicesUnmanagedGetOptions,
-  type DevicesUnmanagedGetParameters,
-  type DevicesUnmanagedGetRequest,
-  type DevicesUnmanagedListOptions,
-  type DevicesUnmanagedListParameters,
-  type DevicesUnmanagedListRequest,
-  type DevicesUnmanagedUpdateOptions,
-  type DevicesUnmanagedUpdateParameters,
-  type DevicesUnmanagedUpdateRequest,
-  SeamHttpDevicesUnmanaged,
-} from './devices/unmanaged/index.js'
-import {
-  type EventsGetOptions,
-  type EventsGetParameters,
-  type EventsGetRequest,
-  type EventsListOptions,
-  type EventsListParameters,
-  type EventsListRequest,
-  SeamHttpEvents,
-} from './events/index.js'
-import {
-  type InstantKeysDeleteOptions,
-  type InstantKeysDeleteParameters,
-  type InstantKeysDeleteRequest,
-  type InstantKeysGetOptions,
-  type InstantKeysGetParameters,
-  type InstantKeysGetRequest,
-  type InstantKeysListOptions,
-  type InstantKeysListParameters,
-  type InstantKeysListRequest,
-  SeamHttpInstantKeys,
-} from './instant-keys/index.js'
-import {
-  type LocksConfigureAutoLockOptions,
-  type LocksConfigureAutoLockParameters,
-  type LocksConfigureAutoLockRequest,
-  type LocksGetOptions,
-  type LocksGetParameters,
-  type LocksGetRequest,
-  type LocksListOptions,
-  type LocksListParameters,
-  type LocksListRequest,
-  type LocksLockDoorOptions,
-  type LocksLockDoorParameters,
-  type LocksLockDoorRequest,
-  type LocksUnlockDoorOptions,
-  type LocksUnlockDoorParameters,
-  type LocksUnlockDoorRequest,
-  SeamHttpLocks,
-} from './locks/index.js'
-import {
-  type LocksSimulateKeypadCodeEntryOptions,
-  type LocksSimulateKeypadCodeEntryParameters,
-  type LocksSimulateKeypadCodeEntryRequest,
-  type LocksSimulateManualLockViaKeypadOptions,
-  type LocksSimulateManualLockViaKeypadParameters,
-  type LocksSimulateManualLockViaKeypadRequest,
-  SeamHttpLocksSimulate,
-} from './locks/simulate/index.js'
-import {
-  type NoiseSensorsListOptions,
-  type NoiseSensorsListParameters,
-  type NoiseSensorsListRequest,
-  SeamHttpNoiseSensors,
-} from './noise-sensors/index.js'
-import {
-  type NoiseSensorsNoiseThresholdsCreateOptions,
-  type NoiseSensorsNoiseThresholdsCreateParameters,
-  type NoiseSensorsNoiseThresholdsCreateRequest,
-  type NoiseSensorsNoiseThresholdsDeleteOptions,
-  type NoiseSensorsNoiseThresholdsDeleteParameters,
-  type NoiseSensorsNoiseThresholdsDeleteRequest,
-  type NoiseSensorsNoiseThresholdsGetOptions,
-  type NoiseSensorsNoiseThresholdsGetParameters,
-  type NoiseSensorsNoiseThresholdsGetRequest,
-  type NoiseSensorsNoiseThresholdsListOptions,
-  type NoiseSensorsNoiseThresholdsListParameters,
-  type NoiseSensorsNoiseThresholdsListRequest,
-  type NoiseSensorsNoiseThresholdsUpdateOptions,
-  type NoiseSensorsNoiseThresholdsUpdateParameters,
-  type NoiseSensorsNoiseThresholdsUpdateRequest,
-  SeamHttpNoiseSensorsNoiseThresholds,
-} from './noise-sensors/noise-thresholds/index.js'
-import {
-  type NoiseSensorsSimulateTriggerNoiseThresholdOptions,
-  type NoiseSensorsSimulateTriggerNoiseThresholdParameters,
-  type NoiseSensorsSimulateTriggerNoiseThresholdRequest,
-  SeamHttpNoiseSensorsSimulate,
-} from './noise-sensors/simulate/index.js'
-import {
-  type PhonesDeactivateOptions,
-  type PhonesDeactivateParameters,
-  type PhonesDeactivateRequest,
-  type PhonesGetOptions,
-  type PhonesGetParameters,
-  type PhonesGetRequest,
-  type PhonesListOptions,
-  type PhonesListParameters,
-  type PhonesListRequest,
-  SeamHttpPhones,
-} from './phones/index.js'
-import {
-  type PhonesSimulateCreateSandboxPhoneOptions,
-  type PhonesSimulateCreateSandboxPhoneParameters,
-  type PhonesSimulateCreateSandboxPhoneRequest,
-  SeamHttpPhonesSimulate,
-} from './phones/simulate/index.js'
-import {
-  SeamHttpSpaces,
-  type SpacesAddAcsEntrancesOptions,
-  type SpacesAddAcsEntrancesParameters,
-  type SpacesAddAcsEntrancesRequest,
-  type SpacesAddConnectedAccountOptions,
-  type SpacesAddConnectedAccountParameters,
-  type SpacesAddConnectedAccountRequest,
-  type SpacesAddDevicesOptions,
-  type SpacesAddDevicesParameters,
-  type SpacesAddDevicesRequest,
-  type SpacesCreateOptions,
-  type SpacesCreateParameters,
-  type SpacesCreateRequest,
-  type SpacesDeleteOptions,
-  type SpacesDeleteParameters,
-  type SpacesDeleteRequest,
-  type SpacesGetOptions,
-  type SpacesGetParameters,
-  type SpacesGetRelatedOptions,
-  type SpacesGetRelatedParameters,
-  type SpacesGetRelatedRequest,
-  type SpacesGetRequest,
-  type SpacesListOptions,
-  type SpacesListParameters,
-  type SpacesListRequest,
-  type SpacesRemoveAcsEntrancesOptions,
-  type SpacesRemoveAcsEntrancesParameters,
-  type SpacesRemoveAcsEntrancesRequest,
-  type SpacesRemoveConnectedAccountOptions,
-  type SpacesRemoveConnectedAccountParameters,
-  type SpacesRemoveConnectedAccountRequest,
-  type SpacesRemoveDevicesOptions,
-  type SpacesRemoveDevicesParameters,
-  type SpacesRemoveDevicesRequest,
-  type SpacesUpdateOptions,
-  type SpacesUpdateParameters,
-  type SpacesUpdateRequest,
-} from './spaces/index.js'
-import {
-  SeamHttpThermostatsDailyPrograms,
-  type ThermostatsDailyProgramsCreateOptions,
-  type ThermostatsDailyProgramsCreateParameters,
-  type ThermostatsDailyProgramsCreateRequest,
-  type ThermostatsDailyProgramsDeleteOptions,
-  type ThermostatsDailyProgramsDeleteParameters,
-  type ThermostatsDailyProgramsDeleteRequest,
-  type ThermostatsDailyProgramsUpdateOptions,
-  type ThermostatsDailyProgramsUpdateParameters,
-  type ThermostatsDailyProgramsUpdateRequest,
-} from './thermostats/daily-programs/index.js'
-import {
-  SeamHttpThermostats,
-  type ThermostatsActivateClimatePresetOptions,
-  type ThermostatsActivateClimatePresetParameters,
-  type ThermostatsActivateClimatePresetRequest,
-  type ThermostatsCoolOptions,
-  type ThermostatsCoolParameters,
-  type ThermostatsCoolRequest,
-  type ThermostatsCreateClimatePresetOptions,
-  type ThermostatsCreateClimatePresetParameters,
-  type ThermostatsCreateClimatePresetRequest,
-  type ThermostatsDeleteClimatePresetOptions,
-  type ThermostatsDeleteClimatePresetParameters,
-  type ThermostatsDeleteClimatePresetRequest,
-  type ThermostatsHeatCoolOptions,
-  type ThermostatsHeatCoolParameters,
-  type ThermostatsHeatCoolRequest,
-  type ThermostatsHeatOptions,
-  type ThermostatsHeatParameters,
-  type ThermostatsHeatRequest,
-  type ThermostatsListOptions,
-  type ThermostatsListParameters,
-  type ThermostatsListRequest,
-  type ThermostatsOffOptions,
-  type ThermostatsOffParameters,
-  type ThermostatsOffRequest,
-  type ThermostatsSetFallbackClimatePresetOptions,
-  type ThermostatsSetFallbackClimatePresetParameters,
-  type ThermostatsSetFallbackClimatePresetRequest,
-  type ThermostatsSetFanModeOptions,
-  type ThermostatsSetFanModeParameters,
-  type ThermostatsSetFanModeRequest,
-  type ThermostatsSetHvacModeOptions,
-  type ThermostatsSetHvacModeParameters,
-  type ThermostatsSetHvacModeRequest,
-  type ThermostatsSetTemperatureThresholdOptions,
-  type ThermostatsSetTemperatureThresholdParameters,
-  type ThermostatsSetTemperatureThresholdRequest,
-  type ThermostatsUpdateClimatePresetOptions,
-  type ThermostatsUpdateClimatePresetParameters,
-  type ThermostatsUpdateClimatePresetRequest,
-  type ThermostatsUpdateWeeklyProgramOptions,
-  type ThermostatsUpdateWeeklyProgramParameters,
-  type ThermostatsUpdateWeeklyProgramRequest,
-} from './thermostats/index.js'
-import {
-  SeamHttpThermostatsSchedules,
-  type ThermostatsSchedulesCreateOptions,
-  type ThermostatsSchedulesCreateParameters,
-  type ThermostatsSchedulesCreateRequest,
-  type ThermostatsSchedulesDeleteOptions,
-  type ThermostatsSchedulesDeleteParameters,
-  type ThermostatsSchedulesDeleteRequest,
-  type ThermostatsSchedulesGetOptions,
-  type ThermostatsSchedulesGetParameters,
-  type ThermostatsSchedulesGetRequest,
-  type ThermostatsSchedulesListOptions,
-  type ThermostatsSchedulesListParameters,
-  type ThermostatsSchedulesListRequest,
-  type ThermostatsSchedulesUpdateOptions,
-  type ThermostatsSchedulesUpdateParameters,
-  type ThermostatsSchedulesUpdateRequest,
-} from './thermostats/schedules/index.js'
-import {
-  SeamHttpThermostatsSimulate,
-  type ThermostatsSimulateHvacModeAdjustedOptions,
-  type ThermostatsSimulateHvacModeAdjustedParameters,
-  type ThermostatsSimulateHvacModeAdjustedRequest,
-  type ThermostatsSimulateTemperatureReachedOptions,
-  type ThermostatsSimulateTemperatureReachedParameters,
-  type ThermostatsSimulateTemperatureReachedRequest,
-} from './thermostats/simulate/index.js'
-import {
-  SeamHttpUserIdentities,
-  type UserIdentitiesAddAcsUserOptions,
-  type UserIdentitiesAddAcsUserParameters,
-  type UserIdentitiesAddAcsUserRequest,
-  type UserIdentitiesCreateOptions,
-  type UserIdentitiesCreateParameters,
-  type UserIdentitiesCreateRequest,
-  type UserIdentitiesDeleteOptions,
-  type UserIdentitiesDeleteParameters,
-  type UserIdentitiesDeleteRequest,
-  type UserIdentitiesGenerateInstantKeyOptions,
-  type UserIdentitiesGenerateInstantKeyParameters,
-  type UserIdentitiesGenerateInstantKeyRequest,
-  type UserIdentitiesGetOptions,
-  type UserIdentitiesGetParameters,
-  type UserIdentitiesGetRequest,
-  type UserIdentitiesGrantAccessToDeviceOptions,
-  type UserIdentitiesGrantAccessToDeviceParameters,
-  type UserIdentitiesGrantAccessToDeviceRequest,
-  type UserIdentitiesListAccessibleDevicesOptions,
-  type UserIdentitiesListAccessibleDevicesParameters,
-  type UserIdentitiesListAccessibleDevicesRequest,
-  type UserIdentitiesListAccessibleEntrancesOptions,
-  type UserIdentitiesListAccessibleEntrancesParameters,
-  type UserIdentitiesListAccessibleEntrancesRequest,
-  type UserIdentitiesListAcsSystemsOptions,
-  type UserIdentitiesListAcsSystemsParameters,
-  type UserIdentitiesListAcsSystemsRequest,
-  type UserIdentitiesListAcsUsersOptions,
-  type UserIdentitiesListAcsUsersParameters,
-  type UserIdentitiesListAcsUsersRequest,
-  type UserIdentitiesListOptions,
-  type UserIdentitiesListParameters,
-  type UserIdentitiesListRequest,
-  type UserIdentitiesRemoveAcsUserOptions,
-  type UserIdentitiesRemoveAcsUserParameters,
-  type UserIdentitiesRemoveAcsUserRequest,
-  type UserIdentitiesRevokeAccessToDeviceOptions,
-  type UserIdentitiesRevokeAccessToDeviceParameters,
-  type UserIdentitiesRevokeAccessToDeviceRequest,
-  type UserIdentitiesUpdateOptions,
-  type UserIdentitiesUpdateParameters,
-  type UserIdentitiesUpdateRequest,
-} from './user-identities/index.js'
-import {
-  SeamHttpUserIdentitiesUnmanaged,
-  type UserIdentitiesUnmanagedGetOptions,
-  type UserIdentitiesUnmanagedGetParameters,
-  type UserIdentitiesUnmanagedGetRequest,
-  type UserIdentitiesUnmanagedListOptions,
-  type UserIdentitiesUnmanagedListParameters,
-  type UserIdentitiesUnmanagedListRequest,
-  type UserIdentitiesUnmanagedUpdateOptions,
-  type UserIdentitiesUnmanagedUpdateParameters,
-  type UserIdentitiesUnmanagedUpdateRequest,
-} from './user-identities/unmanaged/index.js'
-import {
-  SeamHttpWebhooks,
-  type WebhooksCreateOptions,
-  type WebhooksCreateParameters,
-  type WebhooksCreateRequest,
-  type WebhooksDeleteOptions,
-  type WebhooksDeleteParameters,
-  type WebhooksDeleteRequest,
-  type WebhooksGetOptions,
-  type WebhooksGetParameters,
-  type WebhooksGetRequest,
-  type WebhooksListOptions,
-  type WebhooksListParameters,
-  type WebhooksListRequest,
-  type WebhooksUpdateOptions,
-  type WebhooksUpdateParameters,
-  type WebhooksUpdateRequest,
-} from './webhooks/index.js'
-import {
-  SeamHttpWorkspaces,
-  type WorkspacesCreateOptions,
-  type WorkspacesCreateParameters,
-  type WorkspacesCreateRequest,
-  type WorkspacesGetOptions,
-  type WorkspacesGetParameters,
-  type WorkspacesGetRequest,
-  type WorkspacesListOptions,
-  type WorkspacesListParameters,
-  type WorkspacesListRequest,
-  type WorkspacesResetSandboxOptions,
-  type WorkspacesResetSandboxParameters,
-  type WorkspacesResetSandboxRequest,
-  type WorkspacesUpdateOptions,
-  type WorkspacesUpdateParameters,
-  type WorkspacesUpdateRequest,
-} from './workspaces/index.js'
-
-export class SeamHttpEndpoints {
-  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'> = {},
-  ): SeamHttpEndpoints {
-    const constructorOptions = { ...options, client }
-    if (!isSeamHttpOptionsWithClient(constructorOptions)) {
-      throw new SeamHttpInvalidOptionsError('Missing client')
-    }
-    return new SeamHttpEndpoints(constructorOptions)
-  }
-
-  static fromApiKey(
-    apiKey: SeamHttpOptionsWithApiKey['apiKey'],
-    options: Omit<SeamHttpOptionsWithApiKey, 'apiKey'> = {},
-  ): SeamHttpEndpoints {
-    const constructorOptions = { ...options, apiKey }
-    if (!isSeamHttpOptionsWithApiKey(constructorOptions)) {
-      throw new SeamHttpInvalidOptionsError('Missing apiKey')
-    }
-    return new SeamHttpEndpoints(constructorOptions)
-  }
-
-  static fromClientSessionToken(
-    clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'],
-    options: Omit<
-      SeamHttpOptionsWithClientSessionToken,
-      'clientSessionToken'
-    > = {},
-  ): SeamHttpEndpoints {
-    const constructorOptions = { ...options, clientSessionToken }
-    if (!isSeamHttpOptionsWithClientSessionToken(constructorOptions)) {
-      throw new SeamHttpInvalidOptionsError('Missing clientSessionToken')
-    }
-    return new SeamHttpEndpoints(constructorOptions)
-  }
-
-  static async fromPublishableKey(
-    publishableKey: string,
-    userIdentifierKey: string,
-    options: SeamHttpFromPublishableKeyOptions = {},
-  ): Promise<SeamHttpEndpoints> {
-    warnOnInsecureuserIdentifierKey(userIdentifierKey)
-    const clientOptions = parseOptions({ ...options, publishableKey })
-    if (isSeamHttpOptionsWithClient(clientOptions)) {
-      throw new SeamHttpInvalidOptionsError(
-        'The client option cannot be used with SeamHttpEndpoints.fromPublishableKey',
-      )
-    }
-    const client = createClient(clientOptions)
-    const clientSessions = SeamHttpClientSessions.fromClient(client)
-    const { token } = await clientSessions.getOrCreate({
-      user_identifier_key: userIdentifierKey,
-    })
-    return SeamHttpEndpoints.fromClientSessionToken(token, options)
-  }
-
-  static fromConsoleSessionToken(
-    consoleSessionToken: SeamHttpOptionsWithConsoleSessionToken['consoleSessionToken'],
-    workspaceId: SeamHttpOptionsWithConsoleSessionToken['workspaceId'],
-    options: Omit<
-      SeamHttpOptionsWithConsoleSessionToken,
-      'consoleSessionToken' | 'workspaceId'
-    > = {},
-  ): SeamHttpEndpoints {
-    const constructorOptions = { ...options, consoleSessionToken, workspaceId }
-    if (!isSeamHttpOptionsWithConsoleSessionToken(constructorOptions)) {
-      throw new SeamHttpInvalidOptionsError(
-        'Missing consoleSessionToken or workspaceId',
-      )
-    }
-    return new SeamHttpEndpoints(constructorOptions)
-  }
-
-  static fromPersonalAccessToken(
-    personalAccessToken: SeamHttpOptionsWithPersonalAccessToken['personalAccessToken'],
-    workspaceId: SeamHttpOptionsWithPersonalAccessToken['workspaceId'],
-    options: Omit<
-      SeamHttpOptionsWithPersonalAccessToken,
-      'personalAccessToken' | 'workspaceId'
-    > = {},
-  ): SeamHttpEndpoints {
-    const constructorOptions = { ...options, personalAccessToken, workspaceId }
-    if (!isSeamHttpOptionsWithPersonalAccessToken(constructorOptions)) {
-      throw new SeamHttpInvalidOptionsError(
-        'Missing personalAccessToken or workspaceId',
-      )
-    }
-    return new SeamHttpEndpoints(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 '/access_codes/create'(): (
-    parameters: AccessCodesCreateParameters,
-    options?: AccessCodesCreateOptions,
-  ) => AccessCodesCreateRequest {
-    const { client, defaults } = this
-    return function accessCodesCreate(
-      ...args: Parameters<SeamHttpAccessCodes['create']>
-    ): ReturnType<SeamHttpAccessCodes['create']> {
-      const seam = SeamHttpAccessCodes.fromClient(client, defaults)
-      return seam.create(...args)
-    }
-  }
-
-  get '/access_codes/create_multiple'(): (
-    parameters: AccessCodesCreateMultipleParameters,
-    options?: AccessCodesCreateMultipleOptions,
-  ) => AccessCodesCreateMultipleRequest {
-    const { client, defaults } = this
-    return function accessCodesCreateMultiple(
-      ...args: Parameters<SeamHttpAccessCodes['createMultiple']>
-    ): ReturnType<SeamHttpAccessCodes['createMultiple']> {
-      const seam = SeamHttpAccessCodes.fromClient(client, defaults)
-      return seam.createMultiple(...args)
-    }
-  }
-
-  get '/access_codes/delete'(): (
-    parameters: AccessCodesDeleteParameters,
-    options?: AccessCodesDeleteOptions,
-  ) => AccessCodesDeleteRequest {
-    const { client, defaults } = this
-    return function accessCodesDelete(
-      ...args: Parameters<SeamHttpAccessCodes['delete']>
-    ): ReturnType<SeamHttpAccessCodes['delete']> {
-      const seam = SeamHttpAccessCodes.fromClient(client, defaults)
-      return seam.delete(...args)
-    }
-  }
-
-  get '/access_codes/generate_code'(): (
-    parameters: AccessCodesGenerateCodeParameters,
-    options?: AccessCodesGenerateCodeOptions,
-  ) => AccessCodesGenerateCodeRequest {
-    const { client, defaults } = this
-    return function accessCodesGenerateCode(
-      ...args: Parameters<SeamHttpAccessCodes['generateCode']>
-    ): ReturnType<SeamHttpAccessCodes['generateCode']> {
-      const seam = SeamHttpAccessCodes.fromClient(client, defaults)
-      return seam.generateCode(...args)
-    }
-  }
-
-  get '/access_codes/get'(): (
-    parameters?: AccessCodesGetParameters,
-    options?: AccessCodesGetOptions,
-  ) => AccessCodesGetRequest {
-    const { client, defaults } = this
-    return function accessCodesGet(
-      ...args: Parameters<SeamHttpAccessCodes['get']>
-    ): ReturnType<SeamHttpAccessCodes['get']> {
-      const seam = SeamHttpAccessCodes.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/access_codes/list'(): (
-    parameters?: AccessCodesListParameters,
-    options?: AccessCodesListOptions,
-  ) => AccessCodesListRequest {
-    const { client, defaults } = this
-    return function accessCodesList(
-      ...args: Parameters<SeamHttpAccessCodes['list']>
-    ): ReturnType<SeamHttpAccessCodes['list']> {
-      const seam = SeamHttpAccessCodes.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/access_codes/pull_backup_access_code'(): (
-    parameters: AccessCodesPullBackupAccessCodeParameters,
-    options?: AccessCodesPullBackupAccessCodeOptions,
-  ) => AccessCodesPullBackupAccessCodeRequest {
-    const { client, defaults } = this
-    return function accessCodesPullBackupAccessCode(
-      ...args: Parameters<SeamHttpAccessCodes['pullBackupAccessCode']>
-    ): ReturnType<SeamHttpAccessCodes['pullBackupAccessCode']> {
-      const seam = SeamHttpAccessCodes.fromClient(client, defaults)
-      return seam.pullBackupAccessCode(...args)
-    }
-  }
-
-  get '/access_codes/report_device_constraints'(): (
-    parameters: AccessCodesReportDeviceConstraintsParameters,
-    options?: AccessCodesReportDeviceConstraintsOptions,
-  ) => AccessCodesReportDeviceConstraintsRequest {
-    const { client, defaults } = this
-    return function accessCodesReportDeviceConstraints(
-      ...args: Parameters<SeamHttpAccessCodes['reportDeviceConstraints']>
-    ): ReturnType<SeamHttpAccessCodes['reportDeviceConstraints']> {
-      const seam = SeamHttpAccessCodes.fromClient(client, defaults)
-      return seam.reportDeviceConstraints(...args)
-    }
-  }
-
-  get '/access_codes/update'(): (
-    parameters: AccessCodesUpdateParameters,
-    options?: AccessCodesUpdateOptions,
-  ) => AccessCodesUpdateRequest {
-    const { client, defaults } = this
-    return function accessCodesUpdate(
-      ...args: Parameters<SeamHttpAccessCodes['update']>
-    ): ReturnType<SeamHttpAccessCodes['update']> {
-      const seam = SeamHttpAccessCodes.fromClient(client, defaults)
-      return seam.update(...args)
-    }
-  }
-
-  get '/access_codes/update_multiple'(): (
-    parameters: AccessCodesUpdateMultipleParameters,
-    options?: AccessCodesUpdateMultipleOptions,
-  ) => AccessCodesUpdateMultipleRequest {
-    const { client, defaults } = this
-    return function accessCodesUpdateMultiple(
-      ...args: Parameters<SeamHttpAccessCodes['updateMultiple']>
-    ): ReturnType<SeamHttpAccessCodes['updateMultiple']> {
-      const seam = SeamHttpAccessCodes.fromClient(client, defaults)
-      return seam.updateMultiple(...args)
-    }
-  }
-
-  get '/access_codes/simulate/create_unmanaged_access_code'(): (
-    parameters: AccessCodesSimulateCreateUnmanagedAccessCodeParameters,
-    options?: AccessCodesSimulateCreateUnmanagedAccessCodeOptions,
-  ) => AccessCodesSimulateCreateUnmanagedAccessCodeRequest {
-    const { client, defaults } = this
-    return function accessCodesSimulateCreateUnmanagedAccessCode(
-      ...args: Parameters<
-        SeamHttpAccessCodesSimulate['createUnmanagedAccessCode']
-      >
-    ): ReturnType<SeamHttpAccessCodesSimulate['createUnmanagedAccessCode']> {
-      const seam = SeamHttpAccessCodesSimulate.fromClient(client, defaults)
-      return seam.createUnmanagedAccessCode(...args)
-    }
-  }
-
-  get '/access_codes/unmanaged/convert_to_managed'(): (
-    parameters: AccessCodesUnmanagedConvertToManagedParameters,
-    options?: AccessCodesUnmanagedConvertToManagedOptions,
-  ) => AccessCodesUnmanagedConvertToManagedRequest {
-    const { client, defaults } = this
-    return function accessCodesUnmanagedConvertToManaged(
-      ...args: Parameters<SeamHttpAccessCodesUnmanaged['convertToManaged']>
-    ): ReturnType<SeamHttpAccessCodesUnmanaged['convertToManaged']> {
-      const seam = SeamHttpAccessCodesUnmanaged.fromClient(client, defaults)
-      return seam.convertToManaged(...args)
-    }
-  }
-
-  get '/access_codes/unmanaged/delete'(): (
-    parameters: AccessCodesUnmanagedDeleteParameters,
-    options?: AccessCodesUnmanagedDeleteOptions,
-  ) => AccessCodesUnmanagedDeleteRequest {
-    const { client, defaults } = this
-    return function accessCodesUnmanagedDelete(
-      ...args: Parameters<SeamHttpAccessCodesUnmanaged['delete']>
-    ): ReturnType<SeamHttpAccessCodesUnmanaged['delete']> {
-      const seam = SeamHttpAccessCodesUnmanaged.fromClient(client, defaults)
-      return seam.delete(...args)
-    }
-  }
-
-  get '/access_codes/unmanaged/get'(): (
-    parameters?: AccessCodesUnmanagedGetParameters,
-    options?: AccessCodesUnmanagedGetOptions,
-  ) => AccessCodesUnmanagedGetRequest {
-    const { client, defaults } = this
-    return function accessCodesUnmanagedGet(
-      ...args: Parameters<SeamHttpAccessCodesUnmanaged['get']>
-    ): ReturnType<SeamHttpAccessCodesUnmanaged['get']> {
-      const seam = SeamHttpAccessCodesUnmanaged.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/access_codes/unmanaged/list'(): (
-    parameters: AccessCodesUnmanagedListParameters,
-    options?: AccessCodesUnmanagedListOptions,
-  ) => AccessCodesUnmanagedListRequest {
-    const { client, defaults } = this
-    return function accessCodesUnmanagedList(
-      ...args: Parameters<SeamHttpAccessCodesUnmanaged['list']>
-    ): ReturnType<SeamHttpAccessCodesUnmanaged['list']> {
-      const seam = SeamHttpAccessCodesUnmanaged.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/access_codes/unmanaged/update'(): (
-    parameters: AccessCodesUnmanagedUpdateParameters,
-    options?: AccessCodesUnmanagedUpdateOptions,
-  ) => AccessCodesUnmanagedUpdateRequest {
-    const { client, defaults } = this
-    return function accessCodesUnmanagedUpdate(
-      ...args: Parameters<SeamHttpAccessCodesUnmanaged['update']>
-    ): ReturnType<SeamHttpAccessCodesUnmanaged['update']> {
-      const seam = SeamHttpAccessCodesUnmanaged.fromClient(client, defaults)
-      return seam.update(...args)
-    }
-  }
-
-  get '/access_grants/create'(): (
-    parameters: AccessGrantsCreateParameters,
-    options?: AccessGrantsCreateOptions,
-  ) => AccessGrantsCreateRequest {
-    const { client, defaults } = this
-    return function accessGrantsCreate(
-      ...args: Parameters<SeamHttpAccessGrants['create']>
-    ): ReturnType<SeamHttpAccessGrants['create']> {
-      const seam = SeamHttpAccessGrants.fromClient(client, defaults)
-      return seam.create(...args)
-    }
-  }
-
-  get '/access_grants/delete'(): (
-    parameters: AccessGrantsDeleteParameters,
-    options?: AccessGrantsDeleteOptions,
-  ) => AccessGrantsDeleteRequest {
-    const { client, defaults } = this
-    return function accessGrantsDelete(
-      ...args: Parameters<SeamHttpAccessGrants['delete']>
-    ): ReturnType<SeamHttpAccessGrants['delete']> {
-      const seam = SeamHttpAccessGrants.fromClient(client, defaults)
-      return seam.delete(...args)
-    }
-  }
-
-  get '/access_grants/get'(): (
-    parameters?: AccessGrantsGetParameters,
-    options?: AccessGrantsGetOptions,
-  ) => AccessGrantsGetRequest {
-    const { client, defaults } = this
-    return function accessGrantsGet(
-      ...args: Parameters<SeamHttpAccessGrants['get']>
-    ): ReturnType<SeamHttpAccessGrants['get']> {
-      const seam = SeamHttpAccessGrants.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/access_grants/get_related'(): (
-    parameters?: AccessGrantsGetRelatedParameters,
-    options?: AccessGrantsGetRelatedOptions,
-  ) => AccessGrantsGetRelatedRequest {
-    const { client, defaults } = this
-    return function accessGrantsGetRelated(
-      ...args: Parameters<SeamHttpAccessGrants['getRelated']>
-    ): ReturnType<SeamHttpAccessGrants['getRelated']> {
-      const seam = SeamHttpAccessGrants.fromClient(client, defaults)
-      return seam.getRelated(...args)
-    }
-  }
-
-  get '/access_grants/list'(): (
-    parameters?: AccessGrantsListParameters,
-    options?: AccessGrantsListOptions,
-  ) => AccessGrantsListRequest {
-    const { client, defaults } = this
-    return function accessGrantsList(
-      ...args: Parameters<SeamHttpAccessGrants['list']>
-    ): ReturnType<SeamHttpAccessGrants['list']> {
-      const seam = SeamHttpAccessGrants.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/access_grants/request_access_methods'(): (
-    parameters: AccessGrantsRequestAccessMethodsParameters,
-    options?: AccessGrantsRequestAccessMethodsOptions,
-  ) => AccessGrantsRequestAccessMethodsRequest {
-    const { client, defaults } = this
-    return function accessGrantsRequestAccessMethods(
-      ...args: Parameters<SeamHttpAccessGrants['requestAccessMethods']>
-    ): ReturnType<SeamHttpAccessGrants['requestAccessMethods']> {
-      const seam = SeamHttpAccessGrants.fromClient(client, defaults)
-      return seam.requestAccessMethods(...args)
-    }
-  }
-
-  get '/access_grants/update'(): (
-    parameters?: AccessGrantsUpdateParameters,
-    options?: AccessGrantsUpdateOptions,
-  ) => AccessGrantsUpdateRequest {
-    const { client, defaults } = this
-    return function accessGrantsUpdate(
-      ...args: Parameters<SeamHttpAccessGrants['update']>
-    ): ReturnType<SeamHttpAccessGrants['update']> {
-      const seam = SeamHttpAccessGrants.fromClient(client, defaults)
-      return seam.update(...args)
-    }
-  }
-
-  get '/access_grants/unmanaged/get'(): (
-    parameters: AccessGrantsUnmanagedGetParameters,
-    options?: AccessGrantsUnmanagedGetOptions,
-  ) => AccessGrantsUnmanagedGetRequest {
-    const { client, defaults } = this
-    return function accessGrantsUnmanagedGet(
-      ...args: Parameters<SeamHttpAccessGrantsUnmanaged['get']>
-    ): ReturnType<SeamHttpAccessGrantsUnmanaged['get']> {
-      const seam = SeamHttpAccessGrantsUnmanaged.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/access_grants/unmanaged/list'(): (
-    parameters?: AccessGrantsUnmanagedListParameters,
-    options?: AccessGrantsUnmanagedListOptions,
-  ) => AccessGrantsUnmanagedListRequest {
-    const { client, defaults } = this
-    return function accessGrantsUnmanagedList(
-      ...args: Parameters<SeamHttpAccessGrantsUnmanaged['list']>
-    ): ReturnType<SeamHttpAccessGrantsUnmanaged['list']> {
-      const seam = SeamHttpAccessGrantsUnmanaged.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/access_grants/unmanaged/update'(): (
-    parameters: AccessGrantsUnmanagedUpdateParameters,
-    options?: AccessGrantsUnmanagedUpdateOptions,
-  ) => AccessGrantsUnmanagedUpdateRequest {
-    const { client, defaults } = this
-    return function accessGrantsUnmanagedUpdate(
-      ...args: Parameters<SeamHttpAccessGrantsUnmanaged['update']>
-    ): ReturnType<SeamHttpAccessGrantsUnmanaged['update']> {
-      const seam = SeamHttpAccessGrantsUnmanaged.fromClient(client, defaults)
-      return seam.update(...args)
-    }
-  }
-
-  get '/access_methods/assign_card'(): (
-    parameters: AccessMethodsAssignCardParameters,
-    options?: AccessMethodsAssignCardOptions,
-  ) => AccessMethodsAssignCardRequest {
-    const { client, defaults } = this
-    return function accessMethodsAssignCard(
-      ...args: Parameters<SeamHttpAccessMethods['assignCard']>
-    ): ReturnType<SeamHttpAccessMethods['assignCard']> {
-      const seam = SeamHttpAccessMethods.fromClient(client, defaults)
-      return seam.assignCard(...args)
-    }
-  }
-
-  get '/access_methods/delete'(): (
-    parameters?: AccessMethodsDeleteParameters,
-    options?: AccessMethodsDeleteOptions,
-  ) => AccessMethodsDeleteRequest {
-    const { client, defaults } = this
-    return function accessMethodsDelete(
-      ...args: Parameters<SeamHttpAccessMethods['delete']>
-    ): ReturnType<SeamHttpAccessMethods['delete']> {
-      const seam = SeamHttpAccessMethods.fromClient(client, defaults)
-      return seam.delete(...args)
-    }
-  }
-
-  get '/access_methods/encode'(): (
-    parameters: AccessMethodsEncodeParameters,
-    options?: AccessMethodsEncodeOptions,
-  ) => AccessMethodsEncodeRequest {
-    const { client, defaults } = this
-    return function accessMethodsEncode(
-      ...args: Parameters<SeamHttpAccessMethods['encode']>
-    ): ReturnType<SeamHttpAccessMethods['encode']> {
-      const seam = SeamHttpAccessMethods.fromClient(client, defaults)
-      return seam.encode(...args)
-    }
-  }
-
-  get '/access_methods/get'(): (
-    parameters: AccessMethodsGetParameters,
-    options?: AccessMethodsGetOptions,
-  ) => AccessMethodsGetRequest {
-    const { client, defaults } = this
-    return function accessMethodsGet(
-      ...args: Parameters<SeamHttpAccessMethods['get']>
-    ): ReturnType<SeamHttpAccessMethods['get']> {
-      const seam = SeamHttpAccessMethods.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/access_methods/get_related'(): (
-    parameters: AccessMethodsGetRelatedParameters,
-    options?: AccessMethodsGetRelatedOptions,
-  ) => AccessMethodsGetRelatedRequest {
-    const { client, defaults } = this
-    return function accessMethodsGetRelated(
-      ...args: Parameters<SeamHttpAccessMethods['getRelated']>
-    ): ReturnType<SeamHttpAccessMethods['getRelated']> {
-      const seam = SeamHttpAccessMethods.fromClient(client, defaults)
-      return seam.getRelated(...args)
-    }
-  }
-
-  get '/access_methods/list'(): (
-    parameters?: AccessMethodsListParameters,
-    options?: AccessMethodsListOptions,
-  ) => AccessMethodsListRequest {
-    const { client, defaults } = this
-    return function accessMethodsList(
-      ...args: Parameters<SeamHttpAccessMethods['list']>
-    ): ReturnType<SeamHttpAccessMethods['list']> {
-      const seam = SeamHttpAccessMethods.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/access_methods/unlock_door'(): (
-    parameters: AccessMethodsUnlockDoorParameters,
-    options?: AccessMethodsUnlockDoorOptions,
-  ) => AccessMethodsUnlockDoorRequest {
-    const { client, defaults } = this
-    return function accessMethodsUnlockDoor(
-      ...args: Parameters<SeamHttpAccessMethods['unlockDoor']>
-    ): ReturnType<SeamHttpAccessMethods['unlockDoor']> {
-      const seam = SeamHttpAccessMethods.fromClient(client, defaults)
-      return seam.unlockDoor(...args)
-    }
-  }
-
-  get '/access_methods/unmanaged/get'(): (
-    parameters: AccessMethodsUnmanagedGetParameters,
-    options?: AccessMethodsUnmanagedGetOptions,
-  ) => AccessMethodsUnmanagedGetRequest {
-    const { client, defaults } = this
-    return function accessMethodsUnmanagedGet(
-      ...args: Parameters<SeamHttpAccessMethodsUnmanaged['get']>
-    ): ReturnType<SeamHttpAccessMethodsUnmanaged['get']> {
-      const seam = SeamHttpAccessMethodsUnmanaged.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/access_methods/unmanaged/list'(): (
-    parameters: AccessMethodsUnmanagedListParameters,
-    options?: AccessMethodsUnmanagedListOptions,
-  ) => AccessMethodsUnmanagedListRequest {
-    const { client, defaults } = this
-    return function accessMethodsUnmanagedList(
-      ...args: Parameters<SeamHttpAccessMethodsUnmanaged['list']>
-    ): ReturnType<SeamHttpAccessMethodsUnmanaged['list']> {
-      const seam = SeamHttpAccessMethodsUnmanaged.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/acs/access_groups/add_user'(): (
-    parameters: AcsAccessGroupsAddUserParameters,
-    options?: AcsAccessGroupsAddUserOptions,
-  ) => AcsAccessGroupsAddUserRequest {
-    const { client, defaults } = this
-    return function acsAccessGroupsAddUser(
-      ...args: Parameters<SeamHttpAcsAccessGroups['addUser']>
-    ): ReturnType<SeamHttpAcsAccessGroups['addUser']> {
-      const seam = SeamHttpAcsAccessGroups.fromClient(client, defaults)
-      return seam.addUser(...args)
-    }
-  }
-
-  get '/acs/access_groups/delete'(): (
-    parameters: AcsAccessGroupsDeleteParameters,
-    options?: AcsAccessGroupsDeleteOptions,
-  ) => AcsAccessGroupsDeleteRequest {
-    const { client, defaults } = this
-    return function acsAccessGroupsDelete(
-      ...args: Parameters<SeamHttpAcsAccessGroups['delete']>
-    ): ReturnType<SeamHttpAcsAccessGroups['delete']> {
-      const seam = SeamHttpAcsAccessGroups.fromClient(client, defaults)
-      return seam.delete(...args)
-    }
-  }
-
-  get '/acs/access_groups/get'(): (
-    parameters: AcsAccessGroupsGetParameters,
-    options?: AcsAccessGroupsGetOptions,
-  ) => AcsAccessGroupsGetRequest {
-    const { client, defaults } = this
-    return function acsAccessGroupsGet(
-      ...args: Parameters<SeamHttpAcsAccessGroups['get']>
-    ): ReturnType<SeamHttpAcsAccessGroups['get']> {
-      const seam = SeamHttpAcsAccessGroups.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/acs/access_groups/list'(): (
-    parameters?: AcsAccessGroupsListParameters,
-    options?: AcsAccessGroupsListOptions,
-  ) => AcsAccessGroupsListRequest {
-    const { client, defaults } = this
-    return function acsAccessGroupsList(
-      ...args: Parameters<SeamHttpAcsAccessGroups['list']>
-    ): ReturnType<SeamHttpAcsAccessGroups['list']> {
-      const seam = SeamHttpAcsAccessGroups.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/acs/access_groups/list_accessible_entrances'(): (
-    parameters: AcsAccessGroupsListAccessibleEntrancesParameters,
-    options?: AcsAccessGroupsListAccessibleEntrancesOptions,
-  ) => AcsAccessGroupsListAccessibleEntrancesRequest {
-    const { client, defaults } = this
-    return function acsAccessGroupsListAccessibleEntrances(
-      ...args: Parameters<SeamHttpAcsAccessGroups['listAccessibleEntrances']>
-    ): ReturnType<SeamHttpAcsAccessGroups['listAccessibleEntrances']> {
-      const seam = SeamHttpAcsAccessGroups.fromClient(client, defaults)
-      return seam.listAccessibleEntrances(...args)
-    }
-  }
-
-  get '/acs/access_groups/list_users'(): (
-    parameters: AcsAccessGroupsListUsersParameters,
-    options?: AcsAccessGroupsListUsersOptions,
-  ) => AcsAccessGroupsListUsersRequest {
-    const { client, defaults } = this
-    return function acsAccessGroupsListUsers(
-      ...args: Parameters<SeamHttpAcsAccessGroups['listUsers']>
-    ): ReturnType<SeamHttpAcsAccessGroups['listUsers']> {
-      const seam = SeamHttpAcsAccessGroups.fromClient(client, defaults)
-      return seam.listUsers(...args)
-    }
-  }
-
-  get '/acs/access_groups/remove_user'(): (
-    parameters: AcsAccessGroupsRemoveUserParameters,
-    options?: AcsAccessGroupsRemoveUserOptions,
-  ) => AcsAccessGroupsRemoveUserRequest {
-    const { client, defaults } = this
-    return function acsAccessGroupsRemoveUser(
-      ...args: Parameters<SeamHttpAcsAccessGroups['removeUser']>
-    ): ReturnType<SeamHttpAcsAccessGroups['removeUser']> {
-      const seam = SeamHttpAcsAccessGroups.fromClient(client, defaults)
-      return seam.removeUser(...args)
-    }
-  }
-
-  get '/acs/credentials/assign'(): (
-    parameters: AcsCredentialsAssignParameters,
-    options?: AcsCredentialsAssignOptions,
-  ) => AcsCredentialsAssignRequest {
-    const { client, defaults } = this
-    return function acsCredentialsAssign(
-      ...args: Parameters<SeamHttpAcsCredentials['assign']>
-    ): ReturnType<SeamHttpAcsCredentials['assign']> {
-      const seam = SeamHttpAcsCredentials.fromClient(client, defaults)
-      return seam.assign(...args)
-    }
-  }
-
-  get '/acs/credentials/create'(): (
-    parameters: AcsCredentialsCreateParameters,
-    options?: AcsCredentialsCreateOptions,
-  ) => AcsCredentialsCreateRequest {
-    const { client, defaults } = this
-    return function acsCredentialsCreate(
-      ...args: Parameters<SeamHttpAcsCredentials['create']>
-    ): ReturnType<SeamHttpAcsCredentials['create']> {
-      const seam = SeamHttpAcsCredentials.fromClient(client, defaults)
-      return seam.create(...args)
-    }
-  }
-
-  get '/acs/credentials/delete'(): (
-    parameters: AcsCredentialsDeleteParameters,
-    options?: AcsCredentialsDeleteOptions,
-  ) => AcsCredentialsDeleteRequest {
-    const { client, defaults } = this
-    return function acsCredentialsDelete(
-      ...args: Parameters<SeamHttpAcsCredentials['delete']>
-    ): ReturnType<SeamHttpAcsCredentials['delete']> {
-      const seam = SeamHttpAcsCredentials.fromClient(client, defaults)
-      return seam.delete(...args)
-    }
-  }
-
-  get '/acs/credentials/get'(): (
-    parameters: AcsCredentialsGetParameters,
-    options?: AcsCredentialsGetOptions,
-  ) => AcsCredentialsGetRequest {
-    const { client, defaults } = this
-    return function acsCredentialsGet(
-      ...args: Parameters<SeamHttpAcsCredentials['get']>
-    ): ReturnType<SeamHttpAcsCredentials['get']> {
-      const seam = SeamHttpAcsCredentials.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/acs/credentials/list'(): (
-    parameters?: AcsCredentialsListParameters,
-    options?: AcsCredentialsListOptions,
-  ) => AcsCredentialsListRequest {
-    const { client, defaults } = this
-    return function acsCredentialsList(
-      ...args: Parameters<SeamHttpAcsCredentials['list']>
-    ): ReturnType<SeamHttpAcsCredentials['list']> {
-      const seam = SeamHttpAcsCredentials.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/acs/credentials/list_accessible_entrances'(): (
-    parameters: AcsCredentialsListAccessibleEntrancesParameters,
-    options?: AcsCredentialsListAccessibleEntrancesOptions,
-  ) => AcsCredentialsListAccessibleEntrancesRequest {
-    const { client, defaults } = this
-    return function acsCredentialsListAccessibleEntrances(
-      ...args: Parameters<SeamHttpAcsCredentials['listAccessibleEntrances']>
-    ): ReturnType<SeamHttpAcsCredentials['listAccessibleEntrances']> {
-      const seam = SeamHttpAcsCredentials.fromClient(client, defaults)
-      return seam.listAccessibleEntrances(...args)
-    }
-  }
-
-  get '/acs/credentials/unassign'(): (
-    parameters: AcsCredentialsUnassignParameters,
-    options?: AcsCredentialsUnassignOptions,
-  ) => AcsCredentialsUnassignRequest {
-    const { client, defaults } = this
-    return function acsCredentialsUnassign(
-      ...args: Parameters<SeamHttpAcsCredentials['unassign']>
-    ): ReturnType<SeamHttpAcsCredentials['unassign']> {
-      const seam = SeamHttpAcsCredentials.fromClient(client, defaults)
-      return seam.unassign(...args)
-    }
-  }
-
-  get '/acs/credentials/update'(): (
-    parameters: AcsCredentialsUpdateParameters,
-    options?: AcsCredentialsUpdateOptions,
-  ) => AcsCredentialsUpdateRequest {
-    const { client, defaults } = this
-    return function acsCredentialsUpdate(
-      ...args: Parameters<SeamHttpAcsCredentials['update']>
-    ): ReturnType<SeamHttpAcsCredentials['update']> {
-      const seam = SeamHttpAcsCredentials.fromClient(client, defaults)
-      return seam.update(...args)
-    }
-  }
-
-  get '/acs/encoders/encode_credential'(): (
-    parameters: AcsEncodersEncodeCredentialParameters,
-    options?: AcsEncodersEncodeCredentialOptions,
-  ) => AcsEncodersEncodeCredentialRequest {
-    const { client, defaults } = this
-    return function acsEncodersEncodeCredential(
-      ...args: Parameters<SeamHttpAcsEncoders['encodeCredential']>
-    ): ReturnType<SeamHttpAcsEncoders['encodeCredential']> {
-      const seam = SeamHttpAcsEncoders.fromClient(client, defaults)
-      return seam.encodeCredential(...args)
-    }
-  }
-
-  get '/acs/encoders/get'(): (
-    parameters: AcsEncodersGetParameters,
-    options?: AcsEncodersGetOptions,
-  ) => AcsEncodersGetRequest {
-    const { client, defaults } = this
-    return function acsEncodersGet(
-      ...args: Parameters<SeamHttpAcsEncoders['get']>
-    ): ReturnType<SeamHttpAcsEncoders['get']> {
-      const seam = SeamHttpAcsEncoders.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/acs/encoders/list'(): (
-    parameters?: AcsEncodersListParameters,
-    options?: AcsEncodersListOptions,
-  ) => AcsEncodersListRequest {
-    const { client, defaults } = this
-    return function acsEncodersList(
-      ...args: Parameters<SeamHttpAcsEncoders['list']>
-    ): ReturnType<SeamHttpAcsEncoders['list']> {
-      const seam = SeamHttpAcsEncoders.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/acs/encoders/scan_credential'(): (
-    parameters: AcsEncodersScanCredentialParameters,
-    options?: AcsEncodersScanCredentialOptions,
-  ) => AcsEncodersScanCredentialRequest {
-    const { client, defaults } = this
-    return function acsEncodersScanCredential(
-      ...args: Parameters<SeamHttpAcsEncoders['scanCredential']>
-    ): ReturnType<SeamHttpAcsEncoders['scanCredential']> {
-      const seam = SeamHttpAcsEncoders.fromClient(client, defaults)
-      return seam.scanCredential(...args)
-    }
-  }
-
-  get '/acs/encoders/scan_to_assign_credential'(): (
-    parameters: AcsEncodersScanToAssignCredentialParameters,
-    options?: AcsEncodersScanToAssignCredentialOptions,
-  ) => AcsEncodersScanToAssignCredentialRequest {
-    const { client, defaults } = this
-    return function acsEncodersScanToAssignCredential(
-      ...args: Parameters<SeamHttpAcsEncoders['scanToAssignCredential']>
-    ): ReturnType<SeamHttpAcsEncoders['scanToAssignCredential']> {
-      const seam = SeamHttpAcsEncoders.fromClient(client, defaults)
-      return seam.scanToAssignCredential(...args)
-    }
-  }
-
-  get '/acs/encoders/simulate/next_credential_encode_will_fail'(): (
-    parameters: AcsEncodersSimulateNextCredentialEncodeWillFailParameters,
-    options?: AcsEncodersSimulateNextCredentialEncodeWillFailOptions,
-  ) => AcsEncodersSimulateNextCredentialEncodeWillFailRequest {
-    const { client, defaults } = this
-    return function acsEncodersSimulateNextCredentialEncodeWillFail(
-      ...args: Parameters<
-        SeamHttpAcsEncodersSimulate['nextCredentialEncodeWillFail']
-      >
-    ): ReturnType<SeamHttpAcsEncodersSimulate['nextCredentialEncodeWillFail']> {
-      const seam = SeamHttpAcsEncodersSimulate.fromClient(client, defaults)
-      return seam.nextCredentialEncodeWillFail(...args)
-    }
-  }
-
-  get '/acs/encoders/simulate/next_credential_encode_will_succeed'(): (
-    parameters: AcsEncodersSimulateNextCredentialEncodeWillSucceedParameters,
-    options?: AcsEncodersSimulateNextCredentialEncodeWillSucceedOptions,
-  ) => AcsEncodersSimulateNextCredentialEncodeWillSucceedRequest {
-    const { client, defaults } = this
-    return function acsEncodersSimulateNextCredentialEncodeWillSucceed(
-      ...args: Parameters<
-        SeamHttpAcsEncodersSimulate['nextCredentialEncodeWillSucceed']
-      >
-    ): ReturnType<
-      SeamHttpAcsEncodersSimulate['nextCredentialEncodeWillSucceed']
-    > {
-      const seam = SeamHttpAcsEncodersSimulate.fromClient(client, defaults)
-      return seam.nextCredentialEncodeWillSucceed(...args)
-    }
-  }
-
-  get '/acs/encoders/simulate/next_credential_scan_will_fail'(): (
-    parameters: AcsEncodersSimulateNextCredentialScanWillFailParameters,
-    options?: AcsEncodersSimulateNextCredentialScanWillFailOptions,
-  ) => AcsEncodersSimulateNextCredentialScanWillFailRequest {
-    const { client, defaults } = this
-    return function acsEncodersSimulateNextCredentialScanWillFail(
-      ...args: Parameters<
-        SeamHttpAcsEncodersSimulate['nextCredentialScanWillFail']
-      >
-    ): ReturnType<SeamHttpAcsEncodersSimulate['nextCredentialScanWillFail']> {
-      const seam = SeamHttpAcsEncodersSimulate.fromClient(client, defaults)
-      return seam.nextCredentialScanWillFail(...args)
-    }
-  }
-
-  get '/acs/encoders/simulate/next_credential_scan_will_succeed'(): (
-    parameters: AcsEncodersSimulateNextCredentialScanWillSucceedParameters,
-    options?: AcsEncodersSimulateNextCredentialScanWillSucceedOptions,
-  ) => AcsEncodersSimulateNextCredentialScanWillSucceedRequest {
-    const { client, defaults } = this
-    return function acsEncodersSimulateNextCredentialScanWillSucceed(
-      ...args: Parameters<
-        SeamHttpAcsEncodersSimulate['nextCredentialScanWillSucceed']
-      >
-    ): ReturnType<
-      SeamHttpAcsEncodersSimulate['nextCredentialScanWillSucceed']
-    > {
-      const seam = SeamHttpAcsEncodersSimulate.fromClient(client, defaults)
-      return seam.nextCredentialScanWillSucceed(...args)
-    }
-  }
-
-  get '/acs/entrances/get'(): (
-    parameters: AcsEntrancesGetParameters,
-    options?: AcsEntrancesGetOptions,
-  ) => AcsEntrancesGetRequest {
-    const { client, defaults } = this
-    return function acsEntrancesGet(
-      ...args: Parameters<SeamHttpAcsEntrances['get']>
-    ): ReturnType<SeamHttpAcsEntrances['get']> {
-      const seam = SeamHttpAcsEntrances.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/acs/entrances/grant_access'(): (
-    parameters: AcsEntrancesGrantAccessParameters,
-    options?: AcsEntrancesGrantAccessOptions,
-  ) => AcsEntrancesGrantAccessRequest {
-    const { client, defaults } = this
-    return function acsEntrancesGrantAccess(
-      ...args: Parameters<SeamHttpAcsEntrances['grantAccess']>
-    ): ReturnType<SeamHttpAcsEntrances['grantAccess']> {
-      const seam = SeamHttpAcsEntrances.fromClient(client, defaults)
-      return seam.grantAccess(...args)
-    }
-  }
-
-  get '/acs/entrances/list'(): (
-    parameters?: AcsEntrancesListParameters,
-    options?: AcsEntrancesListOptions,
-  ) => AcsEntrancesListRequest {
-    const { client, defaults } = this
-    return function acsEntrancesList(
-      ...args: Parameters<SeamHttpAcsEntrances['list']>
-    ): ReturnType<SeamHttpAcsEntrances['list']> {
-      const seam = SeamHttpAcsEntrances.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/acs/entrances/list_credentials_with_access'(): (
-    parameters: AcsEntrancesListCredentialsWithAccessParameters,
-    options?: AcsEntrancesListCredentialsWithAccessOptions,
-  ) => AcsEntrancesListCredentialsWithAccessRequest {
-    const { client, defaults } = this
-    return function acsEntrancesListCredentialsWithAccess(
-      ...args: Parameters<SeamHttpAcsEntrances['listCredentialsWithAccess']>
-    ): ReturnType<SeamHttpAcsEntrances['listCredentialsWithAccess']> {
-      const seam = SeamHttpAcsEntrances.fromClient(client, defaults)
-      return seam.listCredentialsWithAccess(...args)
-    }
-  }
-
-  get '/acs/entrances/unlock'(): (
-    parameters: AcsEntrancesUnlockParameters,
-    options?: AcsEntrancesUnlockOptions,
-  ) => AcsEntrancesUnlockRequest {
-    const { client, defaults } = this
-    return function acsEntrancesUnlock(
-      ...args: Parameters<SeamHttpAcsEntrances['unlock']>
-    ): ReturnType<SeamHttpAcsEntrances['unlock']> {
-      const seam = SeamHttpAcsEntrances.fromClient(client, defaults)
-      return seam.unlock(...args)
-    }
-  }
-
-  get '/acs/systems/get'(): (
-    parameters: AcsSystemsGetParameters,
-    options?: AcsSystemsGetOptions,
-  ) => AcsSystemsGetRequest {
-    const { client, defaults } = this
-    return function acsSystemsGet(
-      ...args: Parameters<SeamHttpAcsSystems['get']>
-    ): ReturnType<SeamHttpAcsSystems['get']> {
-      const seam = SeamHttpAcsSystems.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/acs/systems/list'(): (
-    parameters?: AcsSystemsListParameters,
-    options?: AcsSystemsListOptions,
-  ) => AcsSystemsListRequest {
-    const { client, defaults } = this
-    return function acsSystemsList(
-      ...args: Parameters<SeamHttpAcsSystems['list']>
-    ): ReturnType<SeamHttpAcsSystems['list']> {
-      const seam = SeamHttpAcsSystems.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/acs/systems/list_compatible_credential_manager_acs_systems'(): (
-    parameters: AcsSystemsListCompatibleCredentialManagerAcsSystemsParameters,
-    options?: AcsSystemsListCompatibleCredentialManagerAcsSystemsOptions,
-  ) => AcsSystemsListCompatibleCredentialManagerAcsSystemsRequest {
-    const { client, defaults } = this
-    return function acsSystemsListCompatibleCredentialManagerAcsSystems(
-      ...args: Parameters<
-        SeamHttpAcsSystems['listCompatibleCredentialManagerAcsSystems']
-      >
-    ): ReturnType<
-      SeamHttpAcsSystems['listCompatibleCredentialManagerAcsSystems']
-    > {
-      const seam = SeamHttpAcsSystems.fromClient(client, defaults)
-      return seam.listCompatibleCredentialManagerAcsSystems(...args)
-    }
-  }
-
-  get '/acs/systems/report_devices'(): (
-    parameters: AcsSystemsReportDevicesParameters,
-    options?: AcsSystemsReportDevicesOptions,
-  ) => AcsSystemsReportDevicesRequest {
-    const { client, defaults } = this
-    return function acsSystemsReportDevices(
-      ...args: Parameters<SeamHttpAcsSystems['reportDevices']>
-    ): ReturnType<SeamHttpAcsSystems['reportDevices']> {
-      const seam = SeamHttpAcsSystems.fromClient(client, defaults)
-      return seam.reportDevices(...args)
-    }
-  }
-
-  get '/acs/users/add_to_access_group'(): (
-    parameters: AcsUsersAddToAccessGroupParameters,
-    options?: AcsUsersAddToAccessGroupOptions,
-  ) => AcsUsersAddToAccessGroupRequest {
-    const { client, defaults } = this
-    return function acsUsersAddToAccessGroup(
-      ...args: Parameters<SeamHttpAcsUsers['addToAccessGroup']>
-    ): ReturnType<SeamHttpAcsUsers['addToAccessGroup']> {
-      const seam = SeamHttpAcsUsers.fromClient(client, defaults)
-      return seam.addToAccessGroup(...args)
-    }
-  }
-
-  get '/acs/users/create'(): (
-    parameters: AcsUsersCreateParameters,
-    options?: AcsUsersCreateOptions,
-  ) => AcsUsersCreateRequest {
-    const { client, defaults } = this
-    return function acsUsersCreate(
-      ...args: Parameters<SeamHttpAcsUsers['create']>
-    ): ReturnType<SeamHttpAcsUsers['create']> {
-      const seam = SeamHttpAcsUsers.fromClient(client, defaults)
-      return seam.create(...args)
-    }
-  }
-
-  get '/acs/users/delete'(): (
-    parameters?: AcsUsersDeleteParameters,
-    options?: AcsUsersDeleteOptions,
-  ) => AcsUsersDeleteRequest {
-    const { client, defaults } = this
-    return function acsUsersDelete(
-      ...args: Parameters<SeamHttpAcsUsers['delete']>
-    ): ReturnType<SeamHttpAcsUsers['delete']> {
-      const seam = SeamHttpAcsUsers.fromClient(client, defaults)
-      return seam.delete(...args)
-    }
-  }
-
-  get '/acs/users/get'(): (
-    parameters?: AcsUsersGetParameters,
-    options?: AcsUsersGetOptions,
-  ) => AcsUsersGetRequest {
-    const { client, defaults } = this
-    return function acsUsersGet(
-      ...args: Parameters<SeamHttpAcsUsers['get']>
-    ): ReturnType<SeamHttpAcsUsers['get']> {
-      const seam = SeamHttpAcsUsers.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/acs/users/list'(): (
-    parameters?: AcsUsersListParameters,
-    options?: AcsUsersListOptions,
-  ) => AcsUsersListRequest {
-    const { client, defaults } = this
-    return function acsUsersList(
-      ...args: Parameters<SeamHttpAcsUsers['list']>
-    ): ReturnType<SeamHttpAcsUsers['list']> {
-      const seam = SeamHttpAcsUsers.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/acs/users/list_accessible_entrances'(): (
-    parameters?: AcsUsersListAccessibleEntrancesParameters,
-    options?: AcsUsersListAccessibleEntrancesOptions,
-  ) => AcsUsersListAccessibleEntrancesRequest {
-    const { client, defaults } = this
-    return function acsUsersListAccessibleEntrances(
-      ...args: Parameters<SeamHttpAcsUsers['listAccessibleEntrances']>
-    ): ReturnType<SeamHttpAcsUsers['listAccessibleEntrances']> {
-      const seam = SeamHttpAcsUsers.fromClient(client, defaults)
-      return seam.listAccessibleEntrances(...args)
-    }
-  }
-
-  get '/acs/users/remove_from_access_group'(): (
-    parameters: AcsUsersRemoveFromAccessGroupParameters,
-    options?: AcsUsersRemoveFromAccessGroupOptions,
-  ) => AcsUsersRemoveFromAccessGroupRequest {
-    const { client, defaults } = this
-    return function acsUsersRemoveFromAccessGroup(
-      ...args: Parameters<SeamHttpAcsUsers['removeFromAccessGroup']>
-    ): ReturnType<SeamHttpAcsUsers['removeFromAccessGroup']> {
-      const seam = SeamHttpAcsUsers.fromClient(client, defaults)
-      return seam.removeFromAccessGroup(...args)
-    }
-  }
-
-  get '/acs/users/revoke_access_to_all_entrances'(): (
-    parameters?: AcsUsersRevokeAccessToAllEntrancesParameters,
-    options?: AcsUsersRevokeAccessToAllEntrancesOptions,
-  ) => AcsUsersRevokeAccessToAllEntrancesRequest {
-    const { client, defaults } = this
-    return function acsUsersRevokeAccessToAllEntrances(
-      ...args: Parameters<SeamHttpAcsUsers['revokeAccessToAllEntrances']>
-    ): ReturnType<SeamHttpAcsUsers['revokeAccessToAllEntrances']> {
-      const seam = SeamHttpAcsUsers.fromClient(client, defaults)
-      return seam.revokeAccessToAllEntrances(...args)
-    }
-  }
-
-  get '/acs/users/suspend'(): (
-    parameters?: AcsUsersSuspendParameters,
-    options?: AcsUsersSuspendOptions,
-  ) => AcsUsersSuspendRequest {
-    const { client, defaults } = this
-    return function acsUsersSuspend(
-      ...args: Parameters<SeamHttpAcsUsers['suspend']>
-    ): ReturnType<SeamHttpAcsUsers['suspend']> {
-      const seam = SeamHttpAcsUsers.fromClient(client, defaults)
-      return seam.suspend(...args)
-    }
-  }
-
-  get '/acs/users/unsuspend'(): (
-    parameters?: AcsUsersUnsuspendParameters,
-    options?: AcsUsersUnsuspendOptions,
-  ) => AcsUsersUnsuspendRequest {
-    const { client, defaults } = this
-    return function acsUsersUnsuspend(
-      ...args: Parameters<SeamHttpAcsUsers['unsuspend']>
-    ): ReturnType<SeamHttpAcsUsers['unsuspend']> {
-      const seam = SeamHttpAcsUsers.fromClient(client, defaults)
-      return seam.unsuspend(...args)
-    }
-  }
-
-  get '/acs/users/update'(): (
-    parameters?: AcsUsersUpdateParameters,
-    options?: AcsUsersUpdateOptions,
-  ) => AcsUsersUpdateRequest {
-    const { client, defaults } = this
-    return function acsUsersUpdate(
-      ...args: Parameters<SeamHttpAcsUsers['update']>
-    ): ReturnType<SeamHttpAcsUsers['update']> {
-      const seam = SeamHttpAcsUsers.fromClient(client, defaults)
-      return seam.update(...args)
-    }
-  }
-
-  get '/action_attempts/get'(): (
-    parameters: ActionAttemptsGetParameters,
-    options?: ActionAttemptsGetOptions,
-  ) => ActionAttemptsGetRequest {
-    const { client, defaults } = this
-    return function actionAttemptsGet(
-      ...args: Parameters<SeamHttpActionAttempts['get']>
-    ): ReturnType<SeamHttpActionAttempts['get']> {
-      const seam = SeamHttpActionAttempts.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/action_attempts/list'(): (
-    parameters?: ActionAttemptsListParameters,
-    options?: ActionAttemptsListOptions,
-  ) => ActionAttemptsListRequest {
-    const { client, defaults } = this
-    return function actionAttemptsList(
-      ...args: Parameters<SeamHttpActionAttempts['list']>
-    ): ReturnType<SeamHttpActionAttempts['list']> {
-      const seam = SeamHttpActionAttempts.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/client_sessions/create'(): (
-    parameters?: ClientSessionsCreateParameters,
-    options?: ClientSessionsCreateOptions,
-  ) => ClientSessionsCreateRequest {
-    const { client, defaults } = this
-    return function clientSessionsCreate(
-      ...args: Parameters<SeamHttpClientSessions['create']>
-    ): ReturnType<SeamHttpClientSessions['create']> {
-      const seam = SeamHttpClientSessions.fromClient(client, defaults)
-      return seam.create(...args)
-    }
-  }
-
-  get '/client_sessions/delete'(): (
-    parameters: ClientSessionsDeleteParameters,
-    options?: ClientSessionsDeleteOptions,
-  ) => ClientSessionsDeleteRequest {
-    const { client, defaults } = this
-    return function clientSessionsDelete(
-      ...args: Parameters<SeamHttpClientSessions['delete']>
-    ): ReturnType<SeamHttpClientSessions['delete']> {
-      const seam = SeamHttpClientSessions.fromClient(client, defaults)
-      return seam.delete(...args)
-    }
-  }
-
-  get '/client_sessions/get'(): (
-    parameters?: ClientSessionsGetParameters,
-    options?: ClientSessionsGetOptions,
-  ) => ClientSessionsGetRequest {
-    const { client, defaults } = this
-    return function clientSessionsGet(
-      ...args: Parameters<SeamHttpClientSessions['get']>
-    ): ReturnType<SeamHttpClientSessions['get']> {
-      const seam = SeamHttpClientSessions.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/client_sessions/get_or_create'(): (
-    parameters?: ClientSessionsGetOrCreateParameters,
-    options?: ClientSessionsGetOrCreateOptions,
-  ) => ClientSessionsGetOrCreateRequest {
-    const { client, defaults } = this
-    return function clientSessionsGetOrCreate(
-      ...args: Parameters<SeamHttpClientSessions['getOrCreate']>
-    ): ReturnType<SeamHttpClientSessions['getOrCreate']> {
-      const seam = SeamHttpClientSessions.fromClient(client, defaults)
-      return seam.getOrCreate(...args)
-    }
-  }
-
-  get '/client_sessions/grant_access'(): (
-    parameters?: ClientSessionsGrantAccessParameters,
-    options?: ClientSessionsGrantAccessOptions,
-  ) => ClientSessionsGrantAccessRequest {
-    const { client, defaults } = this
-    return function clientSessionsGrantAccess(
-      ...args: Parameters<SeamHttpClientSessions['grantAccess']>
-    ): ReturnType<SeamHttpClientSessions['grantAccess']> {
-      const seam = SeamHttpClientSessions.fromClient(client, defaults)
-      return seam.grantAccess(...args)
-    }
-  }
-
-  get '/client_sessions/list'(): (
-    parameters?: ClientSessionsListParameters,
-    options?: ClientSessionsListOptions,
-  ) => ClientSessionsListRequest {
-    const { client, defaults } = this
-    return function clientSessionsList(
-      ...args: Parameters<SeamHttpClientSessions['list']>
-    ): ReturnType<SeamHttpClientSessions['list']> {
-      const seam = SeamHttpClientSessions.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/client_sessions/revoke'(): (
-    parameters: ClientSessionsRevokeParameters,
-    options?: ClientSessionsRevokeOptions,
-  ) => ClientSessionsRevokeRequest {
-    const { client, defaults } = this
-    return function clientSessionsRevoke(
-      ...args: Parameters<SeamHttpClientSessions['revoke']>
-    ): ReturnType<SeamHttpClientSessions['revoke']> {
-      const seam = SeamHttpClientSessions.fromClient(client, defaults)
-      return seam.revoke(...args)
-    }
-  }
-
-  get '/connect_webviews/create'(): (
-    parameters?: ConnectWebviewsCreateParameters,
-    options?: ConnectWebviewsCreateOptions,
-  ) => ConnectWebviewsCreateRequest {
-    const { client, defaults } = this
-    return function connectWebviewsCreate(
-      ...args: Parameters<SeamHttpConnectWebviews['create']>
-    ): ReturnType<SeamHttpConnectWebviews['create']> {
-      const seam = SeamHttpConnectWebviews.fromClient(client, defaults)
-      return seam.create(...args)
-    }
-  }
-
-  get '/connect_webviews/delete'(): (
-    parameters: ConnectWebviewsDeleteParameters,
-    options?: ConnectWebviewsDeleteOptions,
-  ) => ConnectWebviewsDeleteRequest {
-    const { client, defaults } = this
-    return function connectWebviewsDelete(
-      ...args: Parameters<SeamHttpConnectWebviews['delete']>
-    ): ReturnType<SeamHttpConnectWebviews['delete']> {
-      const seam = SeamHttpConnectWebviews.fromClient(client, defaults)
-      return seam.delete(...args)
-    }
-  }
-
-  get '/connect_webviews/get'(): (
-    parameters: ConnectWebviewsGetParameters,
-    options?: ConnectWebviewsGetOptions,
-  ) => ConnectWebviewsGetRequest {
-    const { client, defaults } = this
-    return function connectWebviewsGet(
-      ...args: Parameters<SeamHttpConnectWebviews['get']>
-    ): ReturnType<SeamHttpConnectWebviews['get']> {
-      const seam = SeamHttpConnectWebviews.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/connect_webviews/list'(): (
-    parameters?: ConnectWebviewsListParameters,
-    options?: ConnectWebviewsListOptions,
-  ) => ConnectWebviewsListRequest {
-    const { client, defaults } = this
-    return function connectWebviewsList(
-      ...args: Parameters<SeamHttpConnectWebviews['list']>
-    ): ReturnType<SeamHttpConnectWebviews['list']> {
-      const seam = SeamHttpConnectWebviews.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/connected_accounts/delete'(): (
-    parameters: ConnectedAccountsDeleteParameters,
-    options?: ConnectedAccountsDeleteOptions,
-  ) => ConnectedAccountsDeleteRequest {
-    const { client, defaults } = this
-    return function connectedAccountsDelete(
-      ...args: Parameters<SeamHttpConnectedAccounts['delete']>
-    ): ReturnType<SeamHttpConnectedAccounts['delete']> {
-      const seam = SeamHttpConnectedAccounts.fromClient(client, defaults)
-      return seam.delete(...args)
-    }
-  }
-
-  get '/connected_accounts/get'(): (
-    parameters?: ConnectedAccountsGetParameters,
-    options?: ConnectedAccountsGetOptions,
-  ) => ConnectedAccountsGetRequest {
-    const { client, defaults } = this
-    return function connectedAccountsGet(
-      ...args: Parameters<SeamHttpConnectedAccounts['get']>
-    ): ReturnType<SeamHttpConnectedAccounts['get']> {
-      const seam = SeamHttpConnectedAccounts.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/connected_accounts/list'(): (
-    parameters?: ConnectedAccountsListParameters,
-    options?: ConnectedAccountsListOptions,
-  ) => ConnectedAccountsListRequest {
-    const { client, defaults } = this
-    return function connectedAccountsList(
-      ...args: Parameters<SeamHttpConnectedAccounts['list']>
-    ): ReturnType<SeamHttpConnectedAccounts['list']> {
-      const seam = SeamHttpConnectedAccounts.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/connected_accounts/sync'(): (
-    parameters: ConnectedAccountsSyncParameters,
-    options?: ConnectedAccountsSyncOptions,
-  ) => ConnectedAccountsSyncRequest {
-    const { client, defaults } = this
-    return function connectedAccountsSync(
-      ...args: Parameters<SeamHttpConnectedAccounts['sync']>
-    ): ReturnType<SeamHttpConnectedAccounts['sync']> {
-      const seam = SeamHttpConnectedAccounts.fromClient(client, defaults)
-      return seam.sync(...args)
-    }
-  }
-
-  get '/connected_accounts/update'(): (
-    parameters: ConnectedAccountsUpdateParameters,
-    options?: ConnectedAccountsUpdateOptions,
-  ) => ConnectedAccountsUpdateRequest {
-    const { client, defaults } = this
-    return function connectedAccountsUpdate(
-      ...args: Parameters<SeamHttpConnectedAccounts['update']>
-    ): ReturnType<SeamHttpConnectedAccounts['update']> {
-      const seam = SeamHttpConnectedAccounts.fromClient(client, defaults)
-      return seam.update(...args)
-    }
-  }
-
-  get '/connected_accounts/simulate/disconnect'(): (
-    parameters: ConnectedAccountsSimulateDisconnectParameters,
-    options?: ConnectedAccountsSimulateDisconnectOptions,
-  ) => ConnectedAccountsSimulateDisconnectRequest {
-    const { client, defaults } = this
-    return function connectedAccountsSimulateDisconnect(
-      ...args: Parameters<SeamHttpConnectedAccountsSimulate['disconnect']>
-    ): ReturnType<SeamHttpConnectedAccountsSimulate['disconnect']> {
-      const seam = SeamHttpConnectedAccountsSimulate.fromClient(
-        client,
-        defaults,
-      )
-      return seam.disconnect(...args)
-    }
-  }
-
-  get '/customers/create_portal'(): (
-    parameters?: CustomersCreatePortalParameters,
-    options?: CustomersCreatePortalOptions,
-  ) => CustomersCreatePortalRequest {
-    const { client, defaults } = this
-    return function customersCreatePortal(
-      ...args: Parameters<SeamHttpCustomers['createPortal']>
-    ): ReturnType<SeamHttpCustomers['createPortal']> {
-      const seam = SeamHttpCustomers.fromClient(client, defaults)
-      return seam.createPortal(...args)
-    }
-  }
-
-  get '/customers/delete_data'(): (
-    parameters?: CustomersDeleteDataParameters,
-    options?: CustomersDeleteDataOptions,
-  ) => CustomersDeleteDataRequest {
-    const { client, defaults } = this
-    return function customersDeleteData(
-      ...args: Parameters<SeamHttpCustomers['deleteData']>
-    ): ReturnType<SeamHttpCustomers['deleteData']> {
-      const seam = SeamHttpCustomers.fromClient(client, defaults)
-      return seam.deleteData(...args)
-    }
-  }
-
-  get '/customers/push_data'(): (
-    parameters: CustomersPushDataParameters,
-    options?: CustomersPushDataOptions,
-  ) => CustomersPushDataRequest {
-    const { client, defaults } = this
-    return function customersPushData(
-      ...args: Parameters<SeamHttpCustomers['pushData']>
-    ): ReturnType<SeamHttpCustomers['pushData']> {
-      const seam = SeamHttpCustomers.fromClient(client, defaults)
-      return seam.pushData(...args)
-    }
-  }
-
-  get '/devices/get'(): (
-    parameters?: DevicesGetParameters,
-    options?: DevicesGetOptions,
-  ) => DevicesGetRequest {
-    const { client, defaults } = this
-    return function devicesGet(
-      ...args: Parameters<SeamHttpDevices['get']>
-    ): ReturnType<SeamHttpDevices['get']> {
-      const seam = SeamHttpDevices.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/devices/list'(): (
-    parameters?: DevicesListParameters,
-    options?: DevicesListOptions,
-  ) => DevicesListRequest {
-    const { client, defaults } = this
-    return function devicesList(
-      ...args: Parameters<SeamHttpDevices['list']>
-    ): ReturnType<SeamHttpDevices['list']> {
-      const seam = SeamHttpDevices.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/devices/list_device_providers'(): (
-    parameters?: DevicesListDeviceProvidersParameters,
-    options?: DevicesListDeviceProvidersOptions,
-  ) => DevicesListDeviceProvidersRequest {
-    const { client, defaults } = this
-    return function devicesListDeviceProviders(
-      ...args: Parameters<SeamHttpDevices['listDeviceProviders']>
-    ): ReturnType<SeamHttpDevices['listDeviceProviders']> {
-      const seam = SeamHttpDevices.fromClient(client, defaults)
-      return seam.listDeviceProviders(...args)
-    }
-  }
-
-  get '/devices/report_provider_metadata'(): (
-    parameters: DevicesReportProviderMetadataParameters,
-    options?: DevicesReportProviderMetadataOptions,
-  ) => DevicesReportProviderMetadataRequest {
-    const { client, defaults } = this
-    return function devicesReportProviderMetadata(
-      ...args: Parameters<SeamHttpDevices['reportProviderMetadata']>
-    ): ReturnType<SeamHttpDevices['reportProviderMetadata']> {
-      const seam = SeamHttpDevices.fromClient(client, defaults)
-      return seam.reportProviderMetadata(...args)
-    }
-  }
-
-  get '/devices/update'(): (
-    parameters: DevicesUpdateParameters,
-    options?: DevicesUpdateOptions,
-  ) => DevicesUpdateRequest {
-    const { client, defaults } = this
-    return function devicesUpdate(
-      ...args: Parameters<SeamHttpDevices['update']>
-    ): ReturnType<SeamHttpDevices['update']> {
-      const seam = SeamHttpDevices.fromClient(client, defaults)
-      return seam.update(...args)
-    }
-  }
-
-  get '/devices/simulate/connect'(): (
-    parameters: DevicesSimulateConnectParameters,
-    options?: DevicesSimulateConnectOptions,
-  ) => DevicesSimulateConnectRequest {
-    const { client, defaults } = this
-    return function devicesSimulateConnect(
-      ...args: Parameters<SeamHttpDevicesSimulate['connect']>
-    ): ReturnType<SeamHttpDevicesSimulate['connect']> {
-      const seam = SeamHttpDevicesSimulate.fromClient(client, defaults)
-      return seam.connect(...args)
-    }
-  }
-
-  get '/devices/simulate/connect_to_hub'(): (
-    parameters: DevicesSimulateConnectToHubParameters,
-    options?: DevicesSimulateConnectToHubOptions,
-  ) => DevicesSimulateConnectToHubRequest {
-    const { client, defaults } = this
-    return function devicesSimulateConnectToHub(
-      ...args: Parameters<SeamHttpDevicesSimulate['connectToHub']>
-    ): ReturnType<SeamHttpDevicesSimulate['connectToHub']> {
-      const seam = SeamHttpDevicesSimulate.fromClient(client, defaults)
-      return seam.connectToHub(...args)
-    }
-  }
-
-  get '/devices/simulate/disconnect'(): (
-    parameters: DevicesSimulateDisconnectParameters,
-    options?: DevicesSimulateDisconnectOptions,
-  ) => DevicesSimulateDisconnectRequest {
-    const { client, defaults } = this
-    return function devicesSimulateDisconnect(
-      ...args: Parameters<SeamHttpDevicesSimulate['disconnect']>
-    ): ReturnType<SeamHttpDevicesSimulate['disconnect']> {
-      const seam = SeamHttpDevicesSimulate.fromClient(client, defaults)
-      return seam.disconnect(...args)
-    }
-  }
-
-  get '/devices/simulate/disconnect_from_hub'(): (
-    parameters: DevicesSimulateDisconnectFromHubParameters,
-    options?: DevicesSimulateDisconnectFromHubOptions,
-  ) => DevicesSimulateDisconnectFromHubRequest {
-    const { client, defaults } = this
-    return function devicesSimulateDisconnectFromHub(
-      ...args: Parameters<SeamHttpDevicesSimulate['disconnectFromHub']>
-    ): ReturnType<SeamHttpDevicesSimulate['disconnectFromHub']> {
-      const seam = SeamHttpDevicesSimulate.fromClient(client, defaults)
-      return seam.disconnectFromHub(...args)
-    }
-  }
-
-  get '/devices/simulate/paid_subscription'(): (
-    parameters: DevicesSimulatePaidSubscriptionParameters,
-    options?: DevicesSimulatePaidSubscriptionOptions,
-  ) => DevicesSimulatePaidSubscriptionRequest {
-    const { client, defaults } = this
-    return function devicesSimulatePaidSubscription(
-      ...args: Parameters<SeamHttpDevicesSimulate['paidSubscription']>
-    ): ReturnType<SeamHttpDevicesSimulate['paidSubscription']> {
-      const seam = SeamHttpDevicesSimulate.fromClient(client, defaults)
-      return seam.paidSubscription(...args)
-    }
-  }
-
-  get '/devices/simulate/remove'(): (
-    parameters: DevicesSimulateRemoveParameters,
-    options?: DevicesSimulateRemoveOptions,
-  ) => DevicesSimulateRemoveRequest {
-    const { client, defaults } = this
-    return function devicesSimulateRemove(
-      ...args: Parameters<SeamHttpDevicesSimulate['remove']>
-    ): ReturnType<SeamHttpDevicesSimulate['remove']> {
-      const seam = SeamHttpDevicesSimulate.fromClient(client, defaults)
-      return seam.remove(...args)
-    }
-  }
-
-  get '/devices/unmanaged/get'(): (
-    parameters?: DevicesUnmanagedGetParameters,
-    options?: DevicesUnmanagedGetOptions,
-  ) => DevicesUnmanagedGetRequest {
-    const { client, defaults } = this
-    return function devicesUnmanagedGet(
-      ...args: Parameters<SeamHttpDevicesUnmanaged['get']>
-    ): ReturnType<SeamHttpDevicesUnmanaged['get']> {
-      const seam = SeamHttpDevicesUnmanaged.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/devices/unmanaged/list'(): (
-    parameters?: DevicesUnmanagedListParameters,
-    options?: DevicesUnmanagedListOptions,
-  ) => DevicesUnmanagedListRequest {
-    const { client, defaults } = this
-    return function devicesUnmanagedList(
-      ...args: Parameters<SeamHttpDevicesUnmanaged['list']>
-    ): ReturnType<SeamHttpDevicesUnmanaged['list']> {
-      const seam = SeamHttpDevicesUnmanaged.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/devices/unmanaged/update'(): (
-    parameters: DevicesUnmanagedUpdateParameters,
-    options?: DevicesUnmanagedUpdateOptions,
-  ) => DevicesUnmanagedUpdateRequest {
-    const { client, defaults } = this
-    return function devicesUnmanagedUpdate(
-      ...args: Parameters<SeamHttpDevicesUnmanaged['update']>
-    ): ReturnType<SeamHttpDevicesUnmanaged['update']> {
-      const seam = SeamHttpDevicesUnmanaged.fromClient(client, defaults)
-      return seam.update(...args)
-    }
-  }
-
-  get '/events/get'(): (
-    parameters?: EventsGetParameters,
-    options?: EventsGetOptions,
-  ) => EventsGetRequest {
-    const { client, defaults } = this
-    return function eventsGet(
-      ...args: Parameters<SeamHttpEvents['get']>
-    ): ReturnType<SeamHttpEvents['get']> {
-      const seam = SeamHttpEvents.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/events/list'(): (
-    parameters?: EventsListParameters,
-    options?: EventsListOptions,
-  ) => EventsListRequest {
-    const { client, defaults } = this
-    return function eventsList(
-      ...args: Parameters<SeamHttpEvents['list']>
-    ): ReturnType<SeamHttpEvents['list']> {
-      const seam = SeamHttpEvents.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/instant_keys/delete'(): (
-    parameters: InstantKeysDeleteParameters,
-    options?: InstantKeysDeleteOptions,
-  ) => InstantKeysDeleteRequest {
-    const { client, defaults } = this
-    return function instantKeysDelete(
-      ...args: Parameters<SeamHttpInstantKeys['delete']>
-    ): ReturnType<SeamHttpInstantKeys['delete']> {
-      const seam = SeamHttpInstantKeys.fromClient(client, defaults)
-      return seam.delete(...args)
-    }
-  }
-
-  get '/instant_keys/get'(): (
-    parameters?: InstantKeysGetParameters,
-    options?: InstantKeysGetOptions,
-  ) => InstantKeysGetRequest {
-    const { client, defaults } = this
-    return function instantKeysGet(
-      ...args: Parameters<SeamHttpInstantKeys['get']>
-    ): ReturnType<SeamHttpInstantKeys['get']> {
-      const seam = SeamHttpInstantKeys.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/instant_keys/list'(): (
-    parameters?: InstantKeysListParameters,
-    options?: InstantKeysListOptions,
-  ) => InstantKeysListRequest {
-    const { client, defaults } = this
-    return function instantKeysList(
-      ...args: Parameters<SeamHttpInstantKeys['list']>
-    ): ReturnType<SeamHttpInstantKeys['list']> {
-      const seam = SeamHttpInstantKeys.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/locks/configure_auto_lock'(): (
-    parameters: LocksConfigureAutoLockParameters,
-    options?: LocksConfigureAutoLockOptions,
-  ) => LocksConfigureAutoLockRequest {
-    const { client, defaults } = this
-    return function locksConfigureAutoLock(
-      ...args: Parameters<SeamHttpLocks['configureAutoLock']>
-    ): ReturnType<SeamHttpLocks['configureAutoLock']> {
-      const seam = SeamHttpLocks.fromClient(client, defaults)
-      return seam.configureAutoLock(...args)
-    }
-  }
-
-  get '/locks/get'(): (
-    parameters?: LocksGetParameters,
-    options?: LocksGetOptions,
-  ) => LocksGetRequest {
-    const { client, defaults } = this
-    return function locksGet(
-      ...args: Parameters<SeamHttpLocks['get']>
-    ): ReturnType<SeamHttpLocks['get']> {
-      const seam = SeamHttpLocks.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/locks/list'(): (
-    parameters?: LocksListParameters,
-    options?: LocksListOptions,
-  ) => LocksListRequest {
-    const { client, defaults } = this
-    return function locksList(
-      ...args: Parameters<SeamHttpLocks['list']>
-    ): ReturnType<SeamHttpLocks['list']> {
-      const seam = SeamHttpLocks.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/locks/lock_door'(): (
-    parameters: LocksLockDoorParameters,
-    options?: LocksLockDoorOptions,
-  ) => LocksLockDoorRequest {
-    const { client, defaults } = this
-    return function locksLockDoor(
-      ...args: Parameters<SeamHttpLocks['lockDoor']>
-    ): ReturnType<SeamHttpLocks['lockDoor']> {
-      const seam = SeamHttpLocks.fromClient(client, defaults)
-      return seam.lockDoor(...args)
-    }
-  }
-
-  get '/locks/unlock_door'(): (
-    parameters: LocksUnlockDoorParameters,
-    options?: LocksUnlockDoorOptions,
-  ) => LocksUnlockDoorRequest {
-    const { client, defaults } = this
-    return function locksUnlockDoor(
-      ...args: Parameters<SeamHttpLocks['unlockDoor']>
-    ): ReturnType<SeamHttpLocks['unlockDoor']> {
-      const seam = SeamHttpLocks.fromClient(client, defaults)
-      return seam.unlockDoor(...args)
-    }
-  }
-
-  get '/locks/simulate/keypad_code_entry'(): (
-    parameters: LocksSimulateKeypadCodeEntryParameters,
-    options?: LocksSimulateKeypadCodeEntryOptions,
-  ) => LocksSimulateKeypadCodeEntryRequest {
-    const { client, defaults } = this
-    return function locksSimulateKeypadCodeEntry(
-      ...args: Parameters<SeamHttpLocksSimulate['keypadCodeEntry']>
-    ): ReturnType<SeamHttpLocksSimulate['keypadCodeEntry']> {
-      const seam = SeamHttpLocksSimulate.fromClient(client, defaults)
-      return seam.keypadCodeEntry(...args)
-    }
-  }
-
-  get '/locks/simulate/manual_lock_via_keypad'(): (
-    parameters: LocksSimulateManualLockViaKeypadParameters,
-    options?: LocksSimulateManualLockViaKeypadOptions,
-  ) => LocksSimulateManualLockViaKeypadRequest {
-    const { client, defaults } = this
-    return function locksSimulateManualLockViaKeypad(
-      ...args: Parameters<SeamHttpLocksSimulate['manualLockViaKeypad']>
-    ): ReturnType<SeamHttpLocksSimulate['manualLockViaKeypad']> {
-      const seam = SeamHttpLocksSimulate.fromClient(client, defaults)
-      return seam.manualLockViaKeypad(...args)
-    }
-  }
-
-  get '/noise_sensors/list'(): (
-    parameters?: NoiseSensorsListParameters,
-    options?: NoiseSensorsListOptions,
-  ) => NoiseSensorsListRequest {
-    const { client, defaults } = this
-    return function noiseSensorsList(
-      ...args: Parameters<SeamHttpNoiseSensors['list']>
-    ): ReturnType<SeamHttpNoiseSensors['list']> {
-      const seam = SeamHttpNoiseSensors.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/noise_sensors/noise_thresholds/create'(): (
-    parameters: NoiseSensorsNoiseThresholdsCreateParameters,
-    options?: NoiseSensorsNoiseThresholdsCreateOptions,
-  ) => NoiseSensorsNoiseThresholdsCreateRequest {
-    const { client, defaults } = this
-    return function noiseSensorsNoiseThresholdsCreate(
-      ...args: Parameters<SeamHttpNoiseSensorsNoiseThresholds['create']>
-    ): ReturnType<SeamHttpNoiseSensorsNoiseThresholds['create']> {
-      const seam = SeamHttpNoiseSensorsNoiseThresholds.fromClient(
-        client,
-        defaults,
-      )
-      return seam.create(...args)
-    }
-  }
-
-  get '/noise_sensors/noise_thresholds/delete'(): (
-    parameters: NoiseSensorsNoiseThresholdsDeleteParameters,
-    options?: NoiseSensorsNoiseThresholdsDeleteOptions,
-  ) => NoiseSensorsNoiseThresholdsDeleteRequest {
-    const { client, defaults } = this
-    return function noiseSensorsNoiseThresholdsDelete(
-      ...args: Parameters<SeamHttpNoiseSensorsNoiseThresholds['delete']>
-    ): ReturnType<SeamHttpNoiseSensorsNoiseThresholds['delete']> {
-      const seam = SeamHttpNoiseSensorsNoiseThresholds.fromClient(
-        client,
-        defaults,
-      )
-      return seam.delete(...args)
-    }
-  }
-
-  get '/noise_sensors/noise_thresholds/get'(): (
-    parameters: NoiseSensorsNoiseThresholdsGetParameters,
-    options?: NoiseSensorsNoiseThresholdsGetOptions,
-  ) => NoiseSensorsNoiseThresholdsGetRequest {
-    const { client, defaults } = this
-    return function noiseSensorsNoiseThresholdsGet(
-      ...args: Parameters<SeamHttpNoiseSensorsNoiseThresholds['get']>
-    ): ReturnType<SeamHttpNoiseSensorsNoiseThresholds['get']> {
-      const seam = SeamHttpNoiseSensorsNoiseThresholds.fromClient(
-        client,
-        defaults,
-      )
-      return seam.get(...args)
-    }
-  }
-
-  get '/noise_sensors/noise_thresholds/list'(): (
-    parameters: NoiseSensorsNoiseThresholdsListParameters,
-    options?: NoiseSensorsNoiseThresholdsListOptions,
-  ) => NoiseSensorsNoiseThresholdsListRequest {
-    const { client, defaults } = this
-    return function noiseSensorsNoiseThresholdsList(
-      ...args: Parameters<SeamHttpNoiseSensorsNoiseThresholds['list']>
-    ): ReturnType<SeamHttpNoiseSensorsNoiseThresholds['list']> {
-      const seam = SeamHttpNoiseSensorsNoiseThresholds.fromClient(
-        client,
-        defaults,
-      )
-      return seam.list(...args)
-    }
-  }
-
-  get '/noise_sensors/noise_thresholds/update'(): (
-    parameters: NoiseSensorsNoiseThresholdsUpdateParameters,
-    options?: NoiseSensorsNoiseThresholdsUpdateOptions,
-  ) => NoiseSensorsNoiseThresholdsUpdateRequest {
-    const { client, defaults } = this
-    return function noiseSensorsNoiseThresholdsUpdate(
-      ...args: Parameters<SeamHttpNoiseSensorsNoiseThresholds['update']>
-    ): ReturnType<SeamHttpNoiseSensorsNoiseThresholds['update']> {
-      const seam = SeamHttpNoiseSensorsNoiseThresholds.fromClient(
-        client,
-        defaults,
-      )
-      return seam.update(...args)
-    }
-  }
-
-  get '/noise_sensors/simulate/trigger_noise_threshold'(): (
-    parameters: NoiseSensorsSimulateTriggerNoiseThresholdParameters,
-    options?: NoiseSensorsSimulateTriggerNoiseThresholdOptions,
-  ) => NoiseSensorsSimulateTriggerNoiseThresholdRequest {
-    const { client, defaults } = this
-    return function noiseSensorsSimulateTriggerNoiseThreshold(
-      ...args: Parameters<SeamHttpNoiseSensorsSimulate['triggerNoiseThreshold']>
-    ): ReturnType<SeamHttpNoiseSensorsSimulate['triggerNoiseThreshold']> {
-      const seam = SeamHttpNoiseSensorsSimulate.fromClient(client, defaults)
-      return seam.triggerNoiseThreshold(...args)
-    }
-  }
-
-  get '/phones/deactivate'(): (
-    parameters: PhonesDeactivateParameters,
-    options?: PhonesDeactivateOptions,
-  ) => PhonesDeactivateRequest {
-    const { client, defaults } = this
-    return function phonesDeactivate(
-      ...args: Parameters<SeamHttpPhones['deactivate']>
-    ): ReturnType<SeamHttpPhones['deactivate']> {
-      const seam = SeamHttpPhones.fromClient(client, defaults)
-      return seam.deactivate(...args)
-    }
-  }
-
-  get '/phones/get'(): (
-    parameters: PhonesGetParameters,
-    options?: PhonesGetOptions,
-  ) => PhonesGetRequest {
-    const { client, defaults } = this
-    return function phonesGet(
-      ...args: Parameters<SeamHttpPhones['get']>
-    ): ReturnType<SeamHttpPhones['get']> {
-      const seam = SeamHttpPhones.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/phones/list'(): (
-    parameters?: PhonesListParameters,
-    options?: PhonesListOptions,
-  ) => PhonesListRequest {
-    const { client, defaults } = this
-    return function phonesList(
-      ...args: Parameters<SeamHttpPhones['list']>
-    ): ReturnType<SeamHttpPhones['list']> {
-      const seam = SeamHttpPhones.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/phones/simulate/create_sandbox_phone'(): (
-    parameters: PhonesSimulateCreateSandboxPhoneParameters,
-    options?: PhonesSimulateCreateSandboxPhoneOptions,
-  ) => PhonesSimulateCreateSandboxPhoneRequest {
-    const { client, defaults } = this
-    return function phonesSimulateCreateSandboxPhone(
-      ...args: Parameters<SeamHttpPhonesSimulate['createSandboxPhone']>
-    ): ReturnType<SeamHttpPhonesSimulate['createSandboxPhone']> {
-      const seam = SeamHttpPhonesSimulate.fromClient(client, defaults)
-      return seam.createSandboxPhone(...args)
-    }
-  }
-
-  get '/spaces/add_acs_entrances'(): (
-    parameters: SpacesAddAcsEntrancesParameters,
-    options?: SpacesAddAcsEntrancesOptions,
-  ) => SpacesAddAcsEntrancesRequest {
-    const { client, defaults } = this
-    return function spacesAddAcsEntrances(
-      ...args: Parameters<SeamHttpSpaces['addAcsEntrances']>
-    ): ReturnType<SeamHttpSpaces['addAcsEntrances']> {
-      const seam = SeamHttpSpaces.fromClient(client, defaults)
-      return seam.addAcsEntrances(...args)
-    }
-  }
-
-  get '/spaces/add_connected_account'(): (
-    parameters: SpacesAddConnectedAccountParameters,
-    options?: SpacesAddConnectedAccountOptions,
-  ) => SpacesAddConnectedAccountRequest {
-    const { client, defaults } = this
-    return function spacesAddConnectedAccount(
-      ...args: Parameters<SeamHttpSpaces['addConnectedAccount']>
-    ): ReturnType<SeamHttpSpaces['addConnectedAccount']> {
-      const seam = SeamHttpSpaces.fromClient(client, defaults)
-      return seam.addConnectedAccount(...args)
-    }
-  }
-
-  get '/spaces/add_devices'(): (
-    parameters: SpacesAddDevicesParameters,
-    options?: SpacesAddDevicesOptions,
-  ) => SpacesAddDevicesRequest {
-    const { client, defaults } = this
-    return function spacesAddDevices(
-      ...args: Parameters<SeamHttpSpaces['addDevices']>
-    ): ReturnType<SeamHttpSpaces['addDevices']> {
-      const seam = SeamHttpSpaces.fromClient(client, defaults)
-      return seam.addDevices(...args)
-    }
-  }
-
-  get '/spaces/create'(): (
-    parameters: SpacesCreateParameters,
-    options?: SpacesCreateOptions,
-  ) => SpacesCreateRequest {
-    const { client, defaults } = this
-    return function spacesCreate(
-      ...args: Parameters<SeamHttpSpaces['create']>
-    ): ReturnType<SeamHttpSpaces['create']> {
-      const seam = SeamHttpSpaces.fromClient(client, defaults)
-      return seam.create(...args)
-    }
-  }
-
-  get '/spaces/delete'(): (
-    parameters: SpacesDeleteParameters,
-    options?: SpacesDeleteOptions,
-  ) => SpacesDeleteRequest {
-    const { client, defaults } = this
-    return function spacesDelete(
-      ...args: Parameters<SeamHttpSpaces['delete']>
-    ): ReturnType<SeamHttpSpaces['delete']> {
-      const seam = SeamHttpSpaces.fromClient(client, defaults)
-      return seam.delete(...args)
-    }
-  }
-
-  get '/spaces/get'(): (
-    parameters?: SpacesGetParameters,
-    options?: SpacesGetOptions,
-  ) => SpacesGetRequest {
-    const { client, defaults } = this
-    return function spacesGet(
-      ...args: Parameters<SeamHttpSpaces['get']>
-    ): ReturnType<SeamHttpSpaces['get']> {
-      const seam = SeamHttpSpaces.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/spaces/get_related'(): (
-    parameters?: SpacesGetRelatedParameters,
-    options?: SpacesGetRelatedOptions,
-  ) => SpacesGetRelatedRequest {
-    const { client, defaults } = this
-    return function spacesGetRelated(
-      ...args: Parameters<SeamHttpSpaces['getRelated']>
-    ): ReturnType<SeamHttpSpaces['getRelated']> {
-      const seam = SeamHttpSpaces.fromClient(client, defaults)
-      return seam.getRelated(...args)
-    }
-  }
-
-  get '/spaces/list'(): (
-    parameters?: SpacesListParameters,
-    options?: SpacesListOptions,
-  ) => SpacesListRequest {
-    const { client, defaults } = this
-    return function spacesList(
-      ...args: Parameters<SeamHttpSpaces['list']>
-    ): ReturnType<SeamHttpSpaces['list']> {
-      const seam = SeamHttpSpaces.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/spaces/remove_acs_entrances'(): (
-    parameters: SpacesRemoveAcsEntrancesParameters,
-    options?: SpacesRemoveAcsEntrancesOptions,
-  ) => SpacesRemoveAcsEntrancesRequest {
-    const { client, defaults } = this
-    return function spacesRemoveAcsEntrances(
-      ...args: Parameters<SeamHttpSpaces['removeAcsEntrances']>
-    ): ReturnType<SeamHttpSpaces['removeAcsEntrances']> {
-      const seam = SeamHttpSpaces.fromClient(client, defaults)
-      return seam.removeAcsEntrances(...args)
-    }
-  }
-
-  get '/spaces/remove_connected_account'(): (
-    parameters: SpacesRemoveConnectedAccountParameters,
-    options?: SpacesRemoveConnectedAccountOptions,
-  ) => SpacesRemoveConnectedAccountRequest {
-    const { client, defaults } = this
-    return function spacesRemoveConnectedAccount(
-      ...args: Parameters<SeamHttpSpaces['removeConnectedAccount']>
-    ): ReturnType<SeamHttpSpaces['removeConnectedAccount']> {
-      const seam = SeamHttpSpaces.fromClient(client, defaults)
-      return seam.removeConnectedAccount(...args)
-    }
-  }
-
-  get '/spaces/remove_devices'(): (
-    parameters: SpacesRemoveDevicesParameters,
-    options?: SpacesRemoveDevicesOptions,
-  ) => SpacesRemoveDevicesRequest {
-    const { client, defaults } = this
-    return function spacesRemoveDevices(
-      ...args: Parameters<SeamHttpSpaces['removeDevices']>
-    ): ReturnType<SeamHttpSpaces['removeDevices']> {
-      const seam = SeamHttpSpaces.fromClient(client, defaults)
-      return seam.removeDevices(...args)
-    }
-  }
-
-  get '/spaces/update'(): (
-    parameters?: SpacesUpdateParameters,
-    options?: SpacesUpdateOptions,
-  ) => SpacesUpdateRequest {
-    const { client, defaults } = this
-    return function spacesUpdate(
-      ...args: Parameters<SeamHttpSpaces['update']>
-    ): ReturnType<SeamHttpSpaces['update']> {
-      const seam = SeamHttpSpaces.fromClient(client, defaults)
-      return seam.update(...args)
-    }
-  }
-
-  get '/thermostats/activate_climate_preset'(): (
-    parameters: ThermostatsActivateClimatePresetParameters,
-    options?: ThermostatsActivateClimatePresetOptions,
-  ) => ThermostatsActivateClimatePresetRequest {
-    const { client, defaults } = this
-    return function thermostatsActivateClimatePreset(
-      ...args: Parameters<SeamHttpThermostats['activateClimatePreset']>
-    ): ReturnType<SeamHttpThermostats['activateClimatePreset']> {
-      const seam = SeamHttpThermostats.fromClient(client, defaults)
-      return seam.activateClimatePreset(...args)
-    }
-  }
-
-  get '/thermostats/cool'(): (
-    parameters: ThermostatsCoolParameters,
-    options?: ThermostatsCoolOptions,
-  ) => ThermostatsCoolRequest {
-    const { client, defaults } = this
-    return function thermostatsCool(
-      ...args: Parameters<SeamHttpThermostats['cool']>
-    ): ReturnType<SeamHttpThermostats['cool']> {
-      const seam = SeamHttpThermostats.fromClient(client, defaults)
-      return seam.cool(...args)
-    }
-  }
-
-  get '/thermostats/create_climate_preset'(): (
-    parameters: ThermostatsCreateClimatePresetParameters,
-    options?: ThermostatsCreateClimatePresetOptions,
-  ) => ThermostatsCreateClimatePresetRequest {
-    const { client, defaults } = this
-    return function thermostatsCreateClimatePreset(
-      ...args: Parameters<SeamHttpThermostats['createClimatePreset']>
-    ): ReturnType<SeamHttpThermostats['createClimatePreset']> {
-      const seam = SeamHttpThermostats.fromClient(client, defaults)
-      return seam.createClimatePreset(...args)
-    }
-  }
-
-  get '/thermostats/delete_climate_preset'(): (
-    parameters: ThermostatsDeleteClimatePresetParameters,
-    options?: ThermostatsDeleteClimatePresetOptions,
-  ) => ThermostatsDeleteClimatePresetRequest {
-    const { client, defaults } = this
-    return function thermostatsDeleteClimatePreset(
-      ...args: Parameters<SeamHttpThermostats['deleteClimatePreset']>
-    ): ReturnType<SeamHttpThermostats['deleteClimatePreset']> {
-      const seam = SeamHttpThermostats.fromClient(client, defaults)
-      return seam.deleteClimatePreset(...args)
-    }
-  }
-
-  get '/thermostats/heat'(): (
-    parameters: ThermostatsHeatParameters,
-    options?: ThermostatsHeatOptions,
-  ) => ThermostatsHeatRequest {
-    const { client, defaults } = this
-    return function thermostatsHeat(
-      ...args: Parameters<SeamHttpThermostats['heat']>
-    ): ReturnType<SeamHttpThermostats['heat']> {
-      const seam = SeamHttpThermostats.fromClient(client, defaults)
-      return seam.heat(...args)
-    }
-  }
-
-  get '/thermostats/heat_cool'(): (
-    parameters: ThermostatsHeatCoolParameters,
-    options?: ThermostatsHeatCoolOptions,
-  ) => ThermostatsHeatCoolRequest {
-    const { client, defaults } = this
-    return function thermostatsHeatCool(
-      ...args: Parameters<SeamHttpThermostats['heatCool']>
-    ): ReturnType<SeamHttpThermostats['heatCool']> {
-      const seam = SeamHttpThermostats.fromClient(client, defaults)
-      return seam.heatCool(...args)
-    }
-  }
-
-  get '/thermostats/list'(): (
-    parameters?: ThermostatsListParameters,
-    options?: ThermostatsListOptions,
-  ) => ThermostatsListRequest {
-    const { client, defaults } = this
-    return function thermostatsList(
-      ...args: Parameters<SeamHttpThermostats['list']>
-    ): ReturnType<SeamHttpThermostats['list']> {
-      const seam = SeamHttpThermostats.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/thermostats/off'(): (
-    parameters: ThermostatsOffParameters,
-    options?: ThermostatsOffOptions,
-  ) => ThermostatsOffRequest {
-    const { client, defaults } = this
-    return function thermostatsOff(
-      ...args: Parameters<SeamHttpThermostats['off']>
-    ): ReturnType<SeamHttpThermostats['off']> {
-      const seam = SeamHttpThermostats.fromClient(client, defaults)
-      return seam.off(...args)
-    }
-  }
-
-  get '/thermostats/set_fallback_climate_preset'(): (
-    parameters: ThermostatsSetFallbackClimatePresetParameters,
-    options?: ThermostatsSetFallbackClimatePresetOptions,
-  ) => ThermostatsSetFallbackClimatePresetRequest {
-    const { client, defaults } = this
-    return function thermostatsSetFallbackClimatePreset(
-      ...args: Parameters<SeamHttpThermostats['setFallbackClimatePreset']>
-    ): ReturnType<SeamHttpThermostats['setFallbackClimatePreset']> {
-      const seam = SeamHttpThermostats.fromClient(client, defaults)
-      return seam.setFallbackClimatePreset(...args)
-    }
-  }
-
-  get '/thermostats/set_fan_mode'(): (
-    parameters: ThermostatsSetFanModeParameters,
-    options?: ThermostatsSetFanModeOptions,
-  ) => ThermostatsSetFanModeRequest {
-    const { client, defaults } = this
-    return function thermostatsSetFanMode(
-      ...args: Parameters<SeamHttpThermostats['setFanMode']>
-    ): ReturnType<SeamHttpThermostats['setFanMode']> {
-      const seam = SeamHttpThermostats.fromClient(client, defaults)
-      return seam.setFanMode(...args)
-    }
-  }
-
-  get '/thermostats/set_hvac_mode'(): (
-    parameters: ThermostatsSetHvacModeParameters,
-    options?: ThermostatsSetHvacModeOptions,
-  ) => ThermostatsSetHvacModeRequest {
-    const { client, defaults } = this
-    return function thermostatsSetHvacMode(
-      ...args: Parameters<SeamHttpThermostats['setHvacMode']>
-    ): ReturnType<SeamHttpThermostats['setHvacMode']> {
-      const seam = SeamHttpThermostats.fromClient(client, defaults)
-      return seam.setHvacMode(...args)
-    }
-  }
-
-  get '/thermostats/set_temperature_threshold'(): (
-    parameters: ThermostatsSetTemperatureThresholdParameters,
-    options?: ThermostatsSetTemperatureThresholdOptions,
-  ) => ThermostatsSetTemperatureThresholdRequest {
-    const { client, defaults } = this
-    return function thermostatsSetTemperatureThreshold(
-      ...args: Parameters<SeamHttpThermostats['setTemperatureThreshold']>
-    ): ReturnType<SeamHttpThermostats['setTemperatureThreshold']> {
-      const seam = SeamHttpThermostats.fromClient(client, defaults)
-      return seam.setTemperatureThreshold(...args)
-    }
-  }
-
-  get '/thermostats/update_climate_preset'(): (
-    parameters: ThermostatsUpdateClimatePresetParameters,
-    options?: ThermostatsUpdateClimatePresetOptions,
-  ) => ThermostatsUpdateClimatePresetRequest {
-    const { client, defaults } = this
-    return function thermostatsUpdateClimatePreset(
-      ...args: Parameters<SeamHttpThermostats['updateClimatePreset']>
-    ): ReturnType<SeamHttpThermostats['updateClimatePreset']> {
-      const seam = SeamHttpThermostats.fromClient(client, defaults)
-      return seam.updateClimatePreset(...args)
-    }
-  }
-
-  get '/thermostats/update_weekly_program'(): (
-    parameters: ThermostatsUpdateWeeklyProgramParameters,
-    options?: ThermostatsUpdateWeeklyProgramOptions,
-  ) => ThermostatsUpdateWeeklyProgramRequest {
-    const { client, defaults } = this
-    return function thermostatsUpdateWeeklyProgram(
-      ...args: Parameters<SeamHttpThermostats['updateWeeklyProgram']>
-    ): ReturnType<SeamHttpThermostats['updateWeeklyProgram']> {
-      const seam = SeamHttpThermostats.fromClient(client, defaults)
-      return seam.updateWeeklyProgram(...args)
-    }
-  }
-
-  get '/thermostats/daily_programs/create'(): (
-    parameters: ThermostatsDailyProgramsCreateParameters,
-    options?: ThermostatsDailyProgramsCreateOptions,
-  ) => ThermostatsDailyProgramsCreateRequest {
-    const { client, defaults } = this
-    return function thermostatsDailyProgramsCreate(
-      ...args: Parameters<SeamHttpThermostatsDailyPrograms['create']>
-    ): ReturnType<SeamHttpThermostatsDailyPrograms['create']> {
-      const seam = SeamHttpThermostatsDailyPrograms.fromClient(client, defaults)
-      return seam.create(...args)
-    }
-  }
-
-  get '/thermostats/daily_programs/delete'(): (
-    parameters: ThermostatsDailyProgramsDeleteParameters,
-    options?: ThermostatsDailyProgramsDeleteOptions,
-  ) => ThermostatsDailyProgramsDeleteRequest {
-    const { client, defaults } = this
-    return function thermostatsDailyProgramsDelete(
-      ...args: Parameters<SeamHttpThermostatsDailyPrograms['delete']>
-    ): ReturnType<SeamHttpThermostatsDailyPrograms['delete']> {
-      const seam = SeamHttpThermostatsDailyPrograms.fromClient(client, defaults)
-      return seam.delete(...args)
-    }
-  }
-
-  get '/thermostats/daily_programs/update'(): (
-    parameters: ThermostatsDailyProgramsUpdateParameters,
-    options?: ThermostatsDailyProgramsUpdateOptions,
-  ) => ThermostatsDailyProgramsUpdateRequest {
-    const { client, defaults } = this
-    return function thermostatsDailyProgramsUpdate(
-      ...args: Parameters<SeamHttpThermostatsDailyPrograms['update']>
-    ): ReturnType<SeamHttpThermostatsDailyPrograms['update']> {
-      const seam = SeamHttpThermostatsDailyPrograms.fromClient(client, defaults)
-      return seam.update(...args)
-    }
-  }
-
-  get '/thermostats/schedules/create'(): (
-    parameters: ThermostatsSchedulesCreateParameters,
-    options?: ThermostatsSchedulesCreateOptions,
-  ) => ThermostatsSchedulesCreateRequest {
-    const { client, defaults } = this
-    return function thermostatsSchedulesCreate(
-      ...args: Parameters<SeamHttpThermostatsSchedules['create']>
-    ): ReturnType<SeamHttpThermostatsSchedules['create']> {
-      const seam = SeamHttpThermostatsSchedules.fromClient(client, defaults)
-      return seam.create(...args)
-    }
-  }
-
-  get '/thermostats/schedules/delete'(): (
-    parameters: ThermostatsSchedulesDeleteParameters,
-    options?: ThermostatsSchedulesDeleteOptions,
-  ) => ThermostatsSchedulesDeleteRequest {
-    const { client, defaults } = this
-    return function thermostatsSchedulesDelete(
-      ...args: Parameters<SeamHttpThermostatsSchedules['delete']>
-    ): ReturnType<SeamHttpThermostatsSchedules['delete']> {
-      const seam = SeamHttpThermostatsSchedules.fromClient(client, defaults)
-      return seam.delete(...args)
-    }
-  }
-
-  get '/thermostats/schedules/get'(): (
-    parameters: ThermostatsSchedulesGetParameters,
-    options?: ThermostatsSchedulesGetOptions,
-  ) => ThermostatsSchedulesGetRequest {
-    const { client, defaults } = this
-    return function thermostatsSchedulesGet(
-      ...args: Parameters<SeamHttpThermostatsSchedules['get']>
-    ): ReturnType<SeamHttpThermostatsSchedules['get']> {
-      const seam = SeamHttpThermostatsSchedules.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/thermostats/schedules/list'(): (
-    parameters: ThermostatsSchedulesListParameters,
-    options?: ThermostatsSchedulesListOptions,
-  ) => ThermostatsSchedulesListRequest {
-    const { client, defaults } = this
-    return function thermostatsSchedulesList(
-      ...args: Parameters<SeamHttpThermostatsSchedules['list']>
-    ): ReturnType<SeamHttpThermostatsSchedules['list']> {
-      const seam = SeamHttpThermostatsSchedules.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/thermostats/schedules/update'(): (
-    parameters: ThermostatsSchedulesUpdateParameters,
-    options?: ThermostatsSchedulesUpdateOptions,
-  ) => ThermostatsSchedulesUpdateRequest {
-    const { client, defaults } = this
-    return function thermostatsSchedulesUpdate(
-      ...args: Parameters<SeamHttpThermostatsSchedules['update']>
-    ): ReturnType<SeamHttpThermostatsSchedules['update']> {
-      const seam = SeamHttpThermostatsSchedules.fromClient(client, defaults)
-      return seam.update(...args)
-    }
-  }
-
-  get '/thermostats/simulate/hvac_mode_adjusted'(): (
-    parameters: ThermostatsSimulateHvacModeAdjustedParameters,
-    options?: ThermostatsSimulateHvacModeAdjustedOptions,
-  ) => ThermostatsSimulateHvacModeAdjustedRequest {
-    const { client, defaults } = this
-    return function thermostatsSimulateHvacModeAdjusted(
-      ...args: Parameters<SeamHttpThermostatsSimulate['hvacModeAdjusted']>
-    ): ReturnType<SeamHttpThermostatsSimulate['hvacModeAdjusted']> {
-      const seam = SeamHttpThermostatsSimulate.fromClient(client, defaults)
-      return seam.hvacModeAdjusted(...args)
-    }
-  }
-
-  get '/thermostats/simulate/temperature_reached'(): (
-    parameters: ThermostatsSimulateTemperatureReachedParameters,
-    options?: ThermostatsSimulateTemperatureReachedOptions,
-  ) => ThermostatsSimulateTemperatureReachedRequest {
-    const { client, defaults } = this
-    return function thermostatsSimulateTemperatureReached(
-      ...args: Parameters<SeamHttpThermostatsSimulate['temperatureReached']>
-    ): ReturnType<SeamHttpThermostatsSimulate['temperatureReached']> {
-      const seam = SeamHttpThermostatsSimulate.fromClient(client, defaults)
-      return seam.temperatureReached(...args)
-    }
-  }
-
-  get '/user_identities/add_acs_user'(): (
-    parameters: UserIdentitiesAddAcsUserParameters,
-    options?: UserIdentitiesAddAcsUserOptions,
-  ) => UserIdentitiesAddAcsUserRequest {
-    const { client, defaults } = this
-    return function userIdentitiesAddAcsUser(
-      ...args: Parameters<SeamHttpUserIdentities['addAcsUser']>
-    ): ReturnType<SeamHttpUserIdentities['addAcsUser']> {
-      const seam = SeamHttpUserIdentities.fromClient(client, defaults)
-      return seam.addAcsUser(...args)
-    }
-  }
-
-  get '/user_identities/create'(): (
-    parameters?: UserIdentitiesCreateParameters,
-    options?: UserIdentitiesCreateOptions,
-  ) => UserIdentitiesCreateRequest {
-    const { client, defaults } = this
-    return function userIdentitiesCreate(
-      ...args: Parameters<SeamHttpUserIdentities['create']>
-    ): ReturnType<SeamHttpUserIdentities['create']> {
-      const seam = SeamHttpUserIdentities.fromClient(client, defaults)
-      return seam.create(...args)
-    }
-  }
-
-  get '/user_identities/delete'(): (
-    parameters: UserIdentitiesDeleteParameters,
-    options?: UserIdentitiesDeleteOptions,
-  ) => UserIdentitiesDeleteRequest {
-    const { client, defaults } = this
-    return function userIdentitiesDelete(
-      ...args: Parameters<SeamHttpUserIdentities['delete']>
-    ): ReturnType<SeamHttpUserIdentities['delete']> {
-      const seam = SeamHttpUserIdentities.fromClient(client, defaults)
-      return seam.delete(...args)
-    }
-  }
-
-  get '/user_identities/generate_instant_key'(): (
-    parameters: UserIdentitiesGenerateInstantKeyParameters,
-    options?: UserIdentitiesGenerateInstantKeyOptions,
-  ) => UserIdentitiesGenerateInstantKeyRequest {
-    const { client, defaults } = this
-    return function userIdentitiesGenerateInstantKey(
-      ...args: Parameters<SeamHttpUserIdentities['generateInstantKey']>
-    ): ReturnType<SeamHttpUserIdentities['generateInstantKey']> {
-      const seam = SeamHttpUserIdentities.fromClient(client, defaults)
-      return seam.generateInstantKey(...args)
-    }
-  }
-
-  get '/user_identities/get'(): (
-    parameters?: UserIdentitiesGetParameters,
-    options?: UserIdentitiesGetOptions,
-  ) => UserIdentitiesGetRequest {
-    const { client, defaults } = this
-    return function userIdentitiesGet(
-      ...args: Parameters<SeamHttpUserIdentities['get']>
-    ): ReturnType<SeamHttpUserIdentities['get']> {
-      const seam = SeamHttpUserIdentities.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/user_identities/grant_access_to_device'(): (
-    parameters: UserIdentitiesGrantAccessToDeviceParameters,
-    options?: UserIdentitiesGrantAccessToDeviceOptions,
-  ) => UserIdentitiesGrantAccessToDeviceRequest {
-    const { client, defaults } = this
-    return function userIdentitiesGrantAccessToDevice(
-      ...args: Parameters<SeamHttpUserIdentities['grantAccessToDevice']>
-    ): ReturnType<SeamHttpUserIdentities['grantAccessToDevice']> {
-      const seam = SeamHttpUserIdentities.fromClient(client, defaults)
-      return seam.grantAccessToDevice(...args)
-    }
-  }
-
-  get '/user_identities/list'(): (
-    parameters?: UserIdentitiesListParameters,
-    options?: UserIdentitiesListOptions,
-  ) => UserIdentitiesListRequest {
-    const { client, defaults } = this
-    return function userIdentitiesList(
-      ...args: Parameters<SeamHttpUserIdentities['list']>
-    ): ReturnType<SeamHttpUserIdentities['list']> {
-      const seam = SeamHttpUserIdentities.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/user_identities/list_accessible_devices'(): (
-    parameters: UserIdentitiesListAccessibleDevicesParameters,
-    options?: UserIdentitiesListAccessibleDevicesOptions,
-  ) => UserIdentitiesListAccessibleDevicesRequest {
-    const { client, defaults } = this
-    return function userIdentitiesListAccessibleDevices(
-      ...args: Parameters<SeamHttpUserIdentities['listAccessibleDevices']>
-    ): ReturnType<SeamHttpUserIdentities['listAccessibleDevices']> {
-      const seam = SeamHttpUserIdentities.fromClient(client, defaults)
-      return seam.listAccessibleDevices(...args)
-    }
-  }
-
-  get '/user_identities/list_accessible_entrances'(): (
-    parameters: UserIdentitiesListAccessibleEntrancesParameters,
-    options?: UserIdentitiesListAccessibleEntrancesOptions,
-  ) => UserIdentitiesListAccessibleEntrancesRequest {
-    const { client, defaults } = this
-    return function userIdentitiesListAccessibleEntrances(
-      ...args: Parameters<SeamHttpUserIdentities['listAccessibleEntrances']>
-    ): ReturnType<SeamHttpUserIdentities['listAccessibleEntrances']> {
-      const seam = SeamHttpUserIdentities.fromClient(client, defaults)
-      return seam.listAccessibleEntrances(...args)
-    }
-  }
-
-  get '/user_identities/list_acs_systems'(): (
-    parameters: UserIdentitiesListAcsSystemsParameters,
-    options?: UserIdentitiesListAcsSystemsOptions,
-  ) => UserIdentitiesListAcsSystemsRequest {
-    const { client, defaults } = this
-    return function userIdentitiesListAcsSystems(
-      ...args: Parameters<SeamHttpUserIdentities['listAcsSystems']>
-    ): ReturnType<SeamHttpUserIdentities['listAcsSystems']> {
-      const seam = SeamHttpUserIdentities.fromClient(client, defaults)
-      return seam.listAcsSystems(...args)
-    }
-  }
-
-  get '/user_identities/list_acs_users'(): (
-    parameters: UserIdentitiesListAcsUsersParameters,
-    options?: UserIdentitiesListAcsUsersOptions,
-  ) => UserIdentitiesListAcsUsersRequest {
-    const { client, defaults } = this
-    return function userIdentitiesListAcsUsers(
-      ...args: Parameters<SeamHttpUserIdentities['listAcsUsers']>
-    ): ReturnType<SeamHttpUserIdentities['listAcsUsers']> {
-      const seam = SeamHttpUserIdentities.fromClient(client, defaults)
-      return seam.listAcsUsers(...args)
-    }
-  }
-
-  get '/user_identities/remove_acs_user'(): (
-    parameters: UserIdentitiesRemoveAcsUserParameters,
-    options?: UserIdentitiesRemoveAcsUserOptions,
-  ) => UserIdentitiesRemoveAcsUserRequest {
-    const { client, defaults } = this
-    return function userIdentitiesRemoveAcsUser(
-      ...args: Parameters<SeamHttpUserIdentities['removeAcsUser']>
-    ): ReturnType<SeamHttpUserIdentities['removeAcsUser']> {
-      const seam = SeamHttpUserIdentities.fromClient(client, defaults)
-      return seam.removeAcsUser(...args)
-    }
-  }
-
-  get '/user_identities/revoke_access_to_device'(): (
-    parameters: UserIdentitiesRevokeAccessToDeviceParameters,
-    options?: UserIdentitiesRevokeAccessToDeviceOptions,
-  ) => UserIdentitiesRevokeAccessToDeviceRequest {
-    const { client, defaults } = this
-    return function userIdentitiesRevokeAccessToDevice(
-      ...args: Parameters<SeamHttpUserIdentities['revokeAccessToDevice']>
-    ): ReturnType<SeamHttpUserIdentities['revokeAccessToDevice']> {
-      const seam = SeamHttpUserIdentities.fromClient(client, defaults)
-      return seam.revokeAccessToDevice(...args)
-    }
-  }
-
-  get '/user_identities/update'(): (
-    parameters: UserIdentitiesUpdateParameters,
-    options?: UserIdentitiesUpdateOptions,
-  ) => UserIdentitiesUpdateRequest {
-    const { client, defaults } = this
-    return function userIdentitiesUpdate(
-      ...args: Parameters<SeamHttpUserIdentities['update']>
-    ): ReturnType<SeamHttpUserIdentities['update']> {
-      const seam = SeamHttpUserIdentities.fromClient(client, defaults)
-      return seam.update(...args)
-    }
-  }
-
-  get '/user_identities/unmanaged/get'(): (
-    parameters: UserIdentitiesUnmanagedGetParameters,
-    options?: UserIdentitiesUnmanagedGetOptions,
-  ) => UserIdentitiesUnmanagedGetRequest {
-    const { client, defaults } = this
-    return function userIdentitiesUnmanagedGet(
-      ...args: Parameters<SeamHttpUserIdentitiesUnmanaged['get']>
-    ): ReturnType<SeamHttpUserIdentitiesUnmanaged['get']> {
-      const seam = SeamHttpUserIdentitiesUnmanaged.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/user_identities/unmanaged/list'(): (
-    parameters?: UserIdentitiesUnmanagedListParameters,
-    options?: UserIdentitiesUnmanagedListOptions,
-  ) => UserIdentitiesUnmanagedListRequest {
-    const { client, defaults } = this
-    return function userIdentitiesUnmanagedList(
-      ...args: Parameters<SeamHttpUserIdentitiesUnmanaged['list']>
-    ): ReturnType<SeamHttpUserIdentitiesUnmanaged['list']> {
-      const seam = SeamHttpUserIdentitiesUnmanaged.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/user_identities/unmanaged/update'(): (
-    parameters: UserIdentitiesUnmanagedUpdateParameters,
-    options?: UserIdentitiesUnmanagedUpdateOptions,
-  ) => UserIdentitiesUnmanagedUpdateRequest {
-    const { client, defaults } = this
-    return function userIdentitiesUnmanagedUpdate(
-      ...args: Parameters<SeamHttpUserIdentitiesUnmanaged['update']>
-    ): ReturnType<SeamHttpUserIdentitiesUnmanaged['update']> {
-      const seam = SeamHttpUserIdentitiesUnmanaged.fromClient(client, defaults)
-      return seam.update(...args)
-    }
-  }
-
-  get '/webhooks/create'(): (
-    parameters: WebhooksCreateParameters,
-    options?: WebhooksCreateOptions,
-  ) => WebhooksCreateRequest {
-    const { client, defaults } = this
-    return function webhooksCreate(
-      ...args: Parameters<SeamHttpWebhooks['create']>
-    ): ReturnType<SeamHttpWebhooks['create']> {
-      const seam = SeamHttpWebhooks.fromClient(client, defaults)
-      return seam.create(...args)
-    }
-  }
-
-  get '/webhooks/delete'(): (
-    parameters: WebhooksDeleteParameters,
-    options?: WebhooksDeleteOptions,
-  ) => WebhooksDeleteRequest {
-    const { client, defaults } = this
-    return function webhooksDelete(
-      ...args: Parameters<SeamHttpWebhooks['delete']>
-    ): ReturnType<SeamHttpWebhooks['delete']> {
-      const seam = SeamHttpWebhooks.fromClient(client, defaults)
-      return seam.delete(...args)
-    }
-  }
-
-  get '/webhooks/get'(): (
-    parameters: WebhooksGetParameters,
-    options?: WebhooksGetOptions,
-  ) => WebhooksGetRequest {
-    const { client, defaults } = this
-    return function webhooksGet(
-      ...args: Parameters<SeamHttpWebhooks['get']>
-    ): ReturnType<SeamHttpWebhooks['get']> {
-      const seam = SeamHttpWebhooks.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/webhooks/list'(): (
-    parameters?: WebhooksListParameters,
-    options?: WebhooksListOptions,
-  ) => WebhooksListRequest {
-    const { client, defaults } = this
-    return function webhooksList(
-      ...args: Parameters<SeamHttpWebhooks['list']>
-    ): ReturnType<SeamHttpWebhooks['list']> {
-      const seam = SeamHttpWebhooks.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/webhooks/update'(): (
-    parameters: WebhooksUpdateParameters,
-    options?: WebhooksUpdateOptions,
-  ) => WebhooksUpdateRequest {
-    const { client, defaults } = this
-    return function webhooksUpdate(
-      ...args: Parameters<SeamHttpWebhooks['update']>
-    ): ReturnType<SeamHttpWebhooks['update']> {
-      const seam = SeamHttpWebhooks.fromClient(client, defaults)
-      return seam.update(...args)
-    }
-  }
-
-  get '/workspaces/create'(): (
-    parameters: WorkspacesCreateParameters,
-    options?: WorkspacesCreateOptions,
-  ) => WorkspacesCreateRequest {
-    const { client, defaults } = this
-    return function workspacesCreate(
-      ...args: Parameters<SeamHttpWorkspaces['create']>
-    ): ReturnType<SeamHttpWorkspaces['create']> {
-      const seam = SeamHttpWorkspaces.fromClient(client, defaults)
-      return seam.create(...args)
-    }
-  }
-
-  get '/workspaces/get'(): (
-    parameters?: WorkspacesGetParameters,
-    options?: WorkspacesGetOptions,
-  ) => WorkspacesGetRequest {
-    const { client, defaults } = this
-    return function workspacesGet(
-      ...args: Parameters<SeamHttpWorkspaces['get']>
-    ): ReturnType<SeamHttpWorkspaces['get']> {
-      const seam = SeamHttpWorkspaces.fromClient(client, defaults)
-      return seam.get(...args)
-    }
-  }
-
-  get '/workspaces/list'(): (
-    parameters?: WorkspacesListParameters,
-    options?: WorkspacesListOptions,
-  ) => WorkspacesListRequest {
-    const { client, defaults } = this
-    return function workspacesList(
-      ...args: Parameters<SeamHttpWorkspaces['list']>
-    ): ReturnType<SeamHttpWorkspaces['list']> {
-      const seam = SeamHttpWorkspaces.fromClient(client, defaults)
-      return seam.list(...args)
-    }
-  }
-
-  get '/workspaces/reset_sandbox'(): (
-    parameters?: WorkspacesResetSandboxParameters,
-    options?: WorkspacesResetSandboxOptions,
-  ) => WorkspacesResetSandboxRequest {
-    const { client, defaults } = this
-    return function workspacesResetSandbox(
-      ...args: Parameters<SeamHttpWorkspaces['resetSandbox']>
-    ): ReturnType<SeamHttpWorkspaces['resetSandbox']> {
-      const seam = SeamHttpWorkspaces.fromClient(client, defaults)
-      return seam.resetSandbox(...args)
-    }
-  }
-
-  get '/workspaces/update'(): (
-    parameters?: WorkspacesUpdateParameters,
-    options?: WorkspacesUpdateOptions,
-  ) => WorkspacesUpdateRequest {
-    const { client, defaults } = this
-    return function workspacesUpdate(
-      ...args: Parameters<SeamHttpWorkspaces['update']>
-    ): ReturnType<SeamHttpWorkspaces['update']> {
-      const seam = SeamHttpWorkspaces.fromClient(client, defaults)
-      return seam.update(...args)
-    }
-  }
-}
-
-export type SeamHttpEndpointQueryPaths =
-  | '/access_codes/generate_code'
-  | '/access_codes/get'
-  | '/access_codes/list'
-  | '/access_codes/unmanaged/get'
-  | '/access_codes/unmanaged/list'
-  | '/access_grants/get'
-  | '/access_grants/get_related'
-  | '/access_grants/list'
-  | '/access_grants/unmanaged/get'
-  | '/access_grants/unmanaged/list'
-  | '/access_methods/get'
-  | '/access_methods/get_related'
-  | '/access_methods/list'
-  | '/access_methods/unmanaged/get'
-  | '/access_methods/unmanaged/list'
-  | '/acs/access_groups/get'
-  | '/acs/access_groups/list'
-  | '/acs/access_groups/list_accessible_entrances'
-  | '/acs/access_groups/list_users'
-  | '/acs/credentials/get'
-  | '/acs/credentials/list'
-  | '/acs/credentials/list_accessible_entrances'
-  | '/acs/encoders/get'
-  | '/acs/encoders/list'
-  | '/acs/entrances/get'
-  | '/acs/entrances/list'
-  | '/acs/entrances/list_credentials_with_access'
-  | '/acs/systems/get'
-  | '/acs/systems/list'
-  | '/acs/systems/list_compatible_credential_manager_acs_systems'
-  | '/acs/users/get'
-  | '/acs/users/list'
-  | '/acs/users/list_accessible_entrances'
-  | '/action_attempts/get'
-  | '/action_attempts/list'
-  | '/client_sessions/get'
-  | '/client_sessions/list'
-  | '/connect_webviews/get'
-  | '/connect_webviews/list'
-  | '/connected_accounts/get'
-  | '/connected_accounts/list'
-  | '/devices/get'
-  | '/devices/list'
-  | '/devices/list_device_providers'
-  | '/devices/unmanaged/get'
-  | '/devices/unmanaged/list'
-  | '/events/get'
-  | '/events/list'
-  | '/instant_keys/get'
-  | '/instant_keys/list'
-  | '/locks/get'
-  | '/locks/list'
-  | '/noise_sensors/list'
-  | '/noise_sensors/noise_thresholds/get'
-  | '/noise_sensors/noise_thresholds/list'
-  | '/phones/get'
-  | '/phones/list'
-  | '/spaces/get'
-  | '/spaces/get_related'
-  | '/spaces/list'
-  | '/thermostats/list'
-  | '/thermostats/schedules/get'
-  | '/thermostats/schedules/list'
-  | '/user_identities/get'
-  | '/user_identities/list'
-  | '/user_identities/list_accessible_devices'
-  | '/user_identities/list_accessible_entrances'
-  | '/user_identities/list_acs_systems'
-  | '/user_identities/list_acs_users'
-  | '/user_identities/unmanaged/get'
-  | '/user_identities/unmanaged/list'
-  | '/webhooks/get'
-  | '/webhooks/list'
-  | '/workspaces/get'
-  | '/workspaces/list'
-
-export type SeamHttpEndpointPaginatedQueryPaths =
-  | '/access_codes/list'
-  | '/access_codes/unmanaged/list'
-  | '/access_grants/list'
-  | '/access_grants/unmanaged/list'
-  | '/access_methods/list'
-  | '/acs/credentials/list'
-  | '/acs/encoders/list'
-  | '/acs/entrances/list'
-  | '/acs/users/list'
-  | '/action_attempts/list'
-  | '/connect_webviews/list'
-  | '/connected_accounts/list'
-  | '/devices/list'
-  | '/devices/unmanaged/list'
-  | '/spaces/list'
-  | '/user_identities/list'
-  | '/user_identities/unmanaged/list'
-
-export type SeamHttpEndpointMutationPaths =
-  | '/access_codes/create'
-  | '/access_codes/create_multiple'
-  | '/access_codes/delete'
-  | '/access_codes/pull_backup_access_code'
-  | '/access_codes/report_device_constraints'
-  | '/access_codes/update'
-  | '/access_codes/update_multiple'
-  | '/access_codes/simulate/create_unmanaged_access_code'
-  | '/access_codes/unmanaged/convert_to_managed'
-  | '/access_codes/unmanaged/delete'
-  | '/access_codes/unmanaged/update'
-  | '/access_grants/create'
-  | '/access_grants/delete'
-  | '/access_grants/request_access_methods'
-  | '/access_grants/update'
-  | '/access_grants/unmanaged/update'
-  | '/access_methods/assign_card'
-  | '/access_methods/delete'
-  | '/access_methods/encode'
-  | '/access_methods/unlock_door'
-  | '/acs/access_groups/add_user'
-  | '/acs/access_groups/delete'
-  | '/acs/access_groups/remove_user'
-  | '/acs/credentials/assign'
-  | '/acs/credentials/create'
-  | '/acs/credentials/delete'
-  | '/acs/credentials/unassign'
-  | '/acs/credentials/update'
-  | '/acs/encoders/encode_credential'
-  | '/acs/encoders/scan_credential'
-  | '/acs/encoders/scan_to_assign_credential'
-  | '/acs/encoders/simulate/next_credential_encode_will_fail'
-  | '/acs/encoders/simulate/next_credential_encode_will_succeed'
-  | '/acs/encoders/simulate/next_credential_scan_will_fail'
-  | '/acs/encoders/simulate/next_credential_scan_will_succeed'
-  | '/acs/entrances/grant_access'
-  | '/acs/entrances/unlock'
-  | '/acs/systems/report_devices'
-  | '/acs/users/add_to_access_group'
-  | '/acs/users/create'
-  | '/acs/users/delete'
-  | '/acs/users/remove_from_access_group'
-  | '/acs/users/revoke_access_to_all_entrances'
-  | '/acs/users/suspend'
-  | '/acs/users/unsuspend'
-  | '/acs/users/update'
-  | '/client_sessions/create'
-  | '/client_sessions/delete'
-  | '/client_sessions/get_or_create'
-  | '/client_sessions/grant_access'
-  | '/client_sessions/revoke'
-  | '/connect_webviews/create'
-  | '/connect_webviews/delete'
-  | '/connected_accounts/delete'
-  | '/connected_accounts/sync'
-  | '/connected_accounts/update'
-  | '/connected_accounts/simulate/disconnect'
-  | '/customers/create_portal'
-  | '/customers/delete_data'
-  | '/customers/push_data'
-  | '/devices/report_provider_metadata'
-  | '/devices/update'
-  | '/devices/simulate/connect'
-  | '/devices/simulate/connect_to_hub'
-  | '/devices/simulate/disconnect'
-  | '/devices/simulate/disconnect_from_hub'
-  | '/devices/simulate/paid_subscription'
-  | '/devices/simulate/remove'
-  | '/devices/unmanaged/update'
-  | '/instant_keys/delete'
-  | '/locks/configure_auto_lock'
-  | '/locks/lock_door'
-  | '/locks/unlock_door'
-  | '/locks/simulate/keypad_code_entry'
-  | '/locks/simulate/manual_lock_via_keypad'
-  | '/noise_sensors/noise_thresholds/create'
-  | '/noise_sensors/noise_thresholds/delete'
-  | '/noise_sensors/noise_thresholds/update'
-  | '/noise_sensors/simulate/trigger_noise_threshold'
-  | '/phones/deactivate'
-  | '/phones/simulate/create_sandbox_phone'
-  | '/spaces/add_acs_entrances'
-  | '/spaces/add_connected_account'
-  | '/spaces/add_devices'
-  | '/spaces/create'
-  | '/spaces/delete'
-  | '/spaces/remove_acs_entrances'
-  | '/spaces/remove_connected_account'
-  | '/spaces/remove_devices'
-  | '/spaces/update'
-  | '/thermostats/activate_climate_preset'
-  | '/thermostats/cool'
-  | '/thermostats/create_climate_preset'
-  | '/thermostats/delete_climate_preset'
-  | '/thermostats/heat'
-  | '/thermostats/heat_cool'
-  | '/thermostats/off'
-  | '/thermostats/set_fallback_climate_preset'
-  | '/thermostats/set_fan_mode'
-  | '/thermostats/set_hvac_mode'
-  | '/thermostats/set_temperature_threshold'
-  | '/thermostats/update_climate_preset'
-  | '/thermostats/update_weekly_program'
-  | '/thermostats/daily_programs/create'
-  | '/thermostats/daily_programs/delete'
-  | '/thermostats/daily_programs/update'
-  | '/thermostats/schedules/create'
-  | '/thermostats/schedules/delete'
-  | '/thermostats/schedules/update'
-  | '/thermostats/simulate/hvac_mode_adjusted'
-  | '/thermostats/simulate/temperature_reached'
-  | '/user_identities/add_acs_user'
-  | '/user_identities/create'
-  | '/user_identities/delete'
-  | '/user_identities/generate_instant_key'
-  | '/user_identities/grant_access_to_device'
-  | '/user_identities/remove_acs_user'
-  | '/user_identities/revoke_access_to_device'
-  | '/user_identities/update'
-  | '/user_identities/unmanaged/update'
-  | '/webhooks/create'
-  | '/webhooks/delete'
-  | '/webhooks/update'
-  | '/workspaces/create'
-  | '/workspaces/reset_sandbox'
-  | '/workspaces/update'