Class ScuteClient

Hierarchy

ScuteBaseHttp<this> & ScuteSession<this>
- ScuteClient

Index

Constructors

Properties

admin appData appId autoRefreshTicker channel config emitter getCurrentUserDeferred initializeDeferred instanceID logDebugMessages refreshDeferred refreshProxyCallback scuteStorage visibilityChangedCallback wretcher nextInstanceID

Methods

_addDevice _confirmInvite _getAuthToken _getCurrentUser _getCurrentUserRequest _getSession _identifierExists _initialize _initializeAppData _refreshRequest _revokeSession _sendLoginMagicLink _sendMagicLinkRequest _sendRegisterMagicLink _setupSessionBroadcast _signIn _signInWithVerifyDevice _signOut _signUp _updateUserMeta _userSessionsRequest _verifyMagicLinkTokenRequest _webauthnDeviceRegisterFinalizeRequest _webauthnDeviceRegisterInitializeRequest _webauthnFinalizeLoginRequest _webauthnInitializeLoginRequest _webauthnIsNewDevice addDevice clearRememberedIdentifier confirmInvite debug delete deleteCredentialId emitAuthChangeEvent get getAppData getAuthToken getCredentialIds getCurrentUser getMagicLinkStatus getMagicLinkToken getRememberedIdentifier getSession getUser identifierExists initialSessionState isAnyDeviceRegistered isWebauthnSupported listUserSessions onAuthStateChange patch post put refetchSession refreshSession registerRefetchInterval registerVisibilityChange removeSession revokeSession sendLoginMagicLink sendRegisterMagicLink setRefreshProxyCallback setRememberedIdentifier setSession signIn signInOrUp signInWithMagicLink signInWithMagicLinkId signInWithMagicLinkToken signInWithRegisterDevice signInWithTokenPayload signInWithVerifyDevice signOut signUp startAutoRefresh stopAutoRefresh storeCredentialId updateUserMeta verifyMagicLink verifyMagicLinkToken webauthnFinalizeLogin webauthnFinalizeRegister webauthnInitializeLogin webauthnInitializeRegister

Constructors

constructor

new ScuteClient(config): ScuteClient
Parameters
- config: ScuteClientConfig
Returns ScuteClient
Overrides Mixin(ScuteBaseHttp, ScuteSession).constructor
- Defined in packages/auth/core/src/ScuteClient.ts:104

Properties

`Protected` autoRefreshTicker

autoRefreshTicker: null | Timer = null

`Protected` `Readonly` channel

channel: null | BroadcastChannel = null

`Protected` `Readonly` config

config: {
    autoRefreshToken: boolean;
    persistSession: undefined | boolean;
    refetchInverval: undefined | number;
    refetchOnWindowFocus: undefined | boolean;
}

Type declaration

autoRefreshToken: boolean
persistSession: undefined | boolean
refetchInverval: undefined | number
refetchOnWindowFocus: undefined | boolean

`Protected` `Readonly` emitter

emitter: Emitter<InternalEvent>

`Protected` getCurrentUserDeferred

getCurrentUserDeferred: null | Deferred<{
    data: {
        user: null;
    };
    error: BaseHttpError | InvalidAuthTokenError;
} | {
    data: {
        user: ScuteUserData;
    };
    error: null;
}> = null

`Protected` initializeDeferred

initializeDeferred: null | Deferred<{
error: null | ScuteError;
}> = null

`Private` instanceID

instanceID: number = 0

`Protected` logDebugMessages

logDebugMessages: boolean = false

`Protected` refreshDeferred

refreshDeferred: null | Deferred<{
    data: null;
    error: BaseHttpError;
} | {
    data: Session;
    error: null;
}> = null

`Protected` refreshProxyCallback

refreshProxyCallback: null | (() => Promise<void | Partial<ScuteTokenPayload>>) = null

Type declaration

- (): Promise<void | Partial<ScuteTokenPayload>>
- Returns Promise<void | Partial<ScuteTokenPayload>>

`Protected` `Readonly` scuteStorage

scuteStorage: ScuteStorage | ScuteCookieStorage

`Protected` visibilityChangedCallback

visibilityChangedCallback: null | (() => Promise<any>) = null

Type declaration

- (): Promise<any>
- Returns Promise<any>

`Protected` wretcher

wretcher: Wretch<unknown, unknown, undefined>

`Private` `Static` nextInstanceID

nextInstanceID: number = 0

Methods

`Private` _addDevice

_addDevice(accessToken): Promise<{
    data: null;
    error: Error | WebAuthnError;
} | {
    data: ScuteUserSession;
    error: null;
}>
Internal
Parameters
- accessToken: string
  
  Auth token
Returns Promise<{
    data: null;
    error: Error | WebAuthnError;
} | {
    data: ScuteUserSession;
    error: null;
}>

See
addDevice
- Defined in packages/auth/core/src/ScuteClient.ts:584

`Protected` _confirmInvite

_confirmInvite(token, userMeta?): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteTokenPayload;
    error: null;
}>
Confirm invite.
Parameters
- token: string
  
  Magic link token
- Optional userMeta: Metadata
  
  {UserMeta} Meta fields
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteTokenPayload;
    error: null;
}>

See
confirmInvite
- Defined in packages/auth/core/src/ScuteClient.ts:1190

`Protected` _getAuthToken

_getAuthToken(session): Promise<{
    data: null;
    error: InvalidAuthTokenError;
} | {
    data: {
        access: string;
    };
    error: null;
}>
Internal
Get access token from the current session.
Parameters
- session: Session
  
  {Session}
Returns Promise<{
    data: null;
    error: InvalidAuthTokenError;
} | {
    data: {
        access: string;
    };
    error: null;
}>

See
getAuthToken
Inherited from Mixin(ScuteBaseHttp, ScuteSession)._getAuthToken
- Defined in packages/auth/core/src/lib/ScuteSession.ts:405

`Private` _getCurrentUser

_getCurrentUser(accessToken): Promise<{
    data: {
        user: null;
    };
    error: BaseHttpError | InvalidAuthTokenError;
} | {
    data: {
        user: ScuteUserData;
    };
    error: null;
}>
Internal
Parameters
- accessToken: string
  
  Auth token
Returns Promise<{
    data: {
        user: null;
    };
    error: BaseHttpError | InvalidAuthTokenError;
} | {
    data: {
        user: ScuteUserData;
    };
    error: null;
}>

See
getCurrentUser
- Defined in packages/auth/core/src/ScuteClient.ts:795

`Private` _getCurrentUserRequest

_getCurrentUserRequest(accessToken): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: {
        user: null | ScuteUserData;
    };
    error: null;
}>
Internal
Parameters
- accessToken: string
  
  Auth token
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: {
        user: null | ScuteUserData;
    };
    error: null;
}>

See
getUser
- Defined in packages/auth/core/src/ScuteClient.ts:813

`Protected` _getSession

_getSession(fresh?, emitRefetchEvent?): Promise<{
    data: {
        session: Session;
        user: null;
    };
    error: InvalidAuthTokenError;
} | {
    data: {
        session: Session;
        user: ScuteUserData;
    };
    error: null;
} | {
    data: {
        session: null;
        user: null;
    };
    error: ScuteError;
} | {
    data: {
        session: Session;
        user: null;
    };
    error: null;
}>
Internal
- fresh needs to be set to true to get the latest data from the server.
Parameters
- Optional fresh: boolean
  
  Fetch new data from the server
- emitRefetchEvent: boolean = true
  
  Emit refetch event when getting fresh data
Returns Promise<{
    data: {
        session: Session;
        user: null;
    };
    error: InvalidAuthTokenError;
} | {
    data: {
        session: Session;
        user: ScuteUserData;
    };
    error: null;
} | {
    data: {
        session: null;
        user: null;
    };
    error: ScuteError;
} | {
    data: {
        session: Session;
        user: null;
    };
    error: null;
}>

See
getSession
Inherited from Mixin(ScuteBaseHttp, ScuteSession)._getSession
- Defined in packages/auth/core/src/lib/ScuteSession.ts:87

`Protected` _identifierExists

_identifierExists(identifier): Promise<{
    data: null;
    error: TechnicalError;
} | {
    data: {
        user: null | ScuteUser;
    };
    error: null;
}>
Internal
Parameters
- identifier: string
Returns Promise<{
    data: null;
    error: TechnicalError;
} | {
    data: {
        user: null | ScuteUser;
    };
    error: null;
}>

See
identifierExists
- Defined in packages/auth/core/src/ScuteClient.ts:733

`Protected` _initialize

_initialize(): Promise<{
error: null | ScuteError;
}>
Internal
Initializes the client SDK (making sure it is initialized only once).

Returns Promise<{
error: null | ScuteError;
}>
Overrides Mixin(ScuteBaseHttp, ScuteSession)._initialize
- Defined in packages/auth/core/src/ScuteClient.ts:176

`Private` _initializeAppData

_initializeAppData(fresh?): Promise<{
error: BaseHttpError;
} | {
error: null;
}>
Internal
Parameters
- fresh: boolean = false
  
  fetch new data from the server
Returns Promise<{
error: BaseHttpError;
} | {
error: null;
}>

See
getAppData
- Defined in packages/auth/core/src/ScuteClient.ts:242

`Protected` _refreshRequest

_refreshRequest(jwt): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteTokenPayload;
    error: null;
}>
Internal
Parameters
- jwt: string
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteTokenPayload;
    error: null;
}>

See
refreshSession
Overrides Mixin(ScuteBaseHttp, ScuteSession)._refreshRequest
- Defined in packages/auth/core/src/ScuteClient.ts:1270

`Protected` _revokeSession

_revokeSession(id, accessToken): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: any;
    error: null;
}>
Revoke session.
Parameters
- id: UniqueIdentifier
  
  Session ID
- accessToken: string
  
  Access Token
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: any;
    error: null;
}>

See
revokeSession
- Defined in packages/auth/core/src/ScuteClient.ts:1238

`Private` _sendLoginMagicLink

_sendLoginMagicLink(identifier, webauthnEnabled?): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteMagicLinkIdResponse;
    error: null;
}>
Internal
Send login magic link.
Parameters
- identifier: string
  
  {ScuteIdentifier}
- Optional webauthnEnabled: boolean
  
  {boolean}
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteMagicLinkIdResponse;
    error: null;
}>

See
sendLoginMagicLink
- Defined in packages/auth/core/src/ScuteClient.ts:1054

`Private` _sendMagicLinkRequest

_sendMagicLinkRequest(identifier, method?, userMeta?, webauthnEnabled?): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteMagicLinkIdResponse;
    error: null;
}>
Internal
Send magic link request.
Parameters
- identifier: string
- method: "register" | "login" = "login"
- Optional userMeta: Metadata
- webauthnEnabled: boolean = ...
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteMagicLinkIdResponse;
    error: null;
}>
See
- sendLoginMagicLink
- sendRegisterMagicLink
- Defined in packages/auth/core/src/ScuteClient.ts:1122

`Private` _sendRegisterMagicLink

_sendRegisterMagicLink(identifier, userMeta?, webauthnEnabled?): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteMagicLinkIdResponse;
    error: null;
}>
Internal
Send register magic link.
Parameters
- identifier: string
  
  {ScuteIdentifier}
- Optional userMeta: Metadata
  
  {UserMeta}
- Optional webauthnEnabled: boolean
  
  {boolean}
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteMagicLinkIdResponse;
    error: null;
}>

See
sendRegisterMagicLink
- Defined in packages/auth/core/src/ScuteClient.ts:1103

`Private` _setupSessionBroadcast

_setupSessionBroadcast(): void
Internal
Initializes broadcast channel for other tabs listening.

Returns void
- Defined in packages/auth/core/src/ScuteClient.ts:259

`Private` _signIn

_signIn(identifier, user, options?): Promise<{
    data: ScuteMagicLinkIdResponse;
    error: null;
} | {
    data: null;
    error: Error | WebAuthnError;
} | {
    data: null;
    error: null;
}>
Internal
Log in.
Parameters
- identifier: string
- user: ScuteUser
- Optional options: ScuteSignInOptions
Returns Promise<{
    data: ScuteMagicLinkIdResponse;
    error: null;
} | {
    data: null;
    error: Error | WebAuthnError;
} | {
    data: null;
    error: null;
}>

See
signIn
- Defined in packages/auth/core/src/ScuteClient.ts:394

`Private` _signInWithVerifyDevice

_signInWithVerifyDevice(identifier, userId): Promise<{
error: null;
} | {
error: Error | WebAuthnError;
}>
Internal
Parameters
- identifier: string
  
  {ScuteIdentifier}
- userId: UniqueIdentifier
  
  {UniqueIdentifier}
Returns Promise<{
error: null;
} | {
error: Error | WebAuthnError;
}>

See
signInWithVerifyDevice
- Defined in packages/auth/core/src/ScuteClient.ts:638

`Protected` _signOut

_signOut(accessToken?): Promise<boolean>
Internal
Sign out.
Parameters
- Optional accessToken: null | string
Returns Promise<boolean>

See
signOut
Inherited from Mixin(ScuteBaseHttp, ScuteSession)._signOut
- Defined in packages/auth/core/src/lib/ScuteSession.ts:361

`Private` _signUp

_signUp(identifier, options?): Promise<{
    data: ScuteMagicLinkIdResponse;
    error: null;
} | {
    data: null;
    error: BaseHttpError;
}>
Internal
Creates a user.
Parameters
- identifier: string
- Optional options: ScuteSignUpOptions
Returns Promise<{
    data: ScuteMagicLinkIdResponse;
    error: null;
} | {
    data: null;
    error: BaseHttpError;
}>

See
signUp
- Defined in packages/auth/core/src/ScuteClient.ts:454

`Protected` _updateUserMeta

_updateUserMeta(meta, accessToken): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: {
        user: ScuteUserData;
    };
    error: null;
}>
Update user meta.
Parameters
- meta: Metadata
  
  {UserMeta} - Meta fields
- accessToken: string
  
  Access Token
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: {
        user: ScuteUserData;
    };
    error: null;
}>

See
updateUserMeta
- Defined in packages/auth/core/src/ScuteClient.ts:1165

`Protected` _userSessionsRequest

_userSessionsRequest(accessToken): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteUserSession[];
    error: null;
}>
Get all user sessions.
Parameters
- accessToken: string
  
  Access Token
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteUserSession[];
    error: null;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:1259

`Private` _verifyMagicLinkTokenRequest

_verifyMagicLinkTokenRequest(token): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteTokenPayload;
    error: null;
}>
Internal
Verify magic link token
Parameters
- token: string
  
  Magic link token (sct_magic)
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteTokenPayload;
    error: null;
}>

See
verifyMagicLinkToken
- Defined in packages/auth/core/src/ScuteClient.ts:559

`Private` _webauthnDeviceRegisterFinalizeRequest

_webauthnDeviceRegisterFinalizeRequest(credential, accessToken): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteUserSession;
    error: null;
}>
Internal
Parameters
- credential: PublicKeyCredentialWithAttestationJSON
  
  Credential Attestation
- accessToken: string
  
  Auth token
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteUserSession;
    error: null;
}>

See
webauthnFinalizeRegister
- Defined in packages/auth/core/src/ScuteClient.ts:921

`Private` _webauthnDeviceRegisterInitializeRequest

_webauthnDeviceRegisterInitializeRequest(accessToken): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: {
        options: PublicKeyCredentialCreationOptionsJSON;
    };
    error: null;
}>
Internal
Parameters
- accessToken: string
  
  Auth token
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: {
        options: PublicKeyCredentialCreationOptionsJSON;
    };
    error: null;
}>

See
webauthnInitializeRegister
- Defined in packages/auth/core/src/ScuteClient.ts:909

`Private` _webauthnFinalizeLoginRequest

_webauthnFinalizeLoginRequest(credential): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteTokenPayload;
    error: null;
}>
Internal
Parameters
- credential: PublicKeyCredentialWithAssertionJSON
  
  Credential Attestation
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteTokenPayload;
    error: null;
}>

See
webauthnFinalizeLogin
- Defined in packages/auth/core/src/ScuteClient.ts:998

`Private` _webauthnInitializeLoginRequest

_webauthnInitializeLoginRequest(identifier): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: {
        options: undefined | PublicKeyCredentialRequestOptionsJSON;
    };
    error: null;
}>
Internal
Parameters
- identifier: string
  
  {ScuteIdentifier}
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: {
        options: undefined | PublicKeyCredentialRequestOptionsJSON;
    };
    error: null;
}>

See
webauthnInitializeLogin
- Defined in packages/auth/core/src/ScuteClient.ts:985

`Private` _webauthnIsNewDevice

_webauthnIsNewDevice(userId, options): Promise<boolean>
Parameters
- userId: UniqueIdentifier
  
  {UniqueIdentifier}
- options: undefined | PublicKeyCredentialRequestOptionsJSON
  
  Webauthn credential request options
Returns Promise<boolean>
true if the credential id is not found in the browser and server.
- Defined in packages/auth/core/src/ScuteClient.ts:1010

addDevice

addDevice(): Promise<{
    data: null;
    error: Error | WebAuthnError;
} | {
    data: ScuteUserSession;
    error: null;
}>
Register device for webauthn. This method will trigger the browser popup.

Returns Promise<{
    data: null;
    error: Error | WebAuthnError;
} | {
    data: ScuteUserSession;
    error: null;
}>
Scute Device
- Defined in packages/auth/core/src/ScuteClient.ts:569

clearRememberedIdentifier

clearRememberedIdentifier(): Promise<void>
Clear remembered (last logged) identifier.

Returns Promise<void>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).clearRememberedIdentifier
- Defined in packages/auth/core/src/lib/ScuteSession.ts:701

confirmInvite

confirmInvite(token, userMeta): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteTokenPayload;
    error: null;
}>
Confirm invite.
Parameters
- token: string
  
  Magic link token
- userMeta: Metadata
  
  {UserMeta} Meta fields
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteTokenPayload;
    error: null;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:1180

`Protected` debug

debug(...args): void
Parameters
- Rest ...args: any[]
Returns void
Overrides Mixin(ScuteBaseHttp, ScuteSession).debug
- Defined in packages/auth/core/src/ScuteClient.ts:209

`Protected` delete

delete(url, headers?): BaseResponse<any, BaseHttpError>
Parameters
- url: string
- Optional headers: HeadersInit
Returns BaseResponse<any, BaseHttpError>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).delete
- Defined in packages/auth/core/src/lib/ScuteBaseHttp.ts:91

`Protected` deleteCredentialId

deleteCredentialId(userId, credentialId): Promise<void>
Internal
Delete credential id.
Parameters
- userId: UniqueIdentifier
  
  {UniqueIdentifier}
- credentialId: UniqueIdentifier
  
  {UniqueIdentifier}
Returns Promise<void>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).deleteCredentialId
- Defined in packages/auth/core/src/lib/ScuteSession.ts:835

`Protected` emitAuthChangeEvent

emitAuthChangeEvent(event, session?, user?): void
Internal
Emit an auth event so it can be listened to with onAuthStateChange.
Parameters
- event: AuthChangeEvent
  
  {AuthChangeEvent}
- Optional session: null | Session
  
  {Session}
- Optional user: null | ScuteUserData
  
  {ScuteUserData}
Returns void

See
onAuthStateChange
Overrides Mixin(ScuteBaseHttp, ScuteSession).emitAuthChangeEvent
- Defined in packages/auth/core/src/ScuteClient.ts:1286

`Protected` get

get<T>(url, headers?): BaseResponse<T, BaseHttpError>
Type Parameters
- T
Parameters
- url: string
- Optional headers: HeadersInit
Returns BaseResponse<T, BaseHttpError>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).get
- Defined in packages/auth/core/src/lib/ScuteBaseHttp.ts:26

getAppData

getAppData(fresh?): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteAppData;
    error: null;
}>
Get app config data. fresh needs to be set to true to get the latest data from the server.
Parameters
- fresh: boolean = false
  
  fetch new data from the server instead cached
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteAppData;
    error: null;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:227

getAuthToken

getAuthToken(): Promise<{
    data: null;
    error: InvalidAuthTokenError;
} | {
    data: {
        access: string;
    };
    error: null;
}>
Get the access token from the current session.

Returns Promise<{
    data: null;
    error: InvalidAuthTokenError;
} | {
    data: {
        access: string;
    };
    error: null;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:746

`Protected` getCredentialIds

getCredentialIds(userId): Promise<string[]>
Internal
Get all stored credential ids as array.
Parameters
- userId: UniqueIdentifier
  
  {UniqueIdentifier}
Returns Promise<string[]>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).getCredentialIds
- Defined in packages/auth/core/src/lib/ScuteSession.ts:777

`Protected` getCurrentUser

getCurrentUser(...params): Promise<{
    data: {
        user: null;
    };
    error: BaseHttpError | InvalidAuthTokenError;
} | {
    data: {
        user: ScuteUserData;
    };
    error: null;
}>
Internal
Parameters
- Rest ...params: [accessToken: string]
Returns Promise<{
    data: {
        user: null;
    };
    error: BaseHttpError | InvalidAuthTokenError;
} | {
    data: {
        user: ScuteUserData;
    };
    error: null;
}>

See
getUser
Overrides Mixin(ScuteBaseHttp, ScuteSession).getCurrentUser
- Defined in packages/auth/core/src/ScuteClient.ts:774

getMagicLinkStatus

getMagicLinkStatus(id): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteTokenPayload;
    error: null;
}>
Get access token if the magic link consumed.
Parameters
- id: UniqueIdentifier
  
  Magic link status id
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteTokenPayload;
    error: null;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:1139

getMagicLinkToken

getMagicLinkToken(url?): null | string
Get if the URL has magic link token.
Parameters
- Optional url: string | URL
  
  (Optional) magic link url with sct_magic param. Default window.location.href.
Returns null | string
- Defined in packages/auth/core/src/ScuteClient.ts:505

getRememberedIdentifier

getRememberedIdentifier(): Promise<null | string>
Get remembered (last logged) identifier.

Returns Promise<null | string>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).getRememberedIdentifier
- Defined in packages/auth/core/src/lib/ScuteSession.ts:685

getSession

getSession(): Promise<{
    data: {
        session: Session;
        user: null;
    };
    error: InvalidAuthTokenError;
} | {
    data: {
        session: Session;
        user: ScuteUserData;
    };
    error: null;
} | {
    data: {
        session: null;
        user: null;
    };
    error: ScuteError;
} | {
    data: {
        session: Session;
        user: null;
    };
    error: null;
}>
Get current session.

Returns Promise<{
    data: {
        session: Session;
        user: null;
    };
    error: InvalidAuthTokenError;
} | {
    data: {
        session: Session;
        user: ScuteUserData;
    };
    error: null;
} | {
    data: {
        session: null;
        user: null;
    };
    error: ScuteError;
} | {
    data: {
        session: Session;
        user: null;
    };
    error: null;
}>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).getSession
- Defined in packages/auth/core/src/lib/ScuteSession.ts:76

getUser

getUser(accessToken?): Promise<{
    data: {
        user: null;
    };
    error: BaseHttpError | InvalidAuthTokenError;
} | {
    data: {
        user: ScuteUserData;
    };
    error: null;
}>
Get the user by current session or by an auth token.
Parameters
- Optional accessToken: null | string
  
  Auth token.
Returns Promise<{
    data: {
        user: null;
    };
    error: BaseHttpError | InvalidAuthTokenError;
} | {
    data: {
        user: ScuteUserData;
    };
    error: null;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:756

identifierExists

identifierExists(identifier): Promise<null | ScuteUser>
Check for an identifier and return the user if any.
Parameters
- identifier: string
  
  {ScuteIdentifier}
Returns Promise<null | ScuteUser>

Throws
TechnicalError
- Defined in packages/auth/core/src/ScuteClient.ts:717

`Protected` initialSessionState

initialSessionState(): Promise<Session>
Internal
Get session state from the storage.

Returns Promise<Session>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).initialSessionState
- Defined in packages/auth/core/src/lib/ScuteSession.ts:155

isAnyDeviceRegistered

isAnyDeviceRegistered(): Promise<boolean>
Check if any webauthn device registered on this device with the current user.

Returns Promise<boolean>
true if any webauthn credential is registered on this device with the current user, false otherwise.

Throws
LoginRequiredError
- Defined in packages/auth/core/src/ScuteClient.ts:833

isWebauthnSupported

isWebauthnSupported(): boolean
Check if webauthn is supported on this device.

Returns boolean
true if webauthn is supported on this device, false otherwise.
- Defined in packages/auth/core/src/ScuteClient.ts:824

listUserSessions

listUserSessions(): Promise<{
    data: ScuteUserSession[];
    error: null;
} | {
    data: null;
    error: InvalidAuthTokenError;
}>
Get all sessions for the authenticated user.

Returns Promise<{
    data: ScuteUserSession[];
    error: null;
} | {
    data: null;
    error: InvalidAuthTokenError;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:1245

onAuthStateChange

onAuthStateChange(callback): (() => void)
Receive a notification every time an auth event happens.
Parameters
- callback: (<T>(event, session, user) => void)
  
  A callback function to be invoked when an auth event happens.
  - - <T>(event, session, user): void
    - Type Parameters
      
      T extends Session
      
      Parameters
      
      event: AuthChangeEvent
      
      session: T
      
      user: T extends AuthenticatedSession
      ? ScuteUserData
      : null
      
      Returns void
Returns (() => void)
- - (): void
  - Returns void
- Defined in packages/auth/core/src/ScuteClient.ts:288

`Protected` patch

patch<T>(url, data, headers?): BaseResponse<T, BaseHttpError>
Type Parameters
- T
Parameters
- url: string
- data: any
- Optional headers: HeadersInit
Returns BaseResponse<T, BaseHttpError>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).patch
- Defined in packages/auth/core/src/lib/ScuteBaseHttp.ts:74

`Protected` post

post<T>(url, data, headers?): BaseResponse<T, BaseHttpError>
Type Parameters
- T
Parameters
- url: string
- data: any
- Optional headers: HeadersInit
Returns BaseResponse<T, BaseHttpError>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).post
- Defined in packages/auth/core/src/lib/ScuteBaseHttp.ts:40

`Protected` put

put<T>(url, data, headers?): BaseResponse<T, BaseHttpError>
Type Parameters
- T
Parameters
- url: string
- data: any
- Optional headers: HeadersInit
Returns BaseResponse<T, BaseHttpError>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).put
- Defined in packages/auth/core/src/lib/ScuteBaseHttp.ts:57

refetchSession

refetchSession(): Promise<{
    data: {
        session: Session;
        user: null;
    };
    error: InvalidAuthTokenError;
} | {
    data: {
        session: Session;
        user: ScuteUserData;
    };
    error: null;
}>
Refetch session.

Returns Promise<{
    data: {
        session: Session;
        user: null;
    };
    error: InvalidAuthTokenError;
} | {
    data: {
        session: Session;
        user: ScuteUserData;
    };
    error: null;
}>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).refetchSession
- Defined in packages/auth/core/src/lib/ScuteSession.ts:187

refreshSession

refreshSession(): Promise<{
    data: null;
    error: ScuteError;
} | {
    data: Session;
    error: null;
}>
Refresh and save new auth token with current session.

Returns Promise<{
    data: null;
    error: ScuteError;
} | {
    data: Session;
    error: null;
}>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).refreshSession
- Defined in packages/auth/core/src/lib/ScuteSession.ts:239

`Protected` registerRefetchInterval

registerRefetchInterval(): Promise<void>
Register refetch interval
- (browser-only)
Returns Promise<void>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).registerRefetchInterval
- Defined in packages/auth/core/src/lib/ScuteSession.ts:625

`Protected` registerVisibilityChange

registerVisibilityChange(): Promise<void>
Register callback for visibilitychange browser event.
- (browser-only)
Returns Promise<void>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).registerVisibilityChange
- Defined in packages/auth/core/src/lib/ScuteSession.ts:606

`Protected` removeSession

removeSession(): Promise<void>
Remove session from the storage.

Returns Promise<void>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).removeSession
- Defined in packages/auth/core/src/lib/ScuteSession.ts:325

revokeSession

revokeSession(id, credentialId?): Promise<{
    data: any;
    error: null;
} | {
    data: null;
    error: InvalidAuthTokenError;
}>
Revoke the specific session of the current user.
Parameters
- id: UniqueIdentifier
  
  Session ID
- Optional credentialId: null | UniqueIdentifier
  
  (Optional) credentialId
Returns Promise<{
    data: any;
    error: null;
} | {
    data: null;
    error: InvalidAuthTokenError;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:1202

sendLoginMagicLink

sendLoginMagicLink(identifier, webauthnEnabled?, emitEvent?): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteMagicLinkIdResponse;
    error: null;
}>
Send login magic link and emit the pending event.
Parameters
- identifier: string
  
  {ScuteIdentifier}
- Optional webauthnEnabled: boolean
  
  {boolean} - Magic link token includes this in the payload
- emitEvent: boolean = true
  
  {boolean} - Emit pending event. Default true.
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteMagicLinkIdResponse;
    error: null;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:1030

sendRegisterMagicLink

sendRegisterMagicLink(identifier, userMeta?, webauthnEnabled?, emitEvent?): Promise<{
    data: ScuteMagicLinkIdResponse;
    error: null;
} | {
    data: null;
    error: BaseHttpError;
}>
Send register magic link and emit the pending event.
Parameters
- identifier: string
  
  {ScuteIdentifier}
- Optional userMeta: Metadata
- Optional webauthnEnabled: boolean
  
  {boolean}
- emitEvent: boolean = true
  
  {boolean} - Emit pending event. Default true.
Returns Promise<{
    data: ScuteMagicLinkIdResponse;
    error: null;
} | {
    data: null;
    error: BaseHttpError;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:1072

setRefreshProxyCallback

setRefreshProxyCallback(callback): Promise<void>
Set refresh proxy callback. This is useful when you do not want to pass the refresh token to the client.

Send request to your backend server to refresh session with secret key in callback function.
- Needs backend server
Parameters
- callback: (() => Promise<void | Partial<ScuteTokenPayload>>)
  
  Callback function to
  - - (): Promise<void | Partial<ScuteTokenPayload>>
    - Returns Promise<void | Partial<ScuteTokenPayload>>
Returns Promise<void>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).setRefreshProxyCallback
- Defined in packages/auth/core/src/lib/ScuteSession.ts:385

`Protected` setRememberedIdentifier

setRememberedIdentifier(identifier): Promise<void>
Internal
Parameters
- identifier: string
  
  {ScuteIdentifier}
Returns Promise<void>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).setRememberedIdentifier
- Defined in packages/auth/core/src/lib/ScuteSession.ts:718

`Protected` setSession

setSession(payload): Promise<Session>
Set session to the storage. If persistence is not disabled session will remain between hard refreshes.
Parameters
- payload: Partial<ScuteTokenPayload>
  
  {ScuteTokenPayload}
Returns Promise<Session>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).setSession
- Defined in packages/auth/core/src/lib/ScuteSession.ts:258

signIn

signIn(identifier, options?): Promise<{
    data: ScuteMagicLinkIdResponse;
    error: null;
} | {
    data: null;
    error: Error | WebAuthnError;
} | {
    data: null;
    error: null;
}>
Log in an existing user with an email adress or phone number. Scute will try to sign in with webauthn if not disabled and supported by the browser, otherwise it will continue with fallback method.
Parameters
- identifier: string
  
  {ScuteIdentifier}
- Optional options: ScuteSignInOptions
  
  {ScuteSignInOptions}
Returns Promise<{
    data: ScuteMagicLinkIdResponse;
    error: null;
} | {
    data: null;
    error: Error | WebAuthnError;
} | {
    data: null;
    error: null;
}>
Polling data if webauthn is not available else null.
- Defined in packages/auth/core/src/ScuteClient.ts:347

signInOrUp

signInOrUp(identifier, options?): Promise<{
    data: ScuteMagicLinkIdResponse;
    error: null;
} | {
    data: null;
    error: Error | WebAuthnError;
} | {
    data: null;
    error: null;
}>
Log in or create a new user.
Parameters
- identifier: string
  
  {ScuteIdentifier}
- Optional options: ScuteSignInOrUpOptions
  
  {ScuteSignInOrUpOptions}
Returns Promise<{
    data: ScuteMagicLinkIdResponse;
    error: null;
} | {
    data: null;
    error: Error | WebAuthnError;
} | {
    data: null;
    error: null;
}>
Polling data if webauthn is not available else null.
See
- signIn
- signUp
- Defined in packages/auth/core/src/ScuteClient.ts:373

signInWithMagicLink

signInWithMagicLink(url?): Promise<{
error: UnknownSignInError;
} | {
error: null;
}>
Log in with the magic link url.
Parameters
- Optional url: string | URL
  
  (Optional) magic link url with sct_magic param. Default window.location.href.
Returns Promise<{
error: UnknownSignInError;
} | {
error: null;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:476

signInWithMagicLinkId

signInWithMagicLinkId(id): Promise<{
error: UnknownSignInError;
} | {
error: null;
}>
Log in with the magic link status id if it is consumed.
Parameters
- id: UniqueIdentifier
  
  {UniqueIdentifier} - Magic link status id
Returns Promise<{
error: UnknownSignInError;
} | {
error: null;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:490

signInWithMagicLinkToken

signInWithMagicLinkToken(token): Promise<{
error: UnknownSignInError;
} | {
error: null;
}>
Log in with magic link token.
Parameters
- token: string
  
  Magic link token (sct_magic)
Returns Promise<{
error: UnknownSignInError;
} | {
error: null;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:465

signInWithRegisterDevice

signInWithRegisterDevice(payload): Promise<{
error: null;
} | {
error: Error | WebAuthnError;
}>
Log in with registering the current device.
Parameters
- payload: ScuteTokenPayload
  
  {ScuteTokenPayload} - Scute auth payload
Returns Promise<{
error: null;
} | {
error: Error | WebAuthnError;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:602

signInWithTokenPayload

signInWithTokenPayload(payload): Promise<{
error: UnknownSignInError;
} | {
error: null;
}>
Log in with the auth payload.
Parameters
- payload: ScuteTokenPayload
  
  {ScuteTokenPayload} - Scute auth payload
Returns Promise<{
error: UnknownSignInError;
} | {
error: null;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:668

signInWithVerifyDevice

signInWithVerifyDevice(identifier): Promise<{
error: null;
} | {
error: Error | WebAuthnError;
}>
Verify the device (assert webauthn credentials) and log in.
Parameters
- identifier: string
  
  {ScuteIdentifier}
Returns Promise<{
error: null;
} | {
error: Error | WebAuthnError;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:616

signOut

signOut(): Promise<boolean>
Log out a user by deleting their auth token in the storage and revoking their refresh token.

Returns Promise<boolean>
true if the refresh token is revoked successfully.
- Defined in packages/auth/core/src/ScuteClient.ts:699

signUp

signUp(identifier, options?): Promise<{
    data: ScuteMagicLinkIdResponse;
    error: null;
} | {
    data: null;
    error: TechnicalError;
}>
Creates a new user.
Parameters
- identifier: string
  
  {ScuteIdentifier}
- Optional options: ScuteSignUpOptions
  
  {ScuteSignInOptions}
Returns Promise<{
    data: ScuteMagicLinkIdResponse;
    error: null;
} | {
    data: null;
    error: TechnicalError;
}>
Polling data if magic link is usable.
- Defined in packages/auth/core/src/ScuteClient.ts:431

startAutoRefresh

startAutoRefresh(): Promise<void>
Start auto refresh interval in the background. The session is checked every few seconds.

Returns Promise<void>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).startAutoRefresh
- Defined in packages/auth/core/src/lib/ScuteSession.ts:417

stopAutoRefresh

stopAutoRefresh(): Promise<void>
Stop auto refresh interval in the background (if any).

Returns Promise<void>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).stopAutoRefresh
- Defined in packages/auth/core/src/lib/ScuteSession.ts:425

`Protected` storeCredentialId

storeCredentialId(userId, credentialId): Promise<void>
Internal
Store credential id.
Parameters
- userId: UniqueIdentifier
  
  {UniqueIdentifier}
- credentialId: UniqueIdentifier
  
  {UniqueIdentifier}
Returns Promise<void>
Inherited from Mixin(ScuteBaseHttp, ScuteSession).storeCredentialId
- Defined in packages/auth/core/src/lib/ScuteSession.ts:809

updateUserMeta

updateUserMeta(meta): Promise<{
    data: {
        user: ScuteUserData;
    };
    error: null;
} | {
    data: null;
    error: InvalidAuthTokenError;
}>
Update user meta for the current user.
Parameters
- meta: Metadata
  
  {UserMeta}
Returns Promise<{
    data: {
        user: ScuteUserData;
    };
    error: null;
} | {
    data: null;
    error: InvalidAuthTokenError;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:1149

verifyMagicLink

verifyMagicLink(url?): Promise<{
    data: null;
    error: InvalidMagicLinkError;
} | {
    data: {
        authPayload: ScuteTokenPayload;
        magicPayload: _ScuteMagicLinkTokenPayload;
    };
    error: null;
} | {
    error: InvalidMagicLinkError;
}>
Verify the magic link url.
Parameters
- Optional url: string | URL
  
  (Optional) magic link url with sct_magic param. Default window.location.href.
Returns Promise<{
    data: null;
    error: InvalidMagicLinkError;
} | {
    data: {
        authPayload: ScuteTokenPayload;
        magicPayload: _ScuteMagicLinkTokenPayload;
    };
    error: null;
} | {
    error: InvalidMagicLinkError;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:517

verifyMagicLinkToken

verifyMagicLinkToken(token): Promise<{
    data: null;
    error: InvalidMagicLinkError;
} | {
    data: {
        authPayload: ScuteTokenPayload;
        magicPayload: _ScuteMagicLinkTokenPayload;
    };
    error: null;
}>
Verify magic link token
Parameters
- token: string
  
  Magic link token (sct_magic)
Returns Promise<{
    data: null;
    error: InvalidMagicLinkError;
} | {
    data: {
        authPayload: ScuteTokenPayload;
        magicPayload: _ScuteMagicLinkTokenPayload;
    };
    error: null;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:531

webauthnFinalizeLogin

webauthnFinalizeLogin(options): Promise<{
    data: null;
    error: Error | WebAuthnError;
} | {
    data: ScuteTokenPayload;
    error: null;
}>
Finalizes webauthn login by attempting popup and sending credential to the server.
Parameters
- options: CredentialRequestOptionsJSON
  
  {webauthn.CredentialRequestOptionsJSON} - Credential request options
Returns Promise<{
    data: null;
    error: Error | WebAuthnError;
} | {
    data: ScuteTokenPayload;
    error: null;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:946

webauthnFinalizeRegister

webauthnFinalizeRegister(options, accessToken): Promise<{
    data: null;
    error: Error | WebAuthnError;
} | {
    data: ScuteUserSession;
    error: null;
}>
Finalizes webauthn register by attempting popup and sending credential to the server.
- Needs access token.
Parameters
- options: CredentialCreationOptionsJSON
  
  Credential creation options
- accessToken: string
  
  Auth token
Returns Promise<{
    data: null;
    error: Error | WebAuthnError;
} | {
    data: ScuteUserSession;
    error: null;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:863

webauthnInitializeLogin

webauthnInitializeLogin(identifier): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: {
        options: undefined | PublicKeyCredentialRequestOptionsJSON;
    };
    error: null;
}>
Initialize webauthn login.
Parameters
- identifier: string
  
  {ScuteIdentifier}
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: {
        options: undefined | PublicKeyCredentialRequestOptionsJSON;
    };
    error: null;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:936

webauthnInitializeRegister

webauthnInitializeRegister(accessToken): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: {
        options: PublicKeyCredentialCreationOptionsJSON;
    };
    error: null;
}>
Initializes webauthn register.
- Needs access token.
Parameters
- accessToken: string
  
  Access token
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: {
        options: PublicKeyCredentialCreationOptionsJSON;
    };
    error: null;
}>
- Defined in packages/auth/core/src/ScuteClient.ts:851

Class ScuteClient

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

config: ScuteClientConfig

Returns ScuteClient

Properties

Readonly admin

Protected appData

Protected Readonly appId

Protected autoRefreshTicker

Protected Readonly channel

Protected Readonly config

Type declaration

autoRefreshToken: boolean

persistSession: undefined | boolean

refetchInverval: undefined | number

refetchOnWindowFocus: undefined | boolean

Protected Readonly emitter

Protected getCurrentUserDeferred

Protected initializeDeferred

Private instanceID

Protected logDebugMessages

Protected refreshDeferred

Protected refreshProxyCallback

Type declaration

Returns Promise<void | Partial<ScuteTokenPayload>>

Protected Readonly scuteStorage

Protected visibilityChangedCallback

Type declaration

Returns Promise<any>

Protected wretcher

Private Static nextInstanceID

Methods

Private _addDevice

Parameters

accessToken: string

Returns Promise<{ data: null; error: Error | WebAuthnError; } | { data: ScuteUserSession; error: null; }>

See

Protected _confirmInvite

Parameters

token: string

Optional userMeta: Metadata

Returns Promise<{ data: null; error: BaseHttpError; } | { data: ScuteTokenPayload; error: null; }>

See

Protected _getAuthToken

Parameters

session: Session

Returns Promise<{ data: null; error: InvalidAuthTokenError; } | { data: { access: string; }; error: null; }>

See

Private _getCurrentUser

Parameters

accessToken: string

Returns Promise<{ data: { user: null; }; error: BaseHttpError | InvalidAuthTokenError; } | { data: { user: ScuteUserData; }; error: null; }>

See

Private _getCurrentUserRequest

Parameters

accessToken: string

Returns Promise<{ data: null; error: BaseHttpError; } | { data: { user: null | ScuteUserData; }; error: null; }>

See

Protected _getSession

Parameters

Optional fresh: boolean

emitRefetchEvent: boolean = true

Returns Promise<{ data: { session: Session; user: null; }; error: InvalidAuthTokenError; } | { data: { session: Session; user: ScuteUserData; }; error: null; } | { data: { session: null; user: null; }; error: ScuteError; } | { data: { session: Session; user: null; }; error: null; }>

See

Protected _identifierExists

Parameters

identifier: string

Returns Promise<{ data: null; error: TechnicalError; } | { data: { user: null | ScuteUser; }; error: null; }>

See

Protected _initialize

Returns Promise<{ error: null | ScuteError; }>

Private _initializeAppData

Parameters

`Readonly` admin

`Protected` appData

`Protected` `Readonly` appId

`Protected` autoRefreshTicker

`Protected` `Readonly` channel

`Protected` `Readonly` config

`Protected` `Readonly` emitter

`Protected` getCurrentUserDeferred

`Protected` initializeDeferred

`Private` instanceID

`Protected` logDebugMessages

`Protected` refreshDeferred

`Protected` refreshProxyCallback

`Protected` `Readonly` scuteStorage

`Protected` visibilityChangedCallback

`Protected` wretcher

`Private` `Static` nextInstanceID

`Private` _addDevice

Returns Promise<{
data: null;
error: Error | WebAuthnError;
} | {
data: ScuteUserSession;
error: null;
}>

`Protected` _confirmInvite

`Optional` userMeta: Metadata

Returns Promise<{
data: null;
error: BaseHttpError;
} | {
data: ScuteTokenPayload;
error: null;
}>

`Protected` _getAuthToken

Returns Promise<{
data: null;
error: InvalidAuthTokenError;
} | {
data: {
access: string;
};
error: null;
}>

`Private` _getCurrentUser

Returns Promise<{
data: {
user: null;
};
error: BaseHttpError | InvalidAuthTokenError;
} | {
data: {
user: ScuteUserData;
};
error: null;
}>

`Private` _getCurrentUserRequest

Returns Promise<{
data: null;
error: BaseHttpError;
} | {
data: {
user: null | ScuteUserData;
};
error: null;
}>

`Protected` _getSession

`Optional` fresh: boolean

Returns Promise<{
data: {
session: Session;
user: null;
};
error: InvalidAuthTokenError;
} | {
data: {
session: Session;
user: ScuteUserData;
};
error: null;
} | {
data: {
session: null;
user: null;
};
error: ScuteError;
} | {
data: {
session: Session;
user: null;
};
error: null;
}>

`Protected` _identifierExists

Returns Promise<{
data: null;
error: TechnicalError;
} | {
data: {
user: null | ScuteUser;
};
error: null;
}>

`Protected` _initialize

Returns Promise<{
error: null | ScuteError;
}>

`Private` _initializeAppData

Returns Promise<{
error: BaseHttpError;
} | {
error: null;
}>

`Protected` _refreshRequest

Returns Promise<{
data: null;
error: BaseHttpError;
} | {
data: ScuteTokenPayload;
error: null;
}>

`Protected` _revokeSession

Returns Promise<{
data: null;
error: BaseHttpError;
} | {
data: any;
error: null;
}>

`Private` _sendLoginMagicLink

`Optional` webauthnEnabled: boolean

Returns Promise<{
data: null;
error: BaseHttpError;
} | {
data: ScuteMagicLinkIdResponse;
error: null;
}>

`Private` _sendMagicLinkRequest

`Optional` userMeta: Metadata

Returns Promise<{
data: null;
error: BaseHttpError;
} | {
data: ScuteMagicLinkIdResponse;
error: null;
}>

`Private` _sendRegisterMagicLink

`Optional` userMeta: Metadata

`Optional` webauthnEnabled: boolean

Returns Promise<{
data: null;
error: BaseHttpError;
} | {
data: ScuteMagicLinkIdResponse;
error: null;
}>

`Private` _setupSessionBroadcast

`Private` _signIn

`Optional` options: ScuteSignInOptions

Returns Promise<{
data: ScuteMagicLinkIdResponse;
error: null;
} | {
data: null;
error: Error | WebAuthnError;
} | {
data: null;
error: null;
}>

`Private` _signInWithVerifyDevice

Returns Promise<{
error: null;
} | {
error: Error | WebAuthnError;
}>

`Protected` _signOut

`Optional` accessToken: null | string

`Private` _signUp

`Optional` options: ScuteSignUpOptions

Returns Promise<{
data: ScuteMagicLinkIdResponse;
error: null;
} | {
data: null;
error: BaseHttpError;
}>

`Protected` _updateUserMeta

Returns Promise<{
data: null;
error: BaseHttpError;
} | {
data: {
user: ScuteUserData;
};
error: null;
}>

`Protected` _userSessionsRequest