@go-avro/avro-js 0.0.2-beta.7 → 0.0.2-beta.71

package/dist/client/QueryClient.js

@@ -1,3 +1,6 @@
+import io from 'socket.io-client';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { LoginResponse } from '../types/api';
 import { StandardError } from '../types/error';
 export class AvroQueryClient {
     constructor(config) {
@@ -8,206 +11,109 @@ export class AvroQueryClient {
             retryStrategy: config.retryStrategy ?? 'fixed',
             timeout: config.timeout ?? 0,
         };
-    }
-    getDelay(strategy, attempt) {
-        if (typeof strategy === 'function') {
-            return strategy(attempt);
-        }
-        else if (strategy === 'fixed') {
-            return 1000;
-        }
-        else if (strategy === 'exponential') {
-            return Math.pow(2, attempt) * 100;
-        }
-        throw new Error(`Invalid retry strategy: ${strategy}`);
-    }
-    _xhr(method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0) {
-        const checkCancelled = () => {
-            if (cancelToken?.isCancelled()) {
-                return new StandardError(0, 'Request cancelled');
-            }
-            return null;
-        };
-        return this.config.authManager.accessToken().then(token => {
-            return new Promise((resolve, reject) => {
-                const cancelErr = checkCancelled();
-                if (cancelErr)
-                    return reject(cancelErr);
-                const xhr = new XMLHttpRequest();
-                const url = this.config.baseUrl + path;
-                xhr.open(method, url, true);
-                if (token) {
-                    xhr.setRequestHeader('Authorization', `Bearer ${token}`);
-                }
-                Object.entries(headers).forEach(([key, value]) => {
-                    xhr.setRequestHeader(key, value);
-                });
-                xhr.onload = () => {
-                    const cancelErr = checkCancelled();
-                    if (cancelErr)
-                        return reject(cancelErr);
-                    if (xhr.status === 401 && this.config.authManager.refreshTokens && retryCount === 0) {
-                        this.config.authManager
-                            .refreshTokens()
-                            .then(() => {
-                            this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
-                        })
-                            .catch(() => {
-                            reject(new StandardError(401, 'Unauthorized (refresh failed)'));
-                        });
-                        return;
-                    }
-                    if (xhr.status >= 200 && xhr.status < 300) {
-                        try {
-                            resolve(JSON.parse(xhr.responseText));
-                        }
-                        catch {
-                            resolve(xhr.responseText);
-                        }
-                    }
-                    else {
-                        if (retryCount < this.config.maxRetries) {
-                            const delay = this.getDelay(this.config.retryStrategy, retryCount);
-                            setTimeout(() => {
-                                this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
-                            }, delay);
-                        }
-                        else {
-                            let msg = xhr.statusText;
-                            try {
-                                const parsed = JSON.parse(xhr.responseText);
-                                msg = parsed.message || msg;
-                            }
-                            catch {
-                                console.warn('Failed to parse error response:', xhr.responseText);
-                            }
-                            reject(new StandardError(xhr.status, msg));
-                        }
-                    }
-                };
-                xhr.onerror = () => {
-                    if (retryCount < this.config.maxRetries) {
-                        const delay = this.getDelay(this.config.retryStrategy, retryCount);
-                        setTimeout(() => {
-                            this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
-                        }, delay);
-                    }
-                    else {
-                        reject(new StandardError(0, 'Network Error'));
-                    }
-                };
-                if (this.config.timeout) {
-                    xhr.timeout = this.config.timeout;
-                    xhr.ontimeout = () => reject(new StandardError(0, 'Request timed out'));
-                }
-                xhr.send(body);
+        this.socket = io(config.baseUrl, { autoConnect: false, transports: ["websocket"], });
+        if (!this.socket.connected) {
+            this.config.authManager.accessToken().then(token => {
+                console.log('Initializing socket connection with token...');
+                this.socket.auth = { token: token };
+                this.socket.connect();
             });
+        }
+        this.socket.on('connect', () => {
+            console.log(`Socket connected with ID: ${this.socket?.id}`);
         });
-    }
-    _fetch(method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0) {
-        const checkCancelled = () => {
-            if (cancelToken?.isCancelled()) {
-                return new StandardError(0, 'Request cancelled');
-            }
-            return null;
-        };
-        return this.config.authManager.accessToken().then(token => {
-            const cancelErr = checkCancelled();
-            if (cancelErr)
-                return Promise.reject(cancelErr);
-            const url = this.config.baseUrl + path;
-            const requestHeaders = {
-                'Content-Type': 'application/json',
-                ...headers,
-            };
-            if (token) {
-                requestHeaders['Authorization'] = `Bearer ${token}`;
+        this.socket.on('disconnect', (reason) => {
+            console.log(`Socket disconnected: ${reason}`);
+        });
+        this.socket.on('connect_error', (err) => {
+            console.error(`Socket connection error: ${err.message}`);
+        });
+        this.config.authManager.onTokenRefreshed((newAccessToken) => {
+            if (this.socket && newAccessToken) {
+                console.log('Access token refreshed, updating socket auth...');
+                this.socket.auth = { token: newAccessToken };
+                this.socket.disconnect().connect();
             }
-            const options = {
-                method,
-                headers: requestHeaders,
-                body: body ? JSON.stringify(body) : null,
-            };
-            return fetch(url, options).then(response => {
-                if (response.status === 401 && this.config.authManager.refreshTokens && retryCount === 0) {
-                    return this.config.authManager
-                        .refreshTokens()
-                        .then(() => this._fetch(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1))
-                        .catch(() => Promise.reject(new StandardError(401, 'Unauthorized (refresh failed)')));
-                }
-                if (!response.ok) {
-                    if (retryCount < this.config.maxRetries) {
-                        const delay = this.getDelay(this.config.retryStrategy, retryCount);
-                        return new Promise((resolve, reject) => {
-                            setTimeout(() => {
-                                this._fetch(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1)
-                                    .then(resolve)
-                                    .catch(reject);
-                            }, delay);
-                        });
-                    }
-                    else {
-                        return response.text().then(text => {
-                            let msg = response.statusText;
-                            try {
-                                const parsed = JSON.parse(text);
-                                msg = parsed.message || msg;
-                            }
-                            catch {
-                                console.warn('Failed to parse error response:', text);
-                            }
-                            throw new StandardError(response.status, msg);
-                        });
-                    }
-                }
-                return response.json();
-            });
         });
     }
-    get(path, cancelToken, headers = {}) {
-        return this._xhr('GET', path, null, cancelToken, headers, true);
+    emit(eventName, data) {
+        if (!this.socket?.connected) {
+            console.error('Socket is not connected. Cannot emit event.');
+            return;
+        }
+        this.socket.emit(eventName, data);
+    }
+    on(eventName, callback) {
+        this.socket?.on(eventName, callback);
     }
-    post(path, data, cancelToken, headers = {}) {
-        return this._xhr('POST', path, data, cancelToken, headers, false);
+    off(eventName, callback) {
+        this.socket?.off(eventName, callback);
     }
-    put(path, data, cancelToken, headers = {}) {
-        return this._xhr('PUT', path, data, cancelToken, headers, true);
+    get(path, cancelToken, headers = {}, progressUpdateCallback) {
+        return this._xhr('GET', path, null, cancelToken, headers, true, this.config.maxRetries, progressUpdateCallback);
     }
-    delete(path, cancelToken, headers = {}) {
-        return this._xhr('DELETE', path, null, cancelToken, headers, false);
+    post(path, data, cancelToken, headers = {}, progressUpdateCallback) {
+        return this._xhr('POST', path, data, cancelToken, headers, false, this.config.maxRetries, progressUpdateCallback);
+    }
+    put(path, data, cancelToken, headers = {}, progressUpdateCallback) {
+        return this._xhr('PUT', path, data, cancelToken, headers, true, this.config.maxRetries, progressUpdateCallback);
+    }
+    delete(path, cancelToken, headers = {}, progressUpdateCallback) {
+        return this._xhr('DELETE', path, null, cancelToken, headers, false, this.config.maxRetries, progressUpdateCallback);
     }
     login(data, cancelToken) {
         return this._fetch('POST', '/login', data, cancelToken)
-            .then(tokens => {
-            if (!tokens || !tokens.access_token || !tokens.refresh_token) {
+            .then(resp => {
+            if (!resp || !('access_token' in resp)) {
+                if (resp.msg === "TOTP email sent") {
+                    return LoginResponse.NEEDS_TOTP;
+                }
                 throw new StandardError(401, 'Invalid login response');
             }
-            return this.config.authManager.setTokens(tokens).then(() => true);
+            this.socket.auth = { token: resp.access_token };
+            if (!this.socket.connected) {
+                this.socket.connect();
+            }
+            return this.config.authManager.setTokens({ access_token: resp.access_token, refresh_token: resp.refresh_token }).then(() => {
+                return LoginResponse.SUCCESS;
+            });
         })
             .catch(err => {
             console.error('Login failed:', err);
             throw new StandardError(401, 'Login failed');
         });
     }
-    logout(cancelToken) {
-        return this._fetch('POST', '/logout', null, cancelToken)
-            .then(() => this.config.authManager.clearTokens())
-            .catch(err => {
-            console.error('Logout failed:', err);
-            throw new StandardError(500, 'Logout failed');
+    setTokens(tokens) {
+        return this.config.authManager.setTokens(tokens);
+    }
+    clearTokens() {
+        return this.config.authManager.clearTokens();
+    }
+    useLogout() {
+        const queryClient = useQueryClient();
+        return useMutation({
+            mutationFn: async (cancelToken) => {
+                await this._fetch('POST', '/logout', null, cancelToken);
+                await this.config.authManager.clearTokens();
+                if (this.socket && this.socket.connected) {
+                    this.socket.disconnect();
+                }
+            },
+            onSettled: () => {
+                queryClient.invalidateQueries();
+            },
+            onError: (err) => {
+                this.config.authManager.clearTokens();
+                console.error('Logout failed:', err);
+                throw new StandardError(500, 'Logout failed');
+            }
         });
     }
-    fetchJobs(companyGuid, amt = 50, knownIds = [], unknownIds = [], keyword = '', offset = 0, cancelToken, headers = {}) {
-        const body = {
-            amt,
-            known_ids: knownIds,
-            unknown_ids: unknownIds,
-            query: keyword,
-        };
-        if (!companyGuid) {
+    fetchJobs(companyGuid, body = {}, cancelToken, headers = {}) {
+        if (!companyGuid || companyGuid.trim() === '') {
             return Promise.reject(new StandardError(400, 'Company GUID is required'));
         }
-        return this._fetch('POST', `/company/${companyGuid}/jobs?amt=${amt}&offset=${offset}`, body, cancelToken, headers)
+        return this._fetch('POST', `/company/${companyGuid}/jobs`, body, cancelToken, headers)
             .then(response => {
             if (!response || !Array.isArray(response)) {
                 throw new StandardError(400, 'Invalid jobs response');
@@ -219,17 +125,43 @@ export class AvroQueryClient {
             throw new StandardError(500, 'Failed to fetch jobs');
         });
     }
-    fetchEvents(companyGuid, amt = 50, known_ids = [], unknown_ids = [], keyword = '', offset = 0, cancelToken, headers = {}) {
-        const body = {
-            amt,
-            known_ids,
-            unknown_ids,
-            query: keyword,
-        };
-        if (!companyGuid) {
+    fetchChats(companyGuid, body = {}, cancelToken, headers = {}) {
+        if (!companyGuid || companyGuid.trim() === '') {
             return Promise.reject(new StandardError(400, 'Company GUID is required'));
         }
-        return this._fetch('POST', `/company/${companyGuid}/events?amt=${amt}&offset=${offset}`, body, cancelToken, headers)
+        return this._fetch('POST', `/company/${companyGuid}/chats`, body, cancelToken, headers)
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid chats response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch chats:', err);
+            throw new StandardError(500, 'Failed to fetch chats');
+        });
+    }
+    fetchMessages(chatGuid, body = {}, cancelToken, headers = {}) {
+        if (!chatGuid || chatGuid.trim() === '') {
+            return Promise.reject(new StandardError(400, 'Chat GUID is required'));
+        }
+        return this._fetch('POST', `/chat/${chatGuid}/messages`, body, cancelToken, headers)
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid messages response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch messages:', err);
+            throw new StandardError(500, 'Failed to fetch messages');
+        });
+    }
+    fetchEvents(companyGuid, body = {}, cancelToken, headers = {}) {
+        if (!companyGuid || companyGuid.trim() === '') {
+            return Promise.reject(new StandardError(400, 'Company GUID is required'));
+        }
+        return this._fetch('POST', `/company/${companyGuid}/events`, body, cancelToken, headers)
             .then(response => {
             if (!response || !Array.isArray(response)) {
                 throw new StandardError(400, 'Invalid events response');
@@ -241,4 +173,97 @@ export class AvroQueryClient {
             throw new StandardError(500, 'Failed to fetch events');
         });
     }
+    fetchMonths(companyGuid, body = {}, cancelToken, headers = {}) {
+        if (!companyGuid || companyGuid.trim() === '') {
+            return Promise.reject(new StandardError(400, 'Company GUID is required'));
+        }
+        return this._fetch('POST', `/company/${companyGuid}/months`, body, cancelToken, headers)
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid months response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch months:', err);
+            throw new StandardError(500, 'Failed to fetch months');
+        });
+    }
+    fetchBills(companyGuid, body = {}, cancelToken, headers = {}) {
+        if (!companyGuid || companyGuid.trim() === '') {
+            return Promise.reject(new StandardError(400, 'Company GUID is required'));
+        }
+        return this._fetch('POST', `/company/${companyGuid}/bills`, body, cancelToken, headers)
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid bills response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch bills:', err);
+            throw new StandardError(500, 'Failed to fetch bills');
+        });
+    }
+    fetchRoutes(companyGuid, body = {}, cancelToken, headers = {}) {
+        if (!companyGuid || companyGuid.trim() === '') {
+            return Promise.reject(new StandardError(400, 'Company GUID is required'));
+        }
+        return this._fetch('POST', `/company/${companyGuid}/routes`, body, cancelToken, headers)
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid routes response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch routes:', err);
+            throw new StandardError(500, 'Failed to fetch routes');
+        });
+    }
+    fetchTeams(companyGuid, body = {}, cancelToken, headers = {}) {
+        if (!companyGuid || companyGuid.trim() === '') {
+            return Promise.reject(new StandardError(400, 'Company GUID is required'));
+        }
+        return this._fetch('POST', `/company/${companyGuid}/teams`, body, cancelToken, headers)
+            .then(response => {
+            if (!response || !Array.isArray(response)) {
+                throw new StandardError(400, 'Invalid teams response');
+            }
+            return response;
+        })
+            .catch(err => {
+            console.error('Failed to fetch teams:', err);
+            throw new StandardError(500, 'Failed to fetch teams');
+        });
+    }
+    sendEmail(emailId, formData, progressUpdateCallback) {
+        try {
+            return this.post(`/email/${emailId}`, formData, undefined, {}, progressUpdateCallback);
+        }
+        catch (error) {
+            throw new StandardError(500, `Failed to send email: ${error}`);
+        }
+    }
+    createBill(companyGuid, data, cancelToken) {
+        if (!companyGuid) {
+            return Promise.reject(new StandardError(400, 'Company GUID is required'));
+        }
+        const body = {
+            events: data.line_items.filter(item => item.line_item_type === 'EVENT').map(item => item.id),
+            months: data.line_items.filter(item => item.line_item_type === 'SERVICE_MONTH').map(item => item.id),
+            line_items: data.line_items.filter(item => item.line_item_type === 'CUSTOM'),
+            manual_emails: data.custom_emails,
+            users: data.users,
+            due_date: data.due_date,
+        };
+        try {
+            return this._xhr('POST', `/company/${companyGuid}/bill`, JSON.stringify(body), cancelToken, {
+                'Content-Type': 'application/json',
+            });
+        }
+        catch (error) {
+            throw new StandardError(500, `Failed to create bill: ${error}`);
+        }
+    }
 }

package/dist/client/core/fetch.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client/core/fetch.js

@@ -0,0 +1,67 @@
+import { AvroQueryClient } from '../../client/QueryClient';
+import { StandardError } from '../../types/error';
+AvroQueryClient.prototype._fetch = function (method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0) {
+    const checkCancelled = () => {
+        try {
+            if (cancelToken?.isCancelled()) {
+                return new StandardError(0, 'Request cancelled');
+            }
+        }
+        catch (error) {
+            throw new StandardError(0, `Error checking cancellation (${typeof cancelToken}): ${error}`);
+        }
+        return null;
+    };
+    return this.config.authManager.accessToken().then(token => {
+        const cancelErr = checkCancelled();
+        if (cancelErr)
+            return Promise.reject(cancelErr);
+        const url = this.config.baseUrl + path;
+        const requestHeaders = {
+            'Content-Type': 'application/json',
+            ...headers,
+        };
+        if (token) {
+            requestHeaders['Authorization'] = `Bearer ${token}`;
+        }
+        const options = {
+            method,
+            headers: requestHeaders,
+            body: body ? JSON.stringify(body) : null,
+        };
+        return fetch(url, options).then(response => {
+            if (response.status === 401 && this.config.authManager.refreshTokens && retryCount === 0) {
+                return this.config.authManager
+                    .refreshTokens()
+                    .then(() => this._fetch(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1))
+                    .catch(() => Promise.reject(new StandardError(401, 'Unauthorized (refresh failed)')));
+            }
+            if (!response.ok) {
+                if (retryCount < this.config.maxRetries) {
+                    const delay = this.getDelay(this.config.retryStrategy, retryCount);
+                    return new Promise((resolve, reject) => {
+                        setTimeout(() => {
+                            this._fetch(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1)
+                                .then(resolve)
+                                .catch(reject);
+                        }, delay);
+                    });
+                }
+                else {
+                    return response.text().then(text => {
+                        let msg = response.statusText;
+                        try {
+                            const parsed = JSON.parse(text);
+                            msg = parsed.message || msg;
+                        }
+                        catch {
+                            console.warn('Failed to parse error response:', text);
+                        }
+                        throw new StandardError(response.status, msg);
+                    });
+                }
+            }
+            return response.json();
+        });
+    });
+};

package/dist/client/core/utils.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client/core/utils.js

@@ -0,0 +1,13 @@
+import { AvroQueryClient } from '../../client/QueryClient';
+AvroQueryClient.prototype.getDelay = function (strategy, attempt) {
+    if (typeof strategy === 'function') {
+        return strategy(attempt);
+    }
+    else if (strategy === 'fixed') {
+        return 1000;
+    }
+    else if (strategy === 'exponential') {
+        return Math.pow(2, attempt) * 100;
+    }
+    throw new Error(`Invalid retry strategy: ${strategy}`);
+};

package/dist/client/core/xhr.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client/core/xhr.js

@@ -0,0 +1,87 @@
+import { AvroQueryClient } from '../../client/QueryClient';
+import { StandardError } from '../../types/error';
+AvroQueryClient.prototype._xhr = function (method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0, progressUpdateCallback) {
+    const checkCancelled = () => {
+        if (cancelToken?.isCancelled()) {
+            return new StandardError(0, 'Request cancelled');
+        }
+        return null;
+    };
+    return new Promise((resolve, reject) => {
+        this.config.authManager.accessToken().then(token => {
+            const cancelErr = checkCancelled();
+            if (cancelErr)
+                return reject(cancelErr);
+            const xhr = new XMLHttpRequest();
+            const url = this.config.baseUrl + path;
+            xhr.open(method, url, true);
+            if (token)
+                xhr.setRequestHeader('Authorization', `Bearer ${token}`);
+            Object.entries(headers).forEach(([key, value]) => xhr.setRequestHeader(key, value));
+            xhr.onload = () => {
+                const cancelErr = checkCancelled();
+                if (cancelErr)
+                    return reject(cancelErr);
+                if (xhr.status === 401 && this.config.authManager.refreshTokens && retryCount === 0) {
+                    this.config.authManager
+                        .refreshTokens()
+                        .then(() => {
+                        this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
+                    })
+                        .catch(() => reject(new StandardError(401, 'Unauthorized (refresh failed)')));
+                    return;
+                }
+                if (xhr.status >= 200 && xhr.status < 300) {
+                    try {
+                        resolve(JSON.parse(xhr.responseText));
+                    }
+                    catch {
+                        resolve(xhr.responseText);
+                    }
+                }
+                else {
+                    if (retryCount < this.config.maxRetries) {
+                        const delay = this.getDelay(this.config.retryStrategy, retryCount);
+                        setTimeout(() => {
+                            this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
+                        }, delay);
+                    }
+                    else {
+                        let msg = xhr.statusText;
+                        try {
+                            const parsed = JSON.parse(xhr.responseText);
+                            msg = parsed.msg || msg;
+                        }
+                        catch {
+                            console.warn('Failed to parse error response:', xhr.responseText);
+                        }
+                        reject(new StandardError(xhr.status, msg));
+                    }
+                }
+            };
+            if (progressUpdateCallback && xhr.upload) {
+                xhr.upload.onprogress = (event) => {
+                    if (event.lengthComputable) {
+                        progressUpdateCallback(event.loaded, event.total);
+                    }
+                };
+            }
+            xhr.onerror = () => {
+                if (retryCount < this.config.maxRetries) {
+                    const delay = this.getDelay(this.config.retryStrategy, retryCount);
+                    setTimeout(() => {
+                        this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
+                    }, delay);
+                }
+                else {
+                    reject(new StandardError(0, 'Network Error'));
+                }
+            };
+            if (this.config.timeout) {
+                xhr.timeout = this.config.timeout;
+                xhr.ontimeout = () => reject(new StandardError(0, 'Request timed out'));
+            }
+            xhr.send(body);
+        });
+    });
+};

package/dist/client/hooks/analytics.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client/hooks/analytics.js

@@ -0,0 +1,10 @@
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { AvroQueryClient } from "../../client/QueryClient";
+AvroQueryClient.prototype.useGetAnalytics = function () {
+    const queryClient = useQueryClient();
+    return useQuery({
+        queryKey: ['analytics'],
+        queryFn: () => this.post('/avro/analytics', null),
+        enabled: true,
+    });
+};

package/dist/client/hooks/avro.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client/hooks/avro.js

@@ -0,0 +1,9 @@
+import { useQuery } from "@tanstack/react-query";
+import { AvroQueryClient } from "../../client/QueryClient";
+AvroQueryClient.prototype.useGetAvro = function () {
+    return useQuery({
+        queryKey: ['avro'],
+        queryFn: () => this.get('/avro'),
+        enabled: true,
+    });
+};

package/dist/client/hooks/bills.d.ts

@@ -0,0 +1 @@
+export {};