@seamapi/http 0.0.2 → 0.2.0

package/dist/connect.d.cts

@@ -1,35 +1,492 @@
-import { AxiosRequestConfig, Axios } from 'axios';
-import { RouteRequestParams, RouteResponse } from '@seamapi/types/connect';
+import { Axios, AxiosRequestConfig } from 'axios';
+import { AxiosRetry } from 'axios-retry';
+import { RouteRequestBody, RouteResponse, RouteRequestParams } from '@seamapi/types/connect';
 import { SetNonNullable } from 'type-fest';
 
-type SeamHttpOptions = SeamHttpOptionsWithApiKey | SeamHttpOptionsWithClientSessionToken;
-interface SeamHttpCommonOptions {
-    endpoint?: string;
+type Client = Axios;
+interface ClientOptions {
     axiosOptions?: AxiosRequestConfig;
-    enableLegacyMethodBehaivor?: boolean;
+    axiosRetryOptions?: AxiosRetryConfig;
+    client?: Client;
+}
+type AxiosRetryConfig = Parameters<AxiosRetry>[1];
+
+type SeamHttpOptions = SeamHttpOptionsFromEnv | SeamHttpOptionsWithClient | SeamHttpOptionsWithApiKey | SeamHttpOptionsWithClientSessionToken;
+interface SeamHttpCommonOptions extends ClientOptions {
+    endpoint?: string;
+}
+type SeamHttpFromPublishableKeyOptions = SeamHttpCommonOptions;
+type SeamHttpOptionsFromEnv = SeamHttpCommonOptions;
+interface SeamHttpOptionsWithClient {
+    client: Client;
 }
+declare const isSeamHttpOptionsWithClient: (options: SeamHttpOptions) => options is SeamHttpOptionsWithClient;
 interface SeamHttpOptionsWithApiKey extends SeamHttpCommonOptions {
     apiKey: string;
 }
+declare const isSeamHttpOptionsWithApiKey: (options: SeamHttpOptions) => options is SeamHttpOptionsWithApiKey;
 interface SeamHttpOptionsWithClientSessionToken extends SeamHttpCommonOptions {
     clientSessionToken: string;
 }
+declare const isSeamHttpOptionsWithClientSessionToken: (options: SeamHttpOptions) => options is SeamHttpOptionsWithClientSessionToken;
+declare class SeamHttpInvalidOptionsError extends Error {
+    constructor(message: string);
+}
+
+declare class SeamHttpAccessCodesUnmanaged {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAccessCodesUnmanaged;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAccessCodesUnmanaged;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAccessCodesUnmanaged;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAccessCodesUnmanaged>;
+    convertToManaged(body: AccessCodesUnmanagedConvertToManagedBody): Promise<void>;
+    delete(body: AccessCodesUnmanagedDeleteBody): Promise<void>;
+    get(body: AccessCodesUnmanagedGetBody): Promise<AccessCodesUnmanagedGetResponse['access_code']>;
+    list(body: AccessCodesUnmanagedListBody): Promise<AccessCodesUnmanagedListResponse['access_codes']>;
+    update(body: AccessCodesUnmanagedUpdateBody): Promise<void>;
+}
+type AccessCodesUnmanagedConvertToManagedBody = RouteRequestBody<'/access_codes/unmanaged/convert_to_managed'>;
+type AccessCodesUnmanagedDeleteBody = RouteRequestBody<'/access_codes/unmanaged/delete'>;
+type AccessCodesUnmanagedGetBody = RouteRequestBody<'/access_codes/unmanaged/get'>;
+type AccessCodesUnmanagedGetResponse = SetNonNullable<Required<RouteResponse<'/access_codes/unmanaged/get'>>>;
+type AccessCodesUnmanagedListBody = RouteRequestBody<'/access_codes/unmanaged/list'>;
+type AccessCodesUnmanagedListResponse = SetNonNullable<Required<RouteResponse<'/access_codes/unmanaged/list'>>>;
+type AccessCodesUnmanagedUpdateBody = RouteRequestBody<'/access_codes/unmanaged/update'>;
+
+declare class SeamHttpAccessCodes {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAccessCodes;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAccessCodes;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAccessCodes;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAccessCodes>;
+    get unmanaged(): SeamHttpAccessCodesUnmanaged;
+    create(body: AccessCodesCreateBody): Promise<AccessCodesCreateResponse['access_code']>;
+    createMultiple(body: AccessCodesCreateMultipleBody): Promise<AccessCodesCreateMultipleResponse['access_codes']>;
+    delete(body: AccessCodesDeleteBody): Promise<void>;
+    generateCode(body: AccessCodesGenerateCodeBody): Promise<AccessCodesGenerateCodeResponse['generated_code']>;
+    get(body: AccessCodesGetBody): Promise<AccessCodesGetResponse['access_code']>;
+    list(body: AccessCodesListBody): Promise<AccessCodesListResponse['access_codes']>;
+    pullBackupAccessCode(body: AccessCodesPullBackupAccessCodeBody): Promise<AccessCodesPullBackupAccessCodeResponse['backup_access_code']>;
+    update(body: AccessCodesUpdateBody): Promise<void>;
+}
+type AccessCodesCreateBody = RouteRequestBody<'/access_codes/create'>;
+type AccessCodesCreateResponse = SetNonNullable<Required<RouteResponse<'/access_codes/create'>>>;
+type AccessCodesCreateMultipleBody = RouteRequestBody<'/access_codes/create_multiple'>;
+type AccessCodesCreateMultipleResponse = SetNonNullable<Required<RouteResponse<'/access_codes/create_multiple'>>>;
+type AccessCodesDeleteBody = RouteRequestBody<'/access_codes/delete'>;
+type AccessCodesGenerateCodeBody = RouteRequestBody<'/access_codes/generate_code'>;
+type AccessCodesGenerateCodeResponse = SetNonNullable<Required<RouteResponse<'/access_codes/generate_code'>>>;
+type AccessCodesGetBody = RouteRequestBody<'/access_codes/get'>;
+type AccessCodesGetResponse = SetNonNullable<Required<RouteResponse<'/access_codes/get'>>>;
+type AccessCodesListBody = RouteRequestBody<'/access_codes/list'>;
+type AccessCodesListResponse = SetNonNullable<Required<RouteResponse<'/access_codes/list'>>>;
+type AccessCodesPullBackupAccessCodeBody = RouteRequestBody<'/access_codes/pull_backup_access_code'>;
+type AccessCodesPullBackupAccessCodeResponse = SetNonNullable<Required<RouteResponse<'/access_codes/pull_backup_access_code'>>>;
+type AccessCodesUpdateBody = RouteRequestBody<'/access_codes/update'>;
+
+declare class SeamHttpAcsAccessGroups {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcsAccessGroups;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcsAccessGroups;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcsAccessGroups;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcsAccessGroups>;
+    addUser(body: AcsAccessGroupsAddUserBody): Promise<void>;
+    create(body: AcsAccessGroupsCreateBody): Promise<AcsAccessGroupsCreateResponse['acs_access_group']>;
+    delete(body: AcsAccessGroupsDeleteBody): Promise<void>;
+    get(body: AcsAccessGroupsGetBody): Promise<AcsAccessGroupsGetResponse['acs_access_group']>;
+    list(body: AcsAccessGroupsListBody): Promise<AcsAccessGroupsListResponse['acs_access_groups']>;
+    listUsers(body: AcsAccessGroupsListUsersBody): Promise<AcsAccessGroupsListUsersResponse['acs_users']>;
+    removeUser(body: AcsAccessGroupsRemoveUserBody): Promise<void>;
+    update(body: AcsAccessGroupsUpdateBody): Promise<void>;
+}
+type AcsAccessGroupsAddUserBody = RouteRequestBody<'/acs/access_groups/add_user'>;
+type AcsAccessGroupsCreateBody = RouteRequestBody<'/acs/access_groups/create'>;
+type AcsAccessGroupsCreateResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/create'>>>;
+type AcsAccessGroupsDeleteBody = RouteRequestBody<'/acs/access_groups/delete'>;
+type AcsAccessGroupsGetBody = RouteRequestBody<'/acs/access_groups/get'>;
+type AcsAccessGroupsGetResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/get'>>>;
+type AcsAccessGroupsListBody = RouteRequestBody<'/acs/access_groups/list'>;
+type AcsAccessGroupsListResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/list'>>>;
+type AcsAccessGroupsListUsersBody = RouteRequestBody<'/acs/access_groups/list_users'>;
+type AcsAccessGroupsListUsersResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/list_users'>>>;
+type AcsAccessGroupsRemoveUserBody = RouteRequestBody<'/acs/access_groups/remove_user'>;
+type AcsAccessGroupsUpdateBody = RouteRequestBody<'/acs/access_groups/update'>;
+
+declare class SeamHttpAcsCredentials {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcsCredentials;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcsCredentials;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcsCredentials;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcsCredentials>;
+    create(body: AcsCredentialsCreateBody): Promise<AcsCredentialsCreateResponse['acs_credential']>;
+    delete(body: AcsCredentialsDeleteBody): Promise<void>;
+    get(body: AcsCredentialsGetBody): Promise<AcsCredentialsGetResponse['acs_credential']>;
+    list(body: AcsCredentialsListBody): Promise<AcsCredentialsListResponse['acs_credentials']>;
+}
+type AcsCredentialsCreateBody = RouteRequestBody<'/acs/credentials/create'>;
+type AcsCredentialsCreateResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/create'>>>;
+type AcsCredentialsDeleteBody = RouteRequestBody<'/acs/credentials/delete'>;
+type AcsCredentialsGetBody = RouteRequestBody<'/acs/credentials/get'>;
+type AcsCredentialsGetResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/get'>>>;
+type AcsCredentialsListBody = RouteRequestBody<'/acs/credentials/list'>;
+type AcsCredentialsListResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/list'>>>;
+
+declare class SeamHttpAcsSystems {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcsSystems;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcsSystems;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcsSystems;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcsSystems>;
+    get(body: AcsSystemsGetBody): Promise<AcsSystemsGetResponse['acs_system']>;
+    list(body: AcsSystemsListBody): Promise<AcsSystemsListResponse['acs_systems']>;
+}
+type AcsSystemsGetBody = RouteRequestBody<'/acs/systems/get'>;
+type AcsSystemsGetResponse = SetNonNullable<Required<RouteResponse<'/acs/systems/get'>>>;
+type AcsSystemsListBody = RouteRequestBody<'/acs/systems/list'>;
+type AcsSystemsListResponse = SetNonNullable<Required<RouteResponse<'/acs/systems/list'>>>;
+
+declare class SeamHttpAcsUsers {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcsUsers;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcsUsers;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcsUsers;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcsUsers>;
+    addToAccessGroup(body: AcsUsersAddToAccessGroupBody): Promise<void>;
+    create(body: AcsUsersCreateBody): Promise<AcsUsersCreateResponse['acs_user']>;
+    delete(body: AcsUsersDeleteBody): Promise<void>;
+    get(body: AcsUsersGetBody): Promise<AcsUsersGetResponse['acs_user']>;
+    list(body: AcsUsersListBody): Promise<AcsUsersListResponse['acs_users']>;
+    removeFromAccessGroup(body: AcsUsersRemoveFromAccessGroupBody): Promise<void>;
+    suspend(body: AcsUsersSuspendBody): Promise<void>;
+    unsuspend(body: AcsUsersUnsuspendBody): Promise<void>;
+    update(body: AcsUsersUpdateBody): Promise<void>;
+}
+type AcsUsersAddToAccessGroupBody = RouteRequestBody<'/acs/users/add_to_access_group'>;
+type AcsUsersCreateBody = RouteRequestBody<'/acs/users/create'>;
+type AcsUsersCreateResponse = SetNonNullable<Required<RouteResponse<'/acs/users/create'>>>;
+type AcsUsersDeleteBody = RouteRequestBody<'/acs/users/delete'>;
+type AcsUsersGetBody = RouteRequestBody<'/acs/users/get'>;
+type AcsUsersGetResponse = SetNonNullable<Required<RouteResponse<'/acs/users/get'>>>;
+type AcsUsersListBody = RouteRequestBody<'/acs/users/list'>;
+type AcsUsersListResponse = SetNonNullable<Required<RouteResponse<'/acs/users/list'>>>;
+type AcsUsersRemoveFromAccessGroupBody = RouteRequestBody<'/acs/users/remove_from_access_group'>;
+type AcsUsersSuspendBody = RouteRequestBody<'/acs/users/suspend'>;
+type AcsUsersUnsuspendBody = RouteRequestBody<'/acs/users/unsuspend'>;
+type AcsUsersUpdateBody = RouteRequestBody<'/acs/users/update'>;
+
+declare class SeamHttpAcs {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpAcs;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpAcs;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpAcs;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpAcs>;
+    get accessGroups(): SeamHttpAcsAccessGroups;
+    get credentials(): SeamHttpAcsCredentials;
+    get systems(): SeamHttpAcsSystems;
+    get users(): SeamHttpAcsUsers;
+}
+
+declare class SeamHttpActionAttempts {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpActionAttempts;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpActionAttempts;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpActionAttempts;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpActionAttempts>;
+    get(body: ActionAttemptsGetBody): Promise<ActionAttemptsGetResponse['action_attempt']>;
+    list(body: ActionAttemptsListBody): Promise<ActionAttemptsListResponse['action_attempts']>;
+}
+type ActionAttemptsGetBody = RouteRequestBody<'/action_attempts/get'>;
+type ActionAttemptsGetResponse = SetNonNullable<Required<RouteResponse<'/action_attempts/get'>>>;
+type ActionAttemptsListBody = RouteRequestBody<'/action_attempts/list'>;
+type ActionAttemptsListResponse = SetNonNullable<Required<RouteResponse<'/action_attempts/list'>>>;
+
+declare class SeamHttpClientSessions {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpClientSessions;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpClientSessions;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpClientSessions;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpClientSessions>;
+    create(body: ClientSessionsCreateBody): Promise<ClientSessionsCreateResponse['client_session']>;
+    delete(body: ClientSessionsDeleteBody): Promise<void>;
+    get(body: ClientSessionsGetBody): Promise<ClientSessionsGetResponse['client_session']>;
+    getOrCreate(body: ClientSessionsGetOrCreateBody): Promise<ClientSessionsGetOrCreateResponse['client_session']>;
+    grantAccess(body: ClientSessionsGrantAccessBody): Promise<ClientSessionsGrantAccessResponse['client_session']>;
+    list(body: ClientSessionsListBody): Promise<ClientSessionsListResponse['client_sessions']>;
+}
+type ClientSessionsCreateBody = RouteRequestBody<'/client_sessions/create'>;
+type ClientSessionsCreateResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/create'>>>;
+type ClientSessionsDeleteBody = RouteRequestBody<'/client_sessions/delete'>;
+type ClientSessionsGetBody = RouteRequestBody<'/client_sessions/get'>;
+type ClientSessionsGetResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/get'>>>;
+type ClientSessionsGetOrCreateBody = RouteRequestBody<'/client_sessions/get_or_create'>;
+type ClientSessionsGetOrCreateResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/get_or_create'>>>;
+type ClientSessionsGrantAccessBody = RouteRequestBody<'/client_sessions/grant_access'>;
+type ClientSessionsGrantAccessResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/grant_access'>>>;
+type ClientSessionsListBody = RouteRequestBody<'/client_sessions/list'>;
+type ClientSessionsListResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/list'>>>;
+
+declare class SeamHttpConnectWebviews {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpConnectWebviews;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpConnectWebviews;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpConnectWebviews;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpConnectWebviews>;
+    create(body: ConnectWebviewsCreateBody): Promise<ConnectWebviewsCreateResponse['connect_webview']>;
+    delete(body: ConnectWebviewsDeleteBody): Promise<void>;
+    get(body: ConnectWebviewsGetBody): Promise<ConnectWebviewsGetResponse['connect_webview']>;
+    list(body: ConnectWebviewsListBody): Promise<ConnectWebviewsListResponse['connect_webviews']>;
+    view(params?: ConnectWebviewsViewParams): Promise<void>;
+}
+type ConnectWebviewsCreateBody = RouteRequestBody<'/connect_webviews/create'>;
+type ConnectWebviewsCreateResponse = SetNonNullable<Required<RouteResponse<'/connect_webviews/create'>>>;
+type ConnectWebviewsDeleteBody = RouteRequestBody<'/connect_webviews/delete'>;
+type ConnectWebviewsGetBody = RouteRequestBody<'/connect_webviews/get'>;
+type ConnectWebviewsGetResponse = SetNonNullable<Required<RouteResponse<'/connect_webviews/get'>>>;
+type ConnectWebviewsListBody = RouteRequestBody<'/connect_webviews/list'>;
+type ConnectWebviewsListResponse = SetNonNullable<Required<RouteResponse<'/connect_webviews/list'>>>;
+type ConnectWebviewsViewParams = RouteRequestParams<'/connect_webviews/view'>;
+
+declare class SeamHttpConnectedAccounts {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpConnectedAccounts;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpConnectedAccounts;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpConnectedAccounts;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpConnectedAccounts>;
+    delete(body: ConnectedAccountsDeleteBody): Promise<void>;
+    get(body: ConnectedAccountsGetBody): Promise<ConnectedAccountsGetResponse['connected_account']>;
+    list(params?: ConnectedAccountsListParams): Promise<ConnectedAccountsListResponse['connected_accounts']>;
+}
+type ConnectedAccountsDeleteBody = RouteRequestBody<'/connected_accounts/delete'>;
+type ConnectedAccountsGetBody = RouteRequestBody<'/connected_accounts/get'>;
+type ConnectedAccountsGetResponse = SetNonNullable<Required<RouteResponse<'/connected_accounts/get'>>>;
+type ConnectedAccountsListParams = RouteRequestParams<'/connected_accounts/list'>;
+type ConnectedAccountsListResponse = SetNonNullable<Required<RouteResponse<'/connected_accounts/list'>>>;
+
+declare class SeamHttpDevicesUnmanaged {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpDevicesUnmanaged;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpDevicesUnmanaged;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpDevicesUnmanaged;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpDevicesUnmanaged>;
+    get(body: DevicesUnmanagedGetBody): Promise<DevicesUnmanagedGetResponse['device']>;
+    list(body: DevicesUnmanagedListBody): Promise<DevicesUnmanagedListResponse['devices']>;
+    update(body: DevicesUnmanagedUpdateBody): Promise<void>;
+}
+type DevicesUnmanagedGetBody = RouteRequestBody<'/devices/unmanaged/get'>;
+type DevicesUnmanagedGetResponse = SetNonNullable<Required<RouteResponse<'/devices/unmanaged/get'>>>;
+type DevicesUnmanagedListBody = RouteRequestBody<'/devices/unmanaged/list'>;
+type DevicesUnmanagedListResponse = SetNonNullable<Required<RouteResponse<'/devices/unmanaged/list'>>>;
+type DevicesUnmanagedUpdateBody = RouteRequestBody<'/devices/unmanaged/update'>;
+
+declare class SeamHttpDevices {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpDevices;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpDevices;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpDevices;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpDevices>;
+    get unmanaged(): SeamHttpDevicesUnmanaged;
+    delete(body: DevicesDeleteBody): Promise<void>;
+    get(body: DevicesGetBody): Promise<DevicesGetResponse['device']>;
+    list(body: DevicesListBody): Promise<DevicesListResponse['devices']>;
+    listDeviceProviders(body: DevicesListDeviceProvidersBody): Promise<DevicesListDeviceProvidersResponse['device_providers']>;
+    update(body: DevicesUpdateBody): Promise<void>;
+}
+type DevicesDeleteBody = RouteRequestBody<'/devices/delete'>;
+type DevicesGetBody = RouteRequestBody<'/devices/get'>;
+type DevicesGetResponse = SetNonNullable<Required<RouteResponse<'/devices/get'>>>;
+type DevicesListBody = RouteRequestBody<'/devices/list'>;
+type DevicesListResponse = SetNonNullable<Required<RouteResponse<'/devices/list'>>>;
+type DevicesListDeviceProvidersBody = RouteRequestBody<'/devices/list_device_providers'>;
+type DevicesListDeviceProvidersResponse = SetNonNullable<Required<RouteResponse<'/devices/list_device_providers'>>>;
+type DevicesUpdateBody = RouteRequestBody<'/devices/update'>;
+
+declare class SeamHttpEvents {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpEvents;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpEvents;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpEvents;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpEvents>;
+    get(body: EventsGetBody): Promise<EventsGetResponse['event']>;
+    list(body: EventsListBody): Promise<EventsListResponse['events']>;
+}
+type EventsGetBody = RouteRequestBody<'/events/get'>;
+type EventsGetResponse = SetNonNullable<Required<RouteResponse<'/events/get'>>>;
+type EventsListBody = RouteRequestBody<'/events/list'>;
+type EventsListResponse = SetNonNullable<Required<RouteResponse<'/events/list'>>>;
+
+declare class SeamHttpLocks {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpLocks;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpLocks;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpLocks;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpLocks>;
+    get(body: LocksGetBody): Promise<LocksGetResponse['device']>;
+    list(body: LocksListBody): Promise<LocksListResponse['devices']>;
+    lockDoor(body: LocksLockDoorBody): Promise<LocksLockDoorResponse['action_attempt']>;
+    unlockDoor(body: LocksUnlockDoorBody): Promise<LocksUnlockDoorResponse['action_attempt']>;
+}
+type LocksGetBody = RouteRequestBody<'/locks/get'>;
+type LocksGetResponse = SetNonNullable<Required<RouteResponse<'/locks/get'>>>;
+type LocksListBody = RouteRequestBody<'/locks/list'>;
+type LocksListResponse = SetNonNullable<Required<RouteResponse<'/locks/list'>>>;
+type LocksLockDoorBody = RouteRequestBody<'/locks/lock_door'>;
+type LocksLockDoorResponse = SetNonNullable<Required<RouteResponse<'/locks/lock_door'>>>;
+type LocksUnlockDoorBody = RouteRequestBody<'/locks/unlock_door'>;
+type LocksUnlockDoorResponse = SetNonNullable<Required<RouteResponse<'/locks/unlock_door'>>>;
+
+declare class SeamHttpNoiseSensorsNoiseThresholds {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpNoiseSensorsNoiseThresholds;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpNoiseSensorsNoiseThresholds;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpNoiseSensorsNoiseThresholds;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpNoiseSensorsNoiseThresholds>;
+    create(body: NoiseSensorsNoiseThresholdsCreateBody): Promise<void>;
+    delete(body: NoiseSensorsNoiseThresholdsDeleteBody): Promise<void>;
+    get(body: NoiseSensorsNoiseThresholdsGetBody): Promise<NoiseSensorsNoiseThresholdsGetResponse['noise_threshold']>;
+    list(body: NoiseSensorsNoiseThresholdsListBody): Promise<NoiseSensorsNoiseThresholdsListResponse['noise_thresholds']>;
+    update(body: NoiseSensorsNoiseThresholdsUpdateBody): Promise<void>;
+}
+type NoiseSensorsNoiseThresholdsCreateBody = RouteRequestBody<'/noise_sensors/noise_thresholds/create'>;
+type NoiseSensorsNoiseThresholdsDeleteBody = RouteRequestBody<'/noise_sensors/noise_thresholds/delete'>;
+type NoiseSensorsNoiseThresholdsGetBody = RouteRequestBody<'/noise_sensors/noise_thresholds/get'>;
+type NoiseSensorsNoiseThresholdsGetResponse = SetNonNullable<Required<RouteResponse<'/noise_sensors/noise_thresholds/get'>>>;
+type NoiseSensorsNoiseThresholdsListBody = RouteRequestBody<'/noise_sensors/noise_thresholds/list'>;
+type NoiseSensorsNoiseThresholdsListResponse = SetNonNullable<Required<RouteResponse<'/noise_sensors/noise_thresholds/list'>>>;
+type NoiseSensorsNoiseThresholdsUpdateBody = RouteRequestBody<'/noise_sensors/noise_thresholds/update'>;
+
+declare class SeamHttpNoiseSensors {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpNoiseSensors;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpNoiseSensors;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpNoiseSensors;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpNoiseSensors>;
+    get noiseThresholds(): SeamHttpNoiseSensorsNoiseThresholds;
+}
+
+declare class SeamHttpThermostatsClimateSettingSchedules {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpThermostatsClimateSettingSchedules;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpThermostatsClimateSettingSchedules;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpThermostatsClimateSettingSchedules;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpThermostatsClimateSettingSchedules>;
+    create(body: ThermostatsClimateSettingSchedulesCreateBody): Promise<ThermostatsClimateSettingSchedulesCreateResponse['climate_setting_schedule']>;
+    delete(body: ThermostatsClimateSettingSchedulesDeleteBody): Promise<void>;
+    get(body: ThermostatsClimateSettingSchedulesGetBody): Promise<ThermostatsClimateSettingSchedulesGetResponse['climate_setting_schedule']>;
+    list(body: ThermostatsClimateSettingSchedulesListBody): Promise<ThermostatsClimateSettingSchedulesListResponse['climate_setting_schedules']>;
+    update(body: ThermostatsClimateSettingSchedulesUpdateBody): Promise<void>;
+}
+type ThermostatsClimateSettingSchedulesCreateBody = RouteRequestBody<'/thermostats/climate_setting_schedules/create'>;
+type ThermostatsClimateSettingSchedulesCreateResponse = SetNonNullable<Required<RouteResponse<'/thermostats/climate_setting_schedules/create'>>>;
+type ThermostatsClimateSettingSchedulesDeleteBody = RouteRequestBody<'/thermostats/climate_setting_schedules/delete'>;
+type ThermostatsClimateSettingSchedulesGetBody = RouteRequestBody<'/thermostats/climate_setting_schedules/get'>;
+type ThermostatsClimateSettingSchedulesGetResponse = SetNonNullable<Required<RouteResponse<'/thermostats/climate_setting_schedules/get'>>>;
+type ThermostatsClimateSettingSchedulesListBody = RouteRequestBody<'/thermostats/climate_setting_schedules/list'>;
+type ThermostatsClimateSettingSchedulesListResponse = SetNonNullable<Required<RouteResponse<'/thermostats/climate_setting_schedules/list'>>>;
+type ThermostatsClimateSettingSchedulesUpdateBody = RouteRequestBody<'/thermostats/climate_setting_schedules/update'>;
+
+declare class SeamHttpThermostats {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpThermostats;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpThermostats;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpThermostats;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpThermostats>;
+    get climateSettingSchedules(): SeamHttpThermostatsClimateSettingSchedules;
+    cool(body: ThermostatsCoolBody): Promise<void>;
+    get(body: ThermostatsGetBody): Promise<ThermostatsGetResponse['thermostat']>;
+    heat(body: ThermostatsHeatBody): Promise<void>;
+    heatCool(body: ThermostatsHeatCoolBody): Promise<void>;
+    list(body: ThermostatsListBody): Promise<ThermostatsListResponse['thermostats']>;
+    off(body: ThermostatsOffBody): Promise<void>;
+    setFanMode(body: ThermostatsSetFanModeBody): Promise<void>;
+    update(body: ThermostatsUpdateBody): Promise<void>;
+}
+type ThermostatsCoolBody = RouteRequestBody<'/thermostats/cool'>;
+type ThermostatsGetBody = RouteRequestBody<'/thermostats/get'>;
+type ThermostatsGetResponse = SetNonNullable<Required<RouteResponse<'/thermostats/get'>>>;
+type ThermostatsHeatBody = RouteRequestBody<'/thermostats/heat'>;
+type ThermostatsHeatCoolBody = RouteRequestBody<'/thermostats/heat_cool'>;
+type ThermostatsListBody = RouteRequestBody<'/thermostats/list'>;
+type ThermostatsListResponse = SetNonNullable<Required<RouteResponse<'/thermostats/list'>>>;
+type ThermostatsOffBody = RouteRequestBody<'/thermostats/off'>;
+type ThermostatsSetFanModeBody = RouteRequestBody<'/thermostats/set_fan_mode'>;
+type ThermostatsUpdateBody = RouteRequestBody<'/thermostats/update'>;
+
+declare class SeamHttpWebhooks {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpWebhooks;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpWebhooks;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpWebhooks;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpWebhooks>;
+    create(body: WebhooksCreateBody): Promise<WebhooksCreateResponse['webhook']>;
+    delete(body: WebhooksDeleteBody): Promise<void>;
+    get(body: WebhooksGetBody): Promise<WebhooksGetResponse['webhook']>;
+    list(params?: WebhooksListParams): Promise<WebhooksListResponse['webhooks']>;
+}
+type WebhooksCreateBody = RouteRequestBody<'/webhooks/create'>;
+type WebhooksCreateResponse = SetNonNullable<Required<RouteResponse<'/webhooks/create'>>>;
+type WebhooksDeleteBody = RouteRequestBody<'/webhooks/delete'>;
+type WebhooksGetBody = RouteRequestBody<'/webhooks/get'>;
+type WebhooksGetResponse = SetNonNullable<Required<RouteResponse<'/webhooks/get'>>>;
+type WebhooksListParams = RouteRequestParams<'/webhooks/list'>;
+type WebhooksListResponse = SetNonNullable<Required<RouteResponse<'/webhooks/list'>>>;
 
-declare class WorkspacesHttp {
-    client: Axios;
-    constructor(apiKeyOrOptionsOrClient: Axios | string | SeamHttpOptions);
+declare class SeamHttpWorkspaces {
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttpWorkspaces;
+    static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttpWorkspaces;
+    static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttpWorkspaces;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttpWorkspaces>;
     get(params?: WorkspacesGetParams): Promise<WorkspacesGetResponse['workspace']>;
+    list(params?: WorkspacesListParams): Promise<WorkspacesListResponse['workspaces']>;
+    resetSandbox(body: WorkspacesResetSandboxBody): Promise<void>;
 }
-type WorkspacesGetParams = SetNonNullable<Required<RouteRequestParams<'/workspaces/get'>>>;
+type WorkspacesGetParams = RouteRequestParams<'/workspaces/get'>;
 type WorkspacesGetResponse = SetNonNullable<Required<RouteResponse<'/workspaces/get'>>>;
+type WorkspacesListParams = RouteRequestParams<'/workspaces/list'>;
+type WorkspacesListResponse = SetNonNullable<Required<RouteResponse<'/workspaces/list'>>>;
+type WorkspacesResetSandboxBody = RouteRequestBody<'/workspaces/reset_sandbox'>;
 
 declare class SeamHttp {
-    #private;
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    client: Client;
+    constructor(apiKeyOrOptions?: string | SeamHttpOptions);
+    static fromClient(client: SeamHttpOptionsWithClient['client'], options?: Omit<SeamHttpOptionsWithClient, 'client'>): SeamHttp;
     static fromApiKey(apiKey: SeamHttpOptionsWithApiKey['apiKey'], options?: Omit<SeamHttpOptionsWithApiKey, 'apiKey'>): SeamHttp;
     static fromClientSessionToken(clientSessionToken: SeamHttpOptionsWithClientSessionToken['clientSessionToken'], options?: Omit<SeamHttpOptionsWithClientSessionToken, 'clientSessionToken'>): SeamHttp;
-    get workspaces(): WorkspacesHttp;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttp>;
+    get accessCodes(): SeamHttpAccessCodes;
+    get acs(): SeamHttpAcs;
+    get actionAttempts(): SeamHttpActionAttempts;
+    get clientSessions(): SeamHttpClientSessions;
+    get connectedAccounts(): SeamHttpConnectedAccounts;
+    get connectWebviews(): SeamHttpConnectWebviews;
+    get devices(): SeamHttpDevices;
+    get events(): SeamHttpEvents;
+    get locks(): SeamHttpLocks;
+    get noiseSensors(): SeamHttpNoiseSensors;
+    get thermostats(): SeamHttpThermostats;
+    get webhooks(): SeamHttpWebhooks;
+    get workspaces(): SeamHttpWorkspaces;
 }
 
-export { SeamHttp };
+export { SeamHttp, SeamHttpFromPublishableKeyOptions, SeamHttpInvalidOptionsError, SeamHttpOptions, SeamHttpOptionsFromEnv, SeamHttpOptionsWithApiKey, SeamHttpOptionsWithClient, SeamHttpOptionsWithClientSessionToken, isSeamHttpOptionsWithApiKey, isSeamHttpOptionsWithClient, isSeamHttpOptionsWithClientSessionToken };

package/lib/params-serializer.d.ts

@@ -0,0 +1,5 @@
+import type { CustomParamsSerializer } from 'axios';
+export declare const paramsSerializer: CustomParamsSerializer;
+export declare class UnserializableParamError extends Error {
+    constructor(name: string, message: string);
+}

package/lib/params-serializer.js

@@ -0,0 +1,42 @@
+export const paramsSerializer = (params) => {
+    const searchParams = new URLSearchParams();
+    for (const [name, value] of Object.entries(params)) {
+        if (value == null)
+            continue;
+        if (Array.isArray(value)) {
+            if (value.length === 0)
+                searchParams.set(name, '');
+            if (value.length === 1 && value[0] === '') {
+                throw new UnserializableParamError(name, `is a single element array containing the empty string which is unsupported because it serializes to the empty array`);
+            }
+            for (const v of value) {
+                throwIfUnserializable(name, v);
+                searchParams.append(name, v);
+            }
+            continue;
+        }
+        throwIfUnserializable(name, value);
+        searchParams.set(name, value);
+    }
+    searchParams.sort();
+    return searchParams.toString();
+};
+const throwIfUnserializable = (k, v) => {
+    if (v == null) {
+        throw new UnserializableParamError(k, `is ${v} or contains ${v}`);
+    }
+    if (typeof v === 'function') {
+        throw new UnserializableParamError(k, 'is a function or contains a function');
+    }
+    if (typeof v === 'object') {
+        throw new UnserializableParamError(k, 'is an object or contains an object');
+    }
+};
+export class UnserializableParamError extends Error {
+    constructor(name, message) {
+        super(`Could not serialize parameter: '${name}' ${message}`);
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+//# sourceMappingURL=params-serializer.js.map

package/lib/params-serializer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"params-serializer.js","sourceRoot":"","sources":["../src/lib/params-serializer.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,gBAAgB,GAA2B,CAAC,MAAM,EAAE,EAAE;IACjE,MAAM,YAAY,GAAG,IAAI,eAAe,EAAE,CAAA;IAE1C,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QAClD,IAAI,KAAK,IAAI,IAAI;YAAE,SAAQ;QAE3B,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACxB,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;gBAAE,YAAY,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAA;YAClD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE;gBACzC,MAAM,IAAI,wBAAwB,CAChC,IAAI,EACJ,qHAAqH,CACtH,CAAA;aACF;YACD,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE;gBACrB,qBAAqB,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;gBAC9B,YAAY,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;aAC7B;YACD,SAAQ;SACT;QAED,qBAAqB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;QAClC,YAAY,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;KAC9B;IAED,YAAY,CAAC,IAAI,EAAE,CAAA;IACnB,OAAO,YAAY,CAAC,QAAQ,EAAE,CAAA;AAChC,CAAC,CAAA;AAED,MAAM,qBAAqB,GAAG,CAAC,CAAS,EAAE,CAAU,EAAQ,EAAE;IAC5D,IAAI,CAAC,IAAI,IAAI,EAAE;QACb,MAAM,IAAI,wBAAwB,CAAC,CAAC,EAAE,MAAM,CAAC,gBAAgB,CAAC,EAAE,CAAC,CAAA;KAClE;IAED,IAAI,OAAO,CAAC,KAAK,UAAU,EAAE;QAC3B,MAAM,IAAI,wBAAwB,CAChC,CAAC,EACD,sCAAsC,CACvC,CAAA;KACF;IAED,IAAI,OAAO,CAAC,KAAK,QAAQ,EAAE;QACzB,MAAM,IAAI,wBAAwB,CAAC,CAAC,EAAE,oCAAoC,CAAC,CAAA;KAC5E;AACH,CAAC,CAAA;AAED,MAAM,OAAO,wBAAyB,SAAQ,KAAK;IACjD,YAAY,IAAY,EAAE,OAAe;QACvC,KAAK,CAAC,mCAAmC,IAAI,KAAK,OAAO,EAAE,CAAC,CAAA;QAC5D,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAA;QACjC,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAA;IACjD,CAAC;CACF"}

package/lib/seam/connect/auth.d.ts

@@ -1,7 +1,8 @@
-import { type SeamHttpOptions } from './client-options.js';
+import type { Options } from './parse-options.js';
 type Headers = Record<string, string>;
-export declare const getAuthHeaders: (options: SeamHttpOptions) => Headers;
-export declare class InvalidSeamTokenError extends Error {
+export declare const getAuthHeaders: (options: Options) => Headers;
+export declare class SeamHttpInvalidTokenError extends Error {
     constructor(message: string);
 }
+export declare const warnOnInsecureuserIdentifierKey: (userIdentifierKey: string) => void;
 export {};