@seamapi/http 0.1.0 → 0.2.0

package/dist/connect.d.cts

@@ -1,80 +1,98 @@
 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 = SeamHttpOptionsWithClient | SeamHttpOptionsWithApiKey | SeamHttpOptionsWithClientSessionToken;
-interface SeamHttpCommonOptions {
-    endpoint?: string;
+type Client = Axios;
+interface ClientOptions {
     axiosOptions?: AxiosRequestConfig;
-    enableLegacyMethodBehaivor?: boolean;
+    axiosRetryOptions?: AxiosRetryConfig;
+    client?: Client;
 }
-interface SeamHttpOptionsWithClient extends Pick<SeamHttpCommonOptions, 'enableLegacyMethodBehaivor'> {
-    client: Axios;
+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: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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 = 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 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 = SetNonNullable<Required<RouteRequestBody<'/access_codes/unmanaged/list'>>>;
+type AccessCodesUnmanagedListBody = RouteRequestBody<'/access_codes/unmanaged/list'>;
 type AccessCodesUnmanagedListResponse = SetNonNullable<Required<RouteResponse<'/access_codes/unmanaged/list'>>>;
-type AccessCodesUnmanagedUpdateBody = SetNonNullable<Required<RouteRequestBody<'/access_codes/unmanaged/update'>>>;
+type AccessCodesUnmanagedUpdateBody = RouteRequestBody<'/access_codes/unmanaged/update'>;
 
 declare class SeamHttpAccessCodes {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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(params?: AccessCodesGenerateCodeParams): Promise<AccessCodesGenerateCodeResponse['generated_code']>;
+    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 = SetNonNullable<Required<RouteRequestBody<'/access_codes/create'>>>;
+type AccessCodesCreateBody = RouteRequestBody<'/access_codes/create'>;
 type AccessCodesCreateResponse = SetNonNullable<Required<RouteResponse<'/access_codes/create'>>>;
-type AccessCodesCreateMultipleBody = SetNonNullable<Required<RouteRequestBody<'/access_codes/create_multiple'>>>;
+type AccessCodesCreateMultipleBody = 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 AccessCodesDeleteBody = RouteRequestBody<'/access_codes/delete'>;
+type AccessCodesGenerateCodeBody = RouteRequestBody<'/access_codes/generate_code'>;
 type AccessCodesGenerateCodeResponse = SetNonNullable<Required<RouteResponse<'/access_codes/generate_code'>>>;
-type AccessCodesGetBody = SetNonNullable<Required<RouteRequestBody<'/access_codes/get'>>>;
+type AccessCodesGetBody = RouteRequestBody<'/access_codes/get'>;
 type AccessCodesGetResponse = SetNonNullable<Required<RouteResponse<'/access_codes/get'>>>;
-type AccessCodesListBody = SetNonNullable<Required<RouteRequestBody<'/access_codes/list'>>>;
+type AccessCodesListBody = RouteRequestBody<'/access_codes/list'>;
 type AccessCodesListResponse = SetNonNullable<Required<RouteResponse<'/access_codes/list'>>>;
-type AccessCodesPullBackupAccessCodeBody = SetNonNullable<Required<RouteRequestBody<'/access_codes/pull_backup_access_code'>>>;
+type AccessCodesPullBackupAccessCodeBody = 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'>>>;
+type AccessCodesUpdateBody = RouteRequestBody<'/access_codes/update'>;
 
 declare class SeamHttpAcsAccessGroups {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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>;
@@ -84,83 +102,91 @@ declare class SeamHttpAcsAccessGroups {
     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 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 = SetNonNullable<Required<RouteRequestBody<'/acs/access_groups/delete'>>>;
-type AcsAccessGroupsGetBody = SetNonNullable<Required<RouteRequestBody<'/acs/access_groups/get'>>>;
+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 = SetNonNullable<Required<RouteRequestBody<'/acs/access_groups/list'>>>;
+type AcsAccessGroupsListBody = 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 AcsAccessGroupsListUsersBody = 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'>>>;
+type AcsAccessGroupsRemoveUserBody = RouteRequestBody<'/acs/access_groups/remove_user'>;
+type AcsAccessGroupsUpdateBody = RouteRequestBody<'/acs/access_groups/update'>;
 
 declare class SeamHttpAcsCredentials {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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 = SetNonNullable<Required<RouteRequestBody<'/acs/credentials/create'>>>;
+type AcsCredentialsCreateBody = 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 AcsCredentialsDeleteBody = RouteRequestBody<'/acs/credentials/delete'>;
+type AcsCredentialsGetBody = RouteRequestBody<'/acs/credentials/get'>;
 type AcsCredentialsGetResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/get'>>>;
-type AcsCredentialsListBody = SetNonNullable<Required<RouteRequestBody<'/acs/credentials/list'>>>;
+type AcsCredentialsListBody = RouteRequestBody<'/acs/credentials/list'>;
 type AcsCredentialsListResponse = SetNonNullable<Required<RouteResponse<'/acs/credentials/list'>>>;
 
 declare class SeamHttpAcsSystems {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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(params?: AcsSystemsListParams): Promise<AcsSystemsListResponse['acs_systems']>;
+    list(body: AcsSystemsListBody): Promise<AcsSystemsListResponse['acs_systems']>;
 }
-type AcsSystemsGetBody = SetNonNullable<Required<RouteRequestBody<'/acs/systems/get'>>>;
+type AcsSystemsGetBody = RouteRequestBody<'/acs/systems/get'>;
 type AcsSystemsGetResponse = SetNonNullable<Required<RouteResponse<'/acs/systems/get'>>>;
-type AcsSystemsListParams = SetNonNullable<Required<RouteRequestParams<'/acs/systems/list'>>>;
+type AcsSystemsListBody = RouteRequestBody<'/acs/systems/list'>;
 type AcsSystemsListResponse = SetNonNullable<Required<RouteResponse<'/acs/systems/list'>>>;
 
 declare class SeamHttpAcsUsers {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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 = SetNonNullable<Required<RouteRequestBody<'/acs/users/add_to_access_group'>>>;
-type AcsUsersCreateBody = SetNonNullable<Required<RouteRequestBody<'/acs/users/create'>>>;
+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 = SetNonNullable<Required<RouteRequestBody<'/acs/users/delete'>>>;
-type AcsUsersGetBody = SetNonNullable<Required<RouteRequestBody<'/acs/users/get'>>>;
+type AcsUsersDeleteBody = RouteRequestBody<'/acs/users/delete'>;
+type AcsUsersGetBody = RouteRequestBody<'/acs/users/get'>;
 type AcsUsersGetResponse = SetNonNullable<Required<RouteResponse<'/acs/users/get'>>>;
-type AcsUsersListBody = SetNonNullable<Required<RouteRequestBody<'/acs/users/list'>>>;
+type AcsUsersListBody = 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'>>>;
+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: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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;
@@ -168,100 +194,109 @@ declare class SeamHttpAcs {
 }
 
 declare class SeamHttpActionAttempts {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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 = SetNonNullable<Required<RouteRequestBody<'/action_attempts/get'>>>;
+type ActionAttemptsGetBody = RouteRequestBody<'/action_attempts/get'>;
 type ActionAttemptsGetResponse = SetNonNullable<Required<RouteResponse<'/action_attempts/get'>>>;
-type ActionAttemptsListBody = SetNonNullable<Required<RouteRequestBody<'/action_attempts/list'>>>;
+type ActionAttemptsListBody = RouteRequestBody<'/action_attempts/list'>;
 type ActionAttemptsListResponse = SetNonNullable<Required<RouteResponse<'/action_attempts/list'>>>;
 
 declare class SeamHttpClientSessions {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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 = SetNonNullable<Required<RouteRequestBody<'/client_sessions/create'>>>;
+type ClientSessionsCreateBody = 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 ClientSessionsDeleteBody = RouteRequestBody<'/client_sessions/delete'>;
+type ClientSessionsGetBody = RouteRequestBody<'/client_sessions/get'>;
 type ClientSessionsGetResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/get'>>>;
-type ClientSessionsGrantAccessBody = SetNonNullable<Required<RouteRequestBody<'/client_sessions/grant_access'>>>;
+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 = SetNonNullable<Required<RouteRequestBody<'/client_sessions/list'>>>;
+type ClientSessionsListBody = RouteRequestBody<'/client_sessions/list'>;
 type ClientSessionsListResponse = SetNonNullable<Required<RouteResponse<'/client_sessions/list'>>>;
 
 declare class SeamHttpConnectWebviews {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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(params?: ConnectWebviewsListParams): Promise<ConnectWebviewsListResponse['connect_webviews']>;
+    list(body: ConnectWebviewsListBody): Promise<ConnectWebviewsListResponse['connect_webviews']>;
     view(params?: ConnectWebviewsViewParams): Promise<void>;
 }
-type ConnectWebviewsCreateBody = SetNonNullable<Required<RouteRequestBody<'/connect_webviews/create'>>>;
+type ConnectWebviewsCreateBody = 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 ConnectWebviewsDeleteBody = RouteRequestBody<'/connect_webviews/delete'>;
+type ConnectWebviewsGetBody = RouteRequestBody<'/connect_webviews/get'>;
 type ConnectWebviewsGetResponse = SetNonNullable<Required<RouteResponse<'/connect_webviews/get'>>>;
-type ConnectWebviewsListParams = SetNonNullable<Required<RouteRequestParams<'/connect_webviews/list'>>>;
+type ConnectWebviewsListBody = RouteRequestBody<'/connect_webviews/list'>;
 type ConnectWebviewsListResponse = SetNonNullable<Required<RouteResponse<'/connect_webviews/list'>>>;
-type ConnectWebviewsViewParams = SetNonNullable<Required<RouteRequestParams<'/connect_webviews/view'>>>;
+type ConnectWebviewsViewParams = RouteRequestParams<'/connect_webviews/view'>;
 
 declare class SeamHttpConnectedAccounts {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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 = SetNonNullable<Required<RouteRequestBody<'/connected_accounts/delete'>>>;
-type ConnectedAccountsGetBody = SetNonNullable<Required<RouteRequestBody<'/connected_accounts/get'>>>;
+type ConnectedAccountsDeleteBody = RouteRequestBody<'/connected_accounts/delete'>;
+type ConnectedAccountsGetBody = RouteRequestBody<'/connected_accounts/get'>;
 type ConnectedAccountsGetResponse = SetNonNullable<Required<RouteResponse<'/connected_accounts/get'>>>;
-type ConnectedAccountsListParams = SetNonNullable<Required<RouteRequestParams<'/connected_accounts/list'>>>;
+type ConnectedAccountsListParams = RouteRequestParams<'/connected_accounts/list'>;
 type ConnectedAccountsListResponse = SetNonNullable<Required<RouteResponse<'/connected_accounts/list'>>>;
 
 declare class SeamHttpDevicesUnmanaged {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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 = SetNonNullable<Required<RouteRequestBody<'/devices/unmanaged/get'>>>;
+type DevicesUnmanagedGetBody = RouteRequestBody<'/devices/unmanaged/get'>;
 type DevicesUnmanagedGetResponse = SetNonNullable<Required<RouteResponse<'/devices/unmanaged/get'>>>;
-type DevicesUnmanagedListBody = SetNonNullable<Required<RouteRequestBody<'/devices/unmanaged/list'>>>;
+type DevicesUnmanagedListBody = RouteRequestBody<'/devices/unmanaged/list'>;
 type DevicesUnmanagedListResponse = SetNonNullable<Required<RouteResponse<'/devices/unmanaged/list'>>>;
-type DevicesUnmanagedUpdateBody = SetNonNullable<Required<RouteRequestBody<'/devices/unmanaged/update'>>>;
+type DevicesUnmanagedUpdateBody = RouteRequestBody<'/devices/unmanaged/update'>;
 
 declare class SeamHttpDevices {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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']>;
@@ -269,105 +304,111 @@ declare class SeamHttpDevices {
     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 DevicesDeleteBody = RouteRequestBody<'/devices/delete'>;
+type DevicesGetBody = RouteRequestBody<'/devices/get'>;
 type DevicesGetResponse = SetNonNullable<Required<RouteResponse<'/devices/get'>>>;
-type DevicesListBody = SetNonNullable<Required<RouteRequestBody<'/devices/list'>>>;
+type DevicesListBody = RouteRequestBody<'/devices/list'>;
 type DevicesListResponse = SetNonNullable<Required<RouteResponse<'/devices/list'>>>;
-type DevicesListDeviceProvidersBody = SetNonNullable<Required<RouteRequestBody<'/devices/list_device_providers'>>>;
+type DevicesListDeviceProvidersBody = RouteRequestBody<'/devices/list_device_providers'>;
 type DevicesListDeviceProvidersResponse = SetNonNullable<Required<RouteResponse<'/devices/list_device_providers'>>>;
-type DevicesUpdateBody = SetNonNullable<Required<RouteRequestBody<'/devices/update'>>>;
+type DevicesUpdateBody = RouteRequestBody<'/devices/update'>;
 
 declare class SeamHttpEvents {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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 = SetNonNullable<Required<RouteRequestBody<'/events/get'>>>;
+type EventsGetBody = RouteRequestBody<'/events/get'>;
 type EventsGetResponse = SetNonNullable<Required<RouteResponse<'/events/get'>>>;
-type EventsListBody = SetNonNullable<Required<RouteRequestBody<'/events/list'>>>;
+type EventsListBody = RouteRequestBody<'/events/list'>;
 type EventsListResponse = SetNonNullable<Required<RouteResponse<'/events/list'>>>;
 
 declare class SeamHttpLocks {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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 = SetNonNullable<Required<RouteRequestBody<'/locks/get'>>>;
+type LocksGetBody = RouteRequestBody<'/locks/get'>;
 type LocksGetResponse = SetNonNullable<Required<RouteResponse<'/locks/get'>>>;
-type LocksListBody = SetNonNullable<Required<RouteRequestBody<'/locks/list'>>>;
+type LocksListBody = RouteRequestBody<'/locks/list'>;
 type LocksListResponse = SetNonNullable<Required<RouteResponse<'/locks/list'>>>;
-type LocksLockDoorBody = SetNonNullable<Required<RouteRequestBody<'/locks/lock_door'>>>;
+type LocksLockDoorBody = RouteRequestBody<'/locks/lock_door'>;
 type LocksLockDoorResponse = SetNonNullable<Required<RouteResponse<'/locks/lock_door'>>>;
-type LocksUnlockDoorBody = SetNonNullable<Required<RouteRequestBody<'/locks/unlock_door'>>>;
+type LocksUnlockDoorBody = RouteRequestBody<'/locks/unlock_door'>;
 type LocksUnlockDoorResponse = SetNonNullable<Required<RouteResponse<'/locks/unlock_door'>>>;
 
 declare class SeamHttpNoiseSensorsNoiseThresholds {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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 = 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 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 = SetNonNullable<Required<RouteRequestBody<'/noise_sensors/noise_thresholds/list'>>>;
+type NoiseSensorsNoiseThresholdsListBody = 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'>>>;
+type NoiseSensorsNoiseThresholdsUpdateBody = RouteRequestBody<'/noise_sensors/noise_thresholds/update'>;
 
 declare class SeamHttpNoiseSensors {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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 = SetNonNullable<Required<RouteRequestBody<'/thermostats/climate_setting_schedules/create'>>>;
+type ThermostatsClimateSettingSchedulesCreateBody = 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 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 = SetNonNullable<Required<RouteRequestBody<'/thermostats/climate_setting_schedules/list'>>>;
+type ThermostatsClimateSettingSchedulesListBody = 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'>>>;
+type ThermostatsClimateSettingSchedulesUpdateBody = RouteRequestBody<'/thermostats/climate_setting_schedules/update'>;
 
 declare class SeamHttpThermostats {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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']>;
@@ -378,58 +419,61 @@ declare class SeamHttpThermostats {
     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 ThermostatsCoolBody = RouteRequestBody<'/thermostats/cool'>;
+type ThermostatsGetBody = 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 ThermostatsHeatBody = RouteRequestBody<'/thermostats/heat'>;
+type ThermostatsHeatCoolBody = RouteRequestBody<'/thermostats/heat_cool'>;
+type ThermostatsListBody = 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'>>>;
+type ThermostatsOffBody = RouteRequestBody<'/thermostats/off'>;
+type ThermostatsSetFanModeBody = RouteRequestBody<'/thermostats/set_fan_mode'>;
+type ThermostatsUpdateBody = RouteRequestBody<'/thermostats/update'>;
 
 declare class SeamHttpWebhooks {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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 = SetNonNullable<Required<RouteRequestBody<'/webhooks/create'>>>;
+type WebhooksCreateBody = 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 WebhooksDeleteBody = RouteRequestBody<'/webhooks/delete'>;
+type WebhooksGetBody = RouteRequestBody<'/webhooks/get'>;
 type WebhooksGetResponse = SetNonNullable<Required<RouteResponse<'/webhooks/get'>>>;
-type WebhooksListParams = SetNonNullable<Required<RouteRequestParams<'/webhooks/list'>>>;
+type WebhooksListParams = RouteRequestParams<'/webhooks/list'>;
 type WebhooksListResponse = SetNonNullable<Required<RouteResponse<'/webhooks/list'>>>;
 
 declare class SeamHttpWorkspaces {
-    client: Axios;
-    constructor(apiKeyOrOptions: string | SeamHttpOptions);
+    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 = SetNonNullable<Required<RouteRequestParams<'/workspaces/list'>>>;
+type WorkspacesListParams = RouteRequestParams<'/workspaces/list'>;
 type WorkspacesListResponse = SetNonNullable<Required<RouteResponse<'/workspaces/list'>>>;
-type WorkspacesResetSandboxBody = SetNonNullable<Required<RouteRequestBody<'/workspaces/reset_sandbox'>>>;
+type WorkspacesResetSandboxBody = RouteRequestBody<'/workspaces/reset_sandbox'>;
 
 declare class SeamHttp {
-    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;
+    static fromPublishableKey(publishableKey: string, userIdentifierKey: string, options?: SeamHttpFromPublishableKeyOptions): Promise<SeamHttp>;
     get accessCodes(): SeamHttpAccessCodes;
     get acs(): SeamHttpAcs;
     get actionAttempts(): SeamHttpActionAttempts;
@@ -445,4 +489,4 @@ declare class SeamHttp {
     get workspaces(): SeamHttpWorkspaces;
 }
 
-export { SeamHttp };
+export { SeamHttp, SeamHttpFromPublishableKeyOptions, SeamHttpInvalidOptionsError, SeamHttpOptions, SeamHttpOptionsFromEnv, SeamHttpOptionsWithApiKey, SeamHttpOptionsWithClient, SeamHttpOptionsWithClientSessionToken, isSeamHttpOptionsWithApiKey, isSeamHttpOptionsWithClient, isSeamHttpOptionsWithClientSessionToken };