seam-http-endpoints.ts

/*
 * 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 AccessCodesGetTimelineOptions,
  type AccessCodesGetTimelineParameters,
  type AccessCodesGetTimelineRequest,
  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 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,
  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 AcsAccessGroupsUnmanagedGetOptions,
  type AcsAccessGroupsUnmanagedGetParameters,
  type AcsAccessGroupsUnmanagedGetRequest,
  type AcsAccessGroupsUnmanagedListOptions,
  type AcsAccessGroupsUnmanagedListParameters,
  type AcsAccessGroupsUnmanagedListRequest,
  SeamHttpAcsAccessGroupsUnmanaged,
} from './acs/access-groups/unmanaged/index.js'
import {
  type AcsCredentialPoolsListOptions,
  type AcsCredentialPoolsListParameters,
  type AcsCredentialPoolsListRequest,
  SeamHttpAcsCredentialPools,
} from './acs/credential-pools/index.js'
import {
  type AcsCredentialProvisioningAutomationsLaunchOptions,
  type AcsCredentialProvisioningAutomationsLaunchParameters,
  type AcsCredentialProvisioningAutomationsLaunchRequest,
  SeamHttpAcsCredentialProvisioningAutomations,
} from './acs/credential-provisioning-automations/index.js'
import {
  type AcsCredentialsAssignOptions,
  type AcsCredentialsAssignParameters,
  type AcsCredentialsAssignRequest,
  type AcsCredentialsCreateOfflineCodeOptions,
  type AcsCredentialsCreateOfflineCodeParameters,
  type AcsCredentialsCreateOfflineCodeRequest,
  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 AcsCredentialsUnmanagedGetOptions,
  type AcsCredentialsUnmanagedGetParameters,
  type AcsCredentialsUnmanagedGetRequest,
  type AcsCredentialsUnmanagedListOptions,
  type AcsCredentialsUnmanagedListParameters,
  type AcsCredentialsUnmanagedListRequest,
  SeamHttpAcsCredentialsUnmanaged,
} from './acs/credentials/unmanaged/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,
  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 AcsUsersUnmanagedGetOptions,
  type AcsUsersUnmanagedGetParameters,
  type AcsUsersUnmanagedGetRequest,
  type AcsUsersUnmanagedListOptions,
  type AcsUsersUnmanagedListParameters,
  type AcsUsersUnmanagedListRequest,
  SeamHttpAcsUsersUnmanaged,
} from './acs/users/unmanaged/index.js'
import {
  type ActionAttemptsGetOptions,
  type ActionAttemptsGetParameters,
  type ActionAttemptsGetRequest,
  type ActionAttemptsListOptions,
  type ActionAttemptsListParameters,
  type ActionAttemptsListRequest,
  SeamHttpActionAttempts,
} from './action-attempts/index.js'
import {
  type BridgesGetOptions,
  type BridgesGetParameters,
  type BridgesGetRequest,
  type BridgesListOptions,
  type BridgesListParameters,
  type BridgesListRequest,
  SeamHttpBridges,
} from './bridges/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 CustomersReservationsCreateDeepLinkOptions,
  type CustomersReservationsCreateDeepLinkParameters,
  type CustomersReservationsCreateDeepLinkRequest,
  SeamHttpCustomersReservations,
} from './customers/reservations/index.js'
import {
  type DevicesDeleteOptions,
  type DevicesDeleteParameters,
  type DevicesDeleteRequest,
  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 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 {
  type SeamConsoleV1GetResourceLocatorOptions,
  type SeamConsoleV1GetResourceLocatorParameters,
  type SeamConsoleV1GetResourceLocatorRequest,
  SeamHttpSeamConsoleV1,
} from './seam/console/v1/index.js'
import {
  type SeamConsoleV1TimelinesGetOptions,
  type SeamConsoleV1TimelinesGetParameters,
  type SeamConsoleV1TimelinesGetRequest,
  SeamHttpSeamConsoleV1Timelines,
} from './seam/console/v1/timelines/index.js'
import {
  type SeamCustomerV1AccessGrantsListOptions,
  type SeamCustomerV1AccessGrantsListParameters,
  type SeamCustomerV1AccessGrantsListRequest,
  type SeamCustomerV1AccessGrantsUpdateOptions,
  type SeamCustomerV1AccessGrantsUpdateParameters,
  type SeamCustomerV1AccessGrantsUpdateRequest,
  SeamHttpSeamCustomerV1AccessGrants,
} from './seam/customer/v1/access-grants/index.js'
import {
  type SeamCustomerV1AccessMethodsEncodeOptions,
  type SeamCustomerV1AccessMethodsEncodeParameters,
  type SeamCustomerV1AccessMethodsEncodeRequest,
  SeamHttpSeamCustomerV1AccessMethods,
} from './seam/customer/v1/access-methods/index.js'
import {
  type SeamCustomerV1AutomationRunsListOptions,
  type SeamCustomerV1AutomationRunsListParameters,
  type SeamCustomerV1AutomationRunsListRequest,
  SeamHttpSeamCustomerV1AutomationRuns,
} from './seam/customer/v1/automation-runs/index.js'
import {
  type SeamCustomerV1AutomationsDeleteOptions,
  type SeamCustomerV1AutomationsDeleteParameters,
  type SeamCustomerV1AutomationsDeleteRequest,
  type SeamCustomerV1AutomationsGetOptions,
  type SeamCustomerV1AutomationsGetParameters,
  type SeamCustomerV1AutomationsGetRequest,
  type SeamCustomerV1AutomationsUpdateOptions,
  type SeamCustomerV1AutomationsUpdateParameters,
  type SeamCustomerV1AutomationsUpdateRequest,
  SeamHttpSeamCustomerV1Automations,
} from './seam/customer/v1/automations/index.js'
import {
  type SeamCustomerV1ConnectorCustomersListOptions,
  type SeamCustomerV1ConnectorCustomersListParameters,
  type SeamCustomerV1ConnectorCustomersListRequest,
  SeamHttpSeamCustomerV1ConnectorCustomers,
} from './seam/customer/v1/connector-customers/index.js'
import {
  type SeamCustomerV1ConnectorsAuthorizeOptions,
  type SeamCustomerV1ConnectorsAuthorizeParameters,
  type SeamCustomerV1ConnectorsAuthorizeRequest,
  type SeamCustomerV1ConnectorsConnectorTypesOptions,
  type SeamCustomerV1ConnectorsConnectorTypesParameters,
  type SeamCustomerV1ConnectorsConnectorTypesRequest,
  type SeamCustomerV1ConnectorsCreateOptions,
  type SeamCustomerV1ConnectorsCreateParameters,
  type SeamCustomerV1ConnectorsCreateRequest,
  type SeamCustomerV1ConnectorsDeleteOptions,
  type SeamCustomerV1ConnectorsDeleteParameters,
  type SeamCustomerV1ConnectorsDeleteRequest,
  type SeamCustomerV1ConnectorsListOptions,
  type SeamCustomerV1ConnectorsListParameters,
  type SeamCustomerV1ConnectorsListRequest,
  type SeamCustomerV1ConnectorsSyncOptions,
  type SeamCustomerV1ConnectorsSyncParameters,
  type SeamCustomerV1ConnectorsSyncRequest,
  type SeamCustomerV1ConnectorsUpdateOptions,
  type SeamCustomerV1ConnectorsUpdateParameters,
  type SeamCustomerV1ConnectorsUpdateRequest,
  SeamHttpSeamCustomerV1Connectors,
} from './seam/customer/v1/connectors/index.js'
import {
  type SeamCustomerV1CustomersAutomationsGetOptions,
  type SeamCustomerV1CustomersAutomationsGetParameters,
  type SeamCustomerV1CustomersAutomationsGetRequest,
  type SeamCustomerV1CustomersAutomationsUpdateOptions,
  type SeamCustomerV1CustomersAutomationsUpdateParameters,
  type SeamCustomerV1CustomersAutomationsUpdateRequest,
  SeamHttpSeamCustomerV1CustomersAutomations,
} from './seam/customer/v1/customers/automations/index.js'
import {
  type SeamCustomerV1CustomersListOptions,
  type SeamCustomerV1CustomersListParameters,
  type SeamCustomerV1CustomersListRequest,
  type SeamCustomerV1CustomersMeOptions,
  type SeamCustomerV1CustomersMeParameters,
  type SeamCustomerV1CustomersMeRequest,
  type SeamCustomerV1CustomersOpenPortalOptions,
  type SeamCustomerV1CustomersOpenPortalParameters,
  type SeamCustomerV1CustomersOpenPortalRequest,
  SeamHttpSeamCustomerV1Customers,
} from './seam/customer/v1/customers/index.js'
import {
  type SeamCustomerV1EncodersListOptions,
  type SeamCustomerV1EncodersListParameters,
  type SeamCustomerV1EncodersListRequest,
  SeamHttpSeamCustomerV1Encoders,
} from './seam/customer/v1/encoders/index.js'
import {
  type SeamCustomerV1EventsListOptions,
  type SeamCustomerV1EventsListParameters,
  type SeamCustomerV1EventsListRequest,
  SeamHttpSeamCustomerV1Events,
} from './seam/customer/v1/events/index.js'
import {
  type SeamCustomerV1PortalsGetOptions,
  type SeamCustomerV1PortalsGetParameters,
  type SeamCustomerV1PortalsGetRequest,
  SeamHttpSeamCustomerV1Portals,
} from './seam/customer/v1/portals/index.js'
import {
  type SeamCustomerV1ReservationsGetOptions,
  type SeamCustomerV1ReservationsGetParameters,
  type SeamCustomerV1ReservationsGetRequest,
  type SeamCustomerV1ReservationsListAccessGrantsOptions,
  type SeamCustomerV1ReservationsListAccessGrantsParameters,
  type SeamCustomerV1ReservationsListAccessGrantsRequest,
  type SeamCustomerV1ReservationsListOptions,
  type SeamCustomerV1ReservationsListParameters,
  type SeamCustomerV1ReservationsListRequest,
  SeamHttpSeamCustomerV1Reservations,
} from './seam/customer/v1/reservations/index.js'
import {
  type SeamCustomerV1SettingsGetOptions,
  type SeamCustomerV1SettingsGetParameters,
  type SeamCustomerV1SettingsGetRequest,
  type SeamCustomerV1SettingsUpdateOptions,
  type SeamCustomerV1SettingsUpdateParameters,
  type SeamCustomerV1SettingsUpdateRequest,
  SeamHttpSeamCustomerV1Settings,
} from './seam/customer/v1/settings/index.js'
import {
  type SeamCustomerV1SettingsVerticalResourceAliasesGetOptions,
  type SeamCustomerV1SettingsVerticalResourceAliasesGetParameters,
  type SeamCustomerV1SettingsVerticalResourceAliasesGetRequest,
  SeamHttpSeamCustomerV1SettingsVerticalResourceAliases,
} from './seam/customer/v1/settings/vertical-resource-aliases/index.js'
import {
  type SeamCustomerV1SpacesCreateOptions,
  type SeamCustomerV1SpacesCreateParameters,
  type SeamCustomerV1SpacesCreateRequest,
  type SeamCustomerV1SpacesListOptions,
  type SeamCustomerV1SpacesListParameters,
  type SeamCustomerV1SpacesListRequest,
  type SeamCustomerV1SpacesListReservationsOptions,
  type SeamCustomerV1SpacesListReservationsParameters,
  type SeamCustomerV1SpacesListReservationsRequest,
  type SeamCustomerV1SpacesPushCommonAreasOptions,
  type SeamCustomerV1SpacesPushCommonAreasParameters,
  type SeamCustomerV1SpacesPushCommonAreasRequest,
  SeamHttpSeamCustomerV1Spaces,
} from './seam/customer/v1/spaces/index.js'
import {
  type SeamCustomerV1StaffMembersGetOptions,
  type SeamCustomerV1StaffMembersGetParameters,
  type SeamCustomerV1StaffMembersGetRequest,
  type SeamCustomerV1StaffMembersListOptions,
  type SeamCustomerV1StaffMembersListParameters,
  type SeamCustomerV1StaffMembersListRequest,
  SeamHttpSeamCustomerV1StaffMembers,
} from './seam/customer/v1/staff-members/index.js'
import {
  SeamHttpSeamPartnerV1BuildingBlocksSpaces,
  type SeamPartnerV1BuildingBlocksSpacesAutoMapOptions,
  type SeamPartnerV1BuildingBlocksSpacesAutoMapParameters,
  type SeamPartnerV1BuildingBlocksSpacesAutoMapRequest,
} from './seam/partner/v1/building-blocks/spaces/index.js'
import {
  SeamHttpSpaces,
  type SpacesAddAcsEntrancesOptions,
  type SpacesAddAcsEntrancesParameters,
  type SpacesAddAcsEntrancesRequest,
  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 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 ThermostatsGetOptions,
  type ThermostatsGetParameters,
  type ThermostatsGetRequest,
  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 {
  SeamHttpUnstablePartnerBuildingBlocks,
  type UnstablePartnerBuildingBlocksConnectAccountsOptions,
  type UnstablePartnerBuildingBlocksConnectAccountsParameters,
  type UnstablePartnerBuildingBlocksConnectAccountsRequest,
  type UnstablePartnerBuildingBlocksGenerateMagicLinkOptions,
  type UnstablePartnerBuildingBlocksGenerateMagicLinkParameters,
  type UnstablePartnerBuildingBlocksGenerateMagicLinkRequest,
  type UnstablePartnerBuildingBlocksManageDevicesOptions,
  type UnstablePartnerBuildingBlocksManageDevicesParameters,
  type UnstablePartnerBuildingBlocksManageDevicesRequest,
  type UnstablePartnerBuildingBlocksOrganizeSpacesOptions,
  type UnstablePartnerBuildingBlocksOrganizeSpacesParameters,
  type UnstablePartnerBuildingBlocksOrganizeSpacesRequest,
} from './unstable-partner/building-blocks/index.js'
import {
  SeamHttpUserIdentitiesEnrollmentAutomations,
  type UserIdentitiesEnrollmentAutomationsDeleteOptions,
  type UserIdentitiesEnrollmentAutomationsDeleteParameters,
  type UserIdentitiesEnrollmentAutomationsDeleteRequest,
  type UserIdentitiesEnrollmentAutomationsGetOptions,
  type UserIdentitiesEnrollmentAutomationsGetParameters,
  type UserIdentitiesEnrollmentAutomationsGetRequest,
  type UserIdentitiesEnrollmentAutomationsLaunchOptions,
  type UserIdentitiesEnrollmentAutomationsLaunchParameters,
  type UserIdentitiesEnrollmentAutomationsLaunchRequest,
  type UserIdentitiesEnrollmentAutomationsListOptions,
  type UserIdentitiesEnrollmentAutomationsListParameters,
  type UserIdentitiesEnrollmentAutomationsListRequest,
} from './user-identities/enrollment-automations/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 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 {
  SeamHttpWorkspacesCustomizationProfiles,
  type WorkspacesCustomizationProfilesCreateOptions,
  type WorkspacesCustomizationProfilesCreateParameters,
  type WorkspacesCustomizationProfilesCreateRequest,
  type WorkspacesCustomizationProfilesGetOptions,
  type WorkspacesCustomizationProfilesGetParameters,
  type WorkspacesCustomizationProfilesGetRequest,
  type WorkspacesCustomizationProfilesListOptions,
  type WorkspacesCustomizationProfilesListParameters,
  type WorkspacesCustomizationProfilesListRequest,
  type WorkspacesCustomizationProfilesUpdateOptions,
  type WorkspacesCustomizationProfilesUpdateParameters,
  type WorkspacesCustomizationProfilesUpdateRequest,
  type WorkspacesCustomizationProfilesUploadImagesOptions,
  type WorkspacesCustomizationProfilesUploadImagesParameters,
  type WorkspacesCustomizationProfilesUploadImagesRequest,
} from './workspaces/customization-profiles/index.js'
import {
  SeamHttpWorkspaces,
  type WorkspacesCreateOptions,
  type WorkspacesCreateParameters,
  type WorkspacesCreateRequest,
  type WorkspacesFindAnythingOptions,
  type WorkspacesFindAnythingParameters,
  type WorkspacesFindAnythingRequest,
  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/get_timeline'(): (
    parameters?: AccessCodesGetTimelineParameters,
    options?: AccessCodesGetTimelineOptions,
  ) => AccessCodesGetTimelineRequest {
    const { client, defaults } = this
    return function accessCodesGetTimeline(
      ...args: Parameters<SeamHttpAccessCodes['getTimeline']>
    ): ReturnType<SeamHttpAccessCodes['getTimeline']> {
      const seam = SeamHttpAccessCodes.fromClient(client, defaults)
      return seam.getTimeline(...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/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/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/access_groups/unmanaged/get'(): (
    parameters?: AcsAccessGroupsUnmanagedGetParameters,
    options?: AcsAccessGroupsUnmanagedGetOptions,
  ) => AcsAccessGroupsUnmanagedGetRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function acsAccessGroupsUnmanagedGet(
      ...args: Parameters<SeamHttpAcsAccessGroupsUnmanaged['get']>
    ): ReturnType<SeamHttpAcsAccessGroupsUnmanaged['get']> {
      const seam = SeamHttpAcsAccessGroupsUnmanaged.fromClient(client, defaults)
      return seam.get(...args)
    }
  }

  get '/acs/access_groups/unmanaged/list'(): (
    parameters?: AcsAccessGroupsUnmanagedListParameters,
    options?: AcsAccessGroupsUnmanagedListOptions,
  ) => AcsAccessGroupsUnmanagedListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function acsAccessGroupsUnmanagedList(
      ...args: Parameters<SeamHttpAcsAccessGroupsUnmanaged['list']>
    ): ReturnType<SeamHttpAcsAccessGroupsUnmanaged['list']> {
      const seam = SeamHttpAcsAccessGroupsUnmanaged.fromClient(client, defaults)
      return seam.list(...args)
    }
  }

  get '/acs/credential_pools/list'(): (
    parameters?: AcsCredentialPoolsListParameters,
    options?: AcsCredentialPoolsListOptions,
  ) => AcsCredentialPoolsListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function acsCredentialPoolsList(
      ...args: Parameters<SeamHttpAcsCredentialPools['list']>
    ): ReturnType<SeamHttpAcsCredentialPools['list']> {
      const seam = SeamHttpAcsCredentialPools.fromClient(client, defaults)
      return seam.list(...args)
    }
  }

  get '/acs/credential_provisioning_automations/launch'(): (
    parameters?: AcsCredentialProvisioningAutomationsLaunchParameters,
    options?: AcsCredentialProvisioningAutomationsLaunchOptions,
  ) => AcsCredentialProvisioningAutomationsLaunchRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function acsCredentialProvisioningAutomationsLaunch(
      ...args: Parameters<
        SeamHttpAcsCredentialProvisioningAutomations['launch']
      >
    ): ReturnType<SeamHttpAcsCredentialProvisioningAutomations['launch']> {
      const seam = SeamHttpAcsCredentialProvisioningAutomations.fromClient(
        client,
        defaults,
      )
      return seam.launch(...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/create_offline_code'(): (
    parameters?: AcsCredentialsCreateOfflineCodeParameters,
    options?: AcsCredentialsCreateOfflineCodeOptions,
  ) => AcsCredentialsCreateOfflineCodeRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function acsCredentialsCreateOfflineCode(
      ...args: Parameters<SeamHttpAcsCredentials['createOfflineCode']>
    ): ReturnType<SeamHttpAcsCredentials['createOfflineCode']> {
      const seam = SeamHttpAcsCredentials.fromClient(client, defaults)
      return seam.createOfflineCode(...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/credentials/unmanaged/get'(): (
    parameters?: AcsCredentialsUnmanagedGetParameters,
    options?: AcsCredentialsUnmanagedGetOptions,
  ) => AcsCredentialsUnmanagedGetRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function acsCredentialsUnmanagedGet(
      ...args: Parameters<SeamHttpAcsCredentialsUnmanaged['get']>
    ): ReturnType<SeamHttpAcsCredentialsUnmanaged['get']> {
      const seam = SeamHttpAcsCredentialsUnmanaged.fromClient(client, defaults)
      return seam.get(...args)
    }
  }

  get '/acs/credentials/unmanaged/list'(): (
    parameters?: AcsCredentialsUnmanagedListParameters,
    options?: AcsCredentialsUnmanagedListOptions,
  ) => AcsCredentialsUnmanagedListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function acsCredentialsUnmanagedList(
      ...args: Parameters<SeamHttpAcsCredentialsUnmanaged['list']>
    ): ReturnType<SeamHttpAcsCredentialsUnmanaged['list']> {
      const seam = SeamHttpAcsCredentialsUnmanaged.fromClient(client, defaults)
      return seam.list(...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/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 '/acs/users/unmanaged/get'(): (
    parameters?: AcsUsersUnmanagedGetParameters,
    options?: AcsUsersUnmanagedGetOptions,
  ) => AcsUsersUnmanagedGetRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function acsUsersUnmanagedGet(
      ...args: Parameters<SeamHttpAcsUsersUnmanaged['get']>
    ): ReturnType<SeamHttpAcsUsersUnmanaged['get']> {
      const seam = SeamHttpAcsUsersUnmanaged.fromClient(client, defaults)
      return seam.get(...args)
    }
  }

  get '/acs/users/unmanaged/list'(): (
    parameters?: AcsUsersUnmanagedListParameters,
    options?: AcsUsersUnmanagedListOptions,
  ) => AcsUsersUnmanagedListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function acsUsersUnmanagedList(
      ...args: Parameters<SeamHttpAcsUsersUnmanaged['list']>
    ): ReturnType<SeamHttpAcsUsersUnmanaged['list']> {
      const seam = SeamHttpAcsUsersUnmanaged.fromClient(client, defaults)
      return seam.list(...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 '/bridges/get'(): (
    parameters?: BridgesGetParameters,
    options?: BridgesGetOptions,
  ) => BridgesGetRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function bridgesGet(
      ...args: Parameters<SeamHttpBridges['get']>
    ): ReturnType<SeamHttpBridges['get']> {
      const seam = SeamHttpBridges.fromClient(client, defaults)
      return seam.get(...args)
    }
  }

  get '/bridges/list'(): (
    parameters?: BridgesListParameters,
    options?: BridgesListOptions,
  ) => BridgesListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function bridgesList(
      ...args: Parameters<SeamHttpBridges['list']>
    ): ReturnType<SeamHttpBridges['list']> {
      const seam = SeamHttpBridges.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 '/customers/reservations/create_deep_link'(): (
    parameters?: CustomersReservationsCreateDeepLinkParameters,
    options?: CustomersReservationsCreateDeepLinkOptions,
  ) => CustomersReservationsCreateDeepLinkRequest {
    const { client, defaults } = this
    return function customersReservationsCreateDeepLink(
      ...args: Parameters<SeamHttpCustomersReservations['createDeepLink']>
    ): ReturnType<SeamHttpCustomersReservations['createDeepLink']> {
      const seam = SeamHttpCustomersReservations.fromClient(client, defaults)
      return seam.createDeepLink(...args)
    }
  }

  get '/devices/delete'(): (
    parameters?: DevicesDeleteParameters,
    options?: DevicesDeleteOptions,
  ) => DevicesDeleteRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function devicesDelete(
      ...args: Parameters<SeamHttpDevices['delete']>
    ): ReturnType<SeamHttpDevices['delete']> {
      const seam = SeamHttpDevices.fromClient(client, defaults)
      return seam.delete(...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/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 '/seam/console/v1/get_resource_locator'(): (
    parameters?: SeamConsoleV1GetResourceLocatorParameters,
    options?: SeamConsoleV1GetResourceLocatorOptions,
  ) => SeamConsoleV1GetResourceLocatorRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamConsoleV1GetResourceLocator(
      ...args: Parameters<SeamHttpSeamConsoleV1['getResourceLocator']>
    ): ReturnType<SeamHttpSeamConsoleV1['getResourceLocator']> {
      const seam = SeamHttpSeamConsoleV1.fromClient(client, defaults)
      return seam.getResourceLocator(...args)
    }
  }

  get '/seam/console/v1/timelines/get'(): (
    parameters?: SeamConsoleV1TimelinesGetParameters,
    options?: SeamConsoleV1TimelinesGetOptions,
  ) => SeamConsoleV1TimelinesGetRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamConsoleV1TimelinesGet(
      ...args: Parameters<SeamHttpSeamConsoleV1Timelines['get']>
    ): ReturnType<SeamHttpSeamConsoleV1Timelines['get']> {
      const seam = SeamHttpSeamConsoleV1Timelines.fromClient(client, defaults)
      return seam.get(...args)
    }
  }

  get '/seam/customer/v1/access_grants/list'(): (
    parameters?: SeamCustomerV1AccessGrantsListParameters,
    options?: SeamCustomerV1AccessGrantsListOptions,
  ) => SeamCustomerV1AccessGrantsListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1AccessGrantsList(
      ...args: Parameters<SeamHttpSeamCustomerV1AccessGrants['list']>
    ): ReturnType<SeamHttpSeamCustomerV1AccessGrants['list']> {
      const seam = SeamHttpSeamCustomerV1AccessGrants.fromClient(
        client,
        defaults,
      )
      return seam.list(...args)
    }
  }

  get '/seam/customer/v1/access_grants/update'(): (
    parameters?: SeamCustomerV1AccessGrantsUpdateParameters,
    options?: SeamCustomerV1AccessGrantsUpdateOptions,
  ) => SeamCustomerV1AccessGrantsUpdateRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1AccessGrantsUpdate(
      ...args: Parameters<SeamHttpSeamCustomerV1AccessGrants['update']>
    ): ReturnType<SeamHttpSeamCustomerV1AccessGrants['update']> {
      const seam = SeamHttpSeamCustomerV1AccessGrants.fromClient(
        client,
        defaults,
      )
      return seam.update(...args)
    }
  }

  get '/seam/customer/v1/access_methods/encode'(): (
    parameters?: SeamCustomerV1AccessMethodsEncodeParameters,
    options?: SeamCustomerV1AccessMethodsEncodeOptions,
  ) => SeamCustomerV1AccessMethodsEncodeRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1AccessMethodsEncode(
      ...args: Parameters<SeamHttpSeamCustomerV1AccessMethods['encode']>
    ): ReturnType<SeamHttpSeamCustomerV1AccessMethods['encode']> {
      const seam = SeamHttpSeamCustomerV1AccessMethods.fromClient(
        client,
        defaults,
      )
      return seam.encode(...args)
    }
  }

  get '/seam/customer/v1/automation_runs/list'(): (
    parameters?: SeamCustomerV1AutomationRunsListParameters,
    options?: SeamCustomerV1AutomationRunsListOptions,
  ) => SeamCustomerV1AutomationRunsListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1AutomationRunsList(
      ...args: Parameters<SeamHttpSeamCustomerV1AutomationRuns['list']>
    ): ReturnType<SeamHttpSeamCustomerV1AutomationRuns['list']> {
      const seam = SeamHttpSeamCustomerV1AutomationRuns.fromClient(
        client,
        defaults,
      )
      return seam.list(...args)
    }
  }

  get '/seam/customer/v1/automations/delete'(): (
    parameters?: SeamCustomerV1AutomationsDeleteParameters,
    options?: SeamCustomerV1AutomationsDeleteOptions,
  ) => SeamCustomerV1AutomationsDeleteRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1AutomationsDelete(
      ...args: Parameters<SeamHttpSeamCustomerV1Automations['delete']>
    ): ReturnType<SeamHttpSeamCustomerV1Automations['delete']> {
      const seam = SeamHttpSeamCustomerV1Automations.fromClient(
        client,
        defaults,
      )
      return seam.delete(...args)
    }
  }

  get '/seam/customer/v1/automations/get'(): (
    parameters?: SeamCustomerV1AutomationsGetParameters,
    options?: SeamCustomerV1AutomationsGetOptions,
  ) => SeamCustomerV1AutomationsGetRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1AutomationsGet(
      ...args: Parameters<SeamHttpSeamCustomerV1Automations['get']>
    ): ReturnType<SeamHttpSeamCustomerV1Automations['get']> {
      const seam = SeamHttpSeamCustomerV1Automations.fromClient(
        client,
        defaults,
      )
      return seam.get(...args)
    }
  }

  get '/seam/customer/v1/automations/update'(): (
    parameters?: SeamCustomerV1AutomationsUpdateParameters,
    options?: SeamCustomerV1AutomationsUpdateOptions,
  ) => SeamCustomerV1AutomationsUpdateRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1AutomationsUpdate(
      ...args: Parameters<SeamHttpSeamCustomerV1Automations['update']>
    ): ReturnType<SeamHttpSeamCustomerV1Automations['update']> {
      const seam = SeamHttpSeamCustomerV1Automations.fromClient(
        client,
        defaults,
      )
      return seam.update(...args)
    }
  }

  get '/seam/customer/v1/connector_customers/list'(): (
    parameters?: SeamCustomerV1ConnectorCustomersListParameters,
    options?: SeamCustomerV1ConnectorCustomersListOptions,
  ) => SeamCustomerV1ConnectorCustomersListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1ConnectorCustomersList(
      ...args: Parameters<SeamHttpSeamCustomerV1ConnectorCustomers['list']>
    ): ReturnType<SeamHttpSeamCustomerV1ConnectorCustomers['list']> {
      const seam = SeamHttpSeamCustomerV1ConnectorCustomers.fromClient(
        client,
        defaults,
      )
      return seam.list(...args)
    }
  }

  get '/seam/customer/v1/connectors/authorize'(): (
    parameters?: SeamCustomerV1ConnectorsAuthorizeParameters,
    options?: SeamCustomerV1ConnectorsAuthorizeOptions,
  ) => SeamCustomerV1ConnectorsAuthorizeRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1ConnectorsAuthorize(
      ...args: Parameters<SeamHttpSeamCustomerV1Connectors['authorize']>
    ): ReturnType<SeamHttpSeamCustomerV1Connectors['authorize']> {
      const seam = SeamHttpSeamCustomerV1Connectors.fromClient(client, defaults)
      return seam.authorize(...args)
    }
  }

  get '/seam/customer/v1/connectors/connector_types'(): (
    parameters?: SeamCustomerV1ConnectorsConnectorTypesParameters,
    options?: SeamCustomerV1ConnectorsConnectorTypesOptions,
  ) => SeamCustomerV1ConnectorsConnectorTypesRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1ConnectorsConnectorTypes(
      ...args: Parameters<SeamHttpSeamCustomerV1Connectors['connectorTypes']>
    ): ReturnType<SeamHttpSeamCustomerV1Connectors['connectorTypes']> {
      const seam = SeamHttpSeamCustomerV1Connectors.fromClient(client, defaults)
      return seam.connectorTypes(...args)
    }
  }

  get '/seam/customer/v1/connectors/create'(): (
    parameters?: SeamCustomerV1ConnectorsCreateParameters,
    options?: SeamCustomerV1ConnectorsCreateOptions,
  ) => SeamCustomerV1ConnectorsCreateRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1ConnectorsCreate(
      ...args: Parameters<SeamHttpSeamCustomerV1Connectors['create']>
    ): ReturnType<SeamHttpSeamCustomerV1Connectors['create']> {
      const seam = SeamHttpSeamCustomerV1Connectors.fromClient(client, defaults)
      return seam.create(...args)
    }
  }

  get '/seam/customer/v1/connectors/delete'(): (
    parameters?: SeamCustomerV1ConnectorsDeleteParameters,
    options?: SeamCustomerV1ConnectorsDeleteOptions,
  ) => SeamCustomerV1ConnectorsDeleteRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1ConnectorsDelete(
      ...args: Parameters<SeamHttpSeamCustomerV1Connectors['delete']>
    ): ReturnType<SeamHttpSeamCustomerV1Connectors['delete']> {
      const seam = SeamHttpSeamCustomerV1Connectors.fromClient(client, defaults)
      return seam.delete(...args)
    }
  }

  get '/seam/customer/v1/connectors/list'(): (
    parameters?: SeamCustomerV1ConnectorsListParameters,
    options?: SeamCustomerV1ConnectorsListOptions,
  ) => SeamCustomerV1ConnectorsListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1ConnectorsList(
      ...args: Parameters<SeamHttpSeamCustomerV1Connectors['list']>
    ): ReturnType<SeamHttpSeamCustomerV1Connectors['list']> {
      const seam = SeamHttpSeamCustomerV1Connectors.fromClient(client, defaults)
      return seam.list(...args)
    }
  }

  get '/seam/customer/v1/connectors/sync'(): (
    parameters?: SeamCustomerV1ConnectorsSyncParameters,
    options?: SeamCustomerV1ConnectorsSyncOptions,
  ) => SeamCustomerV1ConnectorsSyncRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1ConnectorsSync(
      ...args: Parameters<SeamHttpSeamCustomerV1Connectors['sync']>
    ): ReturnType<SeamHttpSeamCustomerV1Connectors['sync']> {
      const seam = SeamHttpSeamCustomerV1Connectors.fromClient(client, defaults)
      return seam.sync(...args)
    }
  }

  get '/seam/customer/v1/connectors/update'(): (
    parameters?: SeamCustomerV1ConnectorsUpdateParameters,
    options?: SeamCustomerV1ConnectorsUpdateOptions,
  ) => SeamCustomerV1ConnectorsUpdateRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1ConnectorsUpdate(
      ...args: Parameters<SeamHttpSeamCustomerV1Connectors['update']>
    ): ReturnType<SeamHttpSeamCustomerV1Connectors['update']> {
      const seam = SeamHttpSeamCustomerV1Connectors.fromClient(client, defaults)
      return seam.update(...args)
    }
  }

  get '/seam/customer/v1/customers/automations/get'(): (
    parameters?: SeamCustomerV1CustomersAutomationsGetParameters,
    options?: SeamCustomerV1CustomersAutomationsGetOptions,
  ) => SeamCustomerV1CustomersAutomationsGetRequest {
    const { client, defaults } = this
    return function seamCustomerV1CustomersAutomationsGet(
      ...args: Parameters<SeamHttpSeamCustomerV1CustomersAutomations['get']>
    ): ReturnType<SeamHttpSeamCustomerV1CustomersAutomations['get']> {
      const seam = SeamHttpSeamCustomerV1CustomersAutomations.fromClient(
        client,
        defaults,
      )
      return seam.get(...args)
    }
  }

  get '/seam/customer/v1/customers/automations/update'(): (
    parameters?: SeamCustomerV1CustomersAutomationsUpdateParameters,
    options?: SeamCustomerV1CustomersAutomationsUpdateOptions,
  ) => SeamCustomerV1CustomersAutomationsUpdateRequest {
    const { client, defaults } = this
    return function seamCustomerV1CustomersAutomationsUpdate(
      ...args: Parameters<SeamHttpSeamCustomerV1CustomersAutomations['update']>
    ): ReturnType<SeamHttpSeamCustomerV1CustomersAutomations['update']> {
      const seam = SeamHttpSeamCustomerV1CustomersAutomations.fromClient(
        client,
        defaults,
      )
      return seam.update(...args)
    }
  }

  get '/seam/customer/v1/customers/list'(): (
    parameters?: SeamCustomerV1CustomersListParameters,
    options?: SeamCustomerV1CustomersListOptions,
  ) => SeamCustomerV1CustomersListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1CustomersList(
      ...args: Parameters<SeamHttpSeamCustomerV1Customers['list']>
    ): ReturnType<SeamHttpSeamCustomerV1Customers['list']> {
      const seam = SeamHttpSeamCustomerV1Customers.fromClient(client, defaults)
      return seam.list(...args)
    }
  }

  get '/seam/customer/v1/customers/me'(): (
    parameters?: SeamCustomerV1CustomersMeParameters,
    options?: SeamCustomerV1CustomersMeOptions,
  ) => SeamCustomerV1CustomersMeRequest {
    const { client, defaults } = this
    return function seamCustomerV1CustomersMe(
      ...args: Parameters<SeamHttpSeamCustomerV1Customers['me']>
    ): ReturnType<SeamHttpSeamCustomerV1Customers['me']> {
      const seam = SeamHttpSeamCustomerV1Customers.fromClient(client, defaults)
      return seam.me(...args)
    }
  }

  get '/seam/customer/v1/customers/open_portal'(): (
    parameters?: SeamCustomerV1CustomersOpenPortalParameters,
    options?: SeamCustomerV1CustomersOpenPortalOptions,
  ) => SeamCustomerV1CustomersOpenPortalRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1CustomersOpenPortal(
      ...args: Parameters<SeamHttpSeamCustomerV1Customers['openPortal']>
    ): ReturnType<SeamHttpSeamCustomerV1Customers['openPortal']> {
      const seam = SeamHttpSeamCustomerV1Customers.fromClient(client, defaults)
      return seam.openPortal(...args)
    }
  }

  get '/seam/customer/v1/encoders/list'(): (
    parameters?: SeamCustomerV1EncodersListParameters,
    options?: SeamCustomerV1EncodersListOptions,
  ) => SeamCustomerV1EncodersListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1EncodersList(
      ...args: Parameters<SeamHttpSeamCustomerV1Encoders['list']>
    ): ReturnType<SeamHttpSeamCustomerV1Encoders['list']> {
      const seam = SeamHttpSeamCustomerV1Encoders.fromClient(client, defaults)
      return seam.list(...args)
    }
  }

  get '/seam/customer/v1/events/list'(): (
    parameters?: SeamCustomerV1EventsListParameters,
    options?: SeamCustomerV1EventsListOptions,
  ) => SeamCustomerV1EventsListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1EventsList(
      ...args: Parameters<SeamHttpSeamCustomerV1Events['list']>
    ): ReturnType<SeamHttpSeamCustomerV1Events['list']> {
      const seam = SeamHttpSeamCustomerV1Events.fromClient(client, defaults)
      return seam.list(...args)
    }
  }

  get '/seam/customer/v1/portals/get'(): (
    parameters?: SeamCustomerV1PortalsGetParameters,
    options?: SeamCustomerV1PortalsGetOptions,
  ) => SeamCustomerV1PortalsGetRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1PortalsGet(
      ...args: Parameters<SeamHttpSeamCustomerV1Portals['get']>
    ): ReturnType<SeamHttpSeamCustomerV1Portals['get']> {
      const seam = SeamHttpSeamCustomerV1Portals.fromClient(client, defaults)
      return seam.get(...args)
    }
  }

  get '/seam/customer/v1/reservations/get'(): (
    parameters?: SeamCustomerV1ReservationsGetParameters,
    options?: SeamCustomerV1ReservationsGetOptions,
  ) => SeamCustomerV1ReservationsGetRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1ReservationsGet(
      ...args: Parameters<SeamHttpSeamCustomerV1Reservations['get']>
    ): ReturnType<SeamHttpSeamCustomerV1Reservations['get']> {
      const seam = SeamHttpSeamCustomerV1Reservations.fromClient(
        client,
        defaults,
      )
      return seam.get(...args)
    }
  }

  get '/seam/customer/v1/reservations/list'(): (
    parameters?: SeamCustomerV1ReservationsListParameters,
    options?: SeamCustomerV1ReservationsListOptions,
  ) => SeamCustomerV1ReservationsListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1ReservationsList(
      ...args: Parameters<SeamHttpSeamCustomerV1Reservations['list']>
    ): ReturnType<SeamHttpSeamCustomerV1Reservations['list']> {
      const seam = SeamHttpSeamCustomerV1Reservations.fromClient(
        client,
        defaults,
      )
      return seam.list(...args)
    }
  }

  get '/seam/customer/v1/reservations/list_access_grants'(): (
    parameters?: SeamCustomerV1ReservationsListAccessGrantsParameters,
    options?: SeamCustomerV1ReservationsListAccessGrantsOptions,
  ) => SeamCustomerV1ReservationsListAccessGrantsRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1ReservationsListAccessGrants(
      ...args: Parameters<
        SeamHttpSeamCustomerV1Reservations['listAccessGrants']
      >
    ): ReturnType<SeamHttpSeamCustomerV1Reservations['listAccessGrants']> {
      const seam = SeamHttpSeamCustomerV1Reservations.fromClient(
        client,
        defaults,
      )
      return seam.listAccessGrants(...args)
    }
  }

  get '/seam/customer/v1/settings/get'(): (
    parameters?: SeamCustomerV1SettingsGetParameters,
    options?: SeamCustomerV1SettingsGetOptions,
  ) => SeamCustomerV1SettingsGetRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1SettingsGet(
      ...args: Parameters<SeamHttpSeamCustomerV1Settings['get']>
    ): ReturnType<SeamHttpSeamCustomerV1Settings['get']> {
      const seam = SeamHttpSeamCustomerV1Settings.fromClient(client, defaults)
      return seam.get(...args)
    }
  }

  get '/seam/customer/v1/settings/update'(): (
    parameters?: SeamCustomerV1SettingsUpdateParameters,
    options?: SeamCustomerV1SettingsUpdateOptions,
  ) => SeamCustomerV1SettingsUpdateRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1SettingsUpdate(
      ...args: Parameters<SeamHttpSeamCustomerV1Settings['update']>
    ): ReturnType<SeamHttpSeamCustomerV1Settings['update']> {
      const seam = SeamHttpSeamCustomerV1Settings.fromClient(client, defaults)
      return seam.update(...args)
    }
  }

  get '/seam/customer/v1/settings/vertical_resource_aliases/get'(): (
    parameters?: SeamCustomerV1SettingsVerticalResourceAliasesGetParameters,
    options?: SeamCustomerV1SettingsVerticalResourceAliasesGetOptions,
  ) => SeamCustomerV1SettingsVerticalResourceAliasesGetRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1SettingsVerticalResourceAliasesGet(
      ...args: Parameters<
        SeamHttpSeamCustomerV1SettingsVerticalResourceAliases['get']
      >
    ): ReturnType<
      SeamHttpSeamCustomerV1SettingsVerticalResourceAliases['get']
    > {
      const seam =
        SeamHttpSeamCustomerV1SettingsVerticalResourceAliases.fromClient(
          client,
          defaults,
        )
      return seam.get(...args)
    }
  }

  get '/seam/customer/v1/spaces/create'(): (
    parameters?: SeamCustomerV1SpacesCreateParameters,
    options?: SeamCustomerV1SpacesCreateOptions,
  ) => SeamCustomerV1SpacesCreateRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1SpacesCreate(
      ...args: Parameters<SeamHttpSeamCustomerV1Spaces['create']>
    ): ReturnType<SeamHttpSeamCustomerV1Spaces['create']> {
      const seam = SeamHttpSeamCustomerV1Spaces.fromClient(client, defaults)
      return seam.create(...args)
    }
  }

  get '/seam/customer/v1/spaces/list'(): (
    parameters?: SeamCustomerV1SpacesListParameters,
    options?: SeamCustomerV1SpacesListOptions,
  ) => SeamCustomerV1SpacesListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1SpacesList(
      ...args: Parameters<SeamHttpSeamCustomerV1Spaces['list']>
    ): ReturnType<SeamHttpSeamCustomerV1Spaces['list']> {
      const seam = SeamHttpSeamCustomerV1Spaces.fromClient(client, defaults)
      return seam.list(...args)
    }
  }

  get '/seam/customer/v1/spaces/list_reservations'(): (
    parameters?: SeamCustomerV1SpacesListReservationsParameters,
    options?: SeamCustomerV1SpacesListReservationsOptions,
  ) => SeamCustomerV1SpacesListReservationsRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1SpacesListReservations(
      ...args: Parameters<SeamHttpSeamCustomerV1Spaces['listReservations']>
    ): ReturnType<SeamHttpSeamCustomerV1Spaces['listReservations']> {
      const seam = SeamHttpSeamCustomerV1Spaces.fromClient(client, defaults)
      return seam.listReservations(...args)
    }
  }

  get '/seam/customer/v1/spaces/push_common_areas'(): (
    parameters?: SeamCustomerV1SpacesPushCommonAreasParameters,
    options?: SeamCustomerV1SpacesPushCommonAreasOptions,
  ) => SeamCustomerV1SpacesPushCommonAreasRequest {
    const { client, defaults } = this
    return function seamCustomerV1SpacesPushCommonAreas(
      ...args: Parameters<SeamHttpSeamCustomerV1Spaces['pushCommonAreas']>
    ): ReturnType<SeamHttpSeamCustomerV1Spaces['pushCommonAreas']> {
      const seam = SeamHttpSeamCustomerV1Spaces.fromClient(client, defaults)
      return seam.pushCommonAreas(...args)
    }
  }

  get '/seam/customer/v1/staff_members/get'(): (
    parameters?: SeamCustomerV1StaffMembersGetParameters,
    options?: SeamCustomerV1StaffMembersGetOptions,
  ) => SeamCustomerV1StaffMembersGetRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1StaffMembersGet(
      ...args: Parameters<SeamHttpSeamCustomerV1StaffMembers['get']>
    ): ReturnType<SeamHttpSeamCustomerV1StaffMembers['get']> {
      const seam = SeamHttpSeamCustomerV1StaffMembers.fromClient(
        client,
        defaults,
      )
      return seam.get(...args)
    }
  }

  get '/seam/customer/v1/staff_members/list'(): (
    parameters?: SeamCustomerV1StaffMembersListParameters,
    options?: SeamCustomerV1StaffMembersListOptions,
  ) => SeamCustomerV1StaffMembersListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamCustomerV1StaffMembersList(
      ...args: Parameters<SeamHttpSeamCustomerV1StaffMembers['list']>
    ): ReturnType<SeamHttpSeamCustomerV1StaffMembers['list']> {
      const seam = SeamHttpSeamCustomerV1StaffMembers.fromClient(
        client,
        defaults,
      )
      return seam.list(...args)
    }
  }

  get '/seam/partner/v1/building_blocks/spaces/auto_map'(): (
    parameters?: SeamPartnerV1BuildingBlocksSpacesAutoMapParameters,
    options?: SeamPartnerV1BuildingBlocksSpacesAutoMapOptions,
  ) => SeamPartnerV1BuildingBlocksSpacesAutoMapRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function seamPartnerV1BuildingBlocksSpacesAutoMap(
      ...args: Parameters<SeamHttpSeamPartnerV1BuildingBlocksSpaces['autoMap']>
    ): ReturnType<SeamHttpSeamPartnerV1BuildingBlocksSpaces['autoMap']> {
      const seam = SeamHttpSeamPartnerV1BuildingBlocksSpaces.fromClient(
        client,
        defaults,
      )
      return seam.autoMap(...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_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_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/get'(): (
    parameters?: ThermostatsGetParameters,
    options?: ThermostatsGetOptions,
  ) => ThermostatsGetRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function thermostatsGet(
      ...args: Parameters<SeamHttpThermostats['get']>
    ): ReturnType<SeamHttpThermostats['get']> {
      const seam = SeamHttpThermostats.fromClient(client, defaults)
      return seam.get(...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 '/unstable_partner/building_blocks/connect_accounts'(): (
    parameters?: UnstablePartnerBuildingBlocksConnectAccountsParameters,
    options?: UnstablePartnerBuildingBlocksConnectAccountsOptions,
  ) => UnstablePartnerBuildingBlocksConnectAccountsRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function unstablePartnerBuildingBlocksConnectAccounts(
      ...args: Parameters<
        SeamHttpUnstablePartnerBuildingBlocks['connectAccounts']
      >
    ): ReturnType<SeamHttpUnstablePartnerBuildingBlocks['connectAccounts']> {
      const seam = SeamHttpUnstablePartnerBuildingBlocks.fromClient(
        client,
        defaults,
      )
      return seam.connectAccounts(...args)
    }
  }

  get '/unstable_partner/building_blocks/generate_magic_link'(): (
    parameters?: UnstablePartnerBuildingBlocksGenerateMagicLinkParameters,
    options?: UnstablePartnerBuildingBlocksGenerateMagicLinkOptions,
  ) => UnstablePartnerBuildingBlocksGenerateMagicLinkRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function unstablePartnerBuildingBlocksGenerateMagicLink(
      ...args: Parameters<
        SeamHttpUnstablePartnerBuildingBlocks['generateMagicLink']
      >
    ): ReturnType<SeamHttpUnstablePartnerBuildingBlocks['generateMagicLink']> {
      const seam = SeamHttpUnstablePartnerBuildingBlocks.fromClient(
        client,
        defaults,
      )
      return seam.generateMagicLink(...args)
    }
  }

  get '/unstable_partner/building_blocks/manage_devices'(): (
    parameters?: UnstablePartnerBuildingBlocksManageDevicesParameters,
    options?: UnstablePartnerBuildingBlocksManageDevicesOptions,
  ) => UnstablePartnerBuildingBlocksManageDevicesRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function unstablePartnerBuildingBlocksManageDevices(
      ...args: Parameters<
        SeamHttpUnstablePartnerBuildingBlocks['manageDevices']
      >
    ): ReturnType<SeamHttpUnstablePartnerBuildingBlocks['manageDevices']> {
      const seam = SeamHttpUnstablePartnerBuildingBlocks.fromClient(
        client,
        defaults,
      )
      return seam.manageDevices(...args)
    }
  }

  get '/unstable_partner/building_blocks/organize_spaces'(): (
    parameters?: UnstablePartnerBuildingBlocksOrganizeSpacesParameters,
    options?: UnstablePartnerBuildingBlocksOrganizeSpacesOptions,
  ) => UnstablePartnerBuildingBlocksOrganizeSpacesRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function unstablePartnerBuildingBlocksOrganizeSpaces(
      ...args: Parameters<
        SeamHttpUnstablePartnerBuildingBlocks['organizeSpaces']
      >
    ): ReturnType<SeamHttpUnstablePartnerBuildingBlocks['organizeSpaces']> {
      const seam = SeamHttpUnstablePartnerBuildingBlocks.fromClient(
        client,
        defaults,
      )
      return seam.organizeSpaces(...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_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/enrollment_automations/delete'(): (
    parameters?: UserIdentitiesEnrollmentAutomationsDeleteParameters,
    options?: UserIdentitiesEnrollmentAutomationsDeleteOptions,
  ) => UserIdentitiesEnrollmentAutomationsDeleteRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function userIdentitiesEnrollmentAutomationsDelete(
      ...args: Parameters<SeamHttpUserIdentitiesEnrollmentAutomations['delete']>
    ): ReturnType<SeamHttpUserIdentitiesEnrollmentAutomations['delete']> {
      const seam = SeamHttpUserIdentitiesEnrollmentAutomations.fromClient(
        client,
        defaults,
      )
      return seam.delete(...args)
    }
  }

  get '/user_identities/enrollment_automations/get'(): (
    parameters?: UserIdentitiesEnrollmentAutomationsGetParameters,
    options?: UserIdentitiesEnrollmentAutomationsGetOptions,
  ) => UserIdentitiesEnrollmentAutomationsGetRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function userIdentitiesEnrollmentAutomationsGet(
      ...args: Parameters<SeamHttpUserIdentitiesEnrollmentAutomations['get']>
    ): ReturnType<SeamHttpUserIdentitiesEnrollmentAutomations['get']> {
      const seam = SeamHttpUserIdentitiesEnrollmentAutomations.fromClient(
        client,
        defaults,
      )
      return seam.get(...args)
    }
  }

  get '/user_identities/enrollment_automations/launch'(): (
    parameters?: UserIdentitiesEnrollmentAutomationsLaunchParameters,
    options?: UserIdentitiesEnrollmentAutomationsLaunchOptions,
  ) => UserIdentitiesEnrollmentAutomationsLaunchRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function userIdentitiesEnrollmentAutomationsLaunch(
      ...args: Parameters<SeamHttpUserIdentitiesEnrollmentAutomations['launch']>
    ): ReturnType<SeamHttpUserIdentitiesEnrollmentAutomations['launch']> {
      const seam = SeamHttpUserIdentitiesEnrollmentAutomations.fromClient(
        client,
        defaults,
      )
      return seam.launch(...args)
    }
  }

  get '/user_identities/enrollment_automations/list'(): (
    parameters?: UserIdentitiesEnrollmentAutomationsListParameters,
    options?: UserIdentitiesEnrollmentAutomationsListOptions,
  ) => UserIdentitiesEnrollmentAutomationsListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function userIdentitiesEnrollmentAutomationsList(
      ...args: Parameters<SeamHttpUserIdentitiesEnrollmentAutomations['list']>
    ): ReturnType<SeamHttpUserIdentitiesEnrollmentAutomations['list']> {
      const seam = SeamHttpUserIdentitiesEnrollmentAutomations.fromClient(
        client,
        defaults,
      )
      return seam.list(...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/find_anything'(): (
    parameters?: WorkspacesFindAnythingParameters,
    options?: WorkspacesFindAnythingOptions,
  ) => WorkspacesFindAnythingRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function workspacesFindAnything(
      ...args: Parameters<SeamHttpWorkspaces['findAnything']>
    ): ReturnType<SeamHttpWorkspaces['findAnything']> {
      const seam = SeamHttpWorkspaces.fromClient(client, defaults)
      return seam.findAnything(...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)
    }
  }

  get '/workspaces/customization_profiles/create'(): (
    parameters?: WorkspacesCustomizationProfilesCreateParameters,
    options?: WorkspacesCustomizationProfilesCreateOptions,
  ) => WorkspacesCustomizationProfilesCreateRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function workspacesCustomizationProfilesCreate(
      ...args: Parameters<SeamHttpWorkspacesCustomizationProfiles['create']>
    ): ReturnType<SeamHttpWorkspacesCustomizationProfiles['create']> {
      const seam = SeamHttpWorkspacesCustomizationProfiles.fromClient(
        client,
        defaults,
      )
      return seam.create(...args)
    }
  }

  get '/workspaces/customization_profiles/get'(): (
    parameters?: WorkspacesCustomizationProfilesGetParameters,
    options?: WorkspacesCustomizationProfilesGetOptions,
  ) => WorkspacesCustomizationProfilesGetRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function workspacesCustomizationProfilesGet(
      ...args: Parameters<SeamHttpWorkspacesCustomizationProfiles['get']>
    ): ReturnType<SeamHttpWorkspacesCustomizationProfiles['get']> {
      const seam = SeamHttpWorkspacesCustomizationProfiles.fromClient(
        client,
        defaults,
      )
      return seam.get(...args)
    }
  }

  get '/workspaces/customization_profiles/list'(): (
    parameters?: WorkspacesCustomizationProfilesListParameters,
    options?: WorkspacesCustomizationProfilesListOptions,
  ) => WorkspacesCustomizationProfilesListRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function workspacesCustomizationProfilesList(
      ...args: Parameters<SeamHttpWorkspacesCustomizationProfiles['list']>
    ): ReturnType<SeamHttpWorkspacesCustomizationProfiles['list']> {
      const seam = SeamHttpWorkspacesCustomizationProfiles.fromClient(
        client,
        defaults,
      )
      return seam.list(...args)
    }
  }

  get '/workspaces/customization_profiles/update'(): (
    parameters?: WorkspacesCustomizationProfilesUpdateParameters,
    options?: WorkspacesCustomizationProfilesUpdateOptions,
  ) => WorkspacesCustomizationProfilesUpdateRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function workspacesCustomizationProfilesUpdate(
      ...args: Parameters<SeamHttpWorkspacesCustomizationProfiles['update']>
    ): ReturnType<SeamHttpWorkspacesCustomizationProfiles['update']> {
      const seam = SeamHttpWorkspacesCustomizationProfiles.fromClient(
        client,
        defaults,
      )
      return seam.update(...args)
    }
  }

  get '/workspaces/customization_profiles/upload_images'(): (
    parameters?: WorkspacesCustomizationProfilesUploadImagesParameters,
    options?: WorkspacesCustomizationProfilesUploadImagesOptions,
  ) => WorkspacesCustomizationProfilesUploadImagesRequest {
    const { client, defaults } = this
    if (!this.defaults.isUndocumentedApiEnabled) {
      throw new Error(
        'Cannot use undocumented API without isUndocumentedApiEnabled',
      )
    }
    return function workspacesCustomizationProfilesUploadImages(
      ...args: Parameters<
        SeamHttpWorkspacesCustomizationProfiles['uploadImages']
      >
    ): ReturnType<SeamHttpWorkspacesCustomizationProfiles['uploadImages']> {
      const seam = SeamHttpWorkspacesCustomizationProfiles.fromClient(
        client,
        defaults,
      )
      return seam.uploadImages(...args)
    }
  }
}

export type SeamHttpEndpointQueryPaths =
  | '/access_codes/generate_code'
  | '/access_codes/get'
  | '/access_codes/get_timeline'
  | '/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/access_groups/unmanaged/get'
  | '/acs/access_groups/unmanaged/list'
  | '/acs/credential_pools/list'
  | '/acs/credentials/get'
  | '/acs/credentials/list'
  | '/acs/credentials/list_accessible_entrances'
  | '/acs/credentials/unmanaged/get'
  | '/acs/credentials/unmanaged/list'
  | '/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'
  | '/acs/users/unmanaged/get'
  | '/acs/users/unmanaged/list'
  | '/action_attempts/get'
  | '/action_attempts/list'
  | '/bridges/get'
  | '/bridges/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'
  | '/seam/console/v1/get_resource_locator'
  | '/seam/console/v1/timelines/get'
  | '/seam/customer/v1/access_grants/list'
  | '/seam/customer/v1/automation_runs/list'
  | '/seam/customer/v1/automations/get'
  | '/seam/customer/v1/connector_customers/list'
  | '/seam/customer/v1/connectors/authorize'
  | '/seam/customer/v1/connectors/connector_types'
  | '/seam/customer/v1/connectors/list'
  | '/seam/customer/v1/customers/automations/get'
  | '/seam/customer/v1/customers/list'
  | '/seam/customer/v1/customers/me'
  | '/seam/customer/v1/encoders/list'
  | '/seam/customer/v1/events/list'
  | '/seam/customer/v1/portals/get'
  | '/seam/customer/v1/reservations/get'
  | '/seam/customer/v1/reservations/list'
  | '/seam/customer/v1/reservations/list_access_grants'
  | '/seam/customer/v1/settings/get'
  | '/seam/customer/v1/settings/vertical_resource_aliases/get'
  | '/seam/customer/v1/spaces/list'
  | '/seam/customer/v1/spaces/list_reservations'
  | '/seam/customer/v1/staff_members/get'
  | '/seam/customer/v1/staff_members/list'
  | '/seam/partner/v1/building_blocks/spaces/auto_map'
  | '/spaces/get'
  | '/spaces/get_related'
  | '/spaces/list'
  | '/thermostats/get'
  | '/thermostats/list'
  | '/thermostats/schedules/get'
  | '/thermostats/schedules/list'
  | '/unstable_partner/building_blocks/generate_magic_link'
  | '/user_identities/get'
  | '/user_identities/list'
  | '/user_identities/list_accessible_devices'
  | '/user_identities/list_acs_systems'
  | '/user_identities/list_acs_users'
  | '/user_identities/enrollment_automations/get'
  | '/user_identities/enrollment_automations/list'
  | '/user_identities/unmanaged/get'
  | '/user_identities/unmanaged/list'
  | '/webhooks/get'
  | '/webhooks/list'
  | '/workspaces/find_anything'
  | '/workspaces/get'
  | '/workspaces/list'
  | '/workspaces/customization_profiles/get'
  | '/workspaces/customization_profiles/list'

export type SeamHttpEndpointPaginatedQueryPaths =
  | '/access_codes/list'
  | '/access_codes/unmanaged/list'
  | '/access_grants/list'
  | '/access_grants/unmanaged/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'
  | '/seam/customer/v1/automation_runs/list'
  | '/seam/customer/v1/customers/list'
  | '/seam/customer/v1/reservations/list'
  | '/seam/customer/v1/staff_members/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/delete'
  | '/access_methods/encode'
  | '/acs/access_groups/add_user'
  | '/acs/access_groups/delete'
  | '/acs/access_groups/remove_user'
  | '/acs/credential_provisioning_automations/launch'
  | '/acs/credentials/assign'
  | '/acs/credentials/create'
  | '/acs/credentials/create_offline_code'
  | '/acs/credentials/delete'
  | '/acs/credentials/unassign'
  | '/acs/credentials/update'
  | '/acs/encoders/encode_credential'
  | '/acs/encoders/scan_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'
  | '/customers/reservations/create_deep_link'
  | '/devices/delete'
  | '/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/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'
  | '/seam/customer/v1/access_grants/update'
  | '/seam/customer/v1/access_methods/encode'
  | '/seam/customer/v1/automations/delete'
  | '/seam/customer/v1/automations/update'
  | '/seam/customer/v1/connectors/create'
  | '/seam/customer/v1/connectors/delete'
  | '/seam/customer/v1/connectors/sync'
  | '/seam/customer/v1/connectors/update'
  | '/seam/customer/v1/customers/automations/update'
  | '/seam/customer/v1/customers/open_portal'
  | '/seam/customer/v1/settings/update'
  | '/seam/customer/v1/spaces/create'
  | '/seam/customer/v1/spaces/push_common_areas'
  | '/spaces/add_acs_entrances'
  | '/spaces/add_devices'
  | '/spaces/create'
  | '/spaces/delete'
  | '/spaces/remove_acs_entrances'
  | '/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'
  | '/unstable_partner/building_blocks/connect_accounts'
  | '/unstable_partner/building_blocks/manage_devices'
  | '/unstable_partner/building_blocks/organize_spaces'
  | '/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/enrollment_automations/delete'
  | '/user_identities/enrollment_automations/launch'
  | '/user_identities/unmanaged/update'
  | '/webhooks/create'
  | '/webhooks/delete'
  | '/webhooks/update'
  | '/workspaces/create'
  | '/workspaces/reset_sandbox'
  | '/workspaces/update'
  | '/workspaces/customization_profiles/create'
  | '/workspaces/customization_profiles/update'
  | '/workspaces/customization_profiles/upload_images'