@clicktap/state 0.16.2 → 0.16.3

package/__mocks__/nanoid.d.ts

@@ -0,0 +1,7 @@
+export declare const nanoid: (_size?: number) => string;
+export declare const customAlphabet: (_alphabet: string, _defaultSize?: number) => (_size?: number) => string;
+declare const _default: {
+    nanoid: (_size?: number) => string;
+    customAlphabet: (_alphabet: string, _defaultSize?: number | undefined) => (_size?: number | undefined) => string;
+};
+export default _default;

package/auth/AuthProvider.d.ts

@@ -0,0 +1,255 @@
+import { ReactNode } from 'react';
+import { Actor, InspectionEvent, Observer } from 'xstate';
+import { authMachine } from './auth';
+export interface AuthContextType {
+    authActor: Actor<typeof authMachine>;
+    isLoggedIn: boolean;
+}
+export declare const AuthContext: import('react').Context<Actor<import('xstate').StateMachine<import('./types').AuthMachineContext, import('./types').RefreshTokenEvent | import('./types').LoginEvent | import('./types').LogoutEvent | import('./types').ClearErrorsEvent | import('./types').RestoreEvent | import('xstate').DoneActorEvent<import('./types').AuthenticateSuccessEvent> | import('xstate').DoneActorEvent<import('./types').RefreshTokenSuccessEvent>, {
+    [x: string]: import('xstate').ActorRef<import('xstate').PromiseSnapshot<import('./types').AuthenticateSuccessEvent, import('./actors').AuthenticateInput>, {
+        [k: string]: unknown;
+        type: string;
+    }, import('xstate').EventObject> | import('xstate').ActorRef<import('xstate').PromiseSnapshot<import('./types').RefreshTokenSuccessEvent, import('./actors').RefreshTokenInput>, {
+        [k: string]: unknown;
+        type: string;
+    }, import('xstate').EventObject> | import('xstate').ActorRef<import('xstate').PromiseSnapshot<import('./types').UnauthenticateSuccessEvent, import('./actors').UnauthenticateInput>, {
+        [k: string]: unknown;
+        type: string;
+    }, import('xstate').EventObject> | undefined;
+}, import('xstate').Values<{
+    authenticate: {
+        src: "authenticate";
+        logic: import('xstate').PromiseActorLogic<import('./types').AuthenticateSuccessEvent, import('./actors').AuthenticateInput>;
+        id: string | undefined;
+    };
+    refreshAccessToken: {
+        src: "refreshAccessToken";
+        logic: import('xstate').PromiseActorLogic<import('./types').RefreshTokenSuccessEvent, import('./actors').RefreshTokenInput>;
+        id: string | undefined;
+    };
+    unauthenticate: {
+        src: "unauthenticate";
+        logic: import('xstate').PromiseActorLogic<import('./types').UnauthenticateSuccessEvent, import('./actors').UnauthenticateInput>;
+        id: string | undefined;
+    };
+}>, import('xstate').Values<{
+    addError: {
+        type: "addError";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    clearErrors: {
+        type: "clearErrors";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    notifyAuthenticated: {
+        type: "notifyAuthenticated";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setAccessToken: {
+        type: "setAccessToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setIgnoreRefreshToken: {
+        type: "setIgnoreRefreshToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setUserContext: {
+        type: "setUserContext";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    unsetRefreshToken: {
+        type: "unsetRefreshToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    unsetUserContext: {
+        type: "unsetUserContext";
+        params: import('xstate').NonReducibleUnknown;
+    };
+}>, never, "refresh", "refreshing" | "authenticating" | "loggedIn" | "loggedOut" | "unauthenticating" | "loggedInReady", string, {
+    initialContext: Partial<import('./types').AuthMachineContext>;
+    initialState?: string | undefined;
+}, import('xstate').NonReducibleUnknown, import('./types').AuthenticatedEmittedEvent, import('xstate').MetaObject, import('xstate').ResolveTypegenMeta<import('xstate').TypegenDisabled, import('./types').RefreshTokenEvent | import('./types').LoginEvent | import('./types').LogoutEvent | import('./types').ClearErrorsEvent | import('./types').RestoreEvent | import('xstate').DoneActorEvent<import('./types').AuthenticateSuccessEvent> | import('xstate').DoneActorEvent<import('./types').RefreshTokenSuccessEvent>, import('xstate').Values<{
+    authenticate: {
+        src: "authenticate";
+        logic: import('xstate').PromiseActorLogic<import('./types').AuthenticateSuccessEvent, import('./actors').AuthenticateInput>;
+        id: string | undefined;
+    };
+    refreshAccessToken: {
+        src: "refreshAccessToken";
+        logic: import('xstate').PromiseActorLogic<import('./types').RefreshTokenSuccessEvent, import('./actors').RefreshTokenInput>;
+        id: string | undefined;
+    };
+    unauthenticate: {
+        src: "unauthenticate";
+        logic: import('xstate').PromiseActorLogic<import('./types').UnauthenticateSuccessEvent, import('./actors').UnauthenticateInput>;
+        id: string | undefined;
+    };
+}>, import('xstate').Values<{
+    addError: {
+        type: "addError";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    clearErrors: {
+        type: "clearErrors";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    notifyAuthenticated: {
+        type: "notifyAuthenticated";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setAccessToken: {
+        type: "setAccessToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setIgnoreRefreshToken: {
+        type: "setIgnoreRefreshToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setUserContext: {
+        type: "setUserContext";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    unsetRefreshToken: {
+        type: "unsetRefreshToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    unsetUserContext: {
+        type: "unsetUserContext";
+        params: import('xstate').NonReducibleUnknown;
+    };
+}>, never, "refresh", string, import('./types').AuthenticatedEmittedEvent>>>>;
+export declare const useAuth: () => AuthContextType;
+type AuthOptions = {
+    inspect: Observer<InspectionEvent> | undefined;
+    endpoints: {
+        login: string;
+        logout: string;
+        refresh: string;
+        ssrRefresh: string;
+    };
+};
+/**
+ * runs on server side as part of withAuth HOF
+ *
+ * @todo should probably update signature to pass Partial<AuthContext> and
+ * Options, endpoints should probably be moved into context
+ */
+export declare const getAuth: (refreshToken?: string, options?: AuthOptions) => Promise<Actor<import('xstate').StateMachine<import('./types').AuthMachineContext, import('./types').RefreshTokenEvent | import('./types').LoginEvent | import('./types').LogoutEvent | import('./types').ClearErrorsEvent | import('./types').RestoreEvent | import('xstate').DoneActorEvent<import('./types').AuthenticateSuccessEvent> | import('xstate').DoneActorEvent<import('./types').RefreshTokenSuccessEvent>, {
+    [x: string]: import('xstate').ActorRef<import('xstate').PromiseSnapshot<import('./types').AuthenticateSuccessEvent, import('./actors').AuthenticateInput>, {
+        [k: string]: unknown;
+        type: string;
+    }, import('xstate').EventObject> | import('xstate').ActorRef<import('xstate').PromiseSnapshot<import('./types').RefreshTokenSuccessEvent, import('./actors').RefreshTokenInput>, {
+        [k: string]: unknown;
+        type: string;
+    }, import('xstate').EventObject> | import('xstate').ActorRef<import('xstate').PromiseSnapshot<import('./types').UnauthenticateSuccessEvent, import('./actors').UnauthenticateInput>, {
+        [k: string]: unknown;
+        type: string;
+    }, import('xstate').EventObject> | undefined;
+}, import('xstate').Values<{
+    authenticate: {
+        src: "authenticate";
+        logic: import('xstate').PromiseActorLogic<import('./types').AuthenticateSuccessEvent, import('./actors').AuthenticateInput>;
+        id: string | undefined;
+    };
+    refreshAccessToken: {
+        src: "refreshAccessToken";
+        logic: import('xstate').PromiseActorLogic<import('./types').RefreshTokenSuccessEvent, import('./actors').RefreshTokenInput>;
+        id: string | undefined;
+    };
+    unauthenticate: {
+        src: "unauthenticate";
+        logic: import('xstate').PromiseActorLogic<import('./types').UnauthenticateSuccessEvent, import('./actors').UnauthenticateInput>;
+        id: string | undefined;
+    };
+}>, import('xstate').Values<{
+    addError: {
+        type: "addError";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    clearErrors: {
+        type: "clearErrors";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    notifyAuthenticated: {
+        type: "notifyAuthenticated";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setAccessToken: {
+        type: "setAccessToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setIgnoreRefreshToken: {
+        type: "setIgnoreRefreshToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setUserContext: {
+        type: "setUserContext";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    unsetRefreshToken: {
+        type: "unsetRefreshToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    unsetUserContext: {
+        type: "unsetUserContext";
+        params: import('xstate').NonReducibleUnknown;
+    };
+}>, never, "refresh", "refreshing" | "authenticating" | "loggedIn" | "loggedOut" | "unauthenticating" | "loggedInReady", string, {
+    initialContext: Partial<import('./types').AuthMachineContext>;
+    initialState?: string | undefined;
+}, import('xstate').NonReducibleUnknown, import('./types').AuthenticatedEmittedEvent, import('xstate').MetaObject, import('xstate').ResolveTypegenMeta<import('xstate').TypegenDisabled, import('./types').RefreshTokenEvent | import('./types').LoginEvent | import('./types').LogoutEvent | import('./types').ClearErrorsEvent | import('./types').RestoreEvent | import('xstate').DoneActorEvent<import('./types').AuthenticateSuccessEvent> | import('xstate').DoneActorEvent<import('./types').RefreshTokenSuccessEvent>, import('xstate').Values<{
+    authenticate: {
+        src: "authenticate";
+        logic: import('xstate').PromiseActorLogic<import('./types').AuthenticateSuccessEvent, import('./actors').AuthenticateInput>;
+        id: string | undefined;
+    };
+    refreshAccessToken: {
+        src: "refreshAccessToken";
+        logic: import('xstate').PromiseActorLogic<import('./types').RefreshTokenSuccessEvent, import('./actors').RefreshTokenInput>;
+        id: string | undefined;
+    };
+    unauthenticate: {
+        src: "unauthenticate";
+        logic: import('xstate').PromiseActorLogic<import('./types').UnauthenticateSuccessEvent, import('./actors').UnauthenticateInput>;
+        id: string | undefined;
+    };
+}>, import('xstate').Values<{
+    addError: {
+        type: "addError";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    clearErrors: {
+        type: "clearErrors";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    notifyAuthenticated: {
+        type: "notifyAuthenticated";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setAccessToken: {
+        type: "setAccessToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setIgnoreRefreshToken: {
+        type: "setIgnoreRefreshToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setUserContext: {
+        type: "setUserContext";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    unsetRefreshToken: {
+        type: "unsetRefreshToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    unsetUserContext: {
+        type: "unsetUserContext";
+        params: import('xstate').NonReducibleUnknown;
+    };
+}>, never, "refresh", string, import('./types').AuthenticatedEmittedEvent>>>>;
+type Props = {
+    children: ReactNode;
+    actor: Actor<typeof authMachine>;
+};
+export declare function AuthProvider({ actor, children }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/auth/actions/addError.d.ts

@@ -0,0 +1,8 @@
+import { AuthMachineContext, AuthMachineEvents } from '../types';
+export declare function addError({ context, event, }: {
+    context: AuthMachineContext;
+    event: AuthMachineEvents;
+}): AuthMachineContext | {
+    errors: string[];
+};
+export default addError;

package/auth/actions/clearErrors.d.ts

@@ -0,0 +1,5 @@
+/** @todo should we assertEvent here? */
+export declare function clearErrors(): {
+    errors: never[];
+};
+export default clearErrors;

package/auth/actions/index.d.ts

@@ -0,0 +1,8 @@
+export * from './addError';
+export * from './clearErrors';
+export * from './notifyAuthenticated';
+export * from './setAccessToken';
+export * from './setIgnoreRefreshToken';
+export * from './setUserContext';
+export * from './unsetRefreshToken';
+export * from './unsetUserContext';

package/auth/actions/notifyAuthenticated.d.ts

@@ -0,0 +1,6 @@
+import { AuthenticatedEmittedEvent, AuthMachineContext, AuthMachineEvents } from '../types';
+export declare function notifyAuthenticated({ event, }: {
+    context: AuthMachineContext;
+    event: AuthMachineEvents;
+}): AuthenticatedEmittedEvent;
+export default notifyAuthenticated;

package/auth/actions/setAccessToken.d.ts

@@ -0,0 +1,9 @@
+import { AuthMachineContext, AuthMachineEvents } from '../types';
+export declare function setAccessToken({ context, event, }: {
+    context: AuthMachineContext;
+    event: AuthMachineEvents;
+}): AuthMachineContext | {
+    accessToken: string;
+    ignoreRefreshToken: boolean;
+};
+export default setAccessToken;

package/auth/actions/setIgnoreRefreshToken.d.ts

@@ -0,0 +1,4 @@
+export declare function setIgnoreRefreshToken(): {
+    ignoreRefreshToken: boolean;
+};
+export default setIgnoreRefreshToken;

package/auth/actions/setUserContext.d.ts

@@ -0,0 +1,9 @@
+import { AuthMachineContext, AuthMachineEvents } from '../types';
+export declare function setUserContext({ context, event, }: {
+    context: AuthMachineContext;
+    event: AuthMachineEvents;
+}): AuthMachineContext | {
+    accessToken: string;
+    ignoreRefreshToken: boolean;
+};
+export default setUserContext;

package/auth/actions/unsetRefreshToken.d.ts

@@ -0,0 +1,4 @@
+export declare function unsetRefreshToken(): {
+    refreshToken: string;
+};
+export default unsetRefreshToken;

package/auth/actions/unsetUserContext.d.ts

@@ -0,0 +1,8 @@
+/** @todo should we assertEvent here? */
+export declare function unsetUserContext(): {
+    user: null;
+    accessToken: string;
+    refreshToken: string;
+    ignoreRefreshToken: boolean;
+};
+export default unsetUserContext;

package/auth/actors/authenticate.d.ts

@@ -0,0 +1,16 @@
+import { AuthenticateSuccessEvent, AuthMachineContext } from '../types';
+export type AuthenticateInput = {
+    endpoint: {
+        client: AuthMachineContext['endpoints']['login'];
+    };
+    password: string;
+    username: string;
+};
+export type AuthenticateResponse = {
+    success: boolean;
+    message?: string;
+    accessToken?: string;
+};
+/** @todo pass locale for auth server? */
+export declare const authenticate: import('xstate').PromiseActorLogic<AuthenticateSuccessEvent, AuthenticateInput>;
+export default authenticate;

package/auth/actors/index.d.ts

@@ -0,0 +1,3 @@
+export * from './authenticate';
+export * from './refreshAccessToken';
+export * from './unauthenticate';

package/auth/actors/refreshAccessToken.d.ts

@@ -0,0 +1,18 @@
+import { RefreshTokenSuccessEvent, AuthMachineContext } from '../types';
+export type RefreshTokenInput = {
+    refreshToken: AuthMachineContext['refreshToken'];
+    endpoint: {
+        client: AuthMachineContext['endpoints']['refresh'];
+        server: AuthMachineContext['endpoints']['ssrRefresh'];
+    };
+};
+export type RefreshTokenResponse = {
+    accessToken?: string;
+};
+export type RefreshTokenOutput = {
+    type: string;
+    accessToken: string;
+};
+/** @todo pass locale for auth server? */
+export declare const refreshAccessToken: import('xstate').PromiseActorLogic<RefreshTokenSuccessEvent, RefreshTokenInput>;
+export default refreshAccessToken;

package/auth/actors/unauthenticate.d.ts

@@ -0,0 +1,14 @@
+import { UnauthenticateSuccessEvent, AuthMachineContext } from '../types';
+export type UnauthenticateInput = {
+    endpoint: {
+        client: AuthMachineContext['endpoints']['logout'];
+    };
+};
+export type UnauthenticateResponse = {
+    success: boolean;
+    message?: string;
+    accessToken?: string;
+};
+/** @todo pass locale for auth server? */
+export declare const unauthenticate: import('xstate').PromiseActorLogic<UnauthenticateSuccessEvent, UnauthenticateInput>;
+export default unauthenticate;

package/auth/auth.d.ts

@@ -0,0 +1,115 @@
+import { AuthMachineContext } from './types';
+export declare const authMachine: import('xstate').StateMachine<AuthMachineContext, import('./types').RefreshTokenEvent | import('./types').LoginEvent | import('./types').LogoutEvent | import('./types').ClearErrorsEvent | import('./types').RestoreEvent | import('xstate').DoneActorEvent<import('./types').AuthenticateSuccessEvent> | import('xstate').DoneActorEvent<import('./types').RefreshTokenSuccessEvent>, {
+    [x: string]: import('xstate').ActorRef<import('xstate').PromiseSnapshot<import('./types').AuthenticateSuccessEvent, import('./actors').AuthenticateInput>, {
+        [k: string]: unknown;
+        type: string;
+    }, import('xstate').EventObject> | import('xstate').ActorRef<import('xstate').PromiseSnapshot<import('./types').RefreshTokenSuccessEvent, import('./actors').RefreshTokenInput>, {
+        [k: string]: unknown;
+        type: string;
+    }, import('xstate').EventObject> | import('xstate').ActorRef<import('xstate').PromiseSnapshot<import('./types').UnauthenticateSuccessEvent, import('./actors').UnauthenticateInput>, {
+        [k: string]: unknown;
+        type: string;
+    }, import('xstate').EventObject> | undefined;
+}, import('xstate').Values<{
+    authenticate: {
+        src: "authenticate";
+        logic: import('xstate').PromiseActorLogic<import('./types').AuthenticateSuccessEvent, import('./actors').AuthenticateInput>;
+        id: string | undefined;
+    };
+    refreshAccessToken: {
+        src: "refreshAccessToken";
+        logic: import('xstate').PromiseActorLogic<import('./types').RefreshTokenSuccessEvent, import('./actors').RefreshTokenInput>;
+        id: string | undefined;
+    };
+    unauthenticate: {
+        src: "unauthenticate";
+        logic: import('xstate').PromiseActorLogic<import('./types').UnauthenticateSuccessEvent, import('./actors').UnauthenticateInput>;
+        id: string | undefined;
+    };
+}>, import('xstate').Values<{
+    addError: {
+        type: "addError";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    clearErrors: {
+        type: "clearErrors";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    notifyAuthenticated: {
+        type: "notifyAuthenticated";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setAccessToken: {
+        type: "setAccessToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setIgnoreRefreshToken: {
+        type: "setIgnoreRefreshToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setUserContext: {
+        type: "setUserContext";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    unsetRefreshToken: {
+        type: "unsetRefreshToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    unsetUserContext: {
+        type: "unsetUserContext";
+        params: import('xstate').NonReducibleUnknown;
+    };
+}>, never, "refresh", "refreshing" | "authenticating" | "loggedIn" | "loggedOut" | "unauthenticating" | "loggedInReady", string, {
+    initialContext: Partial<AuthMachineContext>;
+    initialState?: string | undefined;
+}, import('xstate').NonReducibleUnknown, import('./types').AuthenticatedEmittedEvent, import('xstate').MetaObject, import('xstate').ResolveTypegenMeta<import('xstate').TypegenDisabled, import('./types').RefreshTokenEvent | import('./types').LoginEvent | import('./types').LogoutEvent | import('./types').ClearErrorsEvent | import('./types').RestoreEvent | import('xstate').DoneActorEvent<import('./types').AuthenticateSuccessEvent> | import('xstate').DoneActorEvent<import('./types').RefreshTokenSuccessEvent>, import('xstate').Values<{
+    authenticate: {
+        src: "authenticate";
+        logic: import('xstate').PromiseActorLogic<import('./types').AuthenticateSuccessEvent, import('./actors').AuthenticateInput>;
+        id: string | undefined;
+    };
+    refreshAccessToken: {
+        src: "refreshAccessToken";
+        logic: import('xstate').PromiseActorLogic<import('./types').RefreshTokenSuccessEvent, import('./actors').RefreshTokenInput>;
+        id: string | undefined;
+    };
+    unauthenticate: {
+        src: "unauthenticate";
+        logic: import('xstate').PromiseActorLogic<import('./types').UnauthenticateSuccessEvent, import('./actors').UnauthenticateInput>;
+        id: string | undefined;
+    };
+}>, import('xstate').Values<{
+    addError: {
+        type: "addError";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    clearErrors: {
+        type: "clearErrors";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    notifyAuthenticated: {
+        type: "notifyAuthenticated";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setAccessToken: {
+        type: "setAccessToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setIgnoreRefreshToken: {
+        type: "setIgnoreRefreshToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    setUserContext: {
+        type: "setUserContext";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    unsetRefreshToken: {
+        type: "unsetRefreshToken";
+        params: import('xstate').NonReducibleUnknown;
+    };
+    unsetUserContext: {
+        type: "unsetUserContext";
+        params: import('xstate').NonReducibleUnknown;
+    };
+}>, never, "refresh", string, import('./types').AuthenticatedEmittedEvent>>;
+export default authMachine;

package/auth/types.d.ts

@@ -0,0 +1,50 @@
+import { DoneActorEvent } from 'xstate';
+export interface AuthMachineContext {
+    user: Record<string, any> | null;
+    accessToken: string;
+    refreshToken: string;
+    ignoreRefreshToken: boolean;
+    endpoints: {
+        login: string;
+        logout: string;
+        refresh: string;
+        ssrRefresh: string;
+    };
+    errors: Array<string>;
+}
+export interface RefreshTokenEvent {
+    type: 'REFRESH_TOKEN';
+    accessToken: AuthMachineContext['accessToken'];
+}
+export interface LoginEvent {
+    type: 'LOGIN';
+    username: string;
+    password: string;
+}
+export interface LogoutEvent {
+    type: 'LOGOUT';
+}
+export interface ClearErrorsEvent {
+    type: 'CLEAR_ERRORS';
+}
+export interface RestoreEvent {
+    type: 'RESTORE';
+}
+export interface AuthenticateSuccessEvent {
+    type: 'AUTHENTICATE_SUCCESS';
+    user: Partial<AuthMachineContext['user']>;
+    accessToken: AuthMachineContext['accessToken'];
+}
+export interface RefreshTokenSuccessEvent {
+    type: 'REFRESH_TOKEN_SUCCESS';
+    accessToken: AuthMachineContext['accessToken'];
+}
+export interface UnauthenticateSuccessEvent {
+    type: 'UNAUTHENTICATE_SUCCESS';
+}
+export interface AuthenticatedEmittedEvent {
+    type: 'EMIT_AUTHENTICATED';
+    accessToken: AuthMachineContext['accessToken'];
+}
+export type AuthMachineEvents = RefreshTokenEvent | RestoreEvent | LoginEvent | LogoutEvent | ClearErrorsEvent | DoneActorEvent<AuthenticateSuccessEvent> | DoneActorEvent<RefreshTokenSuccessEvent>;
+export type AuthMachineEmittedEvents = AuthenticatedEmittedEvent;

package/helpers/request.d.ts

@@ -0,0 +1,2 @@
+export declare function request<T>(url: string, options: object): Promise<T>;
+export default request;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clicktap/state",
-  "version": "0.16.2",
+  "version": "0.16.3",
   "private": false,
   "author": "Clicktap",
   "description": "A state management library for Clicktap reference frontend.",