@go-avro/avro-js 0.0.2-beta.13 → 0.0.2-beta.131

package/README.md

@@ -10,6 +10,7 @@ This SDK provides:
 - Typed API interfaces for Avro entities (users, jobs, teams, etc.)
 - Pluggable token storage (in-memory, localStorage, SecureStore, etc.)
 - XHR-based requests for compatibility with React Native WebViews and older environments
+- Mutation and Data Hooks for easy plug-in use in React and React Native projects.
 
 ## Installation
 

package/dist/auth/AuthManager.d.ts

@@ -1,15 +1,24 @@
-import { TokenStorage, Tokens } from '../types/auth';
+import { Tokens } from '../types/auth';
+import { Cache, CacheData } from '../types/cache';
 export declare class AuthManager {
     private storages;
     private baseUrl;
+    private tokenRefreshedCallbacks;
+    private tokenRefreshFailedCallbacks;
     constructor({ baseUrl, storage, }: {
         baseUrl: string;
-        storage: TokenStorage | TokenStorage[];
+        storage: Cache | Cache[];
     });
     isAuthenticated(): Promise<boolean>;
     fetchNewTokens(): Promise<Tokens>;
     accessToken(): Promise<string | undefined>;
+    onTokenRefreshed(callback: (accessToken: string) => void): void;
+    onTokenRefreshFailed(callback: () => void): void;
     refreshTokens(): Promise<Tokens | null>;
     setTokens(tokens: Tokens): Promise<void>;
-    clearTokens(): Promise<void>;
+    setCache(data: Partial<CacheData>): Promise<void>;
+    getCache(key?: keyof CacheData): Promise<CacheData | string | null>;
+    clearCache(): Promise<void>;
+    getCompanyId(): Promise<string | null>;
+    setCompanyId(companyId: string): Promise<void[]>;
 }

package/dist/auth/AuthManager.js

@@ -1,5 +1,8 @@
+import { StandardError } from '../types/error';
 export class AuthManager {
     constructor({ baseUrl, storage, }) {
+        this.tokenRefreshedCallbacks = [];
+        this.tokenRefreshFailedCallbacks = [];
         this.storages = Array.isArray(storage) ? storage : [storage];
         if (this.storages.length === 0) {
             throw new Error('At least one token storage must be provided');
@@ -16,14 +19,14 @@ export class AuthManager {
             throw new Error('No token storages initialized');
         }
         for (const storage of this.storages) {
-            const tokens = await storage.get();
-            if (tokens && tokens.access_token) {
+            const cache = await storage.get();
+            if (cache && typeof cache !== 'string' && cache.access_token) {
                 try {
                     const response = await fetch(`${this.baseUrl}/validate`, {
                         method: 'POST',
                         headers: {
                             'Content-Type': 'application/json',
-                            'Authorization': `Bearer ${tokens.access_token}`,
+                            'Authorization': `Bearer ${cache.access_token}`,
                         },
                     });
                     if (response.ok) {
@@ -53,8 +56,8 @@ export class AuthManager {
     }
     async fetchNewTokens() {
         for (const storage of this.storages) {
-            const tokens = await storage.get();
-            if (!tokens || !tokens.refresh_token)
+            const cache = await storage.get();
+            if (!cache || typeof cache === 'string' || !cache.refresh_token)
                 continue;
             try {
                 const response = await fetch(`${this.baseUrl}/refresh`, {
@@ -62,7 +65,7 @@ export class AuthManager {
                     headers: {
                         'Content-Type': 'application/json',
                         'Accept': 'application/json',
-                        'Authorization': `Bearer ${tokens.refresh_token}`,
+                        'Authorization': `Bearer ${cache.refresh_token}`,
                     },
                 });
                 if (response.ok) {
@@ -74,35 +77,76 @@ export class AuthManager {
                 storage.clear();
             }
         }
-        throw new Error('Failed to refresh tokens from all storages');
+        throw new StandardError(410, 'Failed to refresh tokens from all storages');
     }
     async accessToken() {
         if (!this.storages.length) {
             throw new Error('No token storages initialized');
         }
         for (const storage of this.storages) {
-            const token = await storage.get();
-            if (token)
-                return token.access_token;
+            const cache = await storage.get();
+            if (cache && typeof cache !== 'string' && cache.access_token)
+                return cache.access_token;
         }
         const newToken = await this.refreshTokens();
         return newToken?.access_token;
     }
+    onTokenRefreshed(callback) {
+        this.tokenRefreshedCallbacks.push(callback);
+    }
+    onTokenRefreshFailed(callback) {
+        this.tokenRefreshFailedCallbacks.push(callback);
+    }
     async refreshTokens() {
         try {
             const newToken = await this.fetchNewTokens();
             await Promise.all(this.storages.map(s => s.set(newToken)));
+            this.tokenRefreshedCallbacks.forEach(cb => {
+                if (newToken?.access_token)
+                    cb(newToken.access_token);
+            });
             return newToken;
         }
         catch (error) {
-            console.error('Failed to refresh tokens:', error);
+            this.tokenRefreshFailedCallbacks.forEach(cb => cb());
+            if (error?.status !== 410) {
+                console.error('Failed to refresh tokens:', error);
+            }
             return null;
         }
     }
     async setTokens(tokens) {
         await Promise.all(this.storages.map(s => s.set(tokens)));
     }
-    async clearTokens() {
+    async setCache(data) {
+        await Promise.all(this.storages.map(s => s.set(data)));
+    }
+    async getCache(key) {
+        if (!this.storages.length) {
+            return null;
+        }
+        for (const storage of this.storages) {
+            const cache = await storage.get(key);
+            if (cache)
+                return cache;
+        }
+        return null;
+    }
+    async clearCache() {
         await Promise.all(this.storages.map(s => s.clear()));
     }
+    async getCompanyId() {
+        if (!this.storages.length) {
+            return null;
+        }
+        for (const storage of this.storages) {
+            const companyId = await storage.get('companyId');
+            if (companyId && typeof companyId === 'string')
+                return companyId;
+        }
+        return null;
+    }
+    async setCompanyId(companyId) {
+        return Promise.all(this.storages.map(s => s.set({ companyId })));
+    }
 }

package/dist/auth/storage.d.ts

@@ -1,13 +1,13 @@
-import { Tokens, TokenStorage } from '../types/auth';
-export declare class MemoryStorage implements TokenStorage {
-    private tokens;
-    get(): Promise<Tokens | null>;
-    set(tokens: Tokens): Promise<void>;
+import { Cache, CacheData } from '../types/cache';
+export declare class MemoryStorage implements Cache {
+    private data;
+    get(key?: keyof CacheData): Promise<CacheData | string | null>;
+    set(data: Partial<CacheData>): Promise<void>;
     clear(): Promise<void>;
 }
-export declare class LocalStorage implements TokenStorage {
+export declare class LocalStorage implements Cache {
     private key;
-    get(): Promise<Tokens | null>;
-    set(tokens: Tokens): Promise<void>;
+    get(key?: string): Promise<CacheData | null>;
+    set(data: Partial<CacheData>): Promise<void>;
     clear(): Promise<void>;
 }

package/dist/auth/storage.js

@@ -1,27 +1,29 @@
 export class MemoryStorage {
     constructor() {
-        this.tokens = null;
+        this.data = null;
     }
-    async get() {
-        return this.tokens ? this.tokens : null;
+    async get(key) {
+        return this.data ? key ? this.data[key] ?? null : this.data : null;
     }
-    async set(tokens) {
-        this.tokens = tokens;
+    async set(data) {
+        this.data = { ...this.data, ...data };
     }
     async clear() {
-        this.tokens = null;
+        this.data = null;
     }
 }
 export class LocalStorage {
     constructor() {
-        this.key = 'auth_tokens';
+        this.key = 'cache_data';
     }
-    async get() {
+    async get(key) {
         const item = localStorage.getItem(this.key);
         return item ? JSON.parse(item) : null;
     }
-    async set(tokens) {
-        localStorage.setItem(this.key, JSON.stringify(tokens));
+    async set(data) {
+        const current = await this.get() || {};
+        const updated = { ...current, ...data };
+        localStorage.setItem(this.key, JSON.stringify(updated));
     }
     async clear() {
         localStorage.removeItem(this.key);

package/dist/client/QueryClient.d.ts

@@ -1,28 +1,422 @@
+import { Socket } from 'socket.io-client';
+import { InfiniteData, QueryClient, UseInfiniteQueryResult, useMutation, UseQueryResult } from '@tanstack/react-query';
 import { AuthManager } from '../auth/AuthManager';
+import { _Event, ApiInfo, Avro, Bill, Break, Chat, Company, FinancialInsightData, Job, EventInsightData, LoginResponse, Message, Plan, Route, ServiceMonth, Session, Team, User, UserCompanyAssociation, Skill } from '../types/api';
+import { Tokens } from '../types/auth';
 import { CancelToken, RetryStrategy } from '../types/client';
+import { StandardError } from '../types/error';
+import { CacheData } from '../types/cache';
 export interface AvroQueryClientConfig {
     baseUrl: string;
     authManager: AuthManager;
+    queryClient: QueryClient;
     maxRetries?: number;
     retryStrategy?: RetryStrategy;
     timeout?: number;
 }
+declare module '../client/QueryClient' {
+    interface AvroQueryClient {
+        _xhr<T>(method: string, path: string, body: any, cancelToken?: CancelToken, headers?: Record<string, string>, isIdempotent?: boolean, retryCount?: number, progressUpdateCallback?: (loaded: number, total: number) => void): Promise<T>;
+        _fetch<T>(method: string, path: string, body: any, cancelToken?: CancelToken, headers?: Record<string, string>, isIdempotent?: boolean, retryCount?: number): Promise<T>;
+        getDelay(strategy: RetryStrategy, attempt: number): number;
+        sleep(ms: number): Promise<void>;
+        useGetRoot(): UseQueryResult<ApiInfo, StandardError>;
+        useGetJobs(onProgress?: (fraction: number) => void): UseQueryResult<Job[], StandardError>;
+        getJobsFromCache(): Job[];
+        useGetInfiniteJobs(body: {
+            amt?: number;
+            query?: string;
+            routeId?: string;
+        }): UseInfiniteQueryResult<InfiniteData<Job[], unknown>, StandardError>;
+        useGetRoutes(body: {
+            amt?: number;
+            query?: string;
+        }, total: number, onProgress?: (fraction: number) => void): UseQueryResult<Route[], StandardError>;
+        useGetTeams(body: {
+            amt?: number;
+            query?: string;
+        }, total: number, onProgress?: (fraction: number) => void): UseQueryResult<Team[], StandardError>;
+        useGetSkills(body: {
+            amt?: number;
+            query?: string;
+        }, total: number, onProgress?: (fraction: number) => void): UseQueryResult<Skill[], StandardError>;
+        useGetEvents(body: {
+            amt?: number;
+            known_ids?: string[];
+            unknown_ids?: string[];
+            query?: string;
+            unbilled?: boolean;
+            billed?: boolean;
+            paid?: boolean;
+            jobId?: string;
+        }): UseInfiniteQueryResult<InfiniteData<_Event[], unknown>, StandardError>;
+        useGetSessions(body: {
+            amt?: number;
+            query?: string;
+        }): UseInfiniteQueryResult<InfiniteData<Session[], unknown>, StandardError>;
+        useGetChats(body: {
+            amt?: number;
+            known_ids?: string[];
+            unknown_ids?: string[];
+            query?: string;
+        }): UseInfiniteQueryResult<InfiniteData<Chat[], unknown>, StandardError>;
+        useGetMessages(chatId: string, body: {
+            amt?: number;
+            known_ids?: string[];
+            unknown_ids?: string[];
+            query?: string;
+            unbilled?: boolean;
+            billed?: boolean;
+            paid?: boolean;
+            jobId?: string;
+        }): UseInfiniteQueryResult<InfiniteData<Message[], unknown>, StandardError>;
+        useGetMonths(body: {
+            amt?: number;
+            known_ids?: string[];
+            unknown_ids?: string[];
+            query?: string;
+            unbilled?: boolean;
+            billed?: boolean;
+            paid?: boolean;
+            jobId?: string;
+        }): UseInfiniteQueryResult<InfiniteData<ServiceMonth[], unknown>, StandardError>;
+        useGetBills(body: {
+            amt?: number;
+            known_ids?: string[];
+            unknown_ids?: string[];
+            query?: string;
+            paid?: boolean;
+        }): UseInfiniteQueryResult<InfiniteData<Bill[], unknown>, StandardError>;
+        useGetPlans(code: string): UseQueryResult<Plan[], StandardError>;
+        useGetCompanies(options?: {}): UseQueryResult<Company[], StandardError>;
+        useGetAnalytics(): UseQueryResult<any, StandardError>;
+        useFinanceAnalytics({ periods, cumulative }: {
+            periods: number[][];
+            cumulative: boolean;
+        }): UseQueryResult<FinancialInsightData[], StandardError>;
+        useEventAnalytics({ periods }: {
+            periods: number[][];
+        }): UseQueryResult<EventInsightData[], StandardError>;
+        useGetCompany(companyId: string): UseQueryResult<Company, StandardError>;
+        useGetCurrentCompany(): UseQueryResult<Company, StandardError>;
+        useGetJob(jobId: string): UseQueryResult<Job, StandardError>;
+        useGetEvent(eventId: string): UseQueryResult<_Event, StandardError>;
+        useGetUser(userId: string): UseQueryResult<User, StandardError>;
+        useGetSelf(): UseQueryResult<User, StandardError>;
+        useGetBill(billId: string): UseQueryResult<Bill, StandardError>;
+        useGetRoute(routeId: string): UseQueryResult<Route, StandardError>;
+        useGetChat(chatId: string): UseQueryResult<Chat, StandardError>;
+        useGetUserSessions(): UseQueryResult<Session[], StandardError>;
+        useGetAvro(): UseQueryResult<Avro, StandardError>;
+        useSearchUsers(searchUsername: string): UseQueryResult<User[], StandardError>;
+        useCreateSkill(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            skillData: Partial<Skill>;
+        }>>;
+        useCreateEvent(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            eventData: Partial<_Event>;
+        }>>;
+        useCreateUserSession(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            sessionData: Partial<Session>;
+        }>>;
+        useCreateBill(): ReturnType<typeof useMutation<{
+            id: string;
+            invoice_id: number;
+        }, StandardError, {
+            data: Partial<Bill>;
+        }>>;
+        useCreateCompany(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            companyData: Partial<Company | {
+                logo: File | null;
+            }>;
+        }>>;
+        useCreateJob(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            jobData: Partial<Job>;
+        }>>;
+        useCreateRoute(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            routeData: Partial<Route>;
+        }>>;
+        useCreateTeam(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            teamData: Partial<Team>;
+        }>>;
+        useCreateSelf(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            username: string;
+            name: string;
+            email: string;
+            password: string;
+            phone_number: string;
+            code?: string;
+            invite_token?: string;
+        }>>;
+        useCreateSessionBreak(): ReturnType<typeof useMutation<{
+            id: string;
+        }, StandardError, {
+            sessionId: string;
+            breakData: Partial<Break>;
+        }>>;
+        useUpdateEvent(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            eventId: string;
+            updates: Partial<_Event>;
+        }>>;
+        useSyncBillToIntuit(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            billId: string;
+        }>>;
+        useUpdateUserSession(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            sessionId: string;
+            updates: Partial<Session>;
+        }>>;
+        useUpdateJob(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            jobId: string;
+            updates: Partial<Job>;
+        }>>;
+        useUpdateSkill(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            skillId: string;
+            updates: Partial<Skill>;
+        }>>;
+        useUpdateBill(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            billId: string;
+            updates: Partial<Bill>;
+        }>>;
+        useUpdateRoute(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            routeId: string;
+            updates: Partial<Route>;
+        }>>;
+        useUpdateEvents(): ReturnType<typeof useMutation<void, StandardError, {
+            events: (_Event & {
+                page?: number;
+            })[];
+            action: "billed" | "paid";
+        }>>;
+        useUpdateTeam(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            teamId: string;
+            teamData: Partial<Team>;
+        }>>;
+        useUpdateMonths(): ReturnType<typeof useMutation<void, StandardError, {
+            months: (ServiceMonth & {
+                page?: number;
+            })[];
+            action: "billed" | "paid";
+        }>>;
+        useUpdateUserCompany(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            user_id: string;
+            data: Partial<UserCompanyAssociation>;
+        }>>;
+        useUpdateSessionBreak(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            breakId: string;
+            updates: Partial<Break>;
+        }>>;
+        useDeleteJob(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            jobId: string;
+        }>>;
+        useUpdateCompany(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            companyId: string;
+            companyData: Partial<Company | {
+                logo: File | null;
+            }>;
+        }>>;
+        useRemoveUserCompany(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            userId: string;
+        }>>;
+        useDeleteEvent(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            eventId: string;
+        }>>;
+        useDeleteBill(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            billId: string;
+        }>>;
+        useDeleteRoute(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            routeId: string;
+        }>>;
+        useDeleteSkill(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            skillId: string;
+        }>>;
+        useDeleteSelf(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, void>>;
+        useDeleteCompany(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            companyId: string;
+        }>>;
+        useDeleteTeam(): ReturnType<typeof useMutation<{
+            msg: string;
+        }, StandardError, {
+            teamId: string;
+        }>>;
+    }
+}
 export declare class AvroQueryClient {
-    private config;
+    protected config: Required<AvroQueryClientConfig>;
+    readonly socket: Socket;
+    _isAuthenticated: boolean;
+    companyId: string | null;
+    company: Company | null;
     constructor(config: AvroQueryClientConfig);
-    getDelay(strategy: RetryStrategy, attempt: number): number;
-    private _xhr;
-    private _fetch;
-    get<T>(path: string, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<T>;
-    post<T>(path: string, data: any, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<T>;
-    put<T>(path: string, data: any, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<T>;
-    delete<T>(path: string, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<T>;
-    login(data: {
+    emit(eventName: string, data: unknown): void;
+    on<T>(eventName: string, callback: (data: T) => void): void;
+    off(eventName: string, callback?: Function): void;
+    get<T>(path: string, cancelToken?: CancelToken, headers?: Record<string, string>, progressUpdateCallback?: (loaded: number, total: number) => void): Promise<T>;
+    post<T>(path: string, data: any, cancelToken?: CancelToken, headers?: Record<string, string>, progressUpdateCallback?: (loaded: number, total: number) => void): Promise<T>;
+    put<T>(path: string, data: any, cancelToken?: CancelToken, headers?: Record<string, string>, progressUpdateCallback?: (loaded: number, total: number) => void): Promise<T>;
+    delete<T>(path: string, cancelToken?: CancelToken, headers?: Record<string, string>, progressUpdateCallback?: (loaded: number, total: number) => void): Promise<T>;
+    useLogin(): ReturnType<typeof useMutation<LoginResponse, StandardError, {
         username: string;
-        password: string;
-    }, cancelToken?: CancelToken): Promise<Boolean>;
-    logout(cancelToken?: CancelToken): Promise<void>;
-    fetchJobs(companyGuid: string, amt?: number, knownIds?: string[], unknownIds?: string[], keyword?: string, offset?: number, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
-    fetchEvents(companyGuid: string, amt?: number, knownIds?: string[], unknownIds?: string[], keyword?: string, offset?: number, unbilled?: boolean, billed?: boolean, paid?: boolean, jobId?: string | null, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
-    fetchBills(companyGuid: string, amt?: number, known_ids?: string[], unknown_ids?: string[], keyword?: string, offset?: number, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+        password?: string;
+        code?: string;
+        cancelToken?: CancelToken;
+    }>>;
+    useRequestCode(): ReturnType<typeof useMutation<{
+        msg: string;
+    }, StandardError, {
+        username?: string;
+        email?: string;
+        cancelToken?: CancelToken;
+    }>>;
+    useUpdatePassword(): ReturnType<typeof useMutation<void, StandardError, {
+        username?: string;
+        email?: string;
+        code: string;
+        newPassword: string;
+        cancelToken?: CancelToken;
+    }>>;
+    useGoogleLogin(): ReturnType<typeof useMutation<LoginResponse, StandardError, {
+        token: string;
+        cancelToken?: CancelToken;
+    }>>;
+    setTokens(tokens: Tokens): Promise<void>;
+    setCache(data: Partial<CacheData>): Promise<void>;
+    getCache(key?: keyof CacheData | undefined): Promise<CacheData | string | null>;
+    setCompanyId(companyId: string): Promise<void[]>;
+    clearCache(): Promise<void>;
+    isAuthenticated(): boolean;
+    isAuthenticatedAsync(): Promise<boolean>;
+    getQueryClient(): QueryClient;
+    useLogout(): ReturnType<typeof useMutation<void, StandardError, CancelToken | undefined>>;
+    fetchJobs(body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+        route_id?: string;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchChats(body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchMessages(chatId: string, body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchEvents(body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+        unbilled?: boolean;
+        billed?: boolean;
+        paid?: boolean;
+        jobId?: string | null;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchMonths(body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+        unbilled?: boolean;
+        billed?: boolean;
+        paid?: boolean;
+        jobId?: string | null;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchBills(body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+        paid?: boolean;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchRoutes(body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchTeams(body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchSkills(body?: {
+        amt?: number;
+        known_ids?: string[];
+        unknown_ids?: string[];
+        query?: string;
+        offset?: number;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    fetchSessions(body?: {
+        amt?: number;
+        query?: string;
+        offset?: number;
+    }, cancelToken?: CancelToken, headers?: Record<string, string>): Promise<any>;
+    sendEmail(emailId: string, formData: FormData, progressUpdateCallback?: (loaded: number, total: number) => void): Promise<void>;
 }