@wave-av/sdk 2.0.1 → 2.0.2

package/dist/chunk-O6DOGYP5.mjs

@@ -0,0 +1,238 @@
+// src/pipeline.ts
+var PipelineAPI = class {
+  client;
+  basePath = "/v1/streams";
+  constructor(client) {
+    this.client = client;
+  }
+  // ==========================================================================
+  // Stream CRUD
+  // ==========================================================================
+  /**
+   * Create a new stream
+   *
+   * Requires: streams:create permission
+   */
+  async create(request) {
+    return this.client.post(this.basePath, request);
+  }
+  /**
+   * Get a stream by ID
+   *
+   * Requires: streams:read permission
+   */
+  async get(streamId) {
+    return this.client.get(`${this.basePath}/${streamId}`);
+  }
+  /**
+   * Update a stream
+   *
+   * Requires: streams:update permission
+   */
+  async update(streamId, request) {
+    return this.client.patch(`${this.basePath}/${streamId}`, request);
+  }
+  /**
+   * Remove a stream
+   *
+   * Requires: streams:remove permission (server-side RBAC enforced)
+   */
+  async remove(streamId) {
+    await this.client.delete(`${this.basePath}/${streamId}`);
+  }
+  /**
+   * List streams with optional filters
+   *
+   * Requires: streams:read permission
+   */
+  async list(params) {
+    const queryParams = {
+      limit: params?.limit,
+      offset: params?.offset,
+      cursor: params?.cursor,
+      status: params?.status,
+      protocol: params?.protocol,
+      created_after: params?.created_after,
+      created_before: params?.created_before,
+      order_by: params?.order_by,
+      order: params?.order
+    };
+    return this.client.get(this.basePath, {
+      params: queryParams
+    });
+  }
+  // ==========================================================================
+  // Stream Lifecycle
+  // ==========================================================================
+  /**
+   * Start a stream
+   *
+   * Transitions the stream from idle to connecting. The stream will move
+   * to "live" once media is received on the ingest endpoint.
+   *
+   * Requires: streams:start permission
+   */
+  async start(streamId) {
+    return this.client.post(`${this.basePath}/${streamId}/start`);
+  }
+  /**
+   * Stop a stream
+   *
+   * Gracefully ends the stream. Any active recording will be finalized.
+   *
+   * Requires: streams:stop permission
+   */
+  async stop(streamId) {
+    return this.client.post(`${this.basePath}/${streamId}/stop`);
+  }
+  /**
+   * Switch the ingest protocol for a live stream
+   *
+   * Performs a zero-downtime protocol switch. The stream will briefly
+   * enter "reconnecting" status during the transition.
+   *
+   * Requires: streams:update permission
+   */
+  async switchProtocol(streamId, protocol) {
+    return this.client.post(`${this.basePath}/${streamId}/switch-protocol`, { protocol });
+  }
+  // ==========================================================================
+  // Health & Monitoring
+  // ==========================================================================
+  /**
+   * Get real-time health metrics for a stream
+   *
+   * Returns current bitrate, frame rate, latency, and overall health status.
+   *
+   * Requires: streams:read permission
+   */
+  async getHealth(streamId) {
+    return this.client.get(`${this.basePath}/${streamId}/health`);
+  }
+  /**
+   * Get ingest endpoints for a stream
+   *
+   * Returns primary and backup URLs for each configured protocol.
+   *
+   * Requires: streams:read permission
+   */
+  async getIngestEndpoints(streamId) {
+    return this.client.get(`${this.basePath}/${streamId}/ingest-endpoints`);
+  }
+  // ==========================================================================
+  // Recording
+  // ==========================================================================
+  /**
+   * Start recording a live stream
+   *
+   * Begins capturing the stream to a file. The stream must be in "live" status.
+   *
+   * Requires: streams:record permission
+   */
+  async startRecording(streamId) {
+    return this.client.post(`${this.basePath}/${streamId}/recordings/start`);
+  }
+  /**
+   * Stop recording a live stream
+   *
+   * Finalizes the current recording. The recording enters "processing" status
+   * while it is being packaged.
+   *
+   * Requires: streams:record permission
+   */
+  async stopRecording(streamId) {
+    return this.client.post(`${this.basePath}/${streamId}/recordings/stop`);
+  }
+  /**
+   * List recordings for a stream
+   *
+   * Requires: streams:read permission
+   */
+  async listRecordings(streamId, params) {
+    return this.client.get(
+      `${this.basePath}/${streamId}/recordings`,
+      { params }
+    );
+  }
+  /**
+   * Get a specific recording
+   *
+   * Requires: streams:read permission
+   */
+  async getRecording(streamId, recordingId) {
+    return this.client.get(
+      `${this.basePath}/${streamId}/recordings/${recordingId}`
+    );
+  }
+  // ==========================================================================
+  // Viewers
+  // ==========================================================================
+  /**
+   * List active viewer sessions for a stream
+   *
+   * Requires: streams:read permission
+   */
+  async listViewers(streamId, params) {
+    return this.client.get(
+      `${this.basePath}/${streamId}/viewers`,
+      { params }
+    );
+  }
+  /**
+   * Get current and peak viewer count for a stream
+   *
+   * Requires: streams:read permission
+   */
+  async getViewerCount(streamId) {
+    return this.client.get(
+      `${this.basePath}/${streamId}/viewers/count`
+    );
+  }
+  // ==========================================================================
+  // Polling Helpers
+  // ==========================================================================
+  /**
+   * Wait for a stream to reach "live" status
+   *
+   * Polls the stream until it transitions to "live" or a terminal state.
+   * Useful after calling `start()` to wait for the encoder to connect.
+   *
+   * @param streamId - Stream to monitor
+   * @param options - Polling configuration
+   * @param options.pollInterval - Milliseconds between polls (default: 2000)
+   * @param options.timeout - Maximum wait time in milliseconds (default: 120000)
+   * @param options.onProgress - Called on each poll with the current stream state
+   * @returns The stream once it reaches "live" status
+   * @throws Error if the stream enters "failed" or "ended" status, or if the timeout is exceeded
+   */
+  async waitForLive(streamId, options) {
+    const pollInterval = options?.pollInterval || 2e3;
+    const timeout = options?.timeout || 12e4;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const stream = await this.get(streamId);
+      if (options?.onProgress) {
+        options.onProgress(stream);
+      }
+      if (stream.status === "live") {
+        return stream;
+      }
+      if (stream.status === "failed") {
+        throw new Error(`Stream failed to go live: ${stream.id}`);
+      }
+      if (stream.status === "ended") {
+        throw new Error(`Stream ended before going live: ${stream.id}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Stream did not go live within ${timeout}ms`);
+  }
+};
+function createPipelineAPI(client) {
+  return new PipelineAPI(client);
+}
+
+export {
+  PipelineAPI,
+  createPipelineAPI
+};

package/dist/chunk-S25NY5GE.mjs

@@ -0,0 +1,124 @@
+// src/fleet.ts
+var FleetAPI = class {
+  client;
+  basePath = "/v1/fleet/nodes";
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List fleet nodes with optional filters
+   *
+   * Requires: fleet:read permission
+   */
+  async list(params) {
+    const queryParams = {
+      limit: params?.limit,
+      offset: params?.offset,
+      cursor: params?.cursor,
+      status: params?.status,
+      health: params?.health,
+      os: params?.os,
+      order_by: params?.order_by,
+      order: params?.order
+    };
+    return this.client.get(this.basePath, {
+      params: queryParams
+    });
+  }
+  /**
+   * Get a node by ID
+   *
+   * Requires: fleet:read permission
+   */
+  async get(nodeId) {
+    return this.client.get(`${this.basePath}/${nodeId}`);
+  }
+  /**
+   * Register a new node
+   *
+   * Requires: fleet:create permission
+   */
+  async register(request) {
+    return this.client.post(this.basePath, request);
+  }
+  /**
+   * Update a node
+   *
+   * Requires: fleet:update permission
+   */
+  async update(nodeId, request) {
+    return this.client.patch(`${this.basePath}/${nodeId}`, request);
+  }
+  /**
+   * Deregister (remove) a node
+   *
+   * Requires: fleet:remove permission (server-side RBAC enforced)
+   */
+  async deregister(nodeId) {
+    await this.client.delete(`${this.basePath}/${nodeId}`);
+  }
+  /**
+   * Get current health status of a node
+   *
+   * Requires: fleet:read permission
+   */
+  async getHealth(nodeId) {
+    return this.client.get(
+      `${this.basePath}/${nodeId}/health`
+    );
+  }
+  /**
+   * List devices attached to a node
+   *
+   * Requires: fleet:read permission
+   */
+  async listDevices(nodeId) {
+    return this.client.get(`${this.basePath}/${nodeId}/devices`);
+  }
+  /**
+   * Send a command to a node
+   *
+   * Requires: fleet:command permission
+   */
+  async sendCommand(nodeId, command) {
+    return this.client.post(
+      `${this.basePath}/${nodeId}/commands`,
+      command
+    );
+  }
+  /**
+   * Get current resource metrics for a node
+   *
+   * Requires: fleet:read permission
+   */
+  async getMetrics(nodeId) {
+    return this.client.get(`${this.basePath}/${nodeId}/metrics`);
+  }
+  /**
+   * Wait for a node to come online
+   */
+  async waitForOnline(nodeId, options) {
+    const pollInterval = options?.pollInterval || 5e3;
+    const timeout = options?.timeout || 12e4;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const node = await this.get(nodeId);
+      if (options?.onProgress) {
+        options.onProgress(node);
+      }
+      if (node.status === "online") {
+        return node;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Node ${nodeId} did not come online within ${timeout}ms`);
+  }
+};
+function createFleetAPI(client) {
+  return new FleetAPI(client);
+}
+
+export {
+  FleetAPI,
+  createFleetAPI
+};

package/dist/chunk-TFHXBICQ.mjs

@@ -0,0 +1,305 @@
+// src/editor.ts
+var EditorAPI = class {
+  client;
+  basePath = "/v1/editor/projects";
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a new editor project
+   *
+   * Requires: editor:create permission
+   */
+  async createProject(request) {
+    return this.client.post(this.basePath, request);
+  }
+  /**
+   * Get a project by ID
+   *
+   * Requires: editor:read permission
+   */
+  async getProject(projectId) {
+    return this.client.get(`${this.basePath}/${projectId}`);
+  }
+  /**
+   * Update a project
+   *
+   * Requires: editor:update permission
+   */
+  async updateProject(projectId, request) {
+    return this.client.patch(`${this.basePath}/${projectId}`, request);
+  }
+  /**
+   * Remove a project
+   *
+   * Requires: editor:remove permission (server-side RBAC enforced)
+   */
+  async removeProject(projectId) {
+    await this.client.delete(`${this.basePath}/${projectId}`);
+  }
+  /**
+   * List projects
+   *
+   * Requires: editor:read permission
+   */
+  async listProjects(params) {
+    return this.client.get(this.basePath, {
+      params
+    });
+  }
+  /**
+   * Duplicate a project
+   *
+   * Requires: editor:create permission
+   */
+  async duplicateProject(projectId, name) {
+    return this.client.post(`${this.basePath}/${projectId}/duplicate`, {
+      name
+    });
+  }
+  /**
+   * Add a track to a project
+   *
+   * Requires: editor:update permission
+   */
+  async addTrack(projectId, track) {
+    return this.client.post(`${this.basePath}/${projectId}/tracks`, track);
+  }
+  /**
+   * Update a track
+   *
+   * Requires: editor:update permission
+   */
+  async updateTrack(projectId, trackId, updates) {
+    return this.client.patch(
+      `${this.basePath}/${projectId}/tracks/${trackId}`,
+      updates
+    );
+  }
+  /**
+   * Remove a track
+   *
+   * Requires: editor:update permission (server-side RBAC enforced)
+   */
+  async removeTrack(projectId, trackId) {
+    await this.client.delete(
+      `${this.basePath}/${projectId}/tracks/${trackId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * Add an element to a track
+   *
+   * Requires: editor:update permission
+   */
+  async addElement(projectId, element) {
+    return this.client.post(
+      `${this.basePath}/${projectId}/elements`,
+      element
+    );
+  }
+  /**
+   * Update an element
+   *
+   * Requires: editor:update permission
+   */
+  async updateElement(projectId, elementId, updates) {
+    return this.client.patch(
+      `${this.basePath}/${projectId}/elements/${elementId}`,
+      updates
+    );
+  }
+  /**
+   * Remove an element
+   *
+   * Requires: editor:update permission (server-side RBAC enforced)
+   */
+  async removeElement(projectId, elementId) {
+    await this.client.delete(
+      `${this.basePath}/${projectId}/elements/${elementId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * Move an element to a different position
+   *
+   * Requires: editor:update permission
+   */
+  async moveElement(projectId, elementId, options) {
+    return this.client.post(
+      `${this.basePath}/${projectId}/elements/${elementId}/move`,
+      options
+    );
+  }
+  /**
+   * Trim an element
+   *
+   * Requires: editor:update permission
+   */
+  async trimElement(projectId, elementId, options) {
+    return this.client.post(
+      `${this.basePath}/${projectId}/elements/${elementId}/trim`,
+      options
+    );
+  }
+  /**
+   * Add a transition between elements
+   *
+   * Requires: editor:update permission
+   */
+  async addTransition(projectId, transition) {
+    return this.client.post(
+      `${this.basePath}/${projectId}/transitions`,
+      transition
+    );
+  }
+  /**
+   * Update a transition
+   *
+   * Requires: editor:update permission
+   */
+  async updateTransition(projectId, transitionId, updates) {
+    return this.client.patch(
+      `${this.basePath}/${projectId}/transitions/${transitionId}`,
+      updates
+    );
+  }
+  /**
+   * Remove a transition
+   *
+   * Requires: editor:update permission (server-side RBAC enforced)
+   */
+  async removeTransition(projectId, transitionId) {
+    await this.client.delete(
+      `${this.basePath}/${projectId}/transitions/${transitionId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * Add an effect to an element
+   *
+   * Requires: editor:update permission
+   */
+  async addEffect(projectId, effect) {
+    return this.client.post(
+      `${this.basePath}/${projectId}/effects`,
+      effect
+    );
+  }
+  /**
+   * Update an effect
+   *
+   * Requires: editor:update permission
+   */
+  async updateEffect(projectId, effectId, updates) {
+    return this.client.patch(
+      `${this.basePath}/${projectId}/effects/${effectId}`,
+      updates
+    );
+  }
+  /**
+   * Remove an effect
+   *
+   * Requires: editor:update permission (server-side RBAC enforced)
+   */
+  async removeEffect(projectId, effectId) {
+    await this.client.delete(
+      `${this.basePath}/${projectId}/effects/${effectId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * Start rendering a project
+   *
+   * Requires: editor:render permission
+   */
+  async render(projectId, options) {
+    return this.client.post(
+      `${this.basePath}/${projectId}/render`,
+      options
+    );
+  }
+  /**
+   * Get render job status
+   *
+   * Requires: editor:read permission
+   */
+  async getRenderJob(projectId, jobId) {
+    return this.client.get(
+      `${this.basePath}/${projectId}/render/${jobId}`
+    );
+  }
+  /**
+   * List render jobs for a project
+   *
+   * Requires: editor:read permission
+   */
+  async listRenderJobs(projectId, params) {
+    return this.client.get(
+      `${this.basePath}/${projectId}/render`,
+      { params }
+    );
+  }
+  /**
+   * Cancel a render job
+   *
+   * Requires: editor:render permission
+   */
+  async cancelRenderJob(projectId, jobId) {
+    return this.client.post(
+      `${this.basePath}/${projectId}/render/${jobId}/cancel`
+    );
+  }
+  /**
+   * Wait for render to complete
+   */
+  async waitForRender(projectId, jobId, options) {
+    const pollInterval = options?.pollInterval || 3e3;
+    const timeout = options?.timeout || 18e5;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const job = await this.getRenderJob(projectId, jobId);
+      if (options?.onProgress) {
+        options.onProgress(job);
+      }
+      if (job.status === "ready") {
+        return job;
+      }
+      if (job.status === "failed") {
+        throw new Error(`Render failed: ${job.error || "Unknown error"}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Render timed out after ${timeout}ms`);
+  }
+  /**
+   * Generate a preview frame
+   *
+   * Requires: editor:read permission
+   */
+  async getPreviewFrame(projectId, time, options) {
+    return this.client.get(`${this.basePath}/${projectId}/preview`, {
+      params: { time, ...options }
+    });
+  }
+  /**
+   * Generate a preview video segment
+   *
+   * Requires: editor:read permission
+   */
+  async getPreviewSegment(projectId, startTime, endTime, options) {
+    return this.client.post(`${this.basePath}/${projectId}/preview/segment`, {
+      start_time: startTime,
+      end_time: endTime,
+      ...options
+    });
+  }
+};
+function createEditorAPI(client) {
+  return new EditorAPI(client);
+}
+
+export {
+  EditorAPI,
+  createEditorAPI
+};

package/dist/chunk-TXWOA2VR.mjs

@@ -0,0 +1,57 @@
+// src/marketplace.ts
+var MarketplaceAPI = class {
+  client;
+  basePath = "/v1/marketplace";
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    return this.client.get(this.basePath, {
+      params
+    });
+  }
+  async get(itemId) {
+    return this.client.get(`${this.basePath}/${itemId}`);
+  }
+  async install(itemId) {
+    return this.client.post(`${this.basePath}/${itemId}/install`);
+  }
+  async uninstall(itemId) {
+    await this.client.delete(`${this.basePath}/${itemId}/install`);
+  }
+  async listInstalled(params) {
+    return this.client.get(`${this.basePath}/installed`, {
+      params
+    });
+  }
+  async publish(request) {
+    return this.client.post(this.basePath, request);
+  }
+  async update(itemId, updates) {
+    return this.client.patch(`${this.basePath}/${itemId}`, updates);
+  }
+  async deprecate(itemId) {
+    await this.client.post(`${this.basePath}/${itemId}/deprecate`);
+  }
+  async getReviews(itemId, params) {
+    return this.client.get(`${this.basePath}/${itemId}/reviews`, {
+      params
+    });
+  }
+  async addReview(itemId, review) {
+    return this.client.post(`${this.basePath}/${itemId}/reviews`, review);
+  }
+  async search(query, params) {
+    return this.client.get(`${this.basePath}/search`, {
+      params: { q: query, ...params }
+    });
+  }
+};
+function createMarketplaceAPI(client) {
+  return new MarketplaceAPI(client);
+}
+
+export {
+  MarketplaceAPI,
+  createMarketplaceAPI
+};