@xtr-dev/rondevu-client 0.12.3 → 0.13.0

package/dist/api.d.ts

@@ -29,12 +29,9 @@ export interface OfferRequest {
     sdp: string;
 }
 export interface ServiceRequest {
-    username: string;
     serviceFqn: string;
     offers: OfferRequest[];
     ttl?: number;
-    isPublic?: boolean;
-    metadata?: Record<string, any>;
     signature: string;
     message: string;
 }
@@ -46,12 +43,9 @@ export interface ServiceOffer {
 }
 export interface Service {
     serviceId: string;
-    uuid: string;
     offers: ServiceOffer[];
     username: string;
     serviceFqn: string;
-    isPublic: boolean;
-    metadata?: Record<string, any>;
     createdAt: number;
     expiresAt: number;
 }
@@ -99,54 +93,88 @@ export declare class RondevuAPI {
      */
     getOffer(offerId: string): Promise<Offer>;
     /**
-     * Answer a service
+     * Answer a specific offer from a service
      */
-    answerService(serviceUuid: string, sdp: string): Promise<{
+    postOfferAnswer(serviceFqn: string, offerId: string, sdp: string): Promise<{
+        success: boolean;
         offerId: string;
     }>;
     /**
-     * Get answer for a service (offerer polls this)
+     * Get answer for a specific offer (offerer polls this)
      */
-    getServiceAnswer(serviceUuid: string): Promise<{
+    getOfferAnswer(serviceFqn: string, offerId: string): Promise<{
         sdp: string;
         offerId: string;
+        answererId: string;
+        answeredAt: number;
     } | null>;
     /**
      * Search offers by topic
      */
     searchOffers(topic: string): Promise<Offer[]>;
     /**
-     * Add ICE candidates to a service
+     * Add ICE candidates to a specific offer
      */
-    addServiceIceCandidates(serviceUuid: string, candidates: RTCIceCandidateInit[], offerId?: string): Promise<{
+    addOfferIceCandidates(serviceFqn: string, offerId: string, candidates: RTCIceCandidateInit[]): Promise<{
+        count: number;
         offerId: string;
     }>;
     /**
-     * Get ICE candidates for a service (with polling support)
+     * Get ICE candidates for a specific offer (with polling support)
      */
-    getServiceIceCandidates(serviceUuid: string, since?: number, offerId?: string): Promise<{
+    getOfferIceCandidates(serviceFqn: string, offerId: string, since?: number): Promise<{
         candidates: IceCandidate[];
         offerId: string;
     }>;
     /**
      * Publish a service
+     * Service FQN must include username: service:version@username
      */
     publishService(service: ServiceRequest): Promise<Service>;
     /**
-     * Get service by UUID
+     * Get service by FQN (with username) - Direct lookup
+     * Example: chat:1.0.0@alice
      */
-    getService(uuid: string): Promise<Service & {
+    getService(serviceFqn: string): Promise<{
+        serviceId: string;
+        username: string;
+        serviceFqn: string;
         offerId: string;
         sdp: string;
+        createdAt: number;
+        expiresAt: number;
     }>;
     /**
-     * Search services by username - lists all services for a username
+     * Discover a random available service without knowing the username
+     * Example: chat:1.0.0 (without @username)
      */
-    searchServicesByUsername(username: string): Promise<Service[]>;
+    discoverService(serviceVersion: string): Promise<{
+        serviceId: string;
+        username: string;
+        serviceFqn: string;
+        offerId: string;
+        sdp: string;
+        createdAt: number;
+        expiresAt: number;
+    }>;
     /**
-     * Search services by username AND FQN - returns full service details
-     */
-    searchServices(username: string, serviceFqn: string): Promise<Service[]>;
+     * Discover multiple available services with pagination
+     * Example: chat:1.0.0 (without @username)
+     */
+    discoverServices(serviceVersion: string, limit?: number, offset?: number): Promise<{
+        services: Array<{
+            serviceId: string;
+            username: string;
+            serviceFqn: string;
+            offerId: string;
+            sdp: string;
+            createdAt: number;
+            expiresAt: number;
+        }>;
+        count: number;
+        limit: number;
+        offset: number;
+    }>;
     /**
      * Check if username is available
      */

package/dist/api.js

@@ -131,10 +131,10 @@ export class RondevuAPI {
         return await response.json();
     }
     /**
-     * Answer a service
+     * Answer a specific offer from a service
      */
-    async answerService(serviceUuid, sdp) {
-        const response = await fetch(`${this.baseUrl}/services/${serviceUuid}/answer`, {
+    async postOfferAnswer(serviceFqn, offerId, sdp) {
+        const response = await fetch(`${this.baseUrl}/services/${encodeURIComponent(serviceFqn)}/offers/${offerId}/answer`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -144,15 +144,15 @@ export class RondevuAPI {
         });
         if (!response.ok) {
             const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to answer service: ${error.error || response.statusText}`);
+            throw new Error(`Failed to answer offer: ${error.error || response.statusText}`);
         }
         return await response.json();
     }
     /**
-     * Get answer for a service (offerer polls this)
+     * Get answer for a specific offer (offerer polls this)
      */
-    async getServiceAnswer(serviceUuid) {
-        const response = await fetch(`${this.baseUrl}/services/${serviceUuid}/answer`, {
+    async getOfferAnswer(serviceFqn, offerId) {
+        const response = await fetch(`${this.baseUrl}/services/${encodeURIComponent(serviceFqn)}/offers/${offerId}/answer`, {
             headers: this.getAuthHeader(),
         });
         if (!response.ok) {
@@ -163,8 +163,7 @@ export class RondevuAPI {
             const error = await response.json().catch(() => ({ error: 'Unknown error' }));
             throw new Error(`Failed to get answer: ${error.error || response.statusText}`);
         }
-        const data = await response.json();
-        return { sdp: data.sdp, offerId: data.offerId };
+        return await response.json();
     }
     /**
      * Search offers by topic
@@ -183,16 +182,16 @@ export class RondevuAPI {
     // ICE Candidates
     // ============================================
     /**
-     * Add ICE candidates to a service
+     * Add ICE candidates to a specific offer
      */
-    async addServiceIceCandidates(serviceUuid, candidates, offerId) {
-        const response = await fetch(`${this.baseUrl}/services/${serviceUuid}/ice-candidates`, {
+    async addOfferIceCandidates(serviceFqn, offerId, candidates) {
+        const response = await fetch(`${this.baseUrl}/services/${encodeURIComponent(serviceFqn)}/offers/${offerId}/ice-candidates`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
                 ...this.getAuthHeader(),
             },
-            body: JSON.stringify({ candidates, offerId }),
+            body: JSON.stringify({ candidates }),
         });
         if (!response.ok) {
             const error = await response.json().catch(() => ({ error: 'Unknown error' }));
@@ -201,14 +200,11 @@ export class RondevuAPI {
         return await response.json();
     }
     /**
-     * Get ICE candidates for a service (with polling support)
+     * Get ICE candidates for a specific offer (with polling support)
      */
-    async getServiceIceCandidates(serviceUuid, since = 0, offerId) {
-        const url = new URL(`${this.baseUrl}/services/${serviceUuid}/ice-candidates`);
+    async getOfferIceCandidates(serviceFqn, offerId, since = 0) {
+        const url = new URL(`${this.baseUrl}/services/${encodeURIComponent(serviceFqn)}/offers/${offerId}/ice-candidates`);
         url.searchParams.set('since', since.toString());
-        if (offerId) {
-            url.searchParams.set('offerId', offerId);
-        }
         const response = await fetch(url.toString(), { headers: this.getAuthHeader() });
         if (!response.ok) {
             const error = await response.json().catch(() => ({ error: 'Unknown error' }));
@@ -225,9 +221,10 @@ export class RondevuAPI {
     // ============================================
     /**
      * Publish a service
+     * Service FQN must include username: service:version@username
      */
     async publishService(service) {
-        const response = await fetch(`${this.baseUrl}/users/${encodeURIComponent(service.username)}/services`, {
+        const response = await fetch(`${this.baseUrl}/services`, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -242,10 +239,11 @@ export class RondevuAPI {
         return await response.json();
     }
     /**
-     * Get service by UUID
+     * Get service by FQN (with username) - Direct lookup
+     * Example: chat:1.0.0@alice
      */
-    async getService(uuid) {
-        const response = await fetch(`${this.baseUrl}/services/${uuid}`, {
+    async getService(serviceFqn) {
+        const response = await fetch(`${this.baseUrl}/services/${encodeURIComponent(serviceFqn)}`, {
             headers: this.getAuthHeader(),
         });
         if (!response.ok) {
@@ -255,31 +253,35 @@ export class RondevuAPI {
         return await response.json();
     }
     /**
-     * Search services by username - lists all services for a username
+     * Discover a random available service without knowing the username
+     * Example: chat:1.0.0 (without @username)
      */
-    async searchServicesByUsername(username) {
-        const response = await fetch(`${this.baseUrl}/users/${encodeURIComponent(username)}/services`, { headers: this.getAuthHeader() });
+    async discoverService(serviceVersion) {
+        const response = await fetch(`${this.baseUrl}/services/${encodeURIComponent(serviceVersion)}`, {
+            headers: this.getAuthHeader(),
+        });
         if (!response.ok) {
             const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to search services: ${error.error || response.statusText}`);
+            throw new Error(`Failed to discover service: ${error.error || response.statusText}`);
         }
-        const data = await response.json();
-        return data.services || [];
+        return await response.json();
     }
     /**
-     * Search services by username AND FQN - returns full service details
+     * Discover multiple available services with pagination
+     * Example: chat:1.0.0 (without @username)
      */
-    async searchServices(username, serviceFqn) {
-        const response = await fetch(`${this.baseUrl}/users/${encodeURIComponent(username)}/services/${encodeURIComponent(serviceFqn)}`, { headers: this.getAuthHeader() });
+    async discoverServices(serviceVersion, limit = 10, offset = 0) {
+        const url = new URL(`${this.baseUrl}/services/${encodeURIComponent(serviceVersion)}`);
+        url.searchParams.set('limit', limit.toString());
+        url.searchParams.set('offset', offset.toString());
+        const response = await fetch(url.toString(), {
+            headers: this.getAuthHeader(),
+        });
         if (!response.ok) {
-            if (response.status === 404) {
-                return [];
-            }
             const error = await response.json().catch(() => ({ error: 'Unknown error' }));
-            throw new Error(`Failed to search services: ${error.error || response.statusText}`);
+            throw new Error(`Failed to discover services: ${error.error || response.statusText}`);
         }
-        const service = await response.json();
-        return [service];
+        return await response.json();
     }
     // ============================================
     // Usernames

package/dist/index.d.ts

@@ -2,19 +2,10 @@
  * @xtr-dev/rondevu-client
  * WebRTC peer signaling client
  */
-export { EventBus } from './event-bus.js';
+export { Rondevu } from './rondevu.js';
 export { RondevuAPI } from './api.js';
-export { RondevuService } from './rondevu-service.js';
 export { RondevuSignaler } from './rondevu-signaler.js';
-export { WebRTCContext } from './webrtc-context.js';
-export { RTCDurableConnection } from './durable-connection';
-export { ServiceHost } from './service-host.js';
-export { ServiceClient } from './service-client.js';
-export { createBin } from './bin.js';
-export type { ConnectionInterface, QueueMessageOptions, Message, ConnectionEvents, Signaler, } from './types.js';
+export type { Signaler, Binnable, } from './types.js';
 export type { Credentials, Keypair, OfferRequest, Offer, ServiceRequest, Service, IceCandidate, } from './api.js';
-export type { Binnable } from './bin.js';
-export type { RondevuServiceOptions, PublishServiceOptions } from './rondevu-service.js';
-export type { ServiceHostOptions, ServiceHostEvents } from './service-host.js';
-export type { ServiceClientOptions, ServiceClientEvents } from './service-client.js';
+export type { RondevuOptions, PublishServiceOptions } from './rondevu.js';
 export type { PollingConfig } from './rondevu-signaler.js';

package/dist/index.js

@@ -2,12 +2,6 @@
  * @xtr-dev/rondevu-client
  * WebRTC peer signaling client
  */
-export { EventBus } from './event-bus.js';
+export { Rondevu } from './rondevu.js';
 export { RondevuAPI } from './api.js';
-export { RondevuService } from './rondevu-service.js';
 export { RondevuSignaler } from './rondevu-signaler.js';
-export { WebRTCContext } from './webrtc-context.js';
-export { RTCDurableConnection } from './durable-connection';
-export { ServiceHost } from './service-host.js';
-export { ServiceClient } from './service-client.js';
-export { createBin } from './bin.js';

package/dist/rondevu-signaler.d.ts

@@ -1,6 +1,5 @@
-import { Signaler } from './types.js';
-import { RondevuService } from './rondevu-service.js';
-import { Binnable } from './bin.js';
+import { Signaler, Binnable } from './types.js';
+import { Rondevu } from './rondevu.js';
 export interface PollingConfig {
     initialInterval?: number;
     maxInterval?: number;
@@ -44,7 +43,7 @@ export declare class RondevuSignaler implements Signaler {
     private readonly service;
     private readonly host?;
     private offerId;
-    private serviceUuid;
+    private serviceFqn;
     private offerListeners;
     private answerListeners;
     private iceListeners;
@@ -53,7 +52,7 @@ export declare class RondevuSignaler implements Signaler {
     private lastIceTimestamp;
     private isPolling;
     private pollingConfig;
-    constructor(rondevu: RondevuService, service: string, host?: string | undefined, pollingConfig?: PollingConfig);
+    constructor(rondevu: Rondevu, service: string, host?: string | undefined, pollingConfig?: PollingConfig);
     /**
      * Publish an offer as a service
      * Used by the offerer to make their offer available

package/dist/rondevu-signaler.js

@@ -35,7 +35,7 @@ export class RondevuSignaler {
         this.service = service;
         this.host = host;
         this.offerId = null;
-        this.serviceUuid = null;
+        this.serviceFqn = null;
         this.offerListeners = [];
         this.answerListeners = [];
         this.iceListeners = [];
@@ -64,14 +64,13 @@ export class RondevuSignaler {
             serviceFqn: this.service,
             offers: [{ sdp: offer.sdp }],
             ttl: 300000, // 5 minutes
-            isPublic: true,
         });
         // Get the first offer from the published service
         if (!publishedService.offers || publishedService.offers.length === 0) {
             throw new Error('No offers returned from service publication');
         }
         this.offerId = publishedService.offers[0].offerId;
-        this.serviceUuid = publishedService.uuid;
+        this.serviceFqn = publishedService.serviceFqn;
         // Start polling for answer
         this.startAnswerPolling();
         // Start polling for ICE candidates
@@ -85,11 +84,11 @@ export class RondevuSignaler {
         if (!answer.sdp) {
             throw new Error('Answer SDP is required');
         }
-        if (!this.serviceUuid) {
-            throw new Error('No service UUID available. Must receive offer first.');
+        if (!this.serviceFqn || !this.offerId) {
+            throw new Error('No service FQN or offer ID available. Must receive offer first.');
         }
         // Send answer to the service
-        const result = await this.rondevu.getAPI().answerService(this.serviceUuid, answer.sdp);
+        const result = await this.rondevu.getAPI().postOfferAnswer(this.serviceFqn, this.offerId, answer.sdp);
         this.offerId = result.offerId;
         // Start polling for ICE candidates
         this.startIcePolling();
@@ -130,8 +129,8 @@ export class RondevuSignaler {
      * Send an ICE candidate to the remote peer
      */
     async addIceCandidate(candidate) {
-        if (!this.serviceUuid) {
-            console.warn('Cannot send ICE candidate: no service UUID');
+        if (!this.serviceFqn || !this.offerId) {
+            console.warn('Cannot send ICE candidate: no service FQN or offer ID');
             return;
         }
         const candidateData = candidate.toJSON();
@@ -140,11 +139,7 @@ export class RondevuSignaler {
             return;
         }
         try {
-            const result = await this.rondevu.getAPI().addServiceIceCandidates(this.serviceUuid, [candidateData], this.offerId || undefined);
-            // Store offerId if we didn't have it yet
-            if (!this.offerId) {
-                this.offerId = result.offerId;
-            }
+            await this.rondevu.getAPI().addOfferIceCandidates(this.serviceFqn, this.offerId, [candidateData]);
         }
         catch (err) {
             console.error('Failed to send ICE candidate:', err);
@@ -173,28 +168,21 @@ export class RondevuSignaler {
         }
         this.isPolling = true;
         try {
-            // Search for services by username and service FQN
-            const services = await this.rondevu.getAPI().searchServices(this.host, this.service);
-            if (services.length === 0) {
-                console.warn(`No services found for ${this.host}/${this.service}`);
+            // Get service by FQN (service should include @username)
+            const serviceFqn = `${this.service}@${this.host}`;
+            const serviceData = await this.rondevu.getAPI().getService(serviceFqn);
+            if (!serviceData) {
+                console.warn(`No service found for ${serviceFqn}`);
                 this.isPolling = false;
                 return;
             }
-            // Get the first available service (already has full details from searchServices)
-            const service = services[0];
-            // Get the first available offer from the service
-            if (!service.offers || service.offers.length === 0) {
-                console.warn(`No offers available for service ${this.host}/${this.service}`);
-                this.isPolling = false;
-                return;
-            }
-            const firstOffer = service.offers[0];
-            this.offerId = firstOffer.offerId;
-            this.serviceUuid = service.uuid;
+            // Store service details
+            this.offerId = serviceData.offerId;
+            this.serviceFqn = serviceData.serviceFqn;
             // Notify offer listeners
             const offer = {
                 type: 'offer',
-                sdp: firstOffer.sdp,
+                sdp: serviceData.sdp,
             };
             this.offerListeners.forEach(listener => {
                 try {
@@ -214,18 +202,18 @@ export class RondevuSignaler {
      * Start polling for answer (offerer side) with exponential backoff
      */
     startAnswerPolling() {
-        if (this.answerPollingTimeout || !this.serviceUuid) {
+        if (this.answerPollingTimeout || !this.serviceFqn || !this.offerId) {
             return;
         }
         let interval = this.pollingConfig.initialInterval;
         let retries = 0;
         const poll = async () => {
-            if (!this.serviceUuid) {
+            if (!this.serviceFqn || !this.offerId) {
                 this.stopAnswerPolling();
                 return;
             }
             try {
-                const answer = await this.rondevu.getAPI().getServiceAnswer(this.serviceUuid);
+                const answer = await this.rondevu.getAPI().getOfferAnswer(this.serviceFqn, this.offerId);
                 if (answer && answer.sdp) {
                     // Store offerId if we didn't have it yet
                     if (!this.offerId) {
@@ -289,23 +277,19 @@ export class RondevuSignaler {
      * Start polling for ICE candidates with adaptive backoff
      */
     startIcePolling() {
-        if (this.icePollingTimeout || !this.serviceUuid) {
+        if (this.icePollingTimeout || !this.serviceFqn || !this.offerId) {
             return;
         }
         let interval = this.pollingConfig.initialInterval;
         const poll = async () => {
-            if (!this.serviceUuid) {
+            if (!this.serviceFqn || !this.offerId) {
                 this.stopIcePolling();
                 return;
             }
             try {
                 const result = await this.rondevu
                     .getAPI()
-                    .getServiceIceCandidates(this.serviceUuid, this.lastIceTimestamp, this.offerId || undefined);
-                // Store offerId if we didn't have it yet
-                if (!this.offerId) {
-                    this.offerId = result.offerId;
-                }
+                    .getOfferIceCandidates(this.serviceFqn, this.offerId, this.lastIceTimestamp);
                 let foundCandidates = false;
                 for (const item of result.candidates) {
                     if (item.candidate && item.candidate.candidate && item.candidate.candidate !== '') {

package/dist/rondevu.d.ts

@@ -0,0 +1,167 @@
+import { RondevuAPI, Credentials, Keypair, Service, IceCandidate } from './api.js';
+export interface RondevuOptions {
+    apiUrl: string;
+    username: string;
+    keypair?: Keypair;
+    credentials?: Credentials;
+}
+export interface PublishServiceOptions {
+    serviceFqn: string;
+    offers: Array<{
+        sdp: string;
+    }>;
+    ttl?: number;
+}
+/**
+ * Rondevu - Complete WebRTC signaling client
+ *
+ * Provides a unified API for:
+ * - Username claiming with Ed25519 signatures
+ * - Service publishing with automatic signature generation
+ * - Service discovery (direct, random, paginated)
+ * - WebRTC signaling (offer/answer exchange, ICE relay)
+ * - Keypair management
+ *
+ * @example
+ * ```typescript
+ * // Initialize (generates keypair automatically)
+ * const rondevu = new Rondevu({
+ *   apiUrl: 'https://signal.example.com',
+ *   username: 'alice',
+ * })
+ *
+ * await rondevu.initialize()
+ *
+ * // Claim username (one time)
+ * await rondevu.claimUsername()
+ *
+ * // Publish a service
+ * const publishedService = await rondevu.publishService({
+ *   serviceFqn: 'chat:1.0.0@alice',
+ *   offers: [{ sdp: offerSdp }],
+ *   ttl: 300000,
+ * })
+ *
+ * // Discover a service
+ * const service = await rondevu.getService('chat:1.0.0@bob')
+ *
+ * // Post answer
+ * await rondevu.postOfferAnswer(service.serviceFqn, service.offerId, answerSdp)
+ * ```
+ */
+export declare class Rondevu {
+    private readonly api;
+    private readonly username;
+    private keypair;
+    private usernameClaimed;
+    constructor(options: RondevuOptions);
+    /**
+     * Initialize the service - generates keypair if not provided
+     * Call this before using other methods
+     */
+    initialize(): Promise<void>;
+    /**
+     * Claim the username with Ed25519 signature
+     * Should be called once before publishing services
+     */
+    claimUsername(): Promise<void>;
+    /**
+     * Check if username has been claimed (checks with server)
+     */
+    isUsernameClaimed(): Promise<boolean>;
+    /**
+     * Publish a service with automatic signature generation
+     */
+    publishService(options: PublishServiceOptions): Promise<Service>;
+    /**
+     * Get service by FQN (with username) - Direct lookup
+     * Example: chat:1.0.0@alice
+     */
+    getService(serviceFqn: string): Promise<{
+        serviceId: string;
+        username: string;
+        serviceFqn: string;
+        offerId: string;
+        sdp: string;
+        createdAt: number;
+        expiresAt: number;
+    }>;
+    /**
+     * Discover a random available service without knowing the username
+     * Example: chat:1.0.0 (without @username)
+     */
+    discoverService(serviceVersion: string): Promise<{
+        serviceId: string;
+        username: string;
+        serviceFqn: string;
+        offerId: string;
+        sdp: string;
+        createdAt: number;
+        expiresAt: number;
+    }>;
+    /**
+     * Discover multiple available services with pagination
+     * Example: chat:1.0.0 (without @username)
+     */
+    discoverServices(serviceVersion: string, limit?: number, offset?: number): Promise<{
+        services: Array<{
+            serviceId: string;
+            username: string;
+            serviceFqn: string;
+            offerId: string;
+            sdp: string;
+            createdAt: number;
+            expiresAt: number;
+        }>;
+        count: number;
+        limit: number;
+        offset: number;
+    }>;
+    /**
+     * Post answer SDP to specific offer
+     */
+    postOfferAnswer(serviceFqn: string, offerId: string, sdp: string): Promise<{
+        success: boolean;
+        offerId: string;
+    }>;
+    /**
+     * Get answer SDP (offerer polls this)
+     */
+    getOfferAnswer(serviceFqn: string, offerId: string): Promise<{
+        sdp: string;
+        offerId: string;
+        answererId: string;
+        answeredAt: number;
+    } | null>;
+    /**
+     * Add ICE candidates to specific offer
+     */
+    addOfferIceCandidates(serviceFqn: string, offerId: string, candidates: RTCIceCandidateInit[]): Promise<{
+        count: number;
+        offerId: string;
+    }>;
+    /**
+     * Get ICE candidates for specific offer (with polling support)
+     */
+    getOfferIceCandidates(serviceFqn: string, offerId: string, since?: number): Promise<{
+        candidates: IceCandidate[];
+        offerId: string;
+    }>;
+    /**
+     * Get the current keypair (for backup/storage)
+     */
+    getKeypair(): Keypair | null;
+    /**
+     * Get the username
+     */
+    getUsername(): string;
+    /**
+     * Get the public key
+     */
+    getPublicKey(): string | null;
+    /**
+     * Access to underlying API for advanced operations
+     * @deprecated Use direct methods on Rondevu instance instead
+     */
+    getAPI(): RondevuAPI;
+}