@editframe/api 0.12.0-beta.16 → 0.12.0-beta.19

package/dist/ProgressIterator.d.ts

@@ -1,4 +1,4 @@
-import { CompleteEvent, ProgressEvent, StreamEventSource } from './StreamEventSource.ts';
+import { CompleteEvent, ProgressEvent, StreamEventSource } from './StreamEventSource.js';
 declare abstract class BaseEventIterator<T extends CompleteEvent | any> implements AsyncIterable<T> {
     protected eventSource: StreamEventSource;
     protected queue: T[];

package/dist/ProgressIterator.js

@@ -1,9 +1,21 @@
+const promiseWithResolvers = () => {
+  if (typeof Promise.withResolvers === "function") {
+    return Promise.withResolvers();
+  }
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+};
 class BaseEventIterator {
   constructor(eventSource) {
     this.queue = [];
     this.index = 0;
     this.isComplete = false;
-    this.resolversNext = Promise.withResolvers();
+    this.resolversNext = promiseWithResolvers();
     this.eventSource = eventSource;
   }
   async whenComplete() {
@@ -14,7 +26,7 @@ class BaseEventIterator {
   push(event) {
     this.queue.push(event);
     this.resolversNext.resolve();
-    this.resolversNext = Promise.withResolvers();
+    this.resolversNext = promiseWithResolvers();
   }
   get queueLength() {
     return this.queue.length - this.index;

package/dist/StreamEventSource.d.ts

@@ -1,4 +1,4 @@
-type EventCallback<T> = (event: T) => void;
+export type EventCallback<T> = (event: T) => void;
 export type StreamEventSourceEventMap = {
     progress: ProgressEvent;
     complete: CompleteEvent;
@@ -8,7 +8,7 @@ export type StreamEventSourceEventMap = {
         id: string | undefined;
         data: string;
     };
-    end: [];
+    end: Array<unknown>;
     error: Error;
 };
 export type ProgressEvent = {
@@ -47,4 +47,3 @@ export declare class StreamEventSource {
     private startReading;
     close(): void;
 }
-export {};

package/dist/StreamEventSource.js

@@ -105,7 +105,6 @@ class StreamEventSource {
         }
         this.parser.feed(chunk);
       }
-      this.activeReader.releaseLock();
       this.activeReader = null;
       this.emit("end", []);
     } catch (error) {
@@ -119,7 +118,6 @@ class StreamEventSource {
   }
   close() {
     if (this.activeReader) {
-      this.activeReader.releaseLock();
       this.activeReader = null;
     }
     this.parser.reset();

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import { StreamEventSource } from './StreamEventSource.ts';
+import { StreamEventSource } from './StreamEventSource.js';
 export declare class Client {
     #private;
     constructor(token?: string, efHost?: string);

package/dist/index.d.ts

@@ -1,10 +1,13 @@
-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, 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, uploadUnprocessedReadableStream, type LookupUnprocessedFileByMd5Result, lookupUnprocessedFileByMd5, processIsobmffFile, type ProcessIsobmffFileResult, } from './resources/unprocessed-file.ts';
-export { getIsobmffProcessInfo, getIsobmffProcessProgress, type IsobmffProcessInfoResult, } from './resources/process-isobmff.ts';
-export { Client } from './client.ts';
+export { createCaptionFile, CreateCaptionFilePayload, type CreateCaptionFileResult, uploadCaptionFile, type LookupCaptionFileByMd5Result, lookupCaptionFileByMd5, } from './resources/caption-file.js';
+export { createImageFile, CreateImageFilePayload, type CreateImageFileResult, uploadImageFile, type LookupImageFileByMd5Result, lookupImageFileByMd5, } from './resources/image-file.js';
+export { createISOBMFFFile, CreateISOBMFFFilePayload, type CreateISOBMFFFileResult, uploadFragmentIndex, type LookupISOBMFFFileByMd5Result, lookupISOBMFFFileByMd5, type GetISOBMFFFileTranscriptionResult, getISOBMFFFileTranscription, type TranscribeISOBMFFFileResult, transcribeISOBMFFFile, TranscribeISOBMFFFilePayload, } from './resources/isobmff-file.js';
+export { createISOBMFFTrack, CreateISOBMFFTrackPayload, type CreateISOBMFFTrackResult, uploadISOBMFFTrack, } from './resources/isobmff-track.js';
+export { createRender, CreateRenderPayload, type CreateRenderResult, uploadRender, type LookupRenderByMd5Result, lookupRenderByMd5, } from './resources/renders.js';
+export { createTranscription, CreateTranscriptionPayload, type CreateTranscriptionResult, getTranscriptionInfo, getTranscriptionProgress, type TranscriptionInfoResult, } from './resources/transcriptions.js';
+export { createURLToken, type URLTokenResult, } from './resources/url-token.js';
+export { createUnprocessedFile, CreateUnprocessedFilePayload, type CreateUnprocessedFileResult, uploadUnprocessedReadableStream, type LookupUnprocessedFileByMd5Result, lookupUnprocessedFileByMd5, processIsobmffFile, type ProcessIsobmffFileResult, type UnprocessedFileUploadDetails, type UnprocessedFile, } from './resources/unprocessed-file.js';
+export { getIsobmffProcessInfo, getIsobmffProcessProgress, type IsobmffProcessInfoResult, } from './resources/process-isobmff.js';
+export { Client } from './client.js';
+export type { IteratorWithPromise, UploadChunkEvent } from './uploadChunks.js';
+export type { ProgressIterator, CompletionIterator, } from './ProgressIterator.js';
+export type { StreamEventSource, ProgressEvent, CompletionEvent, StreamEventSourceEventMap, EventCallback, } from './StreamEventSource.js';

package/dist/node.d.ts

@@ -1,6 +1,6 @@
-import { Client } from './client.ts';
-import { UnprocessedFileUploadDetails } from './resources/unprocessed-file.ts';
-export declare const createImageFileFromPath: (client: Client, path: string) => Promise<import('./index.ts').CreateImageFileResult>;
-export declare const createUnprocessedFileFromPath: (client: Client, path: string) => Promise<import('./index.ts').CreateUnprocessedFileResult>;
+import { Client } from './client.js';
+import { UnprocessedFileUploadDetails } from './resources/unprocessed-file.js';
+export declare const createImageFileFromPath: (client: Client, path: string) => Promise<import('./index.js').CreateImageFileResult>;
+export declare const createUnprocessedFileFromPath: (client: Client, path: string) => Promise<import('./index.js').CreateUnprocessedFileResult>;
 export declare const uploadUnprocessedFile: (client: Client, uploadDetails: UnprocessedFileUploadDetails, path: string) => Promise<import('./uploadChunks.ts').IteratorWithPromise<import('./uploadChunks.ts').UploadChunkEvent>>;
-export * from './index.ts';
+export * from './index.js';

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

@@ -1,8 +1,17 @@
 import { z } from 'zod';
-import { Client } from '../client.ts';
+import { Client } from '../client.js';
 export declare const CreateCaptionFilePayload: z.ZodObject<{
+    /**
+     * The md5 hash of the caption file
+     */
     md5: z.ZodString;
+    /**
+     * The filename of the caption file
+     */
     filename: z.ZodString;
+    /**
+     * The size of the caption file in bytes
+     */
     byte_size: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     filename: string;
@@ -13,14 +22,33 @@ export declare const CreateCaptionFilePayload: z.ZodObject<{
     md5: string;
     byte_size: number;
 }>;
+export type CreateCaptionFilePayload = z.infer<typeof CreateCaptionFilePayload>;
 export interface CreateCaptionFileResult {
+    /**
+     * Whether the caption file is complete
+     */
     complete: boolean | null;
+    /**
+     * The id of the caption file
+     */
     id: string;
+    /**
+     * The md5 hash of the caption file
+     */
     md5: string;
 }
 export interface LookupCaptionFileByMd5Result {
+    /**
+     * Whether the caption file is complete
+     */
     complete: boolean | null;
+    /**
+     * The id of the caption file
+     */
     id: string;
+    /**
+     * The md5 hash of the caption file
+     */
     md5: string;
 }
 /**
@@ -40,6 +68,6 @@ export interface LookupCaptionFileByMd5Result {
  * @resource
  * @beta
  */
-export declare const createCaptionFile: (client: Client, payload: z.infer<typeof CreateCaptionFilePayload>) => Promise<CreateCaptionFileResult>;
+export declare const createCaptionFile: (client: Client, payload: CreateCaptionFilePayload) => Promise<CreateCaptionFileResult>;
 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/caption-file.js

@@ -3,8 +3,17 @@ import { z } from "zod";
 const log = debug("ef:api:caption-file");
 const MAX_CAPTION_SIZE = 1024 * 1024 * 2;
 const CreateCaptionFilePayload = z.object({
+  /**
+   * The md5 hash of the caption file
+   */
   md5: z.string(),
+  /**
+   * The filename of the caption file
+   */
   filename: z.string(),
+  /**
+   * The size of the caption file in bytes
+   */
   byte_size: z.number().int().max(MAX_CAPTION_SIZE)
 });
 const restrictSize = (size) => {

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

@@ -1,11 +1,29 @@
 import { z } from 'zod';
-import { Client } from '../client.ts';
+import { Client } from '../client.js';
 export declare const CreateImageFilePayload: z.ZodObject<{
+    /**
+     * The md5 hash of the image file.
+     */
     md5: z.ZodString;
+    /**
+     * The height of the image file in pixels.
+     */
     height: z.ZodNumber;
+    /**
+     * The width of the image file in pixels.
+     */
     width: z.ZodNumber;
+    /**
+     * The mime type of the image file.
+     */
     mime_type: z.ZodEnum<["image/jpeg", "image/png", "image/jpg", "image/webp"]>;
+    /**
+     * The filename of the image file.
+     */
     filename: z.ZodString;
+    /**
+     * The byte size of the image file.
+     */
     byte_size: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     width: number;
@@ -22,6 +40,7 @@ export declare const CreateImageFilePayload: z.ZodObject<{
     mime_type: "image/jpeg" | "image/png" | "image/jpg" | "image/webp";
     byte_size: number;
 }>;
+export type CreateImageFilePayload = z.infer<typeof CreateImageFilePayload>;
 export interface CreateImageFileResult {
     complete: boolean | null;
     byte_size: number;
@@ -34,9 +53,9 @@ export interface LookupImageFileByMd5Result {
     id: string;
     md5: string;
 }
-export declare const createImageFile: (client: Client, payload: z.infer<typeof CreateImageFilePayload>) => Promise<CreateImageFileResult>;
+export declare const createImageFile: (client: Client, payload: CreateImageFilePayload) => Promise<CreateImageFileResult>;
 export declare const uploadImageFile: (client: Client, uploadDetails: {
     id: string;
     byte_size: number;
-}, fileStream: ReadableStream) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;
+}, fileStream: ReadableStream) => import('../uploadChunks.js').IteratorWithPromise<import('../uploadChunks.js').UploadChunkEvent>;
 export declare const lookupImageFileByMd5: (client: Client, md5: string) => Promise<LookupImageFileByMd5Result | null>;

package/dist/resources/image-file.js

@@ -4,11 +4,29 @@ import { uploadChunks } from "../uploadChunks.js";
 const log = debug("ef:api:image-file");
 const MAX_IMAGE_SIZE = 1024 * 1024 * 16;
 const CreateImageFilePayload = z.object({
+  /**
+   * The md5 hash of the image file.
+   */
   md5: z.string(),
+  /**
+   * The height of the image file in pixels.
+   */
   height: z.number().int(),
+  /**
+   * The width of the image file in pixels.
+   */
   width: z.number().int(),
+  /**
+   * The mime type of the image file.
+   */
   mime_type: z.enum(["image/jpeg", "image/png", "image/jpg", "image/webp"]),
+  /**
+   * The filename of the image file.
+   */
   filename: z.string(),
+  /**
+   * The byte size of the image file.
+   */
   byte_size: z.number().int().max(MAX_IMAGE_SIZE)
 });
 const createImageFile = async (client, payload) => {

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Client } from '../client.ts';
+import { Client } from '../client.js';
 export declare const CreateISOBMFFFilePayload: z.ZodObject<{
     md5: z.ZodString;
     filename: z.ZodString;
@@ -10,14 +10,33 @@ export declare const CreateISOBMFFFilePayload: z.ZodObject<{
     filename: string;
     md5: string;
 }>;
+export type CreateISOBMFFFilePayload = z.infer<typeof CreateISOBMFFFilePayload>;
 export interface CreateISOBMFFFileResult {
+    /**
+     * Whether the fragment index is complete. The fragment index is used internally by editframe to efficiently seek within files.
+     */
     fragment_index_complete: boolean;
+    /**
+     * The filename of the isobmff file
+     */
     filename: string;
+    /**
+     * The id of the isobmff file
+     */
     id: string;
+    /**
+     * The md5 hash of the isobmff file
+     */
     md5: string;
 }
 export interface LookupISOBMFFFileByMd5Result {
+    /**
+     * Whether the fragment index is complete
+     */
     fragment_index_complete: boolean;
+    /**
+     * The filename of the isobmff file
+     */
     filename: string;
     id: string;
     md5: string;
@@ -29,7 +48,7 @@ export interface GetISOBMFFFileTranscriptionResult {
         duration_ms: number;
     };
 }
-export declare const createISOBMFFFile: (client: Client, payload: z.infer<typeof CreateISOBMFFFilePayload>) => Promise<CreateISOBMFFFileResult>;
+export declare const createISOBMFFFile: (client: Client, payload: CreateISOBMFFFilePayload) => Promise<CreateISOBMFFFileResult>;
 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>;
@@ -40,9 +59,10 @@ export declare const TranscribeISOBMFFFilePayload: z.ZodObject<{
 }, {
     trackId?: string | undefined;
 }>;
+export type TranscribeISOBMFFFilePayload = z.infer<typeof TranscribeISOBMFFFilePayload>;
 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>;
+export declare const transcribeISOBMFFFile: (client: Client, id: string, payload?: TranscribeISOBMFFFilePayload) => Promise<TranscribeISOBMFFFileResult>;

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

@@ -1,5 +1,267 @@
 import { z } from 'zod';
-import { Client } from '../client.ts';
+import { Client } from '../client.js';
+declare const AudioTrackPayload: 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, {
+        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;
+        duration: number;
+        bit_rate: string;
+        disposition: Record<string, unknown>;
+        initial_padding?: number | undefined;
+    }, {
+        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;
+        duration: 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, {
+    codec_name: string;
+    type: "audio";
+    byte_size: number;
+    file_id: string;
+    track_id: number;
+    probe_info: {
+        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;
+        duration: number;
+        bit_rate: string;
+        disposition: Record<string, unknown>;
+        initial_padding?: number | undefined;
+    };
+    duration_ms: number;
+}, {
+    codec_name: string;
+    type: "audio";
+    byte_size: number;
+    file_id: string;
+    track_id: number;
+    probe_info: {
+        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;
+        duration: number;
+        bit_rate: string;
+        disposition: Record<string, unknown>;
+        initial_padding?: number | undefined;
+    };
+    duration_ms: number;
+}>;
+export type AudioTrackPayload = z.infer<typeof AudioTrackPayload>;
+declare const VideoTrackPayload: 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;
+        start_pts?: number | undefined;
+        start_time?: number | undefined;
+        duration_ts?: number | undefined;
+        duration?: 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;
+        start_pts?: number | undefined;
+        start_time?: number | undefined;
+        duration_ts?: number | undefined;
+        duration?: number | undefined;
+        bit_rate?: string | undefined;
+    }>;
+    duration_ms: z.ZodNumber;
+    codec_name: z.ZodString;
+    byte_size: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    codec_name: string;
+    type: "video";
+    byte_size: number;
+    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;
+        start_pts?: number | undefined;
+        start_time?: number | undefined;
+        duration_ts?: number | undefined;
+        duration?: number | undefined;
+        bit_rate?: string | undefined;
+    };
+    duration_ms: number;
+}, {
+    codec_name: string;
+    type: "video";
+    byte_size: number;
+    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;
+        start_pts?: number | undefined;
+        start_time?: number | undefined;
+        duration_ts?: number | undefined;
+        duration?: number | undefined;
+        bit_rate?: string | undefined;
+    };
+    duration_ms: number;
+}>;
+export type VideoTrackPayload = z.infer<typeof VideoTrackPayload>;
 export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     file_id: z.ZodString;
     track_id: z.ZodNumber;
@@ -259,6 +521,7 @@ export declare const CreateISOBMFFTrackPayload: z.ZodDiscriminatedUnion<"type",
     };
     duration_ms: number;
 }>]>;
+export type CreateISOBMFFTrackPayload = z.infer<typeof CreateISOBMFFTrackPayload>;
 export interface CreateISOBMFFTrackResult {
     next_byte: number;
     byte_size: number;
@@ -266,5 +529,6 @@ export interface CreateISOBMFFTrackResult {
     file_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: ReadableStream, trackSize: number) => import('../uploadChunks.ts').IteratorWithPromise<import('../uploadChunks.ts').UploadChunkEvent>;
+export declare const createISOBMFFTrack: (client: Client, payload: CreateISOBMFFTrackPayload) => Promise<CreateISOBMFFTrackResult>;
+export declare const uploadISOBMFFTrack: (client: Client, fileId: string, trackId: number, fileStream: ReadableStream, trackSize: number) => import('../uploadChunks.js').IteratorWithPromise<import('../uploadChunks.js').UploadChunkEvent>;
+export {};

package/dist/resources/isobmff-track.js

@@ -47,25 +47,27 @@ const VideoStreamSchema = z.object({
 });
 const log = debug("ef:api:isobmff-track");
 const MAX_TRACK_SIZE = 1024 * 1024 * 1024;
+const AudioTrackPayload = z.object({
+  file_id: z.string(),
+  track_id: z.number().int(),
+  type: z.literal("audio"),
+  probe_info: AudioStreamSchema,
+  duration_ms: z.number().int(),
+  codec_name: z.string(),
+  byte_size: z.number().int().max(MAX_TRACK_SIZE)
+});
+const VideoTrackPayload = z.object({
+  file_id: z.string(),
+  track_id: z.number().int(),
+  type: z.literal("video"),
+  probe_info: VideoStreamSchema,
+  duration_ms: z.number().int(),
+  codec_name: z.string(),
+  byte_size: z.number().int().max(MAX_TRACK_SIZE)
+});
 const CreateISOBMFFTrackPayload = z.discriminatedUnion("type", [
-  z.object({
-    file_id: z.string(),
-    track_id: z.number().int(),
-    type: z.literal("audio"),
-    probe_info: AudioStreamSchema,
-    duration_ms: z.number().int(),
-    codec_name: z.string(),
-    byte_size: z.number().int().max(MAX_TRACK_SIZE)
-  }),
-  z.object({
-    file_id: z.string(),
-    track_id: z.number().int(),
-    type: z.literal("video"),
-    probe_info: VideoStreamSchema,
-    duration_ms: z.number().int(),
-    codec_name: z.string(),
-    byte_size: z.number().int().max(MAX_TRACK_SIZE)
-  })
+  AudioTrackPayload,
+  VideoTrackPayload
 ]);
 const createISOBMFFTrack = async (client, payload) => {
   log("Creating isobmff track", payload);