@go-avro/avro-js 0.0.1 → 0.0.2-beta.2

package/README.md

@@ -14,4 +14,5 @@ This SDK provides:
 ## Installation
 
 ```bash
-npm install avro-client
+npm i @go-avro/avro-js
+```

package/dist/auth/AuthManager.d.ts

@@ -1,9 +1,15 @@
-import { TokenStorage, Tokens } from '@/types/auth';
+import { TokenStorage, Tokens } from '../types/auth';
 export declare class AuthManager {
-    private fetchNewTokens;
     private storages;
-    constructor(fetchNewTokens: () => Promise<Tokens>, storageOrStorages: TokenStorage | TokenStorage[]);
-    accessToken(): Promise<string>;
-    refreshTokens(): Promise<Tokens>;
-    clearToken(): Promise<void>;
+    private baseUrl;
+    constructor({ baseUrl, storage, }: {
+        baseUrl: string;
+        storage: TokenStorage | TokenStorage[];
+    });
+    hasTokens(): Promise<boolean>;
+    fetchNewTokens(): Promise<Tokens>;
+    accessToken(): Promise<string | undefined>;
+    refreshTokens(): Promise<Tokens | null>;
+    setTokens(tokens: Tokens): Promise<void>;
+    clearTokens(): Promise<void>;
 }

package/dist/auth/AuthManager.js

@@ -1,10 +1,51 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthManager = void 0;
-class AuthManager {
-    constructor(fetchNewTokens, storageOrStorages) {
-        this.fetchNewTokens = fetchNewTokens;
-        this.storages = Array.isArray(storageOrStorages) ? storageOrStorages : [storageOrStorages];
+export class AuthManager {
+    constructor({ baseUrl, storage, }) {
+        this.storages = Array.isArray(storage) ? storage : [storage];
+        if (this.storages.length === 0) {
+            throw new Error('At least one token storage must be provided');
+        }
+        this.storages.forEach(storage => {
+            if (!storage || typeof storage.get !== 'function' || typeof storage.set !== 'function' || typeof storage.clear !== 'function') {
+                throw new Error('Invalid token storage provided');
+            }
+        });
+        this.baseUrl = baseUrl;
+    }
+    async hasTokens() {
+        for (const storage of this.storages) {
+            const tokens = await storage.get();
+            if (tokens && tokens.access_token) {
+                return true;
+            }
+        }
+        return false;
+    }
+    async fetchNewTokens() {
+        const refreshToken = await new Promise((resolve, reject) => {
+            this.storages.map(async (storage) => {
+                const tokens = await storage.get();
+                if (tokens) {
+                    resolve(tokens.refresh_token);
+                }
+            });
+            reject(new Error('No valid refresh token found'));
+        });
+        if (!refreshToken) {
+            throw new Error('No refresh token available');
+        }
+        const response = await fetch(`${this.baseUrl}/refresh`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json',
+                'Authorization': `Bearer ${refreshToken}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error('Failed to refresh tokens');
+        }
+        const tokens = await response.json();
+        return tokens;
     }
     async accessToken() {
         if (!this.storages.length) {
@@ -13,18 +54,26 @@ class AuthManager {
         for (const storage of this.storages) {
             const token = await storage.get();
             if (token)
-                return token;
+                return token.access_token;
         }
-        const newToken = await this.fetchNewTokens();
-        return newToken.accessToken;
+        const newToken = await this.refreshTokens();
+        return newToken?.access_token;
     }
     async refreshTokens() {
-        const newToken = await this.fetchNewTokens();
-        await Promise.all(this.storages.map(s => s.set(newToken)));
-        return newToken;
+        try {
+            const newToken = await this.fetchNewTokens();
+            await Promise.all(this.storages.map(s => s.set(newToken)));
+            return newToken;
+        }
+        catch (error) {
+            console.error('Failed to refresh tokens:', error);
+            return null;
+        }
+    }
+    async setTokens(tokens) {
+        await Promise.all(this.storages.map(s => s.set(tokens)));
     }
-    async clearToken() {
+    async clearTokens() {
         await Promise.all(this.storages.map(s => s.clear()));
     }
 }
-exports.AuthManager = AuthManager;

package/dist/auth/storage.d.ts

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

package/dist/auth/storage.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalStorage = exports.MemoryStorage = void 0;
-class MemoryStorage {
+export class MemoryStorage {
     constructor() {
-        // @ts-ignore: no-unused-vars
         this.tokens = null;
     }
     async get() {
-        return this.tokens ? this.tokens.accessToken : null;
+        return this.tokens ? this.tokens : null;
     }
     async set(tokens) {
         this.tokens = tokens;
@@ -16,14 +12,13 @@ class MemoryStorage {
         this.tokens = null;
     }
 }
-exports.MemoryStorage = MemoryStorage;
-class LocalStorage {
-    constructor(key) {
-        this.key = key;
+export class LocalStorage {
+    constructor() {
+        this.key = 'auth_tokens';
     }
     async get() {
         const item = localStorage.getItem(this.key);
-        return item ? JSON.parse(item).accessToken : null;
+        return item ? JSON.parse(item) : null;
     }
     async set(tokens) {
         localStorage.setItem(this.key, JSON.stringify(tokens));
@@ -32,4 +27,3 @@ class LocalStorage {
         localStorage.removeItem(this.key);
     }
 }
-exports.LocalStorage = LocalStorage;

package/dist/client/QueryClient.d.ts

@@ -1,19 +1,24 @@
-import { AuthManager } from '@/auth/AuthManager';
-import { CancelToken, RetryStrategy } from '@/types/client';
-export interface QueryClientConfig {
+import { AuthManager } from '../auth/AuthManager';
+import { CancelToken, RetryStrategy } from '../types/client';
+export interface AvroQueryClientConfig {
     baseUrl: string;
     authManager: AuthManager;
     maxRetries?: number;
     retryStrategy?: RetryStrategy;
     timeout?: number;
 }
-export declare class QueryClient {
+export declare class AvroQueryClient {
     private config;
-    constructor(config: QueryClientConfig);
+    constructor(config: AvroQueryClientConfig);
     getDelay(strategy: RetryStrategy, attempt: number): number;
     private _xhr;
-    get<T>(path: string, cancelToken?: CancelToken): Promise<T>;
-    post<T>(path: string, data: any, cancelToken?: CancelToken): Promise<T>;
-    put<T>(path: string, data: any, cancelToken?: CancelToken): Promise<T>;
-    delete<T>(path: string, cancelToken?: CancelToken): Promise<T>;
+    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: {
+        username: string;
+        password: string;
+    }, cancelToken?: CancelToken): Promise<Boolean>;
 }

package/dist/client/QueryClient.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryClient = void 0;
-const error_1 = require("@/types/error");
-class QueryClient {
+import { StandardError } from '../types/error';
+export class AvroQueryClient {
     constructor(config) {
         this.config = {
             baseUrl: config.baseUrl,
@@ -24,10 +21,10 @@ class QueryClient {
         }
         throw new Error(`Invalid retry strategy: ${strategy}`);
     }
-    _xhr(method, path, body, cancelToken, retryCount = 0) {
+    _xhr(method, path, body, cancelToken, headers = {}, isIdempotent = false, retryCount = 0) {
         const checkCancelled = () => {
             if (cancelToken?.isCancelled()) {
-                return new error_1.StandardError(0, 'Request cancelled');
+                return new StandardError(0, 'Request cancelled');
             }
             return null;
         };
@@ -39,8 +36,12 @@ class QueryClient {
                 const xhr = new XMLHttpRequest();
                 const url = this.config.baseUrl + path;
                 xhr.open(method, url, true);
-                xhr.setRequestHeader('Content-Type', 'application/json');
-                xhr.setRequestHeader('Authorization', `Bearer ${token}`);
+                if (token) {
+                    xhr.setRequestHeader('Authorization', `Bearer ${token}`);
+                }
+                Object.entries(headers).forEach(([key, value]) => {
+                    xhr.setRequestHeader(key, value);
+                });
                 xhr.onload = () => {
                     const cancelErr = checkCancelled();
                     if (cancelErr)
@@ -49,10 +50,10 @@ class QueryClient {
                         this.config.authManager
                             .refreshTokens()
                             .then(() => {
-                            this._xhr(method, path, body, cancelToken, retryCount + 1).then(resolve, reject);
+                            this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
                         })
                             .catch(() => {
-                            reject(new error_1.StandardError(401, 'Unauthorized (refresh failed)'));
+                            reject(new StandardError(401, 'Unauthorized (refresh failed)'));
                         });
                         return;
                     }
@@ -68,7 +69,7 @@ class QueryClient {
                         if (retryCount < this.config.maxRetries) {
                             const delay = this.getDelay(this.config.retryStrategy, retryCount);
                             setTimeout(() => {
-                                this._xhr(method, path, body, cancelToken, retryCount + 1).then(resolve, reject);
+                                this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
                             }, delay);
                         }
                         else {
@@ -80,7 +81,7 @@ class QueryClient {
                             catch {
                                 console.warn('Failed to parse error response:', xhr.responseText);
                             }
-                            reject(new error_1.StandardError(xhr.status, msg));
+                            reject(new StandardError(xhr.status, msg));
                         }
                     }
                 };
@@ -88,32 +89,105 @@ class QueryClient {
                     if (retryCount < this.config.maxRetries) {
                         const delay = this.getDelay(this.config.retryStrategy, retryCount);
                         setTimeout(() => {
-                            this._xhr(method, path, body, cancelToken, retryCount + 1).then(resolve, reject);
+                            this._xhr(method, path, body, cancelToken, headers, isIdempotent, retryCount + 1).then(resolve, reject);
                         }, delay);
                     }
                     else {
-                        reject(new error_1.StandardError(0, 'Network Error'));
+                        reject(new StandardError(0, 'Network Error'));
                     }
                 };
                 if (this.config.timeout) {
                     xhr.timeout = this.config.timeout;
-                    xhr.ontimeout = () => reject(new error_1.StandardError(0, 'Request timed out'));
+                    xhr.ontimeout = () => reject(new StandardError(0, 'Request timed out'));
+                }
+                xhr.send(body);
+            });
+        });
+    }
+    _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}`;
+            }
+            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);
+                        });
+                    }
                 }
-                xhr.send(body ? JSON.stringify(body) : null);
+                return response.json();
             });
         });
     }
-    get(path, cancelToken) {
-        return this._xhr('GET', path, null, cancelToken);
+    get(path, cancelToken, headers = {}) {
+        return this._xhr('GET', path, null, cancelToken, headers, true);
     }
-    post(path, data, cancelToken) {
-        return this._xhr('POST', path, data, cancelToken);
+    post(path, data, cancelToken, headers = {}) {
+        return this._xhr('POST', path, data, cancelToken, headers, false);
     }
-    put(path, data, cancelToken) {
-        return this._xhr('PUT', path, data, cancelToken);
+    put(path, data, cancelToken, headers = {}) {
+        return this._xhr('PUT', path, data, cancelToken, headers, true);
     }
-    delete(path, cancelToken) {
-        return this._xhr('DELETE', path, null, cancelToken);
+    delete(path, cancelToken, headers = {}) {
+        return this._xhr('DELETE', path, null, cancelToken, headers, false);
+    }
+    // add login that uses fetch and sets the tokens in the auth manager
+    login(data, cancelToken) {
+        return this._fetch('POST', '/login', data, cancelToken)
+            .then(tokens => {
+            if (!tokens || !tokens.access_token || !tokens.refresh_token) {
+                throw new StandardError(401, 'Invalid login response');
+            }
+            return this.config.authManager.setTokens(tokens).then(() => true);
+        })
+            .catch(err => {
+            console.error('Login failed:', err);
+            throw new StandardError(401, 'Login failed');
+        });
     }
 }
-exports.QueryClient = QueryClient;

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { QueryClientConfig, QueryClient } from './client/QueryClient';
+export { AvroQueryClientConfig, AvroQueryClient } from './client/QueryClient';
 export { AuthManager } from './auth/AuthManager';
-export { MemoryStorage } from './auth/storage';
-export * from '@/types/api';
-export * from '@/types/error';
-export * from '@/types/client';
+export { MemoryStorage, LocalStorage } from './auth/storage';
+export * from './types/api';
+export * from './types/error';
+export * from './types/client';

package/dist/index.js

@@ -1,26 +1,6 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MemoryStorage = exports.AuthManager = exports.QueryClient = void 0;
-var QueryClient_1 = require("./client/QueryClient");
-Object.defineProperty(exports, "QueryClient", { enumerable: true, get: function () { return QueryClient_1.QueryClient; } });
-var AuthManager_1 = require("./auth/AuthManager");
-Object.defineProperty(exports, "AuthManager", { enumerable: true, get: function () { return AuthManager_1.AuthManager; } });
-var storage_1 = require("./auth/storage");
-Object.defineProperty(exports, "MemoryStorage", { enumerable: true, get: function () { return storage_1.MemoryStorage; } });
-__exportStar(require("@/types/api"), exports);
-__exportStar(require("@/types/error"), exports);
-__exportStar(require("@/types/client"), exports);
+export { AvroQueryClient } from './client/QueryClient';
+export { AuthManager } from './auth/AuthManager';
+export { MemoryStorage, LocalStorage } from './auth/storage';
+export * from './types/api';
+export * from './types/error';
+export * from './types/client';

package/dist/types/api.d.ts

@@ -1,19 +1,506 @@
-export interface AvroUser {
+export interface PaymentMethod {
+    allow_redisplay: string;
+    autopay: boolean;
+    billing_details: {
+        email: string;
+        name: string;
+    };
+    created: number;
+    customer: string;
+    id: string;
+    type: "us_bank_account" | "card";
+    us_bank_account: {
+        account_holder_type: string;
+        account_type: string;
+        bank_name: string;
+        financial_connections_account: string;
+        fingerprint: string;
+        last4: string;
+        networks: {
+            preferred: string;
+            supported: string[];
+        };
+        routing_number: string;
+        status_details: object;
+    } | null;
+    card: {
+        brand: string;
+        checks: {
+            address_line1_check: string;
+            address_postal_code_check: string;
+            cvc_check: string;
+        };
+        country: string;
+        exp_month: number;
+        exp_year: number;
+        fingerprint: string;
+        funding: string;
+        last4: string;
+        networks: {
+            preferred: string;
+            supported: string[];
+        };
+        three_d_secure_usage: {
+            supported: boolean;
+        };
+        wallet: {
+            type: string;
+        } | null;
+    } | null;
+}
+export interface Avro {
+    id: string;
+    name: string;
+    time_created: number;
+    time_updated: number;
+    emails: Email[];
+    totp_email_id: string;
+    billing_email_id: string;
+    join_email_id: string;
+}
+export interface Friendship {
+}
+export interface MemberState {
+    id: string;
+    state: string;
+    friendship: Friendship | null;
+    last_message_read_at: number | null;
+}
+export interface LineItem {
+    id: string;
+    name: string;
+    description: string;
+    cost: number | null;
+    amount: number | null;
+    time_created: number;
+}
+export interface Reaction {
+    id: string;
+    message_id: string;
+    sender_id: string;
+    reaction: string;
+    time_created: number;
+    time_updated: number;
+}
+export interface Message {
+    id: string;
+    chat_id: string;
+    sender_id: string;
+    reply_to_id: string;
+    content: string;
+    reactions: Reaction[];
+    time_created: number;
+    time_updated: number;
+    time_sent: number;
+    message: string;
+}
+export interface Chat {
+    id: string;
+    name: string;
+    company_id: string;
+    time_created: number;
+    time_updated: number;
+    last_message: Message;
+    user_state: MemberState[];
+    messages: Message[];
+}
+export interface TeamLocation {
+    accuracy: number;
+    heading: number;
+    id: string;
+    latitude: number;
+    longitude: number;
+    time_collected: number;
+    time_created: number;
+    time_updated: number | null;
+}
+export interface Team {
+    autoconfigure: boolean;
+    company_id: string;
+    description: string;
+    end: number[];
+    end_time: number;
+    fixed_cost: number;
+    hourly_cost: number;
+    id: string;
+    items: string[];
+    km_cost: number;
+    max_distance: number;
+    max_jobs: number;
+    max_travel_time: number;
+    color: string;
+    name: string;
+    profile: string;
+    routes: string[];
+    skills: string[];
+    speed_factor: number;
+    start_latitude: number;
+    start_longitude: number;
+    end_latitude: number;
+    end_longitude: number;
+    start_time: number;
+    users: string[];
+    current_location: TeamLocation;
+    start_address: string;
+    end_address: string;
+}
+export interface Subscription {
+    time_created: number;
+    time_updated: string;
+    user: User;
+    user_company_id: string;
+    job_id: string;
+    id: string;
+    notifications: number;
+}
+export interface Plan {
+    id: string;
+    name: string;
+    base_rate: number;
+    price_per_job: number;
+    description: string;
+    referral_codes: string[];
+    trial_period_days: number;
+    time_created: number;
+    time_updated: number;
+}
+export interface BillPayment {
+    id: string;
+    amount: number;
+    stripe_pi_id: string;
+    bill_user_id: string;
+    status: "created" | "processing" | "succeeded" | "failed" | "canceled" | "requires_action";
+    type: "us_bank_account" | "card";
+    action_required_at: number;
+    time_created: number;
+    time_updated: number | null;
+}
+export interface BillUser {
+    id: string;
+    user_id: string;
+    bill_id: string;
+    invoice_id: string;
+    payment_attempts: BillPayment[];
+    time_created: number;
+    time_updated: number | null;
+    amount: number;
+}
+export interface User {
+    id: string;
+    username: string;
+    name: string;
+    verified: boolean;
+    companies: UserCompanyAssociation[] | null;
+    email: string | null;
+    phone_number: string | null;
+    time_created: string | null;
+    time_updated: string | null;
+    can_send_emails: boolean | null;
+    payment_methods: PaymentMethod[];
+    autopay_payment_types: string[];
+    autopay: boolean | null;
+    chats: Chat[];
+    bills: BillUser[];
+}
+export interface Break {
+    id: string;
+    time_started: number;
+    time_ended: number;
+    company_billable: boolean;
+    client_billable: boolean;
+}
+export interface ServiceMonth {
+    id: string;
+    job_name: string;
+    job_id: string | null;
+    bill_id: string | null;
+    cost: number;
+    billed: boolean;
+    paid: boolean;
+    amount: number;
+    time_created: number;
+    time_updated: number | null;
+}
+export interface Session {
+    session_id: string;
+    user_id: string;
+    company_id: string;
+    time_started: number;
+    time_ended: number;
+    break_id: string;
+    is_paused: boolean;
+    team_id: string;
+    current_route_id: string;
+    breaks: Break[];
+}
+export interface Group {
+    id: string;
+    name: string;
+    is_active: boolean;
+    is_user_type: boolean;
+    users: string[];
+    permissions: string[];
+    company_id: string;
+    time_created: number;
+    time_updated: number;
+}
+export interface UserCompanyAssociation {
+    id: string;
+    user: User;
+    company: string;
+    permissions: string[];
+    effective_permissions: string[];
+    time_created: number | null;
+    time_updated: number | null;
+    notification_setting: number[];
+    share_email_company_wide: boolean;
+    notifications: number[];
+    groups: string[];
+}
+export interface Email {
+    id: string;
+    company_id: string;
+    name: string;
+    mail_server: string;
+    mail_port: number;
+    mail_username: string;
+    mail_password: string | null;
+    mail_default_sender: string;
+    mail_use_tls: boolean;
+    mail_use_ssl: boolean;
+    mail_api_key: string;
+    is_company_wide: boolean;
+    users: User[];
+    type: "OUTLOOK" | "SMTP" | "GMAIL";
+    access_token?: string;
+    access_token_expiry?: number;
+    refresh_token?: string;
+    refresh_token_expiry?: number;
+}
+export interface Label {
+    name: string;
+    id: string;
+    company_id: string;
+    color: string;
+    jobs: string[];
+}
+export interface Bill {
+    id: string;
+    invoice_id: number;
+    intuit_id: string | null;
+    name: string;
+    amount: number;
+    billed_by: string;
+    customer_email: string | null;
+    manual_emails: string[][];
+    users: BillUser[];
+    paid_at: number;
+    time_created: number;
+    time_updated: number;
+    events: string[];
+    intent_created_at: number;
+    intent_last_created_at: number;
+    payment: BillPayment | null;
+    line_items: LineItem[];
+    months: string[];
+    due_date: number;
+}
+export interface Skill {
     id: string;
     name: string;
+    company_id: string;
+    time_created: number;
+    time_updated: number;
+}
+export interface PlanPayment {
+    id: string;
+    amount: number;
+    stripe_pi_id: string;
+    company_id: string;
+    plan_id: string;
+    status: "created" | "processing" | "succeeded" | "failed" | "canceled";
+    time_created: number;
+    time_updated: number;
+}
+export interface Company {
+    events: _Event[];
+    months: ServiceMonth[];
+    id: string;
+    jobs: Job[];
+    name: string;
     email: string;
-    teams: AvroTeam[];
+    routes: Route[];
+    teams: Team[];
+    emails: Email[];
+    skills: Skill[];
+    time_created: string;
+    time_updated: string | null;
+    users: UserCompanyAssociation[];
+    use_client_side_customer_start_billing: boolean;
+    use_client_side_customer_stop_billing: boolean;
+    use_client_side_employee_start_billing: boolean;
+    use_client_side_employee_stop_billing: boolean;
+    logo_url: string;
+    delay_scalar: number;
+    incomplete_payments: PlanPayment[];
+    overdue_threshold: number;
+    stripe_account_id: string;
+    is_restricted: false;
+    disabled_reason: string;
+    completed_onboarding: boolean;
+    restricted_soon: boolean;
+    service_email_id: string;
+    billing_email_id: string;
+    num_events: number;
+    num_jobs: number;
+    bills: Bill[];
+    enabled_payment_methods: string[];
+    sessions: Session[];
+    num_sessions: number;
+    labels: Label[];
+    groups: Group[];
+    indicator_lifetime: number;
+    available_plans: Plan[];
+    last_payment: number;
+    last_charged: number;
+    balance: number;
+    plan_id: string;
+    payment_methods: PaymentMethod[];
+    autopay_payment_id: string;
+    intuit_connected: boolean;
+}
+export interface RouteJob {
+    time_created: number;
+    route_id: string;
+    job_id: string;
+    id: string;
+    order: number;
+    estimated_arrival_time: number;
+    scheduled_arrival_time: number;
+    tasks: string[];
 }
-export interface AvroTeam {
+export interface Route {
+    company: string;
     id: string;
+    is_internal: boolean;
+    jobs: RouteJob[];
     name: string;
-    members: AvroUser[];
+    time_created: number;
+    time_updated: number | null;
+    teams: string[];
+    polyline: string;
+    is_optimized: boolean;
+    start_time: number;
+    end_time: number;
+    start_latitude: number;
+    start_longitude: number;
+    end_latitude: number;
+    end_longitude: number;
 }
-export interface AvroJob {
+export interface Job {
+    address: string;
+    company: string;
+    description: string;
     id: string;
-    location: {
-        lat: number;
-        lng: number;
-    };
-    status: 'active' | 'pending' | 'complete';
+    is_one_time: boolean;
+    autostart_radius: number;
+    latitude: number;
+    longitude: number;
+    name: string;
+    internal_notes: string;
+    external_notes: string;
+    priority: number;
+    tasks: Task[];
+    time_created: number;
+    time_updated: number | null;
+    routes: RouteJob[];
+    subscribers: Subscription[];
+    manual_emails: string[][];
+    last_completed_event: _Event | null;
+    last_event: _Event | null;
+    labels: string[];
+    owner: string;
+}
+export interface Task {
+    enforce_proof_amount: boolean;
+    events: _Event[];
+    frequency: number;
+    id: string;
+    job_id: string;
+    name: string;
+    internal_notes: string;
+    external_notes: string;
+    proof_amt: number;
+    images: string[];
+    time_created: number;
+    time_updated: number | null;
+    status: "PENDING_CUSTOMER" | "PENDING_COMPANY" | "ACTIVE" | "ARCHIVED" | "DRAFT";
+    created_by: UserCompanyAssociation | null;
+    overdueness: number | null;
+    overdue_time: number;
+    last_event: _Event | null;
+    delay: number;
+    skills: string[];
+    service: number;
+    bill_mode: "MONTH" | "SERVICE" | "NONE";
+    price: number;
+    services_remaining: number;
+    expire_on: number | null;
+    bill_day: number | null;
+    services_prepaid: number;
+    months_prepaid: number;
+    priority: boolean;
+}
+export interface TaskWrapper {
+    latestEvent: number;
+    task: Task;
+}
+export interface JobWrapper {
+    latestEvent: number;
+    routeIndex: number;
+    job: Job;
+    frequency: number;
+    isOverdue: boolean;
+}
+export interface taskStartInfo {
+    name: string;
+    start: number;
+}
+export interface taskEndInfo {
+    end: number;
+    internal_notes: string;
+    external_notes: string;
+}
+export interface AdditionalCharge {
+    id: string;
+    time_created: number;
+    time_updated: number | null;
+    name: string;
+    amount: number;
+}
+export interface _Event {
+    breaks: string[];
+    id: string;
+    name: string;
+    internal_notes: string;
+    external_notes: string;
+    proofs: string[];
+    tasks: string[];
+    time_created: number;
+    time_ended: number;
+    time_started: number;
+    time_updated: number | null;
+    job_id: string;
+    job_name: string;
+    job_address: string;
+    bill_id: string;
+    billed_amount: number;
+    additional_charges: AdditionalCharge[];
+    user_id: string;
+    team_id: string;
+    cost: number;
+    billed: boolean;
+    paid: boolean;
+    autostart: boolean;
+    job_labels: string[];
 }

package/dist/types/api.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/types/auth.d.ts

@@ -1,9 +1,9 @@
 export interface Tokens {
-    accessToken: string;
-    refreshToken: string;
+    access_token: string;
+    refresh_token: string;
 }
 export interface TokenStorage {
-    get(): Promise<string | null>;
+    get(): Promise<Tokens | null>;
     set(tokens: Tokens): Promise<void>;
     clear(): Promise<void>;
 }

package/dist/types/auth.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/types/client.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/types/error.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StandardError = void 0;
-class StandardError extends Error {
+export class StandardError extends Error {
     constructor(status, message) {
         super(message);
         this.status = status;
         Object.setPrototypeOf(this, StandardError.prototype);
     }
 }
-exports.StandardError = StandardError;

package/package.json

@@ -1,14 +1,22 @@
 {
   "name": "@go-avro/avro-js",
-  "version": "0.0.1",
+  "version": "0.0.2-beta.2",
   "description": "JS client for Avro backend integration.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && tsc-alias",
     "lint": "eslint src",
     "test": "jest",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run lint && npm run build"
+  },
+  "type": "module",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
   },
   "repository": {
     "type": "git",
@@ -33,6 +41,7 @@
     "eslint-plugin-react": "^7.37.5",
     "jest": "^29.0.0",
     "ts-jest": "^29.0.0",
+    "tsc-alias": "^1.8.16",
     "typescript": "^5.8.3",
     "typescript-eslint": "^8.38.0"
   },