@xmaxai/sdk 1.0.1 → 1.0.2

package/dist/index.d.ts

@@ -1,6 +1,5 @@
-import { S as SDKLocale, a as SDKI18n, b as XmaxOpenClient } from './rtc-manager-gYDkADGw.js';
-export { A as ACTIVE_STATUS, C as ClientOptions, c as CosSts, L as LocalPublishReadyResult, M as MEDIA_TIME_EPSILON_S, d as MEDIA_TIME_LOOP_JUMP_S, e as MOBILE_PUBLISH_MAX_WIDTH_PX, f as ModelExtra, P as PUBLISH_COLD_FRAME_TIMEOUT_MS, g as PUBLISH_COLD_MIN_FRAMES, h as PUBLISH_COLD_WARMUP_MS, i as PUBLISH_START_FRAME_TIMEOUT_MS, j as PUBLISH_START_MIN_FRAMES, k as PUBLISH_WARM_SKIP_MS, l as RTC_PUBLISH_FPS, m as RTC_PUBLISH_FPS_MOBILE, n as RTC_PUBLISH_FPS_WEB, o as RTC_PUBLISH_FRAME_INTERVAL_MS, p as RTC_PUBLISH_FRAME_INTERVAL_S, q as RemoteSeiReceivedPayload, r as ResolveRtcPublishFpsOptions, s as RtcJoinInfo, t as RtcLogEntry, u as RtcManager, R as RtcStateSnapshot, v as SDKMessages, w as Session, x as StsCredentials, U as UploadImageResult, y as UploadVideoResult, z as XMAX_OPEN_API_BASE_URLS, B as XMAX_OPEN_API_PRODUCTION_BASE_URL, D as XmaxLogEntry, E as XmaxSdkRegion, F as createSDKI18n, G as getDefaultMessages, H as isMobilePublishEnvironment, I as resolveRtcPublishFps, J as resolveRtcPublishFrameIntervalS } from './rtc-manager-gYDkADGw.js';
-export { D as DragTrackController, a as DragTrackControllerOptions, N as NativeCameraStream, O as OpenNativeCameraStreamOptions, R as RealtimeConnectOptions, b as RealtimeInitialState, c as RealtimeModel, d as RealtimePrewarmHandle, e as RealtimePromptState, f as RealtimeRestartOptions, g as RealtimeSession, h as RealtimeSetImageOptions, i as RealtimeSetInput, j as RealtimeSetModeOptions, k as RemoteViewHost, X as XmaxClient, l as XmaxClientFiles, m as XmaxClientOptions, n as XmaxRealtimeSession, o as createDragTrackController, p as createNativeCameraStream, q as createRemoteViewHost, r as createXmaxClient, s as getContentRect, t as mapTargetPointToCanvas, u as mapViewportPointToCoordinateSpace, v as models, w as observeDragSurfaceVideoSync, x as openNativeCameraStream, y as syncDragSurfaceToVideo } from './index-Cw8C8LbO.js';
+import { S as SDKLocale, a as SDKI18n, X as XmaxOpenClient, R as RtcManager, b as XmaxErrorNotifier, U as UploadImageResult, c as UploadVideoResult } from './rtc-manager-DnQoznIg.js';
+export { A as ACTIVE_STATUS, C as ClientOptions, d as CosSts, L as LocalPublishReadyResult, M as MEDIA_TIME_EPSILON_S, e as MEDIA_TIME_LOOP_JUMP_S, f as MOBILE_PUBLISH_MAX_WIDTH_PX, g as ModelExtra, P as PUBLISH_COLD_FRAME_TIMEOUT_MS, h as PUBLISH_COLD_MIN_FRAMES, i as PUBLISH_COLD_WARMUP_MS, j as PUBLISH_START_FRAME_TIMEOUT_MS, k as PUBLISH_START_MIN_FRAMES, l as PUBLISH_WARM_SKIP_MS, m as RTC_PUBLISH_FPS_MOBILE, n as RTC_PUBLISH_FPS_WEB, o as RTC_PUBLISH_FRAME_INTERVAL_MS, p as RTC_PUBLISH_FRAME_INTERVAL_S, q as RemoteSeiReceivedPayload, r as ResolveRtcPublishFpsOptions, s as RtcJoinInfo, t as RtcLogEntry, u as RtcStateSnapshot, v as SDKMessages, w as Session, x as StsCredentials, y as XMAX_OPEN_API_BASE_URLS, z as XMAX_OPEN_API_PRODUCTION_BASE_URL, B as XmaxLogEntry, D as XmaxSdkRegion, E as createSDKI18n, F as getDefaultMessages, G as isMobilePublishEnvironment, H as resolveRtcPublishFps, I as resolveRtcPublishFrameIntervalS } from './rtc-manager-DnQoznIg.js';
 
 /**
  * Open API business error codes (46xxx) mapped to user-facing messages.
@@ -86,16 +85,14 @@ type VideoFileStreamOptions = {
     loop?: boolean;
     muted?: boolean;
     playbackRate?: number;
-    /** @deprecated Upload video is playback-driven; fps is measured from the source file. */
+    /** Optional fps override; when omitted, fps is measured from the source file. */
     fps?: number;
-    /** @deprecated Mobile/web publish fps is derived from the uploaded file. */
+    /** Optional hint; publish fps is still derived from the uploaded file when applicable. */
     mobile?: boolean;
     targetSize?: [number, number];
     i18n?: SDKI18n;
     onHealthReport?: (health: VideoInputHealth) => void;
     healthIntervalMs?: number;
-    /** Log each canvas draw (proxy for frames fed to RTC captureStream). */
-    logPublishFrames?: boolean;
 };
 type VideoFileStream = {
     url: string;
@@ -122,6 +119,27 @@ declare function isImageMediaFile(file: File | string): boolean;
 declare function isVideoMediaFile(file: File | string): boolean;
 declare function createMediaFileStream(fileOrUrl: File | string, options?: ImageFileStreamOptions): Promise<VideoFileStream>;
 
+type NativeCameraStream = {
+    sourceStream: MediaStream;
+    previewStream: MediaStream;
+    videoTrack: MediaStreamTrack;
+    videoEl: HTMLVideoElement;
+    width: number;
+    height: number;
+    destroy: () => void;
+};
+type OpenNativeCameraStreamOptions = {
+    width?: number;
+    height?: number;
+    frameRate?: number;
+    facingMode?: ConstrainDOMString;
+    i18n?: SDKI18n;
+};
+declare function openNativeCameraStream(options?: OpenNativeCameraStreamOptions): Promise<NativeCameraStream>;
+declare function createNativeCameraStream(sourceStream: MediaStream, options?: {
+    i18n?: SDKI18n;
+}): Promise<NativeCameraStream>;
+
 type MirroredCameraStream = {
     /** Original camera stream from getUserMedia. */
     sourceStream: MediaStream;
@@ -237,4 +255,347 @@ declare const PREVIEW_COVER_ATTR = "data-preview-cover";
 declare function applyUploadPreviewMediaLayout(container: HTMLElement): void;
 declare function observeUploadPreviewMediaLayout(container: HTMLElement): () => void;
 
-export { API_ERROR_MESSAGES, type CameraAccessErrorKind, type CameraCaptureOptions, type CameraEnvironmentIssue, type CameraTrackCapabilities, type CameraTrackSettings, DEFAULT_SESSION_TARGET_SIZE, type ImageFileStreamOptions, type MirroredCameraStream, type MirroredCameraStreamOptions, type OpenMirroredCameraStreamOptions, PREVIEW_CONTAINER_ASPECT_RATIO, PREVIEW_CONTAIN_ATTR, PREVIEW_COVER_ATTR, PREVIEW_OUTPUT_LAYOUT_ATTR, PREVIEW_UPLOAD_FIT_ATTR, PREVIEW_UPLOAD_LAYOUT_ATTR, type RtcRoomEvent, SDKI18n, SDKLocale, type StartRtcRoomEvent, type StopRtcRoomEvent, type TracksRtcRoomEvent, type VideoFileStream, type VideoFileStreamOptions, XmaxOpenClient, applyUploadPreviewMediaLayout, classifyCameraAccessError, createImageFileStream, createMediaFileStream, createMirroredCameraStreamFromMediaStream, createPublishCameraStream, createStartRtcRoomEvent, createStopRtcRoomEvent, createTaskUid, createTracksRtcRoomEvent, createVideoFileStream, getCameraEnvironmentIssue, isCameraAccessError, isImageMediaFile, isVideoMediaFile, observeUploadPreviewMediaLayout, openMirroredCameraStream, requestCameraMediaStream, resolveAdaptiveRtcVideoSize, resolveApiErrorMessage, resolvePreviewAspectRatio, resolveRefImageUrl, resolveSessionTargetSize, resolveUploadPublishSize, resolveUploadVideoSize, stabilizeCameraVideoTrack };
+type PrewarmedRoomResources = {
+    client: XmaxOpenClient;
+    rtc: RtcManager;
+    sessionUid: string;
+};
+/** Holds a joined RTC room before camera input is attached — iOS enterRoom-at-launch equivalent. */
+declare class RealtimePrewarmHandle {
+    readonly client: XmaxOpenClient;
+    readonly rtc: RtcManager;
+    readonly sessionUid: string;
+    readonly modelName: string;
+    private consumed;
+    private disposed;
+    private constructor();
+    static create(model: RealtimeModel, clientOptions: XmaxClientOptions): Promise<RealtimePrewarmHandle>;
+    consume(expectedModelName: string): PrewarmedRoomResources | null;
+    cancel(): Promise<void>;
+}
+
+type RealtimeModel = {
+    name: string;
+    width: number;
+    height: number;
+    fps?: number;
+};
+type RealtimePromptState = {
+    text: string;
+    enhance?: boolean;
+};
+type RemoteSeiReceivedPayload = {
+    sei: string;
+    userId: string;
+};
+type SeiGateState = {
+    expectedSei: string | null;
+    sei: string | null;
+    userId: string | null;
+    matched: boolean;
+};
+type XmaxClientOptions = {
+    apiKey: string;
+    /** @default {@link XMAX_OPEN_API_PRODUCTION_BASE_URL} */
+    baseUrl?: string;
+    authToken?: string;
+    heartbeatIntervalMs?: number;
+    onError?: XmaxErrorNotifier;
+    onLog?: (entry: {
+        scope: 'client' | 'rtc';
+        level: 'info' | 'success' | 'warn' | 'error';
+        message: string;
+        data?: unknown;
+    }) => void;
+    /** Fired when H.264 SEI is received on the remote backend/bot output stream (not local publish). */
+    onRemoteSei?: (payload: RemoteSeiReceivedPayload) => void;
+    /** Fired when remote SEI gate state changes. */
+    onSeiGateChange?: (state: SeiGateState) => void;
+    /** Cleared when generation start completes; used to reset host loading state set before connect. */
+    onPublishPipelineWaitChange?: (waiting: boolean) => void;
+};
+type RealtimeInitialState = {
+    /** Legacy string prompt or Decart-style `{ text, enhance? }`. */
+    prompt?: string | RealtimePromptState;
+    /** Legacy reference image path or URL. */
+    refImage?: string;
+    /** Decart-style reference image (path, URL, File, or Blob). */
+    image?: string | File | Blob;
+    /** When true, send a start event immediately after connect. */
+    autoStart?: boolean;
+    /** @internal Business model label in RTC start params; optional — SDK uses a default when omitted. */
+    model?: string;
+    /** MoX instant — when `true`, sent as `static_generate` on connect start only (never cached). */
+    staticGenerate?: boolean;
+    /**
+     * MoX instant — uploaded source still URL (COS). Sent as `static_image_path` on connect
+     * start only (never cached). Local RTC publish is still used for preview / room compatibility.
+     */
+    staticImagePath?: string;
+};
+/** Why a successfully established realtime session was torn down. */
+type RealtimeDisconnectReason = 'client' | 'session_inactive' | 'heartbeat_error';
+type RealtimeConnectOptions = {
+    model: RealtimeModel;
+    localElement?: HTMLElement;
+    remoteElement?: HTMLElement;
+    onRemoteStream?: (stream: MediaStream) => void;
+    /**
+     * Session-scoped error handler (Decart-style). Prefer over {@link XmaxClientOptions.onError}
+     * when both are set.
+     */
+    onError?: XmaxErrorNotifier;
+    /**
+     * Fired once after a successfully established session disconnects.
+     * Not called when `connect()` itself fails before returning a session.
+     */
+    onDisconnect?: (reason: RealtimeDisconnectReason) => void;
+    initialState?: RealtimeInitialState;
+    size?: [number, number];
+    /** Mobile H5 uses 24fps publish; web uses 30fps. Auto-detected from viewport when omitted. */
+    mobile?: boolean;
+    /** `file` = pre-processed canvas stream (upload). `camera` = normalize via crop/mirror pipeline. */
+    inputKind?: 'camera' | 'file';
+    /** Pre-flip input video: `false` (default), `"auto"`, or `true`. */
+    mirror?: 'auto' | boolean;
+    /** Reuse an already prepared camera publish pipeline (mirror/crop canvas). */
+    prebuiltCameraStream?: NativeCameraStream;
+    /**
+     * Enable drag on {@link RealtimeConnectOptions.remoteElement} after generation starts.
+     * Defaults to `true` when `remoteElement` is provided; `false` for `onRemoteStream`-only connects.
+     */
+    drag?: boolean;
+    /** Reuse a prewarmed RTC room from {@link XmaxClient.realtime.prewarm}. */
+    prewarmed?: RealtimePrewarmHandle;
+};
+type RealtimeRestartOptions = {
+    /** Pass `null` or `''` to clear the stored reference image. */
+    refImage?: string | null;
+    prompt?: string;
+    /** @internal Optional business model label; SDK uses a default when omitted. */
+    model?: string;
+    size?: [number, number];
+    /**
+     * MoX instant — when `true`, sent as `static_generate` on this start only (never cached).
+     * Omit on non-Instant starts.
+     */
+    staticGenerate?: boolean;
+    /**
+     * MoX instant — COS URL sent as `static_image_path` on this start only (never cached).
+     * Omit on non-Instant starts.
+     */
+    staticImagePath?: string;
+    /** Keep the last rendered remote frame visible while waiting for the next start output. */
+    preserveRemoteOutput?: boolean;
+};
+type RealtimeSetInput = {
+    prompt?: string | RealtimePromptState;
+    image?: string | File | Blob | null;
+    enhance?: boolean;
+};
+type RealtimeSetImageOptions = {
+    prompt?: string | RealtimePromptState;
+    enhance?: boolean;
+};
+type RealtimeDisconnectOptions = {};
+type XmaxRealtimeSession = {
+    setPrompt: (prompt: string | RealtimePromptState, options?: {
+        enhance?: boolean;
+    }) => Promise<void>;
+    set: (input: RealtimeSetInput) => Promise<void>;
+    setImage: (image: string | File | Blob, options?: RealtimeSetImageOptions) => Promise<void>;
+    restart: (options?: RealtimeRestartOptions) => Promise<void>;
+    setRefImage: (input: File | string) => Promise<string>;
+    sendTracks: (tracks: Array<[number, number]>) => Promise<void>;
+    /** Re-bind the remote output container (call after output should be visible). */
+    refreshRemoteOutput: (options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    /** Re-bind local preview (call after PiP container is visible). */
+    refreshLocalPreview: () => void;
+    /** Processed canvas stream for local PiP (camera pipeline); null for file input. */
+    getInputPreviewStream: () => MediaStream | null;
+    /** Detach remote output from the RTC player. */
+    detachRemoteOutput: () => void;
+    /** Active server session uid, if connected. */
+    getSessionUid: () => string | null;
+    stop: () => Promise<void>;
+    disconnect: (options?: RealtimeDisconnectOptions) => Promise<void>;
+};
+type XmaxClientFiles = {
+    uploadImage: (file: File) => Promise<UploadImageResult>;
+    uploadVideo: (file: File) => Promise<UploadVideoResult>;
+    /** Decart-style alias for {@link XmaxClientFiles.uploadImage}. */
+    upload: (file: File) => Promise<UploadImageResult>;
+};
+type XmaxClient = {
+    files: XmaxClientFiles;
+    realtime: {
+        /** Join RTC room before camera input — call on explicit user action to avoid idle billing. */
+        prewarm: (options: {
+            model: RealtimeModel;
+        }) => Promise<RealtimePrewarmHandle>;
+        connect: (stream: MediaStream, options: RealtimeConnectOptions) => Promise<XmaxRealtimeSession>;
+    };
+};
+
+declare const models: {
+    realtime(name: string, options?: {
+        width?: number;
+        height?: number;
+        fps?: number;
+    }): RealtimeModel;
+};
+
+declare class RealtimeSession implements XmaxRealtimeSession {
+    private readonly client;
+    private readonly rtc;
+    private readonly reportError;
+    private readonly remoteElement;
+    private readonly onRemoteStream?;
+    private readonly onDisconnect?;
+    private readonly onPublishPipelineWaitChange?;
+    private sessionUid;
+    private taskUid;
+    private localVideoSize;
+    private currentPrompt;
+    private currentGenerationModel;
+    private disconnected;
+    /** True only after `connect()` bootstrap succeeds — gates `onDisconnect`. */
+    private sessionEstablished;
+    private disconnectNotified;
+    private pendingDisconnectReason;
+    private remoteViewHost;
+    private dragController;
+    private dragTrackFitMode;
+    private sessionTargetSize;
+    private sessionSizeOverride;
+    private mirroredInputStream;
+    private hiddenRemoteElement;
+    private remoteStreamNotifyTimer;
+    private lastNotifiedRemoteStream;
+    private dragOption;
+    constructor(client: XmaxOpenClient, rtc: RtcManager, reportError: (error: unknown, fallbackMessage?: string) => never, options: Pick<RealtimeConnectOptions, 'remoteElement' | 'onRemoteStream' | 'onDisconnect' | 'drag'>, clientOptions?: Pick<XmaxClientOptions, 'onPublishPipelineWaitChange'>);
+    private get remoteVideoContainer();
+    static connect(stream: MediaStream, options: RealtimeConnectOptions, clientOptions: XmaxClientOptions): Promise<RealtimeSession>;
+    private bootstrap;
+    setPrompt(prompt: string | RealtimePromptState, _options?: {
+        enhance?: boolean;
+    }): Promise<void>;
+    set(input: RealtimeSetInput): Promise<void>;
+    setImage(image: string | File | Blob, options?: RealtimeSetImageOptions): Promise<void>;
+    setRefImage(input: File | string): Promise<string>;
+    restart(options?: RealtimeRestartOptions): Promise<void>;
+    refreshRemoteOutput(options?: {
+        force?: boolean;
+    }): Promise<void>;
+    refreshLocalPreview(): void;
+    getInputPreviewStream(): MediaStream | null;
+    detachRemoteOutput(): void;
+    sendTracks(tracks: Array<[number, number]>): Promise<void>;
+    stop(options?: {
+        preserveRemoteDom?: boolean;
+    }): Promise<void>;
+    disconnect(options?: RealtimeDisconnectOptions): Promise<void>;
+    getSessionUid(): string | null;
+    private runStart;
+    private isDragEnabled;
+    private updateDragController;
+    private scheduleNotifyRemoteStream;
+    private notifyRemoteStreamOnce;
+    private clearRemoteStreamNotifyTimer;
+    private emitDisconnect;
+    private safeDisconnect;
+}
+
+declare function createXmaxClient(options: XmaxClientOptions): XmaxClient;
+
+type DragTrackControllerOptions = {
+    targetSize: [number, number];
+    fitMode?: 'contain' | 'cover';
+    mirrored?: boolean;
+    enabled?: boolean;
+    onTracks: (tracks: Array<[number, number]>) => void | Promise<void>;
+    /** Fired once when a real drag stroke begins (first pointer down). */
+    onStrokeStart?: () => void | Promise<void>;
+    /** Fired once when a real drag stroke ends (pointer up/cancel), not on disable/destroy. */
+    onStrokeEnd?: () => void | Promise<void>;
+};
+declare class DragTrackController {
+    private readonly container;
+    private readonly canvas;
+    private readonly onTracks;
+    private readonly onStrokeStart;
+    private readonly onStrokeEnd;
+    private strokeActive;
+    private targetSize;
+    private fitMode;
+    private mirrored;
+    private enabled;
+    private readonly activePointers;
+    private readonly lastTargetPoints;
+    private readonly segQueue;
+    private sampleTimer;
+    private sampleInFlight;
+    private rafId;
+    private resizeObserver;
+    private readonly onWindowResize;
+    private readonly onPointerDown;
+    private readonly onPointerMove;
+    private readonly onPointerUp;
+    private readonly onPointerCancel;
+    constructor(container: HTMLElement, options: DragTrackControllerOptions);
+    setEnabled(enabled: boolean): void;
+    setTargetSize(targetSize: [number, number]): void;
+    setFitMode(fitMode: 'contain' | 'cover'): void;
+    setMirrored(mirrored: boolean): void;
+    destroy(): void;
+    private applyInteractionStyle;
+    private bindResizeObserver;
+    private unbindResizeObserver;
+    private bindPointerEvents;
+    private unbindPointerEvents;
+    private clearCanvas;
+    private resizeCanvas;
+    private toTargetPoint;
+    private stopDrawLoop;
+    private startDrawLoop;
+    private stopSampling;
+    private collectCurrentTracks;
+    private flushTracks;
+    private startSampling;
+    private finishStroke;
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerUp;
+    private handlePointerCancel;
+}
+declare function createDragTrackController(container: HTMLElement, options: DragTrackControllerOptions): DragTrackController;
+
+type MapViewportOptions = {
+    fitMode?: 'contain' | 'cover';
+    /** Flip X when the output video is horizontally mirrored in CSS (xmax-open-sdk remote overlay). */
+    mirrored?: boolean;
+};
+declare function mapViewportPointToCoordinateSpace(e: Pick<PointerEvent, 'clientX' | 'clientY'>, container: HTMLElement, targetSize: [number, number], options?: MapViewportOptions): [number, number] | null;
+/** Inverse of mapViewportPointToCoordinateSpace — target coords to canvas pixels (CSS space × dpr). */
+declare function mapTargetPointToCanvas(point: [number, number], container: HTMLElement, targetSize: [number, number], dpr: number, options?: MapViewportOptions): [number, number] | null;
+
+type RemoteViewHost = {
+    wrapper: HTMLElement;
+    videoHost: HTMLElement;
+    dragHost: HTMLElement;
+};
+declare function createRemoteViewHost(wrapper: HTMLElement): RemoteViewHost;
+
+type DragVideoSyncOptions = {
+    getTargetSize: () => [number, number];
+    getFitMode: () => 'contain' | 'cover';
+    onSync?: () => void;
+};
+/** Align app-layer drag overlay to the painted RTC media region (xmax-open-sdk track surface). */
+declare function syncDragSurfaceToVideo(dragSurface: HTMLElement, targetSize: [number, number], fitMode: 'contain' | 'cover'): boolean;
+/** Keep an app-layer drag surface aligned with remote output video layout. */
+declare function observeDragSurfaceVideoSync(dragSurface: HTMLElement, options: DragVideoSyncOptions): () => void;
+
+export { API_ERROR_MESSAGES, type CameraAccessErrorKind, type CameraCaptureOptions, type CameraEnvironmentIssue, type CameraTrackCapabilities, type CameraTrackSettings, DEFAULT_SESSION_TARGET_SIZE, DragTrackController, type DragTrackControllerOptions, type ImageFileStreamOptions, type MirroredCameraStream, type MirroredCameraStreamOptions, type NativeCameraStream, type OpenMirroredCameraStreamOptions, type OpenNativeCameraStreamOptions, PREVIEW_CONTAINER_ASPECT_RATIO, PREVIEW_CONTAIN_ATTR, PREVIEW_COVER_ATTR, PREVIEW_OUTPUT_LAYOUT_ATTR, PREVIEW_UPLOAD_FIT_ATTR, PREVIEW_UPLOAD_LAYOUT_ATTR, type RealtimeConnectOptions, type RealtimeDisconnectReason, type RealtimeInitialState, type RealtimeModel, RealtimePrewarmHandle, type RealtimePromptState, type RealtimeRestartOptions, RealtimeSession, type RealtimeSetImageOptions, type RealtimeSetInput, type RemoteViewHost, RtcManager, type RtcRoomEvent, SDKI18n, SDKLocale, type StartRtcRoomEvent, type StopRtcRoomEvent, type TracksRtcRoomEvent, UploadImageResult, UploadVideoResult, type VideoFileStream, type VideoFileStreamOptions, type XmaxClient, type XmaxClientFiles, type XmaxClientOptions, XmaxOpenClient, type XmaxRealtimeSession, applyUploadPreviewMediaLayout, classifyCameraAccessError, createDragTrackController, createImageFileStream, createMediaFileStream, createMirroredCameraStreamFromMediaStream, createNativeCameraStream, createPublishCameraStream, createRemoteViewHost, createStartRtcRoomEvent, createStopRtcRoomEvent, createTaskUid, createTracksRtcRoomEvent, createVideoFileStream, createXmaxClient, getCameraEnvironmentIssue, isCameraAccessError, isImageMediaFile, isVideoMediaFile, mapTargetPointToCanvas, mapViewportPointToCoordinateSpace, models, observeDragSurfaceVideoSync, observeUploadPreviewMediaLayout, openMirroredCameraStream, openNativeCameraStream, requestCameraMediaStream, resolveAdaptiveRtcVideoSize, resolveApiErrorMessage, resolvePreviewAspectRatio, resolveRefImageUrl, resolveSessionTargetSize, resolveUploadPublishSize, resolveUploadVideoSize, stabilizeCameraVideoTrack, syncDragSurfaceToVideo };