velora-node-sdk 1.0.0

package/dist/client/VeloraClient.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeloraClient = void 0;
+const CredentialManager_1 = require("../auth/CredentialManager");
+const HttpClient_1 = require("../http/HttpClient");
+const WebSocketClient_1 = require("../ws/WebSocketClient");
+const errors_1 = require("../types/errors");
+const events_1 = require("events");
+class VeloraClient extends events_1.EventEmitter {
+    constructor(config) {
+        super();
+        this.wsClient = null;
+        const host = config?.host || '127.0.0.1';
+        const port = config?.port || 39031;
+        this.baseUrl = `http://${host}:${port}`;
+        this.wsBaseUrl = `ws://${host}:${port}`;
+        this.credentialManager = new CredentialManager_1.CredentialManager(this.baseUrl, config?.token);
+        this.httpClient = new HttpClient_1.HttpClient(this.baseUrl, this.credentialManager, config?.httpOptions);
+        if (config?.token) {
+            if (config.requestedPermissions) {
+                this.credentialManager.setToken(config.token, config.requestedPermissions);
+            }
+        }
+    }
+    isAuthenticated() {
+        return this.credentialManager.isAuthenticated();
+    }
+    async registerApp(appConfig) {
+        return this.credentialManager.register(appConfig);
+    }
+    async requestAccessToken(requestId, maxWaitMs) {
+        return this.credentialManager.requestAccessToken(requestId, maxWaitMs);
+    }
+    async getHealth() {
+        return this.httpClient.getHealth();
+    }
+    async getCurrentTrack() {
+        return this.httpClient.getCurrentTrack();
+    }
+    async getPlaybackState() {
+        return this.httpClient.getPlaybackState();
+    }
+    async getPlaybackQueue() {
+        return this.httpClient.getPlaybackQueue();
+    }
+    async getUserPublic() {
+        return this.httpClient.getUserPublic();
+    }
+    async play(trackId) {
+        return this.httpClient.play(trackId);
+    }
+    async pause() {
+        return this.httpClient.pause();
+    }
+    async next() {
+        return this.httpClient.next();
+    }
+    async seek(position) {
+        return this.httpClient.seek(position);
+    }
+    async toggle() {
+        return this.httpClient.toggle();
+    }
+    async connectWebSocket() {
+        if (!this.credentialManager.isAuthenticated()) {
+            throw new errors_1.AuthError('Cannot connect WebSocket without authentication');
+        }
+        if (this.wsClient === null) {
+            const wsOptions = {};
+            this.wsClient = new WebSocketClient_1.WebSocketClient(this.wsBaseUrl, this.credentialManager, 1000, 60000);
+            this.wsClient.on('connected', () => this.emit('ws:connected'));
+            this.wsClient.on('disconnected', () => this.emit('ws:disconnected'));
+            this.wsClient.on('connecting', () => this.emit('ws:connecting'));
+            this.wsClient.on('error', (error) => this.emit('ws:error', error));
+            this.wsClient.on('track_changed', (data) => this.emit('track_changed', data));
+            this.wsClient.on('playback_state_changed', (data) => this.emit('playback_state_changed', data));
+            this.wsClient.on('message', (data) => this.emit('ws:message', data));
+        }
+        await this.wsClient.connect();
+    }
+    async disconnectWebSocket() {
+        if (this.wsClient) {
+            this.wsClient.disconnect();
+            this.wsClient = null;
+        }
+    }
+    isWSConnected() {
+        return this.wsClient?.isWSConnected() || false;
+    }
+    async connect() {
+        try {
+            await this.getHealth();
+        }
+        catch (error) {
+            throw new errors_1.AuthError('Cannot reach Velora API');
+        }
+        if (this.credentialManager.isAuthenticated()) {
+            try {
+                await this.connectWebSocket();
+            }
+            catch (error) {
+                console.warn('WebSocket connection failed, but HTTP client is ready');
+            }
+        }
+    }
+    async disconnect() {
+        if (this.wsClient) {
+            await this.disconnectWebSocket();
+        }
+    }
+    clearCredentials() {
+        this.credentialManager.clear();
+    }
+    getToken() {
+        return this.credentialManager.getToken();
+    }
+    setToken(token, permissions) {
+        this.credentialManager.setToken(token, permissions);
+    }
+    getPermissions() {
+        return this.credentialManager.getPermissions();
+    }
+}
+exports.VeloraClient = VeloraClient;

package/dist/client/index.d.ts

@@ -0,0 +1 @@
+export { VeloraClient } from './VeloraClient';

package/dist/client/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeloraClient = void 0;
+var VeloraClient_1 = require("./VeloraClient");
+Object.defineProperty(exports, "VeloraClient", { enumerable: true, get: function () { return VeloraClient_1.VeloraClient; } });

package/dist/http/HttpClient.d.ts

@@ -0,0 +1,22 @@
+import { CredentialManager } from '../auth/CredentialManager';
+import { HealthResponse, CurrentTrackResponse, PlaybackStateResponse, PlaybackQueueResponse, UserPublicResponse, PlayResponse, PauseResponse, NextResponse, SeekResponse, ToggleResponse } from '../types/api';
+import { HttpRequestOptions } from '../types/client';
+export declare class HttpClient {
+    private readonly baseUrl;
+    private readonly credentialManager;
+    private readonly timeout;
+    private readonly retryManager;
+    constructor(baseUrl: string, credentialManager: CredentialManager, options?: HttpRequestOptions);
+    getHealth(): Promise<HealthResponse>;
+    getCurrentTrack(): Promise<CurrentTrackResponse>;
+    getPlaybackState(): Promise<PlaybackStateResponse>;
+    getPlaybackQueue(): Promise<PlaybackQueueResponse>;
+    getUserPublic(): Promise<UserPublicResponse>;
+    play(trackId?: string): Promise<PlayResponse>;
+    pause(): Promise<PauseResponse>;
+    next(): Promise<NextResponse>;
+    seek(position: number): Promise<SeekResponse>;
+    toggle(): Promise<ToggleResponse>;
+    private requirePermission;
+    private request;
+}

package/dist/http/HttpClient.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const errors_1 = require("../types/errors");
+const RetryManager_1 = require("./RetryManager");
+class HttpClient {
+    constructor(baseUrl, credentialManager, options) {
+        this.baseUrl = baseUrl;
+        this.credentialManager = credentialManager;
+        this.timeout = options?.timeout || 30000;
+        this.retryManager = new RetryManager_1.RetryManager(1000, 32000, options?.maxRetries ?? 3);
+    }
+    async getHealth() {
+        return this.request('GET', '/health');
+    }
+    async getCurrentTrack() {
+        this.requirePermission('read');
+        return this.request('GET', '/current-track');
+    }
+    async getPlaybackState() {
+        this.requirePermission('read');
+        return this.request('GET', '/playback-state');
+    }
+    async getPlaybackQueue() {
+        this.requirePermission('read');
+        return this.request('GET', '/playback-queue');
+    }
+    async getUserPublic() {
+        this.requirePermission('read');
+        return this.request('GET', '/user/public');
+    }
+    async play(trackId) {
+        this.requirePermission('write');
+        const body = {};
+        if (trackId) {
+            body.track_id = trackId;
+        }
+        return this.request('POST', '/play', body);
+    }
+    async pause() {
+        this.requirePermission('write');
+        return this.request('POST', '/pause');
+    }
+    async next() {
+        this.requirePermission('write');
+        return this.request('POST', '/next');
+    }
+    async seek(position) {
+        this.requirePermission('write');
+        if (typeof position !== 'number' || position < 0) {
+            throw new errors_1.ValidationError('position must be a non-negative number (milliseconds)', 'position');
+        }
+        const body = { position };
+        return this.request('POST', '/seek', body);
+    }
+    async toggle() {
+        this.requirePermission('write');
+        return this.request('POST', '/toggle');
+    }
+    requirePermission(permission) {
+        if (!this.credentialManager.hasPermission(permission)) {
+            throw new errors_1.AuthError(`Missing ${permission} permission`);
+        }
+    }
+    async request(method, path, body) {
+        const makeRequest = async () => {
+            const url = `${this.baseUrl}${path}`;
+            const headers = {
+                'Content-Type': 'application/json',
+            };
+            const authHeader = this.credentialManager.getAuthHeader();
+            if (authHeader) {
+                headers['Authorization'] = authHeader;
+            }
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+            try {
+                const response = await fetch(url, {
+                    method,
+                    headers,
+                    body: body ? JSON.stringify(body) : undefined,
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    let errorMsg = `HTTP ${response.status}`;
+                    try {
+                        const errorBody = await response.json();
+                        errorMsg = errorBody.error || errorMsg;
+                    }
+                    catch { }
+                    if (response.status === 401) {
+                        throw new errors_1.AuthError(errorMsg, response.status);
+                    }
+                    throw new errors_1.RequestError(errorMsg, response.status);
+                }
+                return await response.json();
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                if (error instanceof errors_1.RequestError || error instanceof errors_1.AuthError) {
+                    throw error;
+                }
+                if (error instanceof Error && error.name === 'AbortError') {
+                    throw new errors_1.TimeoutError(`Request timeout after ${this.timeout}ms`, this.timeout);
+                }
+                throw (0, errors_1.classifyError)(error);
+            }
+        };
+        return this.retryManager.executeWithRetry(makeRequest, (attempt, backoffMs) => {
+            void backoffMs;
+            void attempt;
+        });
+    }
+}
+exports.HttpClient = HttpClient;

package/dist/http/RetryManager.d.ts

@@ -0,0 +1,9 @@
+export declare class RetryManager {
+    private readonly initialBackoffMs;
+    private readonly maxBackoffMs;
+    private readonly maxRetries;
+    constructor(initialBackoffMs?: number, maxBackoffMs?: number, maxRetries?: number);
+    shouldRetry(statusCode: number): boolean;
+    getBackoffMs(attemptNumber: number): number;
+    executeWithRetry<T>(fn: () => Promise<T>, onRetry?: (attempt: number, backoffMs: number) => void): Promise<T>;
+}

package/dist/http/RetryManager.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryManager = void 0;
+class RetryManager {
+    constructor(initialBackoffMs = 1000, maxBackoffMs = 32000, maxRetries = 3) {
+        this.initialBackoffMs = initialBackoffMs;
+        this.maxBackoffMs = maxBackoffMs;
+        this.maxRetries = maxRetries;
+    }
+    shouldRetry(statusCode) {
+        if (statusCode >= 500 && statusCode < 600) {
+            return true;
+        }
+        if (statusCode === 408 || statusCode === 429) {
+            return true;
+        }
+        return false;
+    }
+    getBackoffMs(attemptNumber) {
+        const exponentialBackoff = this.initialBackoffMs * Math.pow(2, attemptNumber);
+        return Math.min(exponentialBackoff, this.maxBackoffMs);
+    }
+    async executeWithRetry(fn, onRetry) {
+        let lastError = null;
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            try {
+                return await fn();
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (attempt < this.maxRetries) {
+                    const backoffMs = this.getBackoffMs(attempt);
+                    if (onRetry) {
+                        onRetry(attempt + 1, backoffMs);
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, backoffMs));
+                }
+            }
+        }
+        throw lastError || new Error('Request failed after retries');
+    }
+}
+exports.RetryManager = RetryManager;

package/dist/http/index.d.ts

@@ -0,0 +1,2 @@
+export { HttpClient } from './HttpClient';
+export { RetryManager } from './RetryManager';

package/dist/http/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryManager = exports.HttpClient = void 0;
+var HttpClient_1 = require("./HttpClient");
+Object.defineProperty(exports, "HttpClient", { enumerable: true, get: function () { return HttpClient_1.HttpClient; } });
+var RetryManager_1 = require("./RetryManager");
+Object.defineProperty(exports, "RetryManager", { enumerable: true, get: function () { return RetryManager_1.RetryManager; } });

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { VeloraClient } from './client';
+export type { HealthResponse, TrackInfo, CurrentTrackResponse, RepeatMode, QueueTrack, PlaybackQueueResponse, PlaybackStateResponse, UserPublic, UserPublicResponse, PlayRequest, PlayResponse, PauseResponse, NextResponse, SeekRequest, SeekResponse, ToggleResponse, AppMetadata, RegisterAppRequest, PermissionType, RequestStatusResponse, RequestStatusPending, RequestStatusApproved, RequestStatusDenied, WebSocketEventEnvelope, TrackChangedData, PlaybackStateChangedData, ErrorResponse, ClientConfig, HttpRequestOptions, RetryPolicy, WebSocketOptions, AuthRequest, CredentialConfig, } from './types';
+export { VeloraError, NetworkError, AuthError, ValidationError, TimeoutError, RateLimitError, RequestError, classifyError, } from './types/errors';

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyError = exports.RequestError = exports.RateLimitError = exports.TimeoutError = exports.ValidationError = exports.AuthError = exports.NetworkError = exports.VeloraError = exports.VeloraClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "VeloraClient", { enumerable: true, get: function () { return client_1.VeloraClient; } });
+var errors_1 = require("./types/errors");
+Object.defineProperty(exports, "VeloraError", { enumerable: true, get: function () { return errors_1.VeloraError; } });
+Object.defineProperty(exports, "NetworkError", { enumerable: true, get: function () { return errors_1.NetworkError; } });
+Object.defineProperty(exports, "AuthError", { enumerable: true, get: function () { return errors_1.AuthError; } });
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return errors_1.ValidationError; } });
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_1.TimeoutError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_1.RateLimitError; } });
+Object.defineProperty(exports, "RequestError", { enumerable: true, get: function () { return errors_1.RequestError; } });
+Object.defineProperty(exports, "classifyError", { enumerable: true, get: function () { return errors_1.classifyError; } });

package/dist/types/api.d.ts

@@ -0,0 +1,128 @@
+export interface HealthResponse {
+    ok: boolean;
+    status: string;
+    port: number;
+    host: string;
+}
+export interface TrackInfo {
+    id: string;
+    title: string;
+    artist: string;
+    album: string;
+    cover_url: string;
+    thumbnail_url: string;
+    duration: number;
+    position: number;
+    is_playing: boolean;
+}
+export interface CurrentTrackResponse {
+    track: TrackInfo;
+}
+export type RepeatMode = 'off' | 'one' | 'all' | 'on';
+export interface PlaybackStateResponse {
+    is_playing: boolean;
+    shuffle: boolean;
+    repeat: RepeatMode;
+}
+export interface QueueTrack {
+    id: string;
+    title: string;
+    artist: string;
+    duration: number;
+    cover_url: string;
+    thumbnail_url: string;
+}
+export interface PlaybackQueueResponse {
+    queue: QueueTrack[];
+    current_index: number;
+    current_track_id: string;
+    current_track_cover_url: string;
+    is_playing: boolean;
+    shuffle: boolean;
+    repeat: RepeatMode;
+    updated_at: string;
+}
+export interface UserPublic {
+    id: string;
+    username: string;
+    name: string;
+    profile_image_url: string;
+}
+export interface UserPublicResponse {
+    user: UserPublic;
+    updated_at: string;
+}
+export interface PlayRequest extends Record<string, unknown> {
+    track_id?: string;
+}
+export interface PlayResponse {
+    ok: boolean;
+    track_id: string;
+}
+export interface PauseResponse {
+    ok: boolean;
+}
+export interface NextResponse {
+    ok: boolean;
+}
+export interface SeekRequest extends Record<string, unknown> {
+    position: number;
+}
+export interface SeekResponse {
+    ok: boolean;
+    position: number;
+}
+export interface ToggleResponse {
+    ok: boolean;
+    is_playing: boolean;
+}
+export interface AppMetadata {
+    name: string;
+    description?: string;
+    developer?: string;
+    website?: string;
+    icon?: string;
+}
+export interface RegisterAppRequest {
+    app: AppMetadata;
+    permissions?: ('read' | 'write')[];
+}
+export interface RegisterResponse {
+    request_id: string;
+    status: 'pending';
+}
+export type PermissionType = 'read' | 'write';
+export interface RequestStatusPending {
+    request_id: string;
+    status: 'pending';
+}
+export interface RequestStatusApproved {
+    request_id: string;
+    status: 'approved';
+    access_token: string;
+    token_type: string;
+    permissions: PermissionType[];
+}
+export interface RequestStatusDenied {
+    request_id: string;
+    status: 'denied';
+}
+export type RequestStatusResponse = RequestStatusPending | RequestStatusApproved | RequestStatusDenied;
+export interface WebSocketEventEnvelope<T> {
+    event: string;
+    data: T;
+}
+export interface TrackChangedData {
+    id: string;
+    title: string;
+    artist: string;
+    cover_url: string;
+}
+export interface PlaybackStateChangedData {
+    is_playing: boolean;
+    shuffle: boolean;
+    repeat: RepeatMode;
+}
+export interface ErrorResponse {
+    error: string;
+}

package/dist/types/api.js

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

package/dist/types/client.d.ts

@@ -0,0 +1,44 @@
+import { AppMetadata, PermissionType } from './api';
+export interface HttpRequestOptions {
+    timeout?: number;
+    maxRetries?: number;
+}
+export interface RetryPolicy {
+    maxRetries: number;
+    initialBackoffMs: number;
+    maxBackoffMs: number;
+}
+export interface WebSocketOptions {
+    initialBackoffMs?: number;
+    maxBackoffMs?: number;
+    autoConnect?: boolean;
+}
+export interface ClientConfig {
+    host?: string;
+    port?: number;
+    token?: string;
+    appRegistration?: AppMetadata;
+    requestedPermissions?: PermissionType[];
+    httpOptions?: HttpRequestOptions;
+    wsOptions?: WebSocketOptions;
+}
+export interface AuthRequest {
+    app: AppMetadata;
+    permissions: PermissionType[];
+}
+export interface CredentialConfig {
+    token?: string;
+    permissions?: PermissionType[];
+    appName?: string;
+}
+export interface WebSocketConfig {
+    host: string;
+    port: number;
+    token: string;
+    reconnectOptions: WebSocketReconnectOptions;
+}
+export interface WebSocketReconnectOptions {
+    initialBackoffMs: number;
+    maxBackoffMs: number;
+    maxAttempts?: number;
+}

package/dist/types/client.js

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

package/dist/types/errors.d.ts

@@ -0,0 +1,30 @@
+export declare class VeloraError extends Error {
+    readonly code: string;
+    readonly statusCode?: number;
+    constructor(message: string, code: string, statusCode?: number);
+}
+export declare class NetworkError extends VeloraError {
+    readonly originalError?: Error | undefined;
+    constructor(message: string, originalError?: Error | undefined);
+}
+export declare class AuthError extends VeloraError {
+    constructor(message: string, statusCode?: number);
+}
+export declare class ValidationError extends VeloraError {
+    readonly field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
+export declare class TimeoutError extends VeloraError {
+    readonly timeoutMs: number;
+    constructor(message: string, timeoutMs: number);
+}
+export declare class RateLimitError extends VeloraError {
+    readonly retryAfterMs?: number | undefined;
+    constructor(message: string, retryAfterMs?: number | undefined);
+}
+export declare class RequestError extends VeloraError {
+    readonly statusCode: number;
+    readonly response?: Record<string, unknown> | undefined;
+    constructor(message: string, statusCode: number, response?: Record<string, unknown> | undefined);
+}
+export declare function classifyError(error: unknown, statusCode?: number): VeloraError;

package/dist/types/errors.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestError = exports.RateLimitError = exports.TimeoutError = exports.ValidationError = exports.AuthError = exports.NetworkError = exports.VeloraError = void 0;
+exports.classifyError = classifyError;
+class VeloraError extends Error {
+    constructor(message, code, statusCode) {
+        super(message);
+        this.name = 'VeloraError';
+        this.code = code;
+        this.statusCode = statusCode;
+        Object.setPrototypeOf(this, VeloraError.prototype);
+    }
+}
+exports.VeloraError = VeloraError;
+class NetworkError extends VeloraError {
+    constructor(message, originalError) {
+        super(message, 'NETWORK_ERROR');
+        this.originalError = originalError;
+        this.name = 'NetworkError';
+        Object.setPrototypeOf(this, NetworkError.prototype);
+    }
+}
+exports.NetworkError = NetworkError;
+class AuthError extends VeloraError {
+    constructor(message, statusCode) {
+        super(message, 'AUTH_ERROR', statusCode);
+        this.name = 'AuthError';
+        Object.setPrototypeOf(this, AuthError.prototype);
+    }
+}
+exports.AuthError = AuthError;
+class ValidationError extends VeloraError {
+    constructor(message, field) {
+        super(message, 'VALIDATION_ERROR', 400);
+        this.field = field;
+        this.name = 'ValidationError';
+        Object.setPrototypeOf(this, ValidationError.prototype);
+    }
+}
+exports.ValidationError = ValidationError;
+class TimeoutError extends VeloraError {
+    constructor(message, timeoutMs) {
+        super(message, 'TIMEOUT_ERROR');
+        this.timeoutMs = timeoutMs;
+        this.name = 'TimeoutError';
+        Object.setPrototypeOf(this, TimeoutError.prototype);
+    }
+}
+exports.TimeoutError = TimeoutError;
+class RateLimitError extends VeloraError {
+    constructor(message, retryAfterMs) {
+        super(message, 'RATE_LIMIT_ERROR', 429);
+        this.retryAfterMs = retryAfterMs;
+        this.name = 'RateLimitError';
+        Object.setPrototypeOf(this, RateLimitError.prototype);
+    }
+}
+exports.RateLimitError = RateLimitError;
+class RequestError extends VeloraError {
+    constructor(message, statusCode, response) {
+        super(message, 'REQUEST_ERROR', statusCode);
+        this.statusCode = statusCode;
+        this.response = response;
+        this.name = 'RequestError';
+        Object.setPrototypeOf(this, RequestError.prototype);
+    }
+}
+exports.RequestError = RequestError;
+function classifyError(error, statusCode) {
+    if (error instanceof VeloraError) {
+        return error;
+    }
+    if (error instanceof TypeError) {
+        if (error.message.includes('fetch') || error.message.includes('network')) {
+            return new NetworkError(error.message, error);
+        }
+    }
+    if (statusCode === 401 || statusCode === 403) {
+        return new AuthError(error instanceof Error ? error.message : 'Unauthorized', statusCode);
+    }
+    if (statusCode === 400) {
+        return new ValidationError(error instanceof Error ? error.message : 'Invalid request');
+    }
+    if (statusCode === 429) {
+        return new RateLimitError(error instanceof Error ? error.message : 'Rate limited');
+    }
+    if (statusCode && statusCode >= 500) {
+        let message = 'Server error';
+        if (error instanceof Error) {
+            message = error.message;
+        }
+        else if (typeof error === 'string') {
+            message = error;
+        }
+        return new RequestError(message, statusCode);
+    }
+    let fallbackMessage = 'Unknown error';
+    if (error instanceof Error) {
+        fallbackMessage = error.message;
+    }
+    else if (typeof error === 'string') {
+        fallbackMessage = error;
+    }
+    return new VeloraError(fallbackMessage, 'UNKNOWN_ERROR', statusCode);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './api';
+export * from './client';
+export * from './errors';