@editframe/api 0.11.0-beta.9 → 0.12.0-beta.10

package/dist/{resources → api/src/resources}/renders.js

@@ -1,5 +1,5 @@
-import { z } from "zod";
 import debug from "debug";
+import { z } from "zod";
 const log = debug("ef:api:renders");
 const FILE_SIZE_LIMIT = 1024 * 1024 * 16;
 const CreateRenderPayload = z.object({
@@ -35,7 +35,8 @@ const uploadRender = async (client, fileId, fileStream, folderSize) => {
     `/api/v1/renders/${fileId}/upload`,
     {
       method: "POST",
-      body: fileStream
+      body: fileStream,
+      duplex: "half"
     }
   );
   if (response.ok) {
@@ -45,8 +46,26 @@ const uploadRender = async (client, fileId, fileStream, folderSize) => {
     `Failed to upload render ${response.status} ${response.statusText}`
   );
 };
+const lookupRenderByMd5 = async (client, md5) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/renders/md5/${md5}`,
+    {
+      method: "GET"
+    }
+  );
+  if (response.ok) {
+    return await response.json();
+  }
+  if (response.status === 404) {
+    return null;
+  }
+  throw new Error(
+    `Failed to lookup render by md5 ${md5} ${response.status} ${response.statusText}`
+  );
+};
 export {
   CreateRenderPayload,
   createRender,
+  lookupRenderByMd5,
   uploadRender
 };

package/dist/api/src/resources/transcriptions.js

@@ -0,0 +1,45 @@
+import debug from "debug";
+import { z } from "zod";
+import { CompletionIterator } from "../ProgressIterator.js";
+const log = debug("ef:api:transcriptions");
+const CreateTranscriptionPayload = z.object({
+  file_id: z.string(),
+  track_id: z.number().int()
+});
+const createTranscription = async (client, payload) => {
+  log("Creating transcription", payload);
+  const response = await client.authenticatedFetch("/api/v1/transcriptions", {
+    method: "POST",
+    body: JSON.stringify(payload)
+  });
+  log("Transcription created", response);
+  if (response.ok) {
+    return await response.json();
+  }
+  throw new Error(
+    `Failed to create transcription ${response.status} ${response.statusText}`
+  );
+};
+const getTranscriptionProgress = async (client, id) => {
+  const eventSource = await client.authenticatedEventSource(
+    `/api/v1/transcriptions/${id}/progress`
+  );
+  return new CompletionIterator(eventSource);
+};
+const getTranscriptionInfo = async (client, id) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/transcriptions/${id}`
+  );
+  if (response.ok) {
+    return await response.json();
+  }
+  throw new Error(
+    `Failed to get transcription info ${response.status} ${response.statusText}`
+  );
+};
+export {
+  CreateTranscriptionPayload,
+  createTranscription,
+  getTranscriptionInfo,
+  getTranscriptionProgress
+};

package/dist/api/src/resources/unprocessed-file.js

@@ -0,0 +1,114 @@
+import debug from "debug";
+import { z } from "zod";
+import { uploadChunks } from "../uploadChunks.js";
+const log = debug("ef:api:unprocessed-file");
+const MAX_FILE_SIZE = 1024 * 1024 * 1024;
+const CreateUnprocessedFilePayload = z.object({
+  md5: z.string(),
+  filename: z.string(),
+  byte_size: z.number().int().max(MAX_FILE_SIZE)
+});
+z.object({});
+const createUnprocessedFileFromPath = async (client, path) => {
+  const [{ stat }, { basename }, { md5FilePath }] = await Promise.all([
+    import("node:fs/promises"),
+    import("node:path"),
+    import("@editframe/assets")
+  ]).catch((error) => {
+    console.error("Error importing modules", error);
+    console.error(
+      "This is likely because you are bundling for the browser. createUnprocessedFileFromPath can only be run in environments that support importing `node:path`"
+    );
+    throw error;
+  });
+  const fileInfo = await stat(path);
+  const byte_size = fileInfo.size;
+  const md5 = await md5FilePath(path);
+  return createUnprocessedFile(client, {
+    md5,
+    filename: basename(path),
+    byte_size
+  });
+};
+const createUnprocessedFile = async (client, payload) => {
+  log("Creating an unprocessed file", payload);
+  CreateUnprocessedFilePayload.parse(payload);
+  const response = await client.authenticatedFetch(
+    "/api/v1/unprocessed_files",
+    {
+      method: "POST",
+      body: JSON.stringify(payload)
+    }
+  );
+  log(
+    "Unprocessed file created",
+    response.status,
+    response.statusText,
+    response.headers
+  );
+  if (response.ok) {
+    return await response.json();
+  }
+  throw new Error(
+    `Failed to create unprocessed file ${response.status} ${response.statusText}`
+  );
+};
+const uploadUnprocessedFile = async (client, uploadDetails, path) => {
+  const { createReadStream } = await import("node:fs");
+  const readStream = createReadStream(path);
+  const { createReadableStreamFromReadable } = await import("../../../cli/src/utils/createReadableStreamFromReadable.js");
+  return uploadUnprocessedReadableStream(
+    client,
+    uploadDetails,
+    createReadableStreamFromReadable(readStream)
+  );
+};
+const uploadUnprocessedReadableStream = (client, uploadDetails, fileStream) => {
+  log("Uploading unprocessed file", uploadDetails.id);
+  return uploadChunks(client, {
+    url: `/api/v1/unprocessed_files/${uploadDetails.id}/upload`,
+    fileSize: uploadDetails.byte_size,
+    fileStream,
+    maxSize: MAX_FILE_SIZE
+  });
+};
+const lookupUnprocessedFileByMd5 = async (client, md5) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/unprocessed_files/md5/${md5}`,
+    {
+      method: "GET"
+    }
+  );
+  if (response.ok) {
+    return await response.json();
+  }
+  if (response.status === 404) {
+    return null;
+  }
+  throw new Error(
+    `Failed to lookup unprocessed file by md5 ${md5} ${response.status} ${response.statusText}`
+  );
+};
+const processIsobmffFile = async (client, id) => {
+  const response = await client.authenticatedFetch(
+    `/api/v1/unprocessed_files/${id}/isobmff`,
+    {
+      method: "POST"
+    }
+  );
+  if (response.ok) {
+    return await response.json();
+  }
+  throw new Error(
+    `Failed to process isobmff file ${id} ${response.status} ${response.statusText}`
+  );
+};
+export {
+  CreateUnprocessedFilePayload,
+  createUnprocessedFile,
+  createUnprocessedFileFromPath,
+  lookupUnprocessedFileByMd5,
+  processIsobmffFile,
+  uploadUnprocessedFile,
+  uploadUnprocessedReadableStream
+};

package/dist/api/src/streamChunker.js

@@ -0,0 +1,28 @@
+import { CHUNK_SIZE_BYTES } from "./CHUNK_SIZE_BYTES.js";
+async function* streamChunker(readableStream, chunkSize = CHUNK_SIZE_BYTES) {
+  const reader = readableStream.getReader();
+  let buffer = new Uint8Array(0);
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = value;
+      const newBuffer = new Uint8Array(buffer.length + chunk.length);
+      newBuffer.set(buffer);
+      newBuffer.set(chunk, buffer.length);
+      buffer = newBuffer;
+      while (buffer.length >= chunkSize) {
+        yield buffer.slice(0, chunkSize);
+        buffer = buffer.slice(chunkSize);
+      }
+    }
+    if (buffer.length > 0) {
+      yield buffer;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+export {
+  streamChunker
+};

package/dist/{uploadChunks.js → api/src/uploadChunks.js}

@@ -51,7 +51,7 @@ function uploadChunks(client, {
     const uploadStatus = await client.authenticatedFetch(url);
     yield { type: "progress", progress: 0 };
     if (uploadStatus.status === 200) {
-      log("Fragment track already uploaded");
+      log("Chunk already uploaded");
       yield { type: "progress", progress: 1 };
       return;
     }
@@ -72,9 +72,6 @@ function uploadChunks(client, {
         progress: Math.min(1, chunkNumber / (fileSize / chunkSizeBytes))
       };
     }
-    if (!fileStream.readableEnded) {
-      throw new Error("Did not read entire file stream");
-    }
     if (!complete) {
       throw new Error("Did not complete upload");
     }

package/dist/cli/src/utils/createReadableStreamFromReadable.js

@@ -0,0 +1,82 @@
+import { Stream } from "node:stream";
+const createReadableStreamFromReadable = (source) => {
+  const pump = new StreamPump(source);
+  const stream = new ReadableStream(pump, pump);
+  return stream;
+};
+class StreamPump {
+  constructor(stream) {
+    this.highWaterMark = stream.readableHighWaterMark || new Stream.Readable().readableHighWaterMark;
+    this.accumalatedSize = 0;
+    this.stream = stream;
+    this.enqueue = this.enqueue.bind(this);
+    this.error = this.error.bind(this);
+    this.close = this.close.bind(this);
+  }
+  size(chunk) {
+    return chunk?.byteLength || 0;
+  }
+  start(controller) {
+    this.controller = controller;
+    this.stream.on("data", this.enqueue);
+    this.stream.once("error", this.error);
+    this.stream.once("end", this.close);
+    this.stream.once("close", this.close);
+  }
+  pull() {
+    this.resume();
+  }
+  cancel(reason) {
+    if (this.stream.destroy) {
+      this.stream.destroy(reason);
+    }
+    this.stream.off("data", this.enqueue);
+    this.stream.off("error", this.error);
+    this.stream.off("end", this.close);
+    this.stream.off("close", this.close);
+  }
+  enqueue(chunk) {
+    if (this.controller) {
+      try {
+        const bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
+        const available = (this.controller.desiredSize || 0) - bytes.byteLength;
+        this.controller.enqueue(bytes);
+        if (available <= 0) {
+          this.pause();
+        }
+      } catch (error) {
+        this.controller.error(
+          new Error(
+            "Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object"
+          )
+        );
+        this.cancel();
+      }
+    }
+  }
+  pause() {
+    if (this.stream.pause) {
+      this.stream.pause();
+    }
+  }
+  resume() {
+    if (this.stream.readable && this.stream.resume) {
+      this.stream.resume();
+    }
+  }
+  close() {
+    if (this.controller) {
+      this.controller.close();
+      delete this.controller;
+    }
+  }
+  error(error) {
+    if (this.controller) {
+      this.controller.error(error);
+      delete this.controller;
+    }
+  }
+}
+export {
+  createReadableStreamFromReadable
+};

package/dist/client.d.ts

@@ -1,6 +1,9 @@
-import { RequestInit } from 'node-fetch';
+import { StreamEventSource } from './StreamEventSource.ts';
 export declare class Client {
     #private;
-    constructor(token: string, efHost?: string);
-    authenticatedFetch: (path: string, init?: RequestInit) => Promise<import('node-fetch').Response>;
+    constructor(token?: string, efHost?: string);
+    authenticatedEventSource: (path: string, init?: RequestInit) => Promise<StreamEventSource>;
+    authenticatedFetch: (path: string, init?: RequestInit & {
+        duplex?: "half";
+    }) => Promise<Response>;
 }

package/dist/index.d.ts

@@ -1,8 +1,10 @@
-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 { createCaptionFile, CreateCaptionFilePayload, type CreateCaptionFileResult, uploadCaptionFile, type LookupCaptionFileByMd5Result, lookupCaptionFileByMd5, } from './resources/caption-file.ts';
+export { createImageFile, CreateImageFilePayload, type CreateImageFileResult, uploadImageFile, type LookupImageFileByMd5Result, lookupImageFileByMd5, } from './resources/image-file.ts';
+export { createISOBMFFFile, CreateISOBMFFFilePayload, type CreateISOBMFFFileResult, uploadFragmentIndex, type LookupISOBMFFFileByMd5Result, lookupISOBMFFFileByMd5, type GetISOBMFFFileTranscriptionResult, getISOBMFFFileTranscription, type TranscribeISOBMFFFileResult, transcribeISOBMFFFile, TranscribeISOBMFFFilePayload, } 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 { createRender, CreateRenderPayload, type CreateRenderResult, uploadRender, type LookupRenderByMd5Result, lookupRenderByMd5, } from './resources/renders.ts';
+export { createTranscription, CreateTranscriptionPayload, type CreateTranscriptionResult, getTranscriptionInfo, getTranscriptionProgress, type TranscriptionInfoResult, } from './resources/transcriptions.ts';
 export { createURLToken, type URLTokenResult, } from './resources/url-token.ts';
-export { createUnprocessedFile, CreateUnprocessedFilePayload, type CreateUnprocessedFileResult, updateUnprocessedFile, UpdateUnprocessedFilePayload, type UpdateUnprocessedFileResult, uploadUnprocessedFile, processAVFile, processAVFileBuffer, processImageFile, processImageFileBuffer, } from './resources/unprocessed-file.ts';
+export { createUnprocessedFile, CreateUnprocessedFilePayload, type CreateUnprocessedFileResult, uploadUnprocessedReadableStream, type LookupUnprocessedFileByMd5Result, lookupUnprocessedFileByMd5, processIsobmffFile, type ProcessIsobmffFileResult, createUnprocessedFileFromPath, uploadUnprocessedFile, } from './resources/unprocessed-file.ts';
+export { getIsobmffProcessInfo, getIsobmffProcessProgress, type IsobmffProcessInfoResult, } from './resources/process-isobmff.ts';
 export { Client } from './client.ts';

package/dist/readableFromBuffers.d.ts

@@ -1,2 +1 @@
-import { Readable } from 'node:stream';
-export declare const readableFromBuffers: (...buffers: Buffer[]) => Readable;
+export declare const webReadableFromBuffers: (...buffers: Buffer[]) => ReadableStream<any>;

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

@@ -1,4 +1,3 @@
-import { Readable } from 'node:stream';
 import { z } from 'zod';
 import { Client } from '../client.ts';
 export declare const CreateCaptionFilePayload: z.ZodObject<{
@@ -18,7 +17,11 @@ export interface CreateCaptionFileResult {
     complete: boolean | null;
     id: string;
     md5: string;
-    asset_id: string;
+}
+export interface LookupCaptionFileByMd5Result {
+    complete: boolean | null;
+    id: string;
+    md5: string;
 }
 /**
  * Create a caption file
@@ -38,4 +41,5 @@ export interface CreateCaptionFileResult {
  * @beta
  */
 export declare const createCaptionFile: (client: Client, payload: z.infer<typeof CreateCaptionFilePayload>) => Promise<CreateCaptionFileResult>;
-export declare const uploadCaptionFile: (client: Client, fileId: string, fileStream: Readable, fileSize: number) => Promise<unknown>;
+export declare const uploadCaptionFile: (client: Client, fileId: string, fileStream: ReadableStream, fileSize: number) => Promise<any>;
+export declare const lookupCaptionFileByMd5: (client: Client, md5: string) => Promise<LookupCaptionFileByMd5Result | null>;

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

@@ -1,4 +1,3 @@
-import { Readable } from 'node:stream';
 import { z } from 'zod';
 import { Client } from '../client.ts';
 export declare const CreateImageFilePayload: z.ZodObject<{
@@ -12,22 +11,33 @@ export declare const CreateImageFilePayload: z.ZodObject<{
     md5: string;
     filename: string;
     byte_size: number;
-    height: number;
     width: number;
+    height: number;
     mime_type: "image/jpeg" | "image/png" | "image/jpg" | "image/webp";
 }, {
     md5: string;
     filename: string;
     byte_size: number;
-    height: number;
     width: number;
+    height: number;
     mime_type: "image/jpeg" | "image/png" | "image/jpg" | "image/webp";
 }>;
 export interface CreateImageFileResult {
     complete: boolean | null;
+    byte_size: number;
+    id: string;
+    md5: string;
+}
+export interface LookupImageFileByMd5Result {
+    complete: boolean | null;
+    byte_size: number;
     id: string;
     md5: string;
-    asset_id: string;
 }
+export declare const createImageFileFromPath: (client: Client, path: string) => Promise<CreateImageFileResult>;
 export declare const createImageFile: (client: Client, payload: z.infer<typeof CreateImageFilePayload>) => Promise<CreateImageFileResult>;
-export declare const uploadImageFile: (client: Client, fileId: string, fileStream: Readable, fileSize: number) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;
+export declare const uploadImageFile: (client: Client, uploadDetails: {
+    id: string;
+    byte_size: number;
+}, fileStream: ReadableStream) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;
+export declare const lookupImageFileByMd5: (client: Client, md5: string) => Promise<LookupImageFileByMd5Result | null>;

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

@@ -1,4 +1,3 @@
-import { Readable } from 'node:stream';
 import { z } from 'zod';
 import { Client } from '../client.ts';
 export declare const CreateISOBMFFFilePayload: z.ZodObject<{
@@ -16,7 +15,34 @@ export interface CreateISOBMFFFileResult {
     filename: string;
     id: string;
     md5: string;
-    asset_id: string;
+}
+export interface LookupISOBMFFFileByMd5Result {
+    fragment_index_complete: boolean;
+    filename: string;
+    id: string;
+    md5: string;
+}
+export interface GetISOBMFFFileTranscriptionResult {
+    id: string;
+    work_slice_ms: number;
+    isobmff_track: {
+        duration_ms: number;
+    };
 }
 export declare const createISOBMFFFile: (client: Client, payload: z.infer<typeof CreateISOBMFFFilePayload>) => Promise<CreateISOBMFFFileResult>;
-export declare const uploadFragmentIndex: (client: Client, fileId: string, fileStream: Readable, fileSize: number) => Promise<unknown>;
+export declare const uploadFragmentIndex: (client: Client, fileId: string, fileStream: ReadableStream, fileSize: number) => Promise<any>;
+export declare const lookupISOBMFFFileByMd5: (client: Client, md5: string) => Promise<LookupISOBMFFFileByMd5Result | null>;
+export declare const getISOBMFFFileTranscription: (client: Client, id: string) => Promise<GetISOBMFFFileTranscriptionResult | null>;
+export declare const TranscribeISOBMFFFilePayload: z.ZodObject<{
+    trackId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    trackId?: string | undefined;
+}, {
+    trackId?: string | undefined;
+}>;
+export interface TranscribeISOBMFFFileResult {
+    id: string;
+    file_id: string;
+    track_id: number;
+}
+export declare const transcribeISOBMFFFile: (client: Client, id: string, payload?: z.infer<typeof TranscribeISOBMFFFilePayload>) => Promise<TranscribeISOBMFFFileResult>;

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

@@ -1,4 +1,3 @@
-import { Readable } from 'node:stream';
 import { z } from 'zod';
 import { Client } from '../client.ts';
 export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
@@ -76,8 +75,8 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
     codec_name: z.ZodString;
     byte_size: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-    byte_size: number;
     type: "audio";
+    byte_size: number;
     codec_name: string;
     file_id: string;
     track_id: number;
@@ -106,8 +105,8 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
     };
     duration_ms: number;
 }, {
-    byte_size: number;
     type: "audio";
+    byte_size: number;
     codec_name: string;
     file_id: string;
     track_id: number;
@@ -160,8 +159,6 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         bit_rate: z.ZodOptional<z.ZodString>;
         disposition: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, "strip", z.ZodTypeAny, {
-        height: number;
-        width: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -172,6 +169,8 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         avg_frame_rate: string;
         time_base: string;
         disposition: Record<string, unknown>;
+        width: number;
+        height: number;
         coded_width: number;
         coded_height: number;
         start_pts?: number | undefined;
@@ -180,8 +179,6 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         duration?: number | undefined;
         bit_rate?: string | undefined;
     }, {
-        height: number;
-        width: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -192,6 +189,8 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         avg_frame_rate: string;
         time_base: string;
         disposition: Record<string, unknown>;
+        width: number;
+        height: number;
         coded_width: number;
         coded_height: number;
         start_pts?: number | undefined;
@@ -204,14 +203,12 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
     codec_name: z.ZodString;
     byte_size: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
-    byte_size: number;
     type: "video";
+    byte_size: number;
     codec_name: string;
     file_id: string;
     track_id: number;
     probe_info: {
-        height: number;
-        width: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -222,6 +219,8 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         avg_frame_rate: string;
         time_base: string;
         disposition: Record<string, unknown>;
+        width: number;
+        height: number;
         coded_width: number;
         coded_height: number;
         start_pts?: number | undefined;
@@ -232,14 +231,12 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
     };
     duration_ms: number;
 }, {
-    byte_size: number;
     type: "video";
+    byte_size: number;
     codec_name: string;
     file_id: string;
     track_id: number;
     probe_info: {
-        height: number;
-        width: number;
         index: number;
         codec_name: string;
         codec_long_name: string;
@@ -250,6 +247,8 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
         avg_frame_rate: string;
         time_base: string;
         disposition: Record<string, unknown>;
+        width: number;
+        height: number;
         coded_width: number;
         coded_height: number;
         start_pts?: number | undefined;
@@ -265,8 +264,7 @@ export interface CreateISOBMFFTrackResult {
     byte_size: number;
     track_id: number;
     file_id: string;
-    asset_id: string;
     complete: boolean;
 }
 export declare const createISOBMFFTrack: (client: Client, payload: z.infer<typeof CreateISOBMFFTrackPayload>) => Promise<CreateISOBMFFTrackResult>;
-export declare const uploadISOBMFFTrack: (client: Client, fileId: string, trackId: number, fileStream: Readable, trackSize: number) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;
+export declare const uploadISOBMFFTrack: (client: Client, fileId: string, trackId: number, fileStream: ReadableStream, trackSize: number) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;

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

@@ -0,0 +1,12 @@
+import { ProgressIterator } from '../ProgressIterator.ts';
+import { Client } from '../client.ts';
+export interface IsobmffProcessInfoResult {
+    id: string;
+    created_at: string;
+    completed_at: string | null;
+    failed_at: string | null;
+    isobmff_file_id: string | null;
+    unprocessed_file_id: string;
+}
+export declare const getIsobmffProcessProgress: (client: Client, id: string) => Promise<ProgressIterator>;
+export declare const getIsobmffProcessInfo: (client: Client, id: string) => Promise<IsobmffProcessInfoResult>;

package/dist/resources/process-isobmff.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/resources/renders.d.ts

@@ -1,4 +1,3 @@
-import { Readable } from 'node:stream';
 import { z } from 'zod';
 import { Client } from '../client.ts';
 export declare const CreateRenderPayload: z.ZodObject<{
@@ -11,16 +10,16 @@ export declare const CreateRenderPayload: z.ZodObject<{
     strategy: z.ZodEnum<["v1", "v2"]>;
 }, "strip", z.ZodTypeAny, {
     md5: string;
-    height: number;
     width: number;
+    height: number;
     strategy: "v1" | "v2";
     duration_ms: number;
     fps: number;
     work_slice_ms: number;
 }, {
     md5: string;
-    height: number;
     width: number;
+    height: number;
     strategy: "v1" | "v2";
     duration_ms: number;
     fps: number;
@@ -29,7 +28,13 @@ export declare const CreateRenderPayload: z.ZodObject<{
 export interface CreateRenderResult {
     id: string;
     md5: string;
-    status: "complete" | "created" | "failed" | "pending" | "rendering";
+    status: "complete" | "created" | "failed" | "pending" | "rendering" | string;
+}
+export interface LookupRenderByMd5Result {
+    id: string;
+    md5: string;
+    status: "complete" | "created" | "failed" | "pending" | "rendering" | string;
 }
 export declare const createRender: (client: Client, payload: z.infer<typeof CreateRenderPayload>) => Promise<CreateRenderResult>;
-export declare const uploadRender: (client: Client, fileId: string, fileStream: Readable, folderSize: number) => Promise<unknown>;
+export declare const uploadRender: (client: Client, fileId: string, fileStream: ReadableStream, folderSize: number) => Promise<any>;
+export declare const lookupRenderByMd5: (client: Client, md5: string) => Promise<LookupRenderByMd5Result | null>;