tirtc-react-native 2.5.0-alpha.1 → 2.5.0

package/lib/typescript/storage.d.ts

@@ -3,6 +3,7 @@ import { type ViewProps } from 'react-native';
 import { NativeTiRtc, type NativeTiRtcEvent } from './native';
 import { type NativeIdentity } from './native_object_id';
 import { type Resp, type TiRtcGalleryAsset } from './recording';
+import { TiRawDump, type TiCloudStorageRawDumpOptions } from './raw_dump';
 export declare const TI_CLOUD_STORAGE_ERROR_OK: 0;
 export declare const TI_CLOUD_STORAGE_ERROR_INVALID_ARGUMENT: 6000;
 export declare const TI_CLOUD_STORAGE_ERROR_NOT_INITIALIZED: 6001;
@@ -45,6 +46,69 @@ export type TiCloudStorageRecordingDaysResult = Readonly<{
     code: number;
     days: ReadonlyArray<TiCloudStorageRecordingDay>;
 }>;
+export declare const TiCloudStorageRecordingTrackKind: {
+    readonly video: "video";
+    readonly audio: "audio";
+};
+export type TiCloudStorageRecordingTrackKind = (typeof TiCloudStorageRecordingTrackKind)[keyof typeof TiCloudStorageRecordingTrackKind];
+export type TiCloudStorageRecordingTrack = Readonly<{
+    kind: TiCloudStorageRecordingTrackKind;
+    channelId: number;
+}>;
+export declare const TiCloudStorageRecordingGapReason: {
+    readonly unknown: "unknown";
+    readonly notFound: "notFound";
+    readonly downloadFailed: "downloadFailed";
+    readonly integrityFailed: "integrityFailed";
+    readonly mediaUnreadable: "mediaUnreadable";
+    readonly noKeyFrame: "noKeyFrame";
+    readonly noRecording: "noRecording";
+    readonly decryptionFailed: "decryptionFailed";
+    readonly unsupportedMedia: "unsupportedMedia";
+    readonly trackUnavailable: "trackUnavailable";
+};
+export type TiCloudStorageRecordingGapReason = (typeof TiCloudStorageRecordingGapReason)[keyof typeof TiCloudStorageRecordingGapReason];
+export type TiCloudStorageRecordingGap = Readonly<{
+    range: TiCloudStorageRecordingRange;
+    tracks: ReadonlyArray<TiCloudStorageRecordingTrack>;
+    reasons: ReadonlyArray<TiCloudStorageRecordingGapReason>;
+}>;
+export type TiCloudStorageExportProgress = Readonly<{
+    fraction: number;
+    coveredDurationMs: number;
+}>;
+export type TiCloudStorageExportSegment = Readonly<{
+    sourceRange: TiCloudStorageRecordingRange;
+    outputStartMs: number;
+    outputEndMs: number;
+}>;
+export declare const TiCloudStorageExportTermination: {
+    readonly exhausted: "exhausted";
+    readonly interrupted: "interrupted";
+    readonly cancelled: "cancelled";
+    readonly failed: "failed";
+};
+export type TiCloudStorageExportTermination = (typeof TiCloudStorageExportTermination)[keyof typeof TiCloudStorageExportTermination];
+export type TiCloudStorageExportReport = Readonly<{
+    requestedRange: TiCloudStorageRecordingRange;
+    coveredDurationMs: number;
+    segments: ReadonlyArray<TiCloudStorageExportSegment>;
+    gaps: ReadonlyArray<TiCloudStorageRecordingGap>;
+    unprocessedRanges: ReadonlyArray<TiCloudStorageRecordingRange>;
+    complete: boolean;
+    termination: TiCloudStorageExportTermination;
+    cause: number;
+}>;
+export type TiCloudStorageExportOutcome = Readonly<{
+    code: number;
+    file: TiCloudStorageRecordingFile | null;
+    report: TiCloudStorageExportReport | null;
+}>;
+export type TiCloudStorageExportObserver = Readonly<{
+    onProgress?: (progress: number) => void;
+    onProgressDetail?: (progress: TiCloudStorageExportProgress) => void;
+    onRecordingGap?: (gap: TiCloudStorageRecordingGap) => void;
+}>;
 export declare const TiCloudStorageReplaySpeed: {
     readonly x0_125: "x0_125";
     readonly x0_25: "x0_25";
@@ -99,6 +163,7 @@ export declare class TiCloudStorage {
     private token;
     private identity;
     private disposed;
+    private pendingAsyncOperations;
     constructor(token: string);
     static init(options: Readonly<{
         appId: string;
@@ -111,19 +176,22 @@ export declare class TiCloudStorage {
     listRecordings(startTimeMs: number, endTimeMs: number): Promise<TiCloudStorageRecordingRangesResult>;
     listRecordingDays(startDate: string, endDate: string, timeZoneId?: string): Promise<TiCloudStorageRecordingDaysResult>;
     createReplay(): TiCloudStorageReplay;
-    exportRecording(options: TiCloudStorageExportOptions, onProgress?: (progress: number) => void): Resp<TiCloudStorageExportTask>;
+    exportRecording(options: TiCloudStorageExportOptions, observer?: ((progress: number) => void) | TiCloudStorageExportObserver): Resp<TiCloudStorageExportTask>;
     dispose(): number;
+    private trackAsyncOperation;
     private ensureIdentity;
 }
 export declare class TiCloudStorageReplay {
     private readonly cloudStorage;
     private identity;
     private disposed;
+    private inCallback;
     private currentSpeed;
     private currentTime;
     onTimeChanged: ((timeMs: number) => void) | null;
     onError: ((code: number) => void) | null;
     onCompleted: (() => void) | null;
+    onRecordingGap: ((gap: TiCloudStorageRecordingGap) => void) | null;
     constructor(cloudStorage: TiCloudStorage);
     get speed(): TiCloudStorageReplaySpeed;
     get currentTimeMs(): number | null;
@@ -133,6 +201,7 @@ export declare class TiCloudStorageReplay {
     seek(timeMs: number): number;
     setSpeed(speed: TiCloudStorageReplaySpeed): number;
     startRecording(options: TiCloudStorageStartRecordingOptions): Resp<TiCloudStorageRecordingTask>;
+    startRawDump(options: TiCloudStorageRawDumpOptions): Promise<Resp<TiRawDump>>;
     stop(): number;
     dispose(): number;
     private command;
@@ -198,11 +267,21 @@ export declare class TiCloudStorageRecordingTask {
 export declare class TiCloudStorageExportTask {
     private readonly taskId;
     private readonly owner;
-    private readonly onProgress?;
     private resultPromise;
-    constructor(taskId: number, owner: TiCloudStorage, onProgress?: ((progress: number) => void) | undefined);
+    private completionPromise;
+    private readonly identity;
+    private currentProgressDetail;
+    private currentReport;
+    private readonly observer;
+    private terminal;
+    constructor(taskId: number, generation: number, owner: TiCloudStorage, observer?: ((progress: number) => void) | TiCloudStorageExportObserver);
     get progress(): number;
+    get progressDetail(): TiCloudStorageExportProgress;
+    get report(): TiCloudStorageExportReport | null;
+    get completion(): Promise<TiCloudStorageExportOutcome>;
     get result(): Promise<Resp<TiCloudStorageRecordingFile>>;
+    cancel(): number;
     stop(): Promise<Resp<TiCloudStorageRecordingFile>>;
+    private handleEvent;
 }
 export {};

package/lib/typescript/types.d.ts

@@ -66,11 +66,6 @@ export declare const TiRtcVideoCodec: {
     readonly mjpeg: "mjpeg";
 };
 export type TiRtcVideoCodec = (typeof TiRtcVideoCodec)[keyof typeof TiRtcVideoCodec];
-export declare const TiRtcVideoEncoderCodec: {
-    readonly h264: "h264";
-    readonly mjpeg: "mjpeg";
-};
-export type TiRtcVideoEncoderCodec = (typeof TiRtcVideoEncoderCodec)[keyof typeof TiRtcVideoEncoderCodec];
 export declare const TiRtcVideoFrameRate: {
     readonly fps10: "fps10";
     readonly fps15: "fps15";
@@ -145,6 +140,9 @@ export type TiRtcVideoOutputViewProps = ViewProps & Readonly<{
     resizeMode?: 'contain' | 'cover' | 'stretch';
 }>;
 export type TiRtcAudioInputOptions = Readonly<{
+    /** Nano audio media: 1 PCM, 2 G711A, 3 AAC, 4 Opus, 5 AMR. Omitted or -1 uses codec. */
+    media?: number;
+    /** @deprecated Use media. The legacy default is g711a. */
     codec?: TiRtcAudioCodec;
     sampleRate?: TiRtcAudioSampleRate;
     channels?: TiRtcAudioChannelCount;
@@ -153,7 +151,8 @@ export type TiRtcAudioInputOptions = Readonly<{
     ansLevel?: TiRtcAudioAnsLevel;
 }>;
 export type TiRtcVideoInputOptions = Readonly<{
-    codec?: TiRtcVideoEncoderCodec;
+    /** Nano video media: 66 H.264 (default) or 65 MJPEG. */
+    media?: number;
     width?: number;
     height?: number;
     frameRate?: TiRtcVideoFrameRate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tirtc-react-native",
-  "version": "2.5.0-alpha.1",
+  "version": "2.5.0",
   "description": "TiRTC React Native SDK",
   "homepage": "https://tange.ai/",
   "repository": {
@@ -49,7 +49,7 @@
     "build": "node scripts/clean_generated_lib.mjs && tsc -p tsconfig.build.json && node scripts/freeze_build_identity.mjs && node scripts/write_codegen_component_specs.mjs",
     "lint": "node test/source_guard.mjs",
     "preflight:npm": "node scripts/npm_preflight.mjs",
-    "test": "node test/parity_guard.mjs && node test/package_artifact_guard.mjs && node test/lifecycle_contract_guard.mjs && node test/lifecycle_behavior_guard.mjs && node test/integration_contract_guard.mjs && node test/runner_schema_guard.mjs",
+    "test": "node test/parity_guard.mjs && node test/package_artifact_guard.mjs && node test/lifecycle_contract_guard.mjs && node test/lifecycle_behavior_guard.mjs && node test/integration_contract_guard.mjs && node test/runner_schema_guard.mjs && node --test test/source_fingerprint.test.mjs",
     "test:contract-red": "node test/contract_red_summary.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "codegen:check": "node test/codegen_contract_guard.mjs"

package/src/audio_input.ts

@@ -21,6 +21,7 @@ export class TiRtcAudioInput {
   private queue: Promise<unknown> = Promise.resolve();
   private currentState: TiRtcInputState = 'idle';
   private options: Required<TiRtcAudioInputOptions> = {
+    media: -1,
     codec: 'g711a',
     sampleRate: 'rate16k',
     channels: 'mono',
@@ -58,8 +59,20 @@ export class TiRtcAudioInput {
     if (!isPlainObject(options)) {
       return Promise.resolve(TIRTC_ERROR_INVALID_ARGUMENT);
     }
+    const media = options.media === undefined ? -1 : options.media;
+    const source = media === -1 ? (options.codec === undefined ? 'default' : 'legacy') : 'media';
+    const rawLegacy = options.codec === undefined ? 'omitted' :
+      ['g711a', 'aac', 'pcm', 'opus', 'amr'].includes(options.codec) ? options.codec : 'invalid';
+    const legacyCodec = options.codec ?? 'g711a';
+    if (!Number.isInteger(media) || ![-1, 1, 2, 3, 4, 5].includes(media) ||
+        (media === -1 && !['g711a', 'aac', 'pcm', 'opus', 'amr'].includes(legacyCodec))) {
+      logRtcOutcome('audio_input_set_options', TIRTC_ERROR_INVALID_ARGUMENT,
+        ` nano_media=${typeof media === 'number' ? media : typeof media} legacy_codec=${rawLegacy} source=${source}`);
+      return Promise.resolve(TIRTC_ERROR_INVALID_ARGUMENT);
+    }
     const normalized = {
-      codec: options.codec ?? 'g711a',
+      media,
+      codec: media === -1 ? legacyCodec : 'g711a' as const,
       sampleRate: options.sampleRate ?? 'rate16k',
       channels: options.channels ?? 'mono',
       aecMode: options.aecMode ?? 'disabled',
@@ -72,6 +85,8 @@ export class TiRtcAudioInput {
         return identity;
       }
       const code = await NativeTiRtc.audioInputSetOptions(identity.objectId, normalized);
+      logRtcOutcome('audio_input_set_options', code,
+        ` nano_media=${media} legacy_codec=${rawLegacy} source=${source} sample_rate=${['rate8k', 'rate16k'].includes(normalized.sampleRate) ? normalized.sampleRate : 'invalid'} channels=${normalized.channels === 'mono' ? 'mono' : 'invalid'}`);
       if (code === TIRTC_ERROR_OK) {
         this.options = normalized;
       }
@@ -100,16 +115,20 @@ export class TiRtcAudioInput {
   }
 
   start(): Promise<number> {
-    return this.logged(
-      'audio_input_start',
-      this.enqueue(async () => {
-        const identity = this.ensureIdentity();
-        if (typeof identity === 'number') {
-          return identity;
-        }
-        return NativeTiRtc.audioInputStart(identity.objectId);
-      }),
-    );
+    return this.enqueue(async () => {
+      const identity = this.ensureIdentity();
+      if (typeof identity === 'number') {
+        logRtcOutcome('audio_input_start', identity);
+        return identity;
+      }
+      const wasRunning = this.state === 'running';
+      const code = await NativeTiRtc.audioInputStart(identity.objectId);
+      if (code !== TIRTC_ERROR_OK || !wasRunning) {
+        logRtcOutcome('audio_input_start', code,
+          ` object_id=${identity.objectId} nano_media=${this.options.media} legacy_codec=${this.options.codec} sample_rate=${this.options.sampleRate} channels=${this.options.channels}`);
+      }
+      return code;
+    });
   }
 
   stop(): Promise<number> {

package/src/conn.ts

@@ -27,6 +27,12 @@ import type {
   TiRtcOnConnStateChanged,
   TiRtcOnConnStreamMessage,
 } from './types';
+import {
+  createRawDumpFromNative,
+  normalizeRawDumpIds,
+  TiRawDump,
+  type TiRtcRawDumpOptions,
+} from './raw_dump';
 
 export class TiRtcConn {
   private identity: NativeIdentity | null = null;
@@ -59,6 +65,23 @@ export class TiRtcConn {
     return typeof identity === 'number' ? recordingFailure(identity) : startRecording(identity.objectId, options);
   }
 
+  async startRawDump(options: TiRtcRawDumpOptions): Promise<Resp<TiRawDump>> {
+    if (options === null || typeof options !== 'object') return recordingFailure(TIRTC_ERROR_INVALID_ARGUMENT);
+    const audio = normalizeRawDumpIds(options.audioStreamIds ?? [], 15);
+    const video = normalizeRawDumpIds(options.videoStreamIds ?? [], 15);
+    const uplinkAudio = normalizeRawDumpIds(options.uplinkAudioStreamIds ?? [], 15);
+    if (audio === null || video === null || uplinkAudio === null ||
+        (audio.length === 0 && video.length === 0 && uplinkAudio.length === 0)) {
+      return recordingFailure(TIRTC_ERROR_INVALID_ARGUMENT);
+    }
+    const identity = this.ensureIdentity();
+    if (typeof identity === 'number') return recordingFailure(identity);
+    const result = await NativeTiRtc.connStartRawDump(identity.objectId, audio, video, uplinkAudio);
+    return result.code === 0 && result.dumpId !== null
+      ? {success: true, code: null, message: null, data: createRawDumpFromNative(result.dumpId)}
+      : recordingFailure(result.code);
+  }
+
   get state(): TiRtcConnState {
     if (this.identity !== null && !this.disposed) {
       const result = NativeTiRtc.connGetState(this.identity.objectId);

package/src/events.ts

@@ -16,20 +16,25 @@ function ensureSubscribed(): void {
     return;
   }
   subscription = NativeTiRtc.onTiRtcEvent((event) => {
-    if (!isPositiveInt32(event.objectId) || !isPositiveInt32(event.generation)) {
-      return;
-    }
-    const handler = handlers.get(eventKey({
-      objectId: event.objectId,
-      generation: event.generation,
-    }));
-    if (handler !== undefined) {
-      handler(event);
+    if (event.type === 'tiCloudStorageCallbackReady') {
+      const pending = NativeTiRtc.tiCloudStorageTakeCallback();
+      if (pending === null) return;
+      try {
+        deliver(pending.event);
+      } finally {
+        NativeTiRtc.tiCloudStorageAcknowledgeCallback(pending.deliveryId);
+      }
       return;
     }
+    deliver(event);
   });
 }
 
+function deliver(event: NativeTiRtcEvent): void {
+  if (!isPositiveInt32(event.objectId) || !isPositiveInt32(event.generation)) return;
+  handlers.get(eventKey({objectId: event.objectId, generation: event.generation}))?.(event);
+}
+
 export function registerNativeEventHandler(identity: NativeIdentity, handler: NativeEventHandler): void {
   handlers.set(eventKey(identity), handler);
   ensureSubscribed();

package/src/index.ts

@@ -9,7 +9,6 @@ export {
   TiRtcAudioAgcLevel,
   TiRtcAudioAnsLevel,
   TiRtcVideoCodec,
-  TiRtcVideoEncoderCodec,
   TiRtcVideoFrameRate,
   TiRtcCameraFacing,
   TiRtcVideoDecoderPreference,
@@ -60,6 +59,13 @@ export {TiRtcAudioInput} from './audio_input';
 export {TiRtcVideoInput, TiRtcVideoInputPreview} from './video_input';
 export {TiRtcLogging} from './logging';
 export {TiRtcRecordingTask} from './recording';
+export {TiRawDump} from './raw_dump';
+export type {
+  TiRtcRawDumpOptions,
+  TiCloudStorageRawDumpOptions,
+  TiRawDumpStopReason,
+  TiRawDumpArchive,
+} from './raw_dump';
 export type {
   Resp,
   TiRtcGalleryAsset,
@@ -95,6 +101,9 @@ export {
   TI_CLOUD_STORAGE_ERROR_NETWORK_UNAVAILABLE,
   TI_CLOUD_STORAGE_ERROR_ENDPOINT_DNS_RESOLUTION_FAILED,
   TiCloudStorageReplaySpeed,
+  TiCloudStorageRecordingTrackKind,
+  TiCloudStorageRecordingGapReason,
+  TiCloudStorageExportTermination,
   TiCloudStorageAudioOutputState,
   TiCloudStorageVideoOutputState,
   TiCloudStorage,
@@ -107,6 +116,13 @@ export {
 } from './storage';
 export type {
   TiCloudStorageRecordingRange,
+  TiCloudStorageRecordingTrack,
+  TiCloudStorageRecordingGap,
+  TiCloudStorageExportProgress,
+  TiCloudStorageExportSegment,
+  TiCloudStorageExportReport,
+  TiCloudStorageExportOutcome,
+  TiCloudStorageExportObserver,
   TiCloudStorageRecordingRangesResult,
   TiCloudStorageRecordingDay,
   TiCloudStorageRecordingDaysResult,

package/src/native.ts

@@ -3,4 +3,10 @@ import NativeTiRtcVideoInputPreview from './specs/TiRtcVideoInputPreviewNativeCo
 import NativeTiRtcVideoOutputView from './specs/TiRtcVideoOutputViewNativeComponent';
 
 export {NativeTiRtc, NativeTiRtcVideoOutputView, NativeTiRtcVideoInputPreview};
-export type {NativeTiRtcEvent} from './specs/NativeTiRtc';
+export type {
+  NativeTiRtcEvent,
+  NativeTiCloudStorageExportProgress,
+  NativeTiCloudStorageExportReport,
+  NativeTiCloudStorageRecordingGap,
+  NativeRawDumpArchive,
+} from './specs/NativeTiRtc';

package/src/raw_dump.ts

@@ -0,0 +1,84 @@
+import {isFiniteSafeInteger, TIRTC_ERROR_INVALID_ARGUMENT} from './errors';
+import {NativeTiRtc, type NativeRawDumpArchive} from './native';
+import type {Resp} from './recording';
+
+export type TiRawDumpStopReason =
+  | 'unknown' | 'user' | 'timeLimit' | 'byteLimit' | 'sourceClosed'
+  | 'resourceLimit' | 'writeFailed';
+
+export type TiRtcRawDumpOptions = Readonly<{
+  /** Remote downlink audio stream IDs. */
+  audioStreamIds?: ReadonlyArray<number>;
+  /** Remote downlink video stream IDs. */
+  videoStreamIds?: ReadonlyArray<number>;
+  /** Local uplink audio stream IDs used by TiRtcAudioInput.attach. */
+  uplinkAudioStreamIds?: ReadonlyArray<number>;
+}>;
+
+export type TiCloudStorageRawDumpOptions = Readonly<{
+  audioChannelIds?: ReadonlyArray<number>;
+  videoChannelIds?: ReadonlyArray<number>;
+}>;
+
+export type TiRawDumpArchive = Readonly<{
+  captureId: string; path: string; size: number; sha256: string; capturedDurationMs: number;
+  captureComplete: boolean; stopReason: TiRawDumpStopReason;
+  unsavedPacketCount: number; unsavedByteCount: number; empty: boolean;
+}>;
+
+const reasons: ReadonlyArray<TiRawDumpStopReason> = [
+  'unknown', 'user', 'timeLimit', 'byteLimit', 'sourceClosed', 'resourceLimit', 'writeFailed',
+];
+
+function archiveFromNative(value: NativeRawDumpArchive): TiRawDumpArchive {
+  return {...value, stopReason: reasons[value.stopReason] ?? 'unknown'};
+}
+
+function failure<T>(code: number): Resp<T> {
+  return {success: false, code, message: null, data: null};
+}
+
+export function normalizeRawDumpIds(
+  value: unknown,
+  maximum: number,
+): ReadonlyArray<number> | null {
+  if (!Array.isArray(value)) return null;
+  const result = new Set<number>();
+  for (const item of value) {
+    if (!isFiniteSafeInteger(item) || item < 0 || item > maximum) return null;
+    result.add(item);
+  }
+  return [...result];
+}
+
+export class TiRawDump {
+  private stopPromise: Promise<Resp<TiRawDumpArchive>> | null = null;
+
+  private constructor(private readonly nativeId: number) {}
+
+  stop(): Promise<Resp<TiRawDumpArchive>> {
+    if (this.stopPromise === null) {
+      this.stopPromise = NativeTiRtc.rawDumpStop(this.nativeId).then((result) => {
+        if (result.code !== 0 || result.archive === null) {
+          if (!result.terminal) this.stopPromise = null;
+          return failure<TiRawDumpArchive>(result.code);
+        }
+        const archive = archiveFromNative(result.archive);
+        return {success: true, code: null, message: null, data: archive};
+      }).catch(() => {
+        this.stopPromise = null;
+        return failure<TiRawDumpArchive>(TIRTC_ERROR_INVALID_ARGUMENT);
+      });
+    }
+    return this.stopPromise!;
+  }
+
+  async dispose(): Promise<number> {
+    const result = await this.stop();
+    return result.success ? 0 : result.code ?? TIRTC_ERROR_INVALID_ARGUMENT;
+  }
+}
+
+export function createRawDumpFromNative(nativeId: number): TiRawDump {
+  return Reflect.construct(TiRawDump, [nativeId]) as TiRawDump;
+}

package/src/specs/NativeTiRtc.ts

@@ -36,6 +36,7 @@ export type NativeVideoOutputOptions = Readonly<{
 }>;
 
 export type NativeAudioInputOptions = Readonly<{
+  media: number;
   codec: 'g711a' | 'aac' | 'pcm' | 'opus' | 'amr';
   sampleRate: 'rate8k' | 'rate16k';
   channels: 'mono';
@@ -45,7 +46,7 @@ export type NativeAudioInputOptions = Readonly<{
 }>;
 
 export type NativeVideoInputOptions = Readonly<{
-  codec: 'h264' | 'mjpeg';
+  media: number;
   width: number;
   height: number;
   frameRate: 'fps10' | 'fps15' | 'fps30';
@@ -102,11 +103,63 @@ export type NativeLoggingUploadResult = Readonly<{
   logId: string | null;
 }>;
 
+export type NativeRawDumpStartResult = Readonly<{code: number; dumpId: NativeObjectId | null}>;
+export type NativeRawDumpArchive = Readonly<{
+  captureId: string; path: string; size: number; sha256: string; capturedDurationMs: number;
+  captureComplete: boolean; stopReason: number;
+  unsavedPacketCount: number; unsavedByteCount: number; empty: boolean;
+}>;
+export type NativeRawDumpStopResult = Readonly<{
+  code: number; archive: NativeRawDumpArchive | null; terminal: boolean;
+}>;
+
 export type NativeTiCloudStorageRecordingRange = Readonly<{
   startTimeMs: number;
   endTimeMs: number;
 }>;
 
+export type NativeTiCloudStorageRecordingTrack = Readonly<{
+  kind: number;
+  channelId: number;
+}>;
+
+export type NativeTiCloudStorageRecordingGap = Readonly<{
+  range: NativeTiCloudStorageRecordingRange;
+  tracks: ReadonlyArray<NativeTiCloudStorageRecordingTrack>;
+  reasons: ReadonlyArray<number>;
+}>;
+
+export type NativeTiCloudStorageExportProgress = Readonly<{
+  fraction: number;
+  coveredDurationMs: number;
+}>;
+
+export type NativeTiCloudStorageExportSegment = Readonly<{
+  sourceRange: NativeTiCloudStorageRecordingRange;
+  outputStartMs: number;
+  outputEndMs: number;
+}>;
+
+export type NativeTiCloudStorageExportReport = Readonly<{
+  requestedRange: NativeTiCloudStorageRecordingRange;
+  coveredDurationMs: number;
+  segments: ReadonlyArray<NativeTiCloudStorageExportSegment>;
+  gaps: ReadonlyArray<NativeTiCloudStorageRecordingGap>;
+  unprocessedRanges: ReadonlyArray<NativeTiCloudStorageRecordingRange>;
+  complete: boolean;
+  termination: number;
+  cause: number;
+}>;
+
+export type NativeTiCloudStorageExportResult = Readonly<{
+  code: number;
+  fileId: NativeObjectId | null;
+  filePath: string | null;
+  durationMs: number | null;
+  report: NativeTiCloudStorageExportReport | null;
+  progressDetail: NativeTiCloudStorageExportProgress | null;
+}>;
+
 export type NativeTiCloudStorageRecordingRangesResult = Readonly<{
   code: number;
   recordings: ReadonlyArray<NativeTiCloudStorageRecordingRange>;
@@ -131,6 +184,7 @@ export type NativeTiCloudStorageReplayInfo = Readonly<{
 export type NativeTiCloudStorageTaskStartResult = Readonly<{
   code: number;
   taskId: NativeObjectId | null;
+  generation: number;
 }>;
 
 export type NativeTiRtcEvent = Readonly<{
@@ -147,6 +201,8 @@ export type NativeTiRtcEvent = Readonly<{
   data?: NativeBytes;
   size?: NativeSize;
   fps?: number;
+  exportProgress?: NativeTiCloudStorageExportProgress;
+  recordingGap?: NativeTiCloudStorageRecordingGap;
 }>;
 
 type NativeConnMetricsResult = Readonly<{
@@ -242,6 +298,11 @@ type NativeVideoOutputDebugSnapshotResult = Readonly<{
   }> | null;
 }>;
 
+type NativeTiCloudStorageCallback = Readonly<{
+  deliveryId: number;
+  event: NativeTiRtcEvent;
+}>;
+
 interface Spec extends TurboModule {
   readonly onTiRtcEvent: CodegenTypes.EventEmitter<NativeTiRtcEvent>;
 
@@ -251,6 +312,8 @@ interface Spec extends TurboModule {
   writeLog(level: number, tag: string, message: string): number;
   uploadLogs(): Promise<NativeLoggingUploadResult>;
 
+  tiCloudStorageTakeCallback(): NativeTiCloudStorageCallback | null;
+  tiCloudStorageAcknowledgeCallback(deliveryId: number): number;
   tiCloudStorageInitialize(options: NativeInitOptions): Promise<number>;
   tiCloudStorageShutdown(): number;
   tiCloudStorageCreate(token: string): NativeCreateResult;
@@ -275,7 +338,9 @@ interface Spec extends TurboModule {
     audioChannelId: number | null,
   ): NativeTiCloudStorageTaskStartResult;
   tiCloudStorageExportProgress(id: NativeObjectId): number;
-  tiCloudStorageExportResult(id: NativeObjectId): Promise<NativeMp4Result>;
+  tiCloudStorageExportProgressDetail(id: NativeObjectId): NativeTiCloudStorageExportProgress;
+  tiCloudStorageExportResult(id: NativeObjectId): Promise<NativeTiCloudStorageExportResult>;
+  tiCloudStorageExportCancel(id: NativeObjectId): number;
   tiCloudStorageExportStop(id: NativeObjectId): number;
   tiCloudStorageDispose(id: NativeObjectId): number;
 
@@ -290,6 +355,11 @@ interface Spec extends TurboModule {
     videoChannelId: number,
     audioChannelId: number | null,
   ): NativeTiCloudStorageTaskStartResult;
+  tiCloudStorageReplayStartRawDump(
+    id: NativeObjectId,
+    audioChannelIds: ReadonlyArray<number>,
+    videoChannelIds: ReadonlyArray<number>,
+  ): Promise<NativeRawDumpStartResult>;
   tiCloudStorageRecordingTaskStop(id: NativeObjectId): Promise<NativeMp4Result>;
   tiCloudStorageReplayStop(id: NativeObjectId): number;
   tiCloudStorageReplayDispose(id: NativeObjectId): number;
@@ -326,6 +396,13 @@ interface Spec extends TurboModule {
     id: NativeObjectId,
     options: NativeRecordingOptions,
   ): NativeRecordingStartResult;
+  connStartRawDump(
+    id: NativeObjectId,
+    audioStreamIds: ReadonlyArray<number>,
+    videoStreamIds: ReadonlyArray<number>,
+    uplinkAudioStreamIds: ReadonlyArray<number>,
+  ): Promise<NativeRawDumpStartResult>;
+  rawDumpStop(id: NativeObjectId): Promise<NativeRawDumpStopResult>;
   recordingTaskStop(id: NativeObjectId): Promise<NativeMp4Result>;
   mediaFileMoveToGallery(id: NativeObjectId, fileName: string | null): Promise<NativeGalleryResult>;
   mediaFileDelete(id: NativeObjectId): Promise<number>;