@seamapi/http 0.0.2 → 0.1.0

package/dist/connect.d.cts

@@ -1,13 +1,16 @@
-import { AxiosRequestConfig, Axios } from 'axios';
-import { RouteRequestParams, RouteResponse } from '@seamapi/types/connect';
+import { Axios, AxiosRequestConfig } from 'axios';
+import { RouteRequestBody, RouteResponse, RouteRequestParams } from '@seamapi/types/connect';
 import { SetNonNullable } from 'type-fest';
 
-type SeamHttpOptions = SeamHttpOptionsWithApiKey | SeamHttpOptionsWithClientSessionToken;
+type SeamHttpOptions = SeamHttpOptionsWithClient | SeamHttpOptionsWithApiKey | SeamHttpOptionsWithClientSessionToken;
 interface SeamHttpCommonOptions {
     endpoint?: string;
     axiosOptions?: AxiosRequestConfig;
     enableLegacyMethodBehaivor?: boolean;
 }
+interface SeamHttpOptionsWithClient extends Pick<SeamHttpCommonOptions, 'enableLegacyMethodBehaivor'> {
+    client: Axios;
+}
 interface SeamHttpOptionsWithApiKey extends SeamHttpCommonOptions {
     apiKey: string;
 }
@@ -15,21 +18,431 @@ interface SeamHttpOptionsWithClientSessionToken extends SeamHttpCommonOptions {
     clientSessionToken: string;
 }
 
-declare class WorkspacesHttp {
+declare class SeamHttpAccessCodesUnmanaged {
+    client: Axios;
+    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;
+    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 = SetNonNullable<Required<RouteRequestBody<'/access_codes/unmanaged/convert_to_managed'>>>;
+type AccessCodesUnmanagedDeleteBody = SetNonNullable<Required<RouteRequestBody<'/access_codes/unmanaged/delete'>>>;
+type AccessCodesUnmanagedGetBody = SetNonNullable<Required<RouteRequestBody<'/access_codes/unmanaged/get'>>>;
+type AccessCodesUnmanagedGetResponse = SetNonNullable<Required<RouteResponse<'/access_codes/unmanaged/get'>>>;
+type AccessCodesUnmanagedListBody = SetNonNullable<Required<RouteRequestBody<'/access_codes/unmanaged/list'>>>;
+type AccessCodesUnmanagedListResponse = SetNonNullable<Required<RouteResponse<'/access_codes/unmanaged/list'>>>;
+type AccessCodesUnmanagedUpdateBody = SetNonNullable<Required<RouteRequestBody<'/access_codes/unmanaged/update'>>>;
+
+declare class SeamHttpAccessCodes {
+    client: Axios;
+    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;
+    get unmanaged(): SeamHttpAccessCodesUnmanaged;
+    create(body: AccessCodesCreateBody): Promise<AccessCodesCreateResponse['access_code']>;
+    createMultiple(body: AccessCodesCreateMultipleBody): Promise<AccessCodesCreateMultipleResponse['access_codes']>;
+    delete(body: AccessCodesDeleteBody): Promise<void>;
+    generateCode(params?: AccessCodesGenerateCodeParams): 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 = SetNonNullable<Required<RouteRequestBody<'/access_codes/create'>>>;
+type AccessCodesCreateResponse = SetNonNullable<Required<RouteResponse<'/access_codes/create'>>>;
+type AccessCodesCreateMultipleBody = SetNonNullable<Required<RouteRequestBody<'/access_codes/create_multiple'>>>;
+type AccessCodesCreateMultipleResponse = SetNonNullable<Required<RouteResponse<'/access_codes/create_multiple'>>>;
+type AccessCodesDeleteBody = SetNonNullable<Required<RouteRequestBody<'/access_codes/delete'>>>;
+type AccessCodesGenerateCodeParams = SetNonNullable<Required<RouteRequestParams<'/access_codes/generate_code'>>>;
+type AccessCodesGenerateCodeResponse = SetNonNullable<Required<RouteResponse<'/access_codes/generate_code'>>>;
+type AccessCodesGetBody = SetNonNullable<Required<RouteRequestBody<'/access_codes/get'>>>;
+type AccessCodesGetResponse = SetNonNullable<Required<RouteResponse<'/access_codes/get'>>>;
+type AccessCodesListBody = SetNonNullable<Required<RouteRequestBody<'/access_codes/list'>>>;
+type AccessCodesListResponse = SetNonNullable<Required<RouteResponse<'/access_codes/list'>>>;
+type AccessCodesPullBackupAccessCodeBody = SetNonNullable<Required<RouteRequestBody<'/access_codes/pull_backup_access_code'>>>;
+type AccessCodesPullBackupAccessCodeResponse = SetNonNullable<Required<RouteResponse<'/access_codes/pull_backup_access_code'>>>;
+type AccessCodesUpdateBody = SetNonNullable<Required<RouteRequestBody<'/access_codes/update'>>>;
+
+declare class SeamHttpAcsAccessGroups {
+    client: Axios;
+    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;
+    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 = SetNonNullable<Required<RouteRequestBody<'/acs/access_groups/add_user'>>>;
+type AcsAccessGroupsCreateBody = SetNonNullable<Required<RouteRequestBody<'/acs/access_groups/create'>>>;
+type AcsAccessGroupsCreateResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/create'>>>;
+type AcsAccessGroupsDeleteBody = SetNonNullable<Required<RouteRequestBody<'/acs/access_groups/delete'>>>;
+type AcsAccessGroupsGetBody = SetNonNullable<Required<RouteRequestBody<'/acs/access_groups/get'>>>;
+type AcsAccessGroupsGetResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/get'>>>;
+type AcsAccessGroupsListBody = SetNonNullable<Required<RouteRequestBody<'/acs/access_groups/list'>>>;
+type AcsAccessGroupsListResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/list'>>>;
+type AcsAccessGroupsListUsersBody = SetNonNullable<Required<RouteRequestBody<'/acs/access_groups/list_users'>>>;
+type AcsAccessGroupsListUsersResponse = SetNonNullable<Required<RouteResponse<'/acs/access_groups/list_users'>>>;
+type AcsAccessGroupsRemoveUserBody = SetNonNullable<Required<RouteRequestBody<'/acs/access_groups/remove_user'>>>;
+type AcsAccessGroupsUpdateBody = SetNonNullable<Required<RouteRequestBody<'/acs/access_groups/update'>>>;
+
+declare class SeamHttpAcsCredentials {
+    client: Axios;
+    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;
+    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 = SetNonNullable<Required<RouteRequestBody<'/acs/credentials/create'>>>;
+type AcsCredentialsCreateResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/create'>>>;
+type AcsCredentialsDeleteBody = SetNonNullable<Required<RouteRequestBody<'/acs/credentials/delete'>>>;
+type AcsCredentialsGetBody = SetNonNullable<Required<RouteRequestBody<'/acs/credentials/get'>>>;
+type AcsCredentialsGetResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/get'>>>;
+type AcsCredentialsListBody = SetNonNullable<Required<RouteRequestBody<'/acs/credentials/list'>>>;
+type AcsCredentialsListResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/list'>>>;
+
+declare class SeamHttpAcsSystems {
+    client: Axios;
+    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;
+    get(body: AcsSystemsGetBody): Promise<AcsSystemsGetResponse['acs_system']>;
+    list(params?: AcsSystemsListParams): Promise<AcsSystemsListResponse['acs_systems']>;
+}
+type AcsSystemsGetBody = SetNonNullable<Required<RouteRequestBody<'/acs/systems/get'>>>;
+type AcsSystemsGetResponse = SetNonNullable<Required<RouteResponse<'/acs/systems/get'>>>;
+type AcsSystemsListParams = SetNonNullable<Required<RouteRequestParams<'/acs/systems/list'>>>;
+type AcsSystemsListResponse = SetNonNullable<Required<RouteResponse<'/acs/systems/list'>>>;
+
+declare class SeamHttpAcsUsers {
+    client: Axios;
+    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;
+    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>;
+    update(body: AcsUsersUpdateBody): Promise<void>;
+}
+type AcsUsersAddToAccessGroupBody = SetNonNullable<Required<RouteRequestBody<'/acs/users/add_to_access_group'>>>;
+type AcsUsersCreateBody = SetNonNullable<Required<RouteRequestBody<'/acs/users/create'>>>;
+type AcsUsersCreateResponse = SetNonNullable<Required<RouteResponse<'/acs/users/create'>>>;
+type AcsUsersDeleteBody = SetNonNullable<Required<RouteRequestBody<'/acs/users/delete'>>>;
+type AcsUsersGetBody = SetNonNullable<Required<RouteRequestBody<'/acs/users/get'>>>;
+type AcsUsersGetResponse = SetNonNullable<Required<RouteResponse<'/acs/users/get'>>>;
+type AcsUsersListBody = SetNonNullable<Required<RouteRequestBody<'/acs/users/list'>>>;
+type AcsUsersListResponse = SetNonNullable<Required<RouteResponse<'/acs/users/list'>>>;
+type AcsUsersRemoveFromAccessGroupBody = SetNonNullable<Required<RouteRequestBody<'/acs/users/remove_from_access_group'>>>;
+type AcsUsersUpdateBody = SetNonNullable<Required<RouteRequestBody<'/acs/users/update'>>>;
+
+declare class SeamHttpAcs {
+    client: Axios;
+    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;
+    get accessGroups(): SeamHttpAcsAccessGroups;
+    get credentials(): SeamHttpAcsCredentials;
+    get systems(): SeamHttpAcsSystems;
+    get users(): SeamHttpAcsUsers;
+}
+
+declare class SeamHttpActionAttempts {
+    client: Axios;
+    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;
+    get(body: ActionAttemptsGetBody): Promise<ActionAttemptsGetResponse['action_attempt']>;
+    list(body: ActionAttemptsListBody): Promise<ActionAttemptsListResponse['action_attempts']>;
+}
+type ActionAttemptsGetBody = SetNonNullable<Required<RouteRequestBody<'/action_attempts/get'>>>;
+type ActionAttemptsGetResponse = SetNonNullable<Required<RouteResponse<'/action_attempts/get'>>>;
+type ActionAttemptsListBody = SetNonNullable<Required<RouteRequestBody<'/action_attempts/list'>>>;
+type ActionAttemptsListResponse = SetNonNullable<Required<RouteResponse<'/action_attempts/list'>>>;
+
+declare class SeamHttpClientSessions {
+    client: Axios;
+    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;
+    create(body: ClientSessionsCreateBody): Promise<ClientSessionsCreateResponse['client_session']>;
+    delete(body: ClientSessionsDeleteBody): Promise<void>;
+    get(body: ClientSessionsGetBody): Promise<ClientSessionsGetResponse['client_session']>;
+    grantAccess(body: ClientSessionsGrantAccessBody): Promise<ClientSessionsGrantAccessResponse['client_session']>;
+    list(body: ClientSessionsListBody): Promise<ClientSessionsListResponse['client_sessions']>;
+}
+type ClientSessionsCreateBody = SetNonNullable<Required<RouteRequestBody<'/client_sessions/create'>>>;
+type ClientSessionsCreateResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/create'>>>;
+type ClientSessionsDeleteBody = SetNonNullable<Required<RouteRequestBody<'/client_sessions/delete'>>>;
+type ClientSessionsGetBody = SetNonNullable<Required<RouteRequestBody<'/client_sessions/get'>>>;
+type ClientSessionsGetResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/get'>>>;
+type ClientSessionsGrantAccessBody = SetNonNullable<Required<RouteRequestBody<'/client_sessions/grant_access'>>>;
+type ClientSessionsGrantAccessResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/grant_access'>>>;
+type ClientSessionsListBody = SetNonNullable<Required<RouteRequestBody<'/client_sessions/list'>>>;
+type ClientSessionsListResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/list'>>>;
+
+declare class SeamHttpConnectWebviews {
+    client: Axios;
+    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;
+    create(body: ConnectWebviewsCreateBody): Promise<ConnectWebviewsCreateResponse['connect_webview']>;
+    delete(body: ConnectWebviewsDeleteBody): Promise<void>;
+    get(body: ConnectWebviewsGetBody): Promise<ConnectWebviewsGetResponse['connect_webview']>;
+    list(params?: ConnectWebviewsListParams): Promise<ConnectWebviewsListResponse['connect_webviews']>;
+    view(params?: ConnectWebviewsViewParams): Promise<void>;
+}
+type ConnectWebviewsCreateBody = SetNonNullable<Required<RouteRequestBody<'/connect_webviews/create'>>>;
+type ConnectWebviewsCreateResponse = SetNonNullable<Required<RouteResponse<'/connect_webviews/create'>>>;
+type ConnectWebviewsDeleteBody = SetNonNullable<Required<RouteRequestBody<'/connect_webviews/delete'>>>;
+type ConnectWebviewsGetBody = SetNonNullable<Required<RouteRequestBody<'/connect_webviews/get'>>>;
+type ConnectWebviewsGetResponse = SetNonNullable<Required<RouteResponse<'/connect_webviews/get'>>>;
+type ConnectWebviewsListParams = SetNonNullable<Required<RouteRequestParams<'/connect_webviews/list'>>>;
+type ConnectWebviewsListResponse = SetNonNullable<Required<RouteResponse<'/connect_webviews/list'>>>;
+type ConnectWebviewsViewParams = SetNonNullable<Required<RouteRequestParams<'/connect_webviews/view'>>>;
+
+declare class SeamHttpConnectedAccounts {
     client: Axios;
-    constructor(apiKeyOrOptionsOrClient: Axios | string | SeamHttpOptions);
+    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;
+    delete(body: ConnectedAccountsDeleteBody): Promise<void>;
+    get(body: ConnectedAccountsGetBody): Promise<ConnectedAccountsGetResponse['connected_account']>;
+    list(params?: ConnectedAccountsListParams): Promise<ConnectedAccountsListResponse['connected_accounts']>;
+}
+type ConnectedAccountsDeleteBody = SetNonNullable<Required<RouteRequestBody<'/connected_accounts/delete'>>>;
+type ConnectedAccountsGetBody = SetNonNullable<Required<RouteRequestBody<'/connected_accounts/get'>>>;
+type ConnectedAccountsGetResponse = SetNonNullable<Required<RouteResponse<'/connected_accounts/get'>>>;
+type ConnectedAccountsListParams = SetNonNullable<Required<RouteRequestParams<'/connected_accounts/list'>>>;
+type ConnectedAccountsListResponse = SetNonNullable<Required<RouteResponse<'/connected_accounts/list'>>>;
+
+declare class SeamHttpDevicesUnmanaged {
+    client: Axios;
+    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;
+    get(body: DevicesUnmanagedGetBody): Promise<DevicesUnmanagedGetResponse['device']>;
+    list(body: DevicesUnmanagedListBody): Promise<DevicesUnmanagedListResponse['devices']>;
+    update(body: DevicesUnmanagedUpdateBody): Promise<void>;
+}
+type DevicesUnmanagedGetBody = SetNonNullable<Required<RouteRequestBody<'/devices/unmanaged/get'>>>;
+type DevicesUnmanagedGetResponse = SetNonNullable<Required<RouteResponse<'/devices/unmanaged/get'>>>;
+type DevicesUnmanagedListBody = SetNonNullable<Required<RouteRequestBody<'/devices/unmanaged/list'>>>;
+type DevicesUnmanagedListResponse = SetNonNullable<Required<RouteResponse<'/devices/unmanaged/list'>>>;
+type DevicesUnmanagedUpdateBody = SetNonNullable<Required<RouteRequestBody<'/devices/unmanaged/update'>>>;
+
+declare class SeamHttpDevices {
+    client: Axios;
+    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;
+    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 = SetNonNullable<Required<RouteRequestBody<'/devices/delete'>>>;
+type DevicesGetBody = SetNonNullable<Required<RouteRequestBody<'/devices/get'>>>;
+type DevicesGetResponse = SetNonNullable<Required<RouteResponse<'/devices/get'>>>;
+type DevicesListBody = SetNonNullable<Required<RouteRequestBody<'/devices/list'>>>;
+type DevicesListResponse = SetNonNullable<Required<RouteResponse<'/devices/list'>>>;
+type DevicesListDeviceProvidersBody = SetNonNullable<Required<RouteRequestBody<'/devices/list_device_providers'>>>;
+type DevicesListDeviceProvidersResponse = SetNonNullable<Required<RouteResponse<'/devices/list_device_providers'>>>;
+type DevicesUpdateBody = SetNonNullable<Required<RouteRequestBody<'/devices/update'>>>;
+
+declare class SeamHttpEvents {
+    client: Axios;
+    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;
+    get(body: EventsGetBody): Promise<EventsGetResponse['event']>;
+    list(body: EventsListBody): Promise<EventsListResponse['events']>;
+}
+type EventsGetBody = SetNonNullable<Required<RouteRequestBody<'/events/get'>>>;
+type EventsGetResponse = SetNonNullable<Required<RouteResponse<'/events/get'>>>;
+type EventsListBody = SetNonNullable<Required<RouteRequestBody<'/events/list'>>>;
+type EventsListResponse = SetNonNullable<Required<RouteResponse<'/events/list'>>>;
+
+declare class SeamHttpLocks {
+    client: Axios;
+    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;
+    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 = SetNonNullable<Required<RouteRequestBody<'/locks/get'>>>;
+type LocksGetResponse = SetNonNullable<Required<RouteResponse<'/locks/get'>>>;
+type LocksListBody = SetNonNullable<Required<RouteRequestBody<'/locks/list'>>>;
+type LocksListResponse = SetNonNullable<Required<RouteResponse<'/locks/list'>>>;
+type LocksLockDoorBody = SetNonNullable<Required<RouteRequestBody<'/locks/lock_door'>>>;
+type LocksLockDoorResponse = SetNonNullable<Required<RouteResponse<'/locks/lock_door'>>>;
+type LocksUnlockDoorBody = SetNonNullable<Required<RouteRequestBody<'/locks/unlock_door'>>>;
+type LocksUnlockDoorResponse = SetNonNullable<Required<RouteResponse<'/locks/unlock_door'>>>;
+
+declare class SeamHttpNoiseSensorsNoiseThresholds {
+    client: Axios;
+    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;
+    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 = SetNonNullable<Required<RouteRequestBody<'/noise_sensors/noise_thresholds/create'>>>;
+type NoiseSensorsNoiseThresholdsDeleteBody = SetNonNullable<Required<RouteRequestBody<'/noise_sensors/noise_thresholds/delete'>>>;
+type NoiseSensorsNoiseThresholdsGetBody = SetNonNullable<Required<RouteRequestBody<'/noise_sensors/noise_thresholds/get'>>>;
+type NoiseSensorsNoiseThresholdsGetResponse = SetNonNullable<Required<RouteResponse<'/noise_sensors/noise_thresholds/get'>>>;
+type NoiseSensorsNoiseThresholdsListBody = SetNonNullable<Required<RouteRequestBody<'/noise_sensors/noise_thresholds/list'>>>;
+type NoiseSensorsNoiseThresholdsListResponse = SetNonNullable<Required<RouteResponse<'/noise_sensors/noise_thresholds/list'>>>;
+type NoiseSensorsNoiseThresholdsUpdateBody = SetNonNullable<Required<RouteRequestBody<'/noise_sensors/noise_thresholds/update'>>>;
+
+declare class SeamHttpNoiseSensors {
+    client: Axios;
+    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;
+    get noiseThresholds(): SeamHttpNoiseSensorsNoiseThresholds;
+}
+
+declare class SeamHttpThermostatsClimateSettingSchedules {
+    client: Axios;
+    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;
+    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 = SetNonNullable<Required<RouteRequestBody<'/thermostats/climate_setting_schedules/create'>>>;
+type ThermostatsClimateSettingSchedulesCreateResponse = SetNonNullable<Required<RouteResponse<'/thermostats/climate_setting_schedules/create'>>>;
+type ThermostatsClimateSettingSchedulesDeleteBody = SetNonNullable<Required<RouteRequestBody<'/thermostats/climate_setting_schedules/delete'>>>;
+type ThermostatsClimateSettingSchedulesGetBody = SetNonNullable<Required<RouteRequestBody<'/thermostats/climate_setting_schedules/get'>>>;
+type ThermostatsClimateSettingSchedulesGetResponse = SetNonNullable<Required<RouteResponse<'/thermostats/climate_setting_schedules/get'>>>;
+type ThermostatsClimateSettingSchedulesListBody = SetNonNullable<Required<RouteRequestBody<'/thermostats/climate_setting_schedules/list'>>>;
+type ThermostatsClimateSettingSchedulesListResponse = SetNonNullable<Required<RouteResponse<'/thermostats/climate_setting_schedules/list'>>>;
+type ThermostatsClimateSettingSchedulesUpdateBody = SetNonNullable<Required<RouteRequestBody<'/thermostats/climate_setting_schedules/update'>>>;
+
+declare class SeamHttpThermostats {
+    client: Axios;
+    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;
+    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 = SetNonNullable<Required<RouteRequestBody<'/thermostats/cool'>>>;
+type ThermostatsGetBody = SetNonNullable<Required<RouteRequestBody<'/thermostats/get'>>>;
+type ThermostatsGetResponse = SetNonNullable<Required<RouteResponse<'/thermostats/get'>>>;
+type ThermostatsHeatBody = SetNonNullable<Required<RouteRequestBody<'/thermostats/heat'>>>;
+type ThermostatsHeatCoolBody = SetNonNullable<Required<RouteRequestBody<'/thermostats/heat_cool'>>>;
+type ThermostatsListBody = SetNonNullable<Required<RouteRequestBody<'/thermostats/list'>>>;
+type ThermostatsListResponse = SetNonNullable<Required<RouteResponse<'/thermostats/list'>>>;
+type ThermostatsOffBody = SetNonNullable<Required<RouteRequestBody<'/thermostats/off'>>>;
+type ThermostatsSetFanModeBody = SetNonNullable<Required<RouteRequestBody<'/thermostats/set_fan_mode'>>>;
+type ThermostatsUpdateBody = SetNonNullable<Required<RouteRequestBody<'/thermostats/update'>>>;
+
+declare class SeamHttpWebhooks {
+    client: Axios;
+    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;
+    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 = SetNonNullable<Required<RouteRequestBody<'/webhooks/create'>>>;
+type WebhooksCreateResponse = SetNonNullable<Required<RouteResponse<'/webhooks/create'>>>;
+type WebhooksDeleteBody = SetNonNullable<Required<RouteRequestBody<'/webhooks/delete'>>>;
+type WebhooksGetBody = SetNonNullable<Required<RouteRequestBody<'/webhooks/get'>>>;
+type WebhooksGetResponse = SetNonNullable<Required<RouteResponse<'/webhooks/get'>>>;
+type WebhooksListParams = SetNonNullable<Required<RouteRequestParams<'/webhooks/list'>>>;
+type WebhooksListResponse = SetNonNullable<Required<RouteResponse<'/webhooks/list'>>>;
+
+declare class SeamHttpWorkspaces {
+    client: Axios;
+    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;
     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 WorkspacesGetResponse = SetNonNullable<Required<RouteResponse<'/workspaces/get'>>>;
+type WorkspacesListParams = SetNonNullable<Required<RouteRequestParams<'/workspaces/list'>>>;
+type WorkspacesListResponse = SetNonNullable<Required<RouteResponse<'/workspaces/list'>>>;
+type WorkspacesResetSandboxBody = SetNonNullable<Required<RouteRequestBody<'/workspaces/reset_sandbox'>>>;
 
 declare class SeamHttp {
-    #private;
     client: Axios;
     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;
+    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 };

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

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

package/lib/seam/connect/auth.js

@@ -1,4 +1,4 @@
-import { InvalidSeamHttpOptionsError, isSeamHttpOptionsWithApiKey, isSeamHttpOptionsWithClientSessionToken, } from './client-options.js';
+import { isSeamHttpOptionsWithApiKey, isSeamHttpOptionsWithClientSessionToken, SeamHttpInvalidOptionsError, } from './client-options.js';
 export const getAuthHeaders = (options) => {
     if (isSeamHttpOptionsWithApiKey(options)) {
         return getAuthHeadersForApiKey(options);
@@ -6,17 +6,17 @@ export const getAuthHeaders = (options) => {
     if (isSeamHttpOptionsWithClientSessionToken(options)) {
         return getAuthHeadersForClientSessionToken(options);
     }
-    throw new InvalidSeamHttpOptionsError('Must specify an apiKey or clientSessionToken');
+    throw new SeamHttpInvalidOptionsError('Must specify an apiKey or clientSessionToken');
 };
 const getAuthHeadersForApiKey = ({ apiKey, }) => {
     if (isClientSessionToken(apiKey)) {
-        throw new InvalidSeamTokenError('A Client Session Token cannot be used as an apiKey');
+        throw new SeamHttpInvalidTokenError('A Client Session Token cannot be used as an apiKey');
     }
     if (isAccessToken(apiKey)) {
-        throw new InvalidSeamTokenError('An access token cannot be used as an apiKey');
+        throw new SeamHttpInvalidTokenError('An access token cannot be used as an apiKey');
     }
     if (isJwt(apiKey) || !isSeamToken(apiKey)) {
-        throw new InvalidSeamTokenError(`Unknown or invalid apiKey format, expected token to start with ${tokenPrefix}`);
+        throw new SeamHttpInvalidTokenError(`Unknown or invalid apiKey format, expected token to start with ${tokenPrefix}`);
     }
     return {
         authorization: `Bearer ${apiKey}`,
@@ -24,14 +24,14 @@ const getAuthHeadersForApiKey = ({ apiKey, }) => {
 };
 const getAuthHeadersForClientSessionToken = ({ clientSessionToken, }) => {
     if (!isClientSessionToken(clientSessionToken)) {
-        throw new InvalidSeamTokenError(`Unknown or invalid clientSessionToken format, expected token to start with ${clientSessionTokenPrefix}`);
+        throw new SeamHttpInvalidTokenError(`Unknown or invalid clientSessionToken format, expected token to start with ${clientSessionTokenPrefix}`);
     }
     return {
         authorization: `Bearer ${clientSessionToken}`,
         'client-session-token': clientSessionToken,
     };
 };
-export class InvalidSeamTokenError extends Error {
+export class SeamHttpInvalidTokenError extends Error {
     constructor(message) {
         super(`SeamHttp received an invalid token: ${message}`);
         this.name = this.constructor.name;

package/lib/seam/connect/auth.js.map

@@ -1 +1 @@
-{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../../src/lib/seam/connect/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,2BAA2B,EAC3B,uCAAuC,GAIxC,MAAM,qBAAqB,CAAA;AAI5B,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,OAAwB,EAAW,EAAE;IAClE,IAAI,2BAA2B,CAAC,OAAO,CAAC,EAAE;QACxC,OAAO,uBAAuB,CAAC,OAAO,CAAC,CAAA;KACxC;IAED,IAAI,uCAAuC,CAAC,OAAO,CAAC,EAAE;QACpD,OAAO,mCAAmC,CAAC,OAAO,CAAC,CAAA;KACpD;IAED,MAAM,IAAI,2BAA2B,CACnC,8CAA8C,CAC/C,CAAA;AACH,CAAC,CAAA;AAED,MAAM,uBAAuB,GAAG,CAAC,EAC/B,MAAM,GACoB,EAAW,EAAE;IACvC,IAAI,oBAAoB,CAAC,MAAM,CAAC,EAAE;QAChC,MAAM,IAAI,qBAAqB,CAC7B,oDAAoD,CACrD,CAAA;KACF;IAED,IAAI,aAAa,CAAC,MAAM,CAAC,EAAE;QACzB,MAAM,IAAI,qBAAqB,CAC7B,6CAA6C,CAC9C,CAAA;KACF;IAED,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE;QACzC,MAAM,IAAI,qBAAqB,CAC7B,kEAAkE,WAAW,EAAE,CAChF,CAAA;KACF;IAED,OAAO;QACL,aAAa,EAAE,UAAU,MAAM,EAAE;KAClC,CAAA;AACH,CAAC,CAAA;AAED,MAAM,mCAAmC,GAAG,CAAC,EAC3C,kBAAkB,GACoB,EAAW,EAAE;IACnD,IAAI,CAAC,oBAAoB,CAAC,kBAAkB,CAAC,EAAE;QAC7C,MAAM,IAAI,qBAAqB,CAC7B,8EAA8E,wBAAwB,EAAE,CACzG,CAAA;KACF;IAED,OAAO;QACL,aAAa,EAAE,UAAU,kBAAkB,EAAE;QAC7C,sBAAsB,EAAE,kBAAkB;KAC3C,CAAA;AACH,CAAC,CAAA;AAED,MAAM,OAAO,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,OAAe;QACzB,KAAK,CAAC,uCAAuC,OAAO,EAAE,CAAC,CAAA;QACvD,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;AAED,MAAM,WAAW,GAAG,OAAO,CAAA;AAE3B,MAAM,wBAAwB,GAAG,UAAU,CAAA;AAE3C,MAAM,oBAAoB,GAAG,CAAC,KAAa,EAAW,EAAE,CACtD,KAAK,CAAC,UAAU,CAAC,wBAAwB,CAAC,CAAA;AAE5C,MAAM,aAAa,GAAG,CAAC,KAAa,EAAW,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,SAAS,CAAC,CAAA;AAE7E,MAAM,KAAK,GAAG,CAAC,KAAa,EAAW,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;AAEhE,MAAM,WAAW,GAAG,CAAC,KAAa,EAAW,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC,CAAA"}
+{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../../src/lib/seam/connect/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,uCAAuC,EACvC,2BAA2B,GAI5B,MAAM,qBAAqB,CAAA;AAI5B,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,OAAwB,EAAW,EAAE;IAClE,IAAI,2BAA2B,CAAC,OAAO,CAAC,EAAE;QACxC,OAAO,uBAAuB,CAAC,OAAO,CAAC,CAAA;KACxC;IAED,IAAI,uCAAuC,CAAC,OAAO,CAAC,EAAE;QACpD,OAAO,mCAAmC,CAAC,OAAO,CAAC,CAAA;KACpD;IAED,MAAM,IAAI,2BAA2B,CACnC,8CAA8C,CAC/C,CAAA;AACH,CAAC,CAAA;AAED,MAAM,uBAAuB,GAAG,CAAC,EAC/B,MAAM,GACoB,EAAW,EAAE;IACvC,IAAI,oBAAoB,CAAC,MAAM,CAAC,EAAE;QAChC,MAAM,IAAI,yBAAyB,CACjC,oDAAoD,CACrD,CAAA;KACF;IAED,IAAI,aAAa,CAAC,MAAM,CAAC,EAAE;QACzB,MAAM,IAAI,yBAAyB,CACjC,6CAA6C,CAC9C,CAAA;KACF;IAED,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE;QACzC,MAAM,IAAI,yBAAyB,CACjC,kEAAkE,WAAW,EAAE,CAChF,CAAA;KACF;IAED,OAAO;QACL,aAAa,EAAE,UAAU,MAAM,EAAE;KAClC,CAAA;AACH,CAAC,CAAA;AAED,MAAM,mCAAmC,GAAG,CAAC,EAC3C,kBAAkB,GACoB,EAAW,EAAE;IACnD,IAAI,CAAC,oBAAoB,CAAC,kBAAkB,CAAC,EAAE;QAC7C,MAAM,IAAI,yBAAyB,CACjC,8EAA8E,wBAAwB,EAAE,CACzG,CAAA;KACF;IAED,OAAO;QACL,aAAa,EAAE,UAAU,kBAAkB,EAAE;QAC7C,sBAAsB,EAAE,kBAAkB;KAC3C,CAAA;AACH,CAAC,CAAA;AAED,MAAM,OAAO,yBAA0B,SAAQ,KAAK;IAClD,YAAY,OAAe;QACzB,KAAK,CAAC,uCAAuC,OAAO,EAAE,CAAC,CAAA;QACvD,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;AAED,MAAM,WAAW,GAAG,OAAO,CAAA;AAE3B,MAAM,wBAAwB,GAAG,UAAU,CAAA;AAE3C,MAAM,oBAAoB,GAAG,CAAC,KAAa,EAAW,EAAE,CACtD,KAAK,CAAC,UAAU,CAAC,wBAAwB,CAAC,CAAA;AAE5C,MAAM,aAAa,GAAG,CAAC,KAAa,EAAW,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,SAAS,CAAC,CAAA;AAE7E,MAAM,KAAK,GAAG,CAAC,KAAa,EAAW,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;AAEhE,MAAM,WAAW,GAAG,CAAC,KAAa,EAAW,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC,CAAA"}

package/lib/seam/connect/axios.js

@@ -1,7 +1,9 @@
 import axios, {} from 'axios';
 import { getAuthHeaders } from './auth.js';
-import { isSeamHttpOptionsWithClientSessionToken, } from './client-options.js';
+import { isSeamHttpOptionsWithClient, isSeamHttpOptionsWithClientSessionToken, } from './client-options.js';
 export const createAxiosClient = (options) => {
+    if (isSeamHttpOptionsWithClient(options))
+        return options.client;
     // TODO: axiosRetry? Allow options to configure this if so
     return axios.create({
         baseURL: options.endpoint,

package/lib/seam/connect/axios.js.map

@@ -1 +1 @@
-{"version":3,"file":"axios.js","sourceRoot":"","sources":["../../../src/lib/seam/connect/axios.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAc,MAAM,OAAO,CAAA;AAEzC,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAC1C,OAAO,EACL,uCAAuC,GAExC,MAAM,qBAAqB,CAAA;AAE5B,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,OAAkC,EAC3B,EAAE;IACT,0DAA0D;IAC1D,OAAO,KAAK,CAAC,MAAM,CAAC;QAClB,OAAO,EAAE,OAAO,CAAC,QAAQ;QACzB,eAAe,EAAE,uCAAuC,CAAC,OAAO,CAAC;QACjE,GAAG,OAAO,CAAC,YAAY;QACvB,OAAO,EAAE;YACP,GAAG,cAAc,CAAC,OAAO,CAAC;YAC1B,GAAG,OAAO,CAAC,YAAY,CAAC,OAAO;YAC/B,mBAAmB;SACpB;KACF,CAAC,CAAA;AACJ,CAAC,CAAA"}
+{"version":3,"file":"axios.js","sourceRoot":"","sources":["../../../src/lib/seam/connect/axios.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAc,MAAM,OAAO,CAAA;AAEzC,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAC1C,OAAO,EACL,2BAA2B,EAC3B,uCAAuC,GAExC,MAAM,qBAAqB,CAAA;AAE5B,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,OAAkC,EAC3B,EAAE;IACT,IAAI,2BAA2B,CAAC,OAAO,CAAC;QAAE,OAAO,OAAO,CAAC,MAAM,CAAA;IAC/D,0DAA0D;IAC1D,OAAO,KAAK,CAAC,MAAM,CAAC;QAClB,OAAO,EAAE,OAAO,CAAC,QAAQ;QACzB,eAAe,EAAE,uCAAuC,CAAC,OAAO,CAAC;QACjE,GAAG,OAAO,CAAC,YAAY;QACvB,OAAO,EAAE;YACP,GAAG,cAAc,CAAC,OAAO,CAAC;YAC1B,GAAG,OAAO,CAAC,YAAY,CAAC,OAAO;YAC/B,mBAAmB;SACpB;KACF,CAAC,CAAA;AACJ,CAAC,CAAA"}

package/lib/seam/connect/client-options.d.ts

@@ -1,10 +1,14 @@
-import type { AxiosRequestConfig } from 'axios';
-export type SeamHttpOptions = SeamHttpOptionsWithApiKey | SeamHttpOptionsWithClientSessionToken;
+import type { Axios, AxiosRequestConfig } from 'axios';
+export type SeamHttpOptions = SeamHttpOptionsWithClient | SeamHttpOptionsWithApiKey | SeamHttpOptionsWithClientSessionToken;
 interface SeamHttpCommonOptions {
     endpoint?: string;
     axiosOptions?: AxiosRequestConfig;
     enableLegacyMethodBehaivor?: boolean;
 }
+export interface SeamHttpOptionsWithClient extends Pick<SeamHttpCommonOptions, 'enableLegacyMethodBehaivor'> {
+    client: Axios;
+}
+export declare const isSeamHttpOptionsWithClient: (options: SeamHttpOptions) => options is SeamHttpOptionsWithClient;
 export interface SeamHttpOptionsWithApiKey extends SeamHttpCommonOptions {
     apiKey: string;
 }
@@ -13,7 +17,7 @@ export interface SeamHttpOptionsWithClientSessionToken extends SeamHttpCommonOpt
     clientSessionToken: string;
 }
 export declare const isSeamHttpOptionsWithClientSessionToken: (options: SeamHttpOptions) => options is SeamHttpOptionsWithClientSessionToken;
-export declare class InvalidSeamHttpOptionsError extends Error {
+export declare class SeamHttpInvalidOptionsError extends Error {
     constructor(message: string);
 }
 export {};

package/lib/seam/connect/client-options.js

@@ -1,20 +1,35 @@
+export const isSeamHttpOptionsWithClient = (options) => {
+    if (!('client' in options))
+        return false;
+    if (options.client == null)
+        return false;
+    const keys = Object.keys(options).filter((k) => !['client', 'enableLegacyMethodBehaivor'].includes(k));
+    if (keys.length > 0) {
+        throw new SeamHttpInvalidOptionsError(`The client option cannot be used with any other option except enableLegacyMethodBehaivor, but received: ${keys.join(', ')}`);
+    }
+    return true;
+};
 export const isSeamHttpOptionsWithApiKey = (options) => {
     if (!('apiKey' in options))
         return false;
+    if (options.apiKey == null)
+        return false;
     if ('clientSessionToken' in options && options.clientSessionToken != null) {
-        throw new InvalidSeamHttpOptionsError('The clientSessionToken option cannot be used with the apiKey option.');
+        throw new SeamHttpInvalidOptionsError('The clientSessionToken option cannot be used with the apiKey option.');
     }
     return true;
 };
 export const isSeamHttpOptionsWithClientSessionToken = (options) => {
     if (!('clientSessionToken' in options))
         return false;
+    if (options.clientSessionToken == null)
+        return false;
     if ('apiKey' in options && options.apiKey != null) {
-        throw new InvalidSeamHttpOptionsError('The clientSessionToken option cannot be used with the apiKey option.');
+        throw new SeamHttpInvalidOptionsError('The clientSessionToken option cannot be used with the apiKey option.');
     }
     return true;
 };
-export class InvalidSeamHttpOptionsError extends Error {
+export class SeamHttpInvalidOptionsError extends Error {
     constructor(message) {
         super(`SeamHttp received invalid options: ${message}`);
         this.name = this.constructor.name;