@editframe/api 0.7.0-beta.6 → 0.8.0-beta.1

package/dist/client.d.ts

@@ -0,0 +1,8 @@
+import { RequestInit } from 'node-fetch';
+import * as jwt from "jsonwebtoken";
+export declare class Client {
+    #private;
+    constructor(token: string, efHost?: string);
+    authenticatedFetch: (path: string, init?: RequestInit) => Promise<import('node-fetch').Response>;
+    sign(payload: Record<string, unknown>, expiresIn?: Parameters<typeof jwt.sign>[2]["expiresIn"]): string;
+}

package/dist/client.js

@@ -1,26 +1,45 @@
 import debug from "debug";
+import * as jwt from "jsonwebtoken";
+import fetch from "node-fetch";
 const log = debug("ef:api:client");
 class Client {
-  constructor(token, efHost) {
-    this.token = token;
-    this.efHost = efHost;
+  constructor(token, efHost = "https://editframe.dev") {
     this.authenticatedFetch = async (path, init = {}) => {
       init.headers ||= {};
+      const url = new URL(path, this.#efHost);
       log(
         "Authenticated fetch",
-        { path, init },
+        { url, init },
         "(Token will be added as Bearer token)"
       );
       Object.assign(init.headers, {
-        Authorization: `Bearer ${this.token}`,
+        Authorization: `Bearer ${this.#token}`,
         "Content-Type": "application/json"
       });
-      const url = new URL(path, this.efHost);
       const response = await fetch(url, init);
       log("Authenticated fetch response", response.status, response.statusText);
       return response;
     };
-    log("Creating client with efHost", efHost, "and !!token", !!token);
+    log("Creating client with efHost", { efHost, tokenIsSet: !!token });
+    this.#token = token;
+    this.#efHost = efHost;
+    const { apiKey, apiSecret } = token.match(/^(?<apiSecret>ef_[^_]+)_(?<apiKey>.+)$/)?.groups ?? {};
+    if (!apiKey || !apiSecret) {
+      throw new Error("Invalid token format");
+    }
+    this.#apiKey = apiKey;
+    this.#apiSecret = apiSecret;
+  }
+  #apiKey;
+  #apiSecret;
+  #token;
+  #efHost;
+  sign(payload, expiresIn = 60) {
+    payload.cid = this.#apiKey;
+    return jwt.sign(payload, this.#apiSecret, {
+      algorithm: "HS256",
+      expiresIn
+    });
   }
 }
 export {

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { createCaptionFile, CreateCaptionFilePayload, type CreateCaptionFileResult, uploadCaptionFile, } from './resources/caption-file.ts';
+export { createImageFile, CreateImageFilePayload, type CreateImageFileResult, uploadImageFile, } from './resources/image-file.ts';
+export { createISOBMFFFile, CreateISOBMFFFilePayload, type CreateISOBMFFFileResult, uploadFragmentIndex, } from './resources/isobmff-file.ts';
+export { createISOBMFFTrack, CreateISOBMFFTrackPayload, type CreateISOBMFFTrackResult, uploadISOBMFFTrack, } from './resources/isobmff-track.ts';
+export { createRender, CreateRenderPayload, type CreateRenderResult, uploadRender, } from './resources/renders.ts';
+export { createSignedURL, type SignedURLResult, } from './resources/signed-url.ts';
+export { createUnprocessedFile, CreateUnprocessedFilePayload, type CreateUnprocessedFileResult, updateUnprocessedFile, UpdateUnprocessedFilePayload, type UpdateUnprocessedFileResult, uploadUnprocessedFile, processAVFile, processAVFileBuffer, } from './resources/unprocessed-file.ts';
+export { Client } from './client.ts';

package/dist/index.js

@@ -3,6 +3,8 @@ import { CreateImageFilePayload, createImageFile, uploadImageFile } from "./reso
 import { CreateISOBMFFFilePayload, createISOBMFFFile, uploadFragmentIndex } from "./resources/isobmff-file.js";
 import { CreateISOBMFFTrackPayload, createISOBMFFTrack, uploadISOBMFFTrack } from "./resources/isobmff-track.js";
 import { CreateRenderPayload, createRender, uploadRender } from "./resources/renders.js";
+import { createSignedURL } from "./resources/signed-url.js";
+import { CreateUnprocessedFilePayload, UpdateUnprocessedFilePayload, createUnprocessedFile, processAVFile, processAVFileBuffer, updateUnprocessedFile, uploadUnprocessedFile } from "./resources/unprocessed-file.js";
 import { Client } from "./client.js";
 export {
   Client,
@@ -11,14 +13,22 @@ export {
   CreateISOBMFFTrackPayload,
   CreateImageFilePayload,
   CreateRenderPayload,
+  CreateUnprocessedFilePayload,
+  UpdateUnprocessedFilePayload,
   createCaptionFile,
   createISOBMFFFile,
   createISOBMFFTrack,
   createImageFile,
   createRender,
+  createSignedURL,
+  createUnprocessedFile,
+  processAVFile,
+  processAVFileBuffer,
+  updateUnprocessedFile,
   uploadCaptionFile,
   uploadFragmentIndex,
   uploadISOBMFFTrack,
   uploadImageFile,
-  uploadRender
+  uploadRender,
+  uploadUnprocessedFile
 };

package/dist/resources/caption-file.d.ts

@@ -0,0 +1,20 @@
+import { Readable } from 'node:stream';
+import { z } from 'zod';
+import { Client } from '../client.ts';
+
+export declare const CreateCaptionFilePayload: z.ZodObject<{
+    id: z.ZodString;
+    filename: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    filename: string;
+}, {
+    id: string;
+    filename: string;
+}>;
+export interface CreateCaptionFileResult {
+    complete: boolean | null;
+    id: string;
+}
+export declare const createCaptionFile: (client: Client, payload: z.infer<typeof CreateCaptionFilePayload>) => Promise<CreateCaptionFileResult | undefined>;
+export declare const uploadCaptionFile: (client: Client, fileId: string, fileStream: Readable) => Promise<unknown>;

package/dist/resources/caption-file.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import debug from "debug";
-import { nodeStreamToWebStream } from "../util/nodeStreamToWebStream.js";
 const log = debug("ef:api:caption-file");
 const CreateCaptionFilePayload = z.object({
   id: z.string(),
@@ -34,7 +33,7 @@ const uploadCaptionFile = async (client, fileId, fileStream) => {
     `/api/video2/caption_files/${fileId}/upload`,
     {
       method: "POST",
-      body: nodeStreamToWebStream(fileStream)
+      body: fileStream
     }
   );
   log("Caption file uploaded", fileIndex);

package/dist/resources/image-file.d.ts

@@ -0,0 +1,29 @@
+import { Readable } from 'node:stream';
+import { z } from 'zod';
+import { Client } from '../client.ts';
+
+export declare const CreateImageFilePayload: z.ZodObject<{
+    id: z.ZodString;
+    height: z.ZodNumber;
+    width: z.ZodNumber;
+    mime_type: z.ZodEnum<["image/jpeg", "image/png", "image/jpg", "image/webp"]>;
+    filename: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    filename: string;
+    height: number;
+    width: number;
+    mime_type: "image/jpeg" | "image/png" | "image/jpg" | "image/webp";
+}, {
+    id: string;
+    filename: string;
+    height: number;
+    width: number;
+    mime_type: "image/jpeg" | "image/png" | "image/jpg" | "image/webp";
+}>;
+export interface CreateImageFileResult {
+    complete: boolean | null;
+    id: string;
+}
+export declare const createImageFile: (client: Client, payload: z.infer<typeof CreateImageFilePayload>) => Promise<CreateImageFileResult | undefined>;
+export declare const uploadImageFile: (client: Client, fileId: string, fileStream: Readable) => Promise<unknown>;

package/dist/resources/image-file.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import debug from "debug";
-import { nodeStreamToWebStream } from "../util/nodeStreamToWebStream.js";
 const log = debug("ef:api:image-file");
 const CreateImageFilePayload = z.object({
   id: z.string(),
@@ -33,7 +32,7 @@ const uploadImageFile = async (client, fileId, fileStream) => {
     `/api/video2/image_files/${fileId}/upload`,
     {
       method: "POST",
-      body: nodeStreamToWebStream(fileStream)
+      body: fileStream
     }
   );
   switch (fileIndex.status) {

package/dist/resources/isobmff-file.d.ts

@@ -0,0 +1,20 @@
+import { Readable } from 'node:stream';
+import { z } from 'zod';
+import { Client } from '../client.ts';
+
+export declare const CreateISOBMFFFilePayload: z.ZodObject<{
+    id: z.ZodString;
+    filename: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    filename: string;
+}, {
+    id: string;
+    filename: string;
+}>;
+export interface CreateISOBMFFFileResult {
+    fragment_index_complete: boolean;
+    id: string;
+}
+export declare const createISOBMFFFile: (client: Client, payload: z.infer<typeof CreateISOBMFFFilePayload>) => Promise<CreateISOBMFFFileResult | undefined>;
+export declare const uploadFragmentIndex: (client: Client, fileId: string, fileStream: Readable) => Promise<unknown>;

package/dist/resources/isobmff-file.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import debug from "debug";
-import { nodeStreamToWebStream } from "../util/nodeStreamToWebStream.js";
 const log = debug("ef:api:isobmff-file");
 const CreateISOBMFFFilePayload = z.object({
   id: z.string(),
@@ -34,7 +33,7 @@ const uploadFragmentIndex = async (client, fileId, fileStream) => {
     `/api/video2/isobmff_files/${fileId}/index/upload`,
     {
       method: "POST",
-      body: nodeStreamToWebStream(fileStream)
+      body: fileStream
     }
   );
   log("Fragment index uploaded", fileIndex);

package/dist/resources/isobmff-track.d.ts

@@ -0,0 +1,271 @@
+import { Readable } from 'node:stream';
+import { z } from 'zod';
+import { Client } from '../client.ts';
+
+export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    file_id: z.ZodString;
+    track_id: z.ZodNumber;
+    type: z.ZodLiteral<"audio">;
+    probe_info: z.ZodObject<{
+        index: z.ZodNumber;
+        codec_name: z.ZodString;
+        codec_long_name: z.ZodString;
+        codec_type: z.ZodLiteral<"audio">;
+        codec_tag_string: z.ZodString;
+        codec_tag: z.ZodString;
+        sample_fmt: z.ZodString;
+        sample_rate: z.ZodString;
+        channels: z.ZodNumber;
+        channel_layout: z.ZodString;
+        bits_per_sample: z.ZodNumber;
+        initial_padding: z.ZodOptional<z.ZodNumber>;
+        r_frame_rate: z.ZodString;
+        avg_frame_rate: z.ZodString;
+        time_base: z.ZodString;
+        start_pts: z.ZodNumber;
+        start_time: z.ZodNumber;
+        duration_ts: z.ZodNumber;
+        duration: z.ZodNumber;
+        bit_rate: z.ZodString;
+        disposition: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        duration: number;
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "audio";
+        codec_tag_string: string;
+        codec_tag: string;
+        sample_fmt: string;
+        sample_rate: string;
+        channels: number;
+        channel_layout: string;
+        bits_per_sample: number;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        start_pts: number;
+        start_time: number;
+        duration_ts: number;
+        bit_rate: string;
+        disposition: Record<string, unknown>;
+        initial_padding?: number | undefined;
+    }, {
+        duration: number;
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "audio";
+        codec_tag_string: string;
+        codec_tag: string;
+        sample_fmt: string;
+        sample_rate: string;
+        channels: number;
+        channel_layout: string;
+        bits_per_sample: number;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        start_pts: number;
+        start_time: number;
+        duration_ts: number;
+        bit_rate: string;
+        disposition: Record<string, unknown>;
+        initial_padding?: number | undefined;
+    }>;
+    duration_ms: z.ZodNumber;
+    codec_name: z.ZodString;
+    byte_size: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "audio";
+    file_id: string;
+    track_id: number;
+    probe_info: {
+        duration: number;
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "audio";
+        codec_tag_string: string;
+        codec_tag: string;
+        sample_fmt: string;
+        sample_rate: string;
+        channels: number;
+        channel_layout: string;
+        bits_per_sample: number;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        start_pts: number;
+        start_time: number;
+        duration_ts: number;
+        bit_rate: string;
+        disposition: Record<string, unknown>;
+        initial_padding?: number | undefined;
+    };
+    duration_ms: number;
+    codec_name: string;
+    byte_size: number;
+}, {
+    type: "audio";
+    file_id: string;
+    track_id: number;
+    probe_info: {
+        duration: number;
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "audio";
+        codec_tag_string: string;
+        codec_tag: string;
+        sample_fmt: string;
+        sample_rate: string;
+        channels: number;
+        channel_layout: string;
+        bits_per_sample: number;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        start_pts: number;
+        start_time: number;
+        duration_ts: number;
+        bit_rate: string;
+        disposition: Record<string, unknown>;
+        initial_padding?: number | undefined;
+    };
+    duration_ms: number;
+    codec_name: string;
+    byte_size: number;
+}>, z.ZodObject<{
+    file_id: z.ZodString;
+    track_id: z.ZodNumber;
+    type: z.ZodLiteral<"video">;
+    probe_info: z.ZodObject<{
+        index: z.ZodNumber;
+        codec_name: z.ZodString;
+        codec_long_name: z.ZodString;
+        codec_type: z.ZodLiteral<"video">;
+        codec_tag_string: z.ZodString;
+        codec_tag: z.ZodString;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        coded_width: z.ZodNumber;
+        coded_height: z.ZodNumber;
+        r_frame_rate: z.ZodString;
+        avg_frame_rate: z.ZodString;
+        time_base: z.ZodString;
+        start_pts: z.ZodOptional<z.ZodNumber>;
+        start_time: z.ZodOptional<z.ZodNumber>;
+        duration_ts: z.ZodOptional<z.ZodNumber>;
+        duration: z.ZodOptional<z.ZodNumber>;
+        bit_rate: z.ZodOptional<z.ZodString>;
+        disposition: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "video";
+        codec_tag_string: string;
+        codec_tag: string;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        disposition: Record<string, unknown>;
+        width: number;
+        height: number;
+        coded_width: number;
+        coded_height: number;
+        duration?: number | undefined;
+        start_pts?: number | undefined;
+        start_time?: number | undefined;
+        duration_ts?: number | undefined;
+        bit_rate?: string | undefined;
+    }, {
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "video";
+        codec_tag_string: string;
+        codec_tag: string;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        disposition: Record<string, unknown>;
+        width: number;
+        height: number;
+        coded_width: number;
+        coded_height: number;
+        duration?: number | undefined;
+        start_pts?: number | undefined;
+        start_time?: number | undefined;
+        duration_ts?: number | undefined;
+        bit_rate?: string | undefined;
+    }>;
+    duration_ms: z.ZodNumber;
+    codec_name: z.ZodString;
+    byte_size: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "video";
+    file_id: string;
+    track_id: number;
+    probe_info: {
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "video";
+        codec_tag_string: string;
+        codec_tag: string;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        disposition: Record<string, unknown>;
+        width: number;
+        height: number;
+        coded_width: number;
+        coded_height: number;
+        duration?: number | undefined;
+        start_pts?: number | undefined;
+        start_time?: number | undefined;
+        duration_ts?: number | undefined;
+        bit_rate?: string | undefined;
+    };
+    duration_ms: number;
+    codec_name: string;
+    byte_size: number;
+}, {
+    type: "video";
+    file_id: string;
+    track_id: number;
+    probe_info: {
+        index: number;
+        codec_name: string;
+        codec_long_name: string;
+        codec_type: "video";
+        codec_tag_string: string;
+        codec_tag: string;
+        r_frame_rate: string;
+        avg_frame_rate: string;
+        time_base: string;
+        disposition: Record<string, unknown>;
+        width: number;
+        height: number;
+        coded_width: number;
+        coded_height: number;
+        duration?: number | undefined;
+        start_pts?: number | undefined;
+        start_time?: number | undefined;
+        duration_ts?: number | undefined;
+        bit_rate?: string | undefined;
+    };
+    duration_ms: number;
+    codec_name: string;
+    byte_size: number;
+}>]>;
+export interface CreateISOBMFFTrackResult {
+    last_received_byte: number;
+    byte_size: number;
+    track_id: number;
+    file_id: string;
+}
+export declare const createISOBMFFTrack: (client: Client, payload: z.infer<typeof CreateISOBMFFTrackPayload>) => Promise<CreateISOBMFFTrackResult | undefined>;
+export declare const uploadISOBMFFTrack: (client: Client, fileId: string, trackId: number, fileStream: Readable) => Promise<unknown>;

package/dist/resources/isobmff-track.js

@@ -1,7 +1,6 @@
 import { z } from "zod";
 import debug from "debug";
 import { AudioStreamSchema, VideoStreamSchema } from "@editframe/assets";
-import { nodeStreamToWebStream } from "../util/nodeStreamToWebStream.js";
 const log = debug("ef:api:isobmff-track");
 const CreateISOBMFFTrackPayload = z.discriminatedUnion("type", [
   z.object({
@@ -50,7 +49,7 @@ const uploadISOBMFFTrack = async (client, fileId, trackId, fileStream) => {
     `/api/video2/isobmff_tracks/${fileId}/${trackId}/upload`,
     {
       method: "POST",
-      body: nodeStreamToWebStream(fileStream)
+      body: fileStream
     }
   );
   log("ISOBMFF track uploaded", trackIndex);

package/dist/resources/renders.d.ts

@@ -0,0 +1,35 @@
+import { Readable } from 'node:stream';
+import { z } from 'zod';
+import { Client } from '../client.ts';
+
+export declare const CreateRenderPayload: z.ZodObject<{
+    id: z.ZodString;
+    fps: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    work_slice_ms: z.ZodNumber;
+    duration_ms: z.ZodNumber;
+    strategy: z.ZodEnum<["v1", "v2"]>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    height: number;
+    width: number;
+    duration_ms: number;
+    fps: number;
+    work_slice_ms: number;
+    strategy: "v1" | "v2";
+}, {
+    id: string;
+    height: number;
+    width: number;
+    duration_ms: number;
+    fps: number;
+    work_slice_ms: number;
+    strategy: "v1" | "v2";
+}>;
+export interface CreateRenderResult {
+    status: "complete" | "created" | "failed" | "pending" | "rendering";
+    id: string;
+}
+export declare const createRender: (client: Client, payload: z.infer<typeof CreateRenderPayload>) => Promise<CreateRenderResult | undefined>;
+export declare const uploadRender: (client: Client, fileId: string, fileStream: Readable) => Promise<unknown>;

package/dist/resources/renders.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import debug from "debug";
-import { nodeStreamToWebStream } from "../util/nodeStreamToWebStream.js";
 const log = debug("ef:api:renders");
 const CreateRenderPayload = z.object({
   id: z.string().uuid(),
@@ -35,7 +34,7 @@ const uploadRender = async (client, fileId, fileStream) => {
     `/api/video2/renders/${fileId}/upload`,
     {
       method: "POST",
-      body: nodeStreamToWebStream(fileStream)
+      body: fileStream
     }
   );
   log("Render uploaded", fileIndex);

package/dist/resources/signed-url.d.ts

@@ -0,0 +1,6 @@
+import { Client } from '../client.ts';
+
+export interface SignedURLResult {
+    url: string;
+}
+export declare const createSignedURL: (client: Client, url: string) => Promise<string>;

package/dist/resources/signed-url.js

@@ -0,0 +1,20 @@
+import debug from "debug";
+const log = debug("ef:api:signed-url");
+const createSignedURL = async (client, url) => {
+  log("Creating signed url for", url);
+  const response = await client.authenticatedFetch("/api/v1/signed-url", {
+    method: "POST",
+    body: JSON.stringify({
+      url
+    })
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Failed to create signed url: ${response.status} ${response.statusText} ${await response.text()}`
+    );
+  }
+  return (await response.json()).url;
+};
+export {
+  createSignedURL
+};

package/dist/resources/unprocessed-file.d.ts

@@ -0,0 +1,43 @@
+import { Readable } from 'node:stream';
+import { z } from 'zod';
+import { Client } from '../client.ts';
+
+declare const FileProcessors: z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"isobmff">, z.ZodLiteral<"captions">]>, "many">, ("isobmff" | "captions")[], ("isobmff" | "captions")[]>;
+export declare const CreateUnprocessedFilePayload: z.ZodObject<{
+    id: z.ZodString;
+    filename: z.ZodString;
+    processes: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"isobmff">, z.ZodLiteral<"captions">]>, "many">, ("isobmff" | "captions")[], ("isobmff" | "captions")[]>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    filename: string;
+    processes?: ("isobmff" | "captions")[] | undefined;
+}, {
+    id: string;
+    filename: string;
+    processes?: ("isobmff" | "captions")[] | undefined;
+}>;
+export declare const UpdateUnprocessedFilePayload: z.ZodObject<{
+    processes: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"isobmff">, z.ZodLiteral<"captions">]>, "many">, ("isobmff" | "captions")[], ("isobmff" | "captions")[]>>;
+}, "strip", z.ZodTypeAny, {
+    processes?: ("isobmff" | "captions")[] | undefined;
+}, {
+    processes?: ("isobmff" | "captions")[] | undefined;
+}>;
+export interface CreateUnprocessedFileResult {
+    byte_size: number;
+    last_received_byte: number;
+    id: string;
+    processes: z.infer<typeof FileProcessors>;
+}
+export interface UpdateUnprocessedFileResult {
+    byte_size: number;
+    last_received_byte: number;
+    id: string;
+    processes: z.infer<typeof FileProcessors>;
+}
+export declare const createUnprocessedFile: (client: Client, payload: z.infer<typeof CreateUnprocessedFilePayload>) => Promise<CreateUnprocessedFileResult>;
+export declare const updateUnprocessedFile: (client: Client, fileId: string, payload: Partial<z.infer<typeof UpdateUnprocessedFilePayload>>) => Promise<UpdateUnprocessedFileResult>;
+export declare const uploadUnprocessedFile: (client: Client, fileId: string, fileStream: Readable) => Promise<unknown>;
+export declare const processAVFileBuffer: (client: Client, buffer: Buffer, filename?: string) => Promise<UpdateUnprocessedFileResult>;
+export declare const processAVFile: (client: Client, filePath: string) => Promise<UpdateUnprocessedFileResult>;
+export {};