@spatialwalk/avatarkit 1.0.0-beta.4 → 1.0.0-beta.40

package/dist/withJoi/admin/src/composables/useMaterialFilters.d.ts

@@ -0,0 +1,14 @@
+type MaterialType = 'MATERIAL_TYPE_VIDEO' | 'MATERIAL_TYPE_IMAGE' | 'MATERIAL_TYPE_UNSPECIFIED' | 'all';
+export declare function useMaterialFilters(): {
+    searchFilter: import('@vueuse/core').RemovableRef<string>;
+    typeFilter: import('@vueuse/core').RemovableRef<MaterialType>;
+    sourceFilter: import('@vueuse/core').RemovableRef<string>;
+    tagFilter: import('@vueuse/core').RemovableRef<("driving_video" | "verified_good")[]>;
+    createdByFilter: import('@vueuse/core').RemovableRef<string>;
+    createdAfterFilter: import('@vueuse/core').RemovableRef<string | undefined>;
+    createdBeforeFilter: import('@vueuse/core').RemovableRef<string | undefined>;
+    formatDateForApi: (dateString?: string, isEndDate?: boolean) => string | undefined;
+    resetAllFilters: () => void;
+    hasActiveFilters: () => boolean;
+};
+export {};

package/dist/withJoi/admin/src/composables/useModelEvaluation.d.ts

@@ -0,0 +1,11 @@
+import { ModelEvaluationConfig, ModelEvaluationProviderConfig } from '../../generated/platform/v1/model_evaluation';
+import { ModelSettings } from '../types/model-settings';
+import { ModelConfig } from '../types/test-ground';
+
+export declare function convertModelConfigToModelSettings(_config: ModelConfig, _baseModelSettings?: ModelSettings): ModelSettings | undefined;
+
+export declare function generateStyleNpy(assetGroupId: string, styleStartTime: number, drivenVersion: string): Promise<Uint8Array>;
+
+export declare function buildProviderConfig(providerId: string, additionalMetadata?: Record<string, string>): Promise<ModelEvaluationProviderConfig | null>;
+
+export declare function buildModelEvaluationConfig(assetGroupId: string, modelConfig: ModelConfig, baseModelSettings?: ModelSettings): Promise<ModelEvaluationConfig | null>;

package/dist/withJoi/admin/src/composables/useModelEvaluationWebSocket.d.ts

@@ -0,0 +1,111 @@
+import { ModelEvaluationConfig } from '../../generated/platform/v1/model_evaluation';
+import { MessageType } from '../../generated/realtime/v1/messages';
+
+export declare enum WebSocketState {
+    DISCONNECTED = "disconnected",
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    ERROR = "error"
+}
+export { MessageType };
+
+export interface ResponseCallbacks {
+    onResponseStart?: (reqId: string) => void;
+    onText?: (reqId: string, text: string) => void;
+    onAudio?: (reqId: string, audio: Uint8Array, isLast: boolean) => void;
+    onAnimation?: (reqId: string, animation: any) => void;
+    onAsrResult?: (reqId: string, asrText: string) => void;
+    onResponseEnd?: (reqId: string) => void;
+    onError?: (reqId: string, code: number, reason: string) => void;
+}
+
+export declare function useModelEvaluationWebSocket(): {
+    ws: import('vue').Ref<{
+        binaryType: BinaryType;
+        readonly bufferedAmount: number;
+        readonly extensions: string;
+        onclose: ((this: WebSocket, ev: CloseEvent) => any) | null;
+        onerror: ((this: WebSocket, ev: Event) => any) | null;
+        onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null;
+        onopen: ((this: WebSocket, ev: Event) => any) | null;
+        readonly protocol: string;
+        readonly readyState: number;
+        readonly url: string;
+        close: {
+            (code?: number, reason?: string): void;
+            (code?: number, reason?: string): void;
+        };
+        send: {
+            (data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+            (data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+        };
+        readonly CONNECTING: 0;
+        readonly OPEN: 1;
+        readonly CLOSING: 2;
+        readonly CLOSED: 3;
+        addEventListener: {
+            <K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            <K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            <K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        dispatchEvent: {
+            (event: Event): boolean;
+            (event: Event): boolean;
+        };
+    } | null, WebSocket | {
+        binaryType: BinaryType;
+        readonly bufferedAmount: number;
+        readonly extensions: string;
+        onclose: ((this: WebSocket, ev: CloseEvent) => any) | null;
+        onerror: ((this: WebSocket, ev: Event) => any) | null;
+        onmessage: ((this: WebSocket, ev: MessageEvent) => any) | null;
+        onopen: ((this: WebSocket, ev: Event) => any) | null;
+        readonly protocol: string;
+        readonly readyState: number;
+        readonly url: string;
+        close: {
+            (code?: number, reason?: string): void;
+            (code?: number, reason?: string): void;
+        };
+        send: {
+            (data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+            (data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+        };
+        readonly CONNECTING: 0;
+        readonly OPEN: 1;
+        readonly CLOSING: 2;
+        readonly CLOSED: 3;
+        addEventListener: {
+            <K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            <K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            <K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        dispatchEvent: {
+            (event: Event): boolean;
+            (event: Event): boolean;
+        };
+    } | null>;
+    state: import('vue').Ref<WebSocketState, WebSocketState>;
+    error: import('vue').Ref<string | null, string | null>;
+    configSent: import('vue').Ref<boolean, boolean>;
+    connect: () => Promise<boolean>;
+    sendConfig: (config: ModelEvaluationConfig, forceReconnect?: boolean) => Promise<boolean>;
+    sendTextInput: (text: string, reqId?: string) => boolean;
+    setCallbacks: (callbacks: ResponseCallbacks) => void;
+    disconnect: () => void;
+    hasConfigChanged: (newConfig: ModelEvaluationConfig) => boolean;
+};

package/dist/withJoi/admin/src/composables/useModelSettings.d.ts

@@ -0,0 +1,12 @@
+import { Ref } from 'vue';
+import { ModelSettings } from '../types/model-settings';
+
+export declare function useModelSettings(): {
+    modelSettings: Ref<ModelSettings, ModelSettings>;
+    modelJson: Ref<string, string>;
+    defaultModelSettings: ModelSettings;
+    loadFromJson: (jsonString: string) => void;
+    loadFromObject: (settings: ModelSettings | Record<string, any> | null | undefined) => void;
+    resetToDefaults: () => void;
+    getJsonString: () => string;
+};

package/dist/withJoi/admin/src/composables/usePageScrollLock.d.ts

@@ -0,0 +1,6 @@
+import { Ref } from 'vue';
+
+export declare function usePageScrollLock(containerRef?: Ref<HTMLElement | null>): {
+    lockScroll: (containers?: HTMLElement[]) => void;
+    unlockScroll: () => void;
+};

package/dist/withJoi/admin/src/composables/useTaskFilters.d.ts

@@ -0,0 +1,11 @@
+import { V1TaskStatus, V1TaskType } from '../client';
+export declare function useTaskFilters(): {
+    statusFilter: import('@vueuse/core').RemovableRef<V1TaskStatus[]>;
+    typeFilter: import('@vueuse/core').RemovableRef<V1TaskType[]>;
+    creatorSearch: import('@vueuse/core').RemovableRef<string>;
+    timeRangeStart: import('@vueuse/core').RemovableRef<string | undefined>;
+    timeRangeEnd: import('@vueuse/core').RemovableRef<string | undefined>;
+    getStatusNumbers: () => number[];
+    getTypeNumbers: () => number[];
+    formatDateForApi: (dateString?: string) => string | undefined;
+};

package/dist/withJoi/admin/src/constants/character.d.ts

@@ -0,0 +1,4 @@
+export declare const CHARACTER_SCENE_OPTIONS: {
+    name: string;
+    value: string;
+}[];

package/dist/withJoi/admin/src/constants/collection-task.d.ts

@@ -0,0 +1,5 @@
+export declare const COLLECTION_TASK_CONSTANTS: {
+
+    readonly SHARE_TOKEN_PARAM: "sharetoken";
+    readonly REGION_PARAM: "region";
+};

package/dist/withJoi/admin/src/constants/config-previews.d.ts

@@ -0,0 +1,8 @@
+export interface PreviewData {
+    baseImage: string;
+    changeImage: string;
+    beforeValue: string;
+    afterValue: string;
+}
+
+export declare const configPreviewData: Record<string, PreviewData>;

package/dist/withJoi/admin/src/constants/container.d.ts

@@ -0,0 +1 @@
+export declare const containerImageNamespace: any;

package/dist/withJoi/admin/src/constants/links.d.ts

@@ -0,0 +1,5 @@
+export declare const GUIDE_LINKS: {
+    readonly TASK_RECONSTRUCTION: "https://spatialwalk.feishu.cn/wiki/QFfWwpXP0i3DnVkrjHoc5wUcn4g";
+    readonly TASK_MATERIAL_GENERATION: "#";
+};
+export type GuideLinkKey = keyof typeof GUIDE_LINKS;

package/dist/withJoi/admin/src/constants/nav.d.ts

@@ -0,0 +1,17 @@
+export declare const navMain: ({
+    title: string;
+    icon: string;
+    isActive: boolean;
+    items: {
+        title: string;
+        url: string;
+    }[];
+    url?: undefined;
+} | {
+    title: string;
+    url: string;
+    icon: string;
+    isActive?: undefined;
+    items?: undefined;
+})[];
+export declare const navMap: Record<string, any>;

package/dist/withJoi/admin/src/constants/providers.d.ts

@@ -0,0 +1,17 @@
+export declare const PROVIDER_TYPES: readonly [{
+    readonly label: "Driven";
+    readonly value: "PROVIDER_TYPE_DRIVEN_BASE";
+}, {
+    readonly label: "LLM";
+    readonly value: "PROVIDER_TYPE_LLM_BASE";
+}, {
+    readonly label: "ASR";
+    readonly value: "PROVIDER_TYPE_ASR_BASE";
+}, {
+    readonly label: "TTS";
+    readonly value: "PROVIDER_TYPE_TTS_BASE";
+}, {
+    readonly label: "VLM";
+    readonly value: "PROVIDER_TYPE_VLM_BASE";
+}];
+export declare const VALID_METADATA_KEYS: string[];

package/dist/withJoi/admin/src/constants/regions.d.ts

@@ -0,0 +1,10 @@
+export interface Region {
+    name: string;
+    logo: string;
+    plan: string;
+    apiBaseUrl: string;
+    recordWebUrl: string;
+    envKey: string;
+    prod: boolean;
+}
+export declare const regions: Region[];

package/dist/withJoi/admin/src/constants/test-ground-voices.d.ts

@@ -0,0 +1,19 @@
+export declare const TEST_GROUND_VOICE_OPTIONS: readonly [{
+    readonly value: "zh_male_wennuanahu_moon_bigtts";
+    readonly label: "zh_male_wennuanahu_moon_bigtts";
+}, {
+    readonly value: "zh_female_shuangkuaisisi_moon_bigtts";
+    readonly label: "zh_female_shuangkuaisisi_moon_bigtts";
+}, {
+    readonly value: "zh_male_qingse_moon_bigtts";
+    readonly label: "zh_male_qingse_moon_bigtts";
+}, {
+    readonly value: "zh_male_jingying_moon_bigtts";
+    readonly label: "zh_male_jingying_moon_bigtts";
+}, {
+    readonly value: "zh_female_shaonv_moon_bigtts";
+    readonly label: "zh_female_shaonv_moon_bigtts";
+}, {
+    readonly value: "zh_female_yujie_moon_bigtts";
+    readonly label: "zh_female_yujie_moon_bigtts";
+}];

package/dist/withJoi/admin/src/constants/ui.d.ts

@@ -0,0 +1,4 @@
+export declare const TOASTER_DURATION_KEY = "ui/toaster-duration";
+export declare const TOASTER_DEFAULT_DURATION = 3000;
+export declare const TOASTER_MIN_DURATION = 1000;
+export declare const TOASTER_MAX_DURATION = 60000;

package/dist/withJoi/admin/src/constants/voice.d.ts

@@ -0,0 +1,12 @@
+export declare const OPENAI_VOICES: {
+    id: string;
+    label: string;
+}[];
+export declare const MINIMAX_VOICES: {
+    id: string;
+    label: string;
+}[];
+export declare const ZHIPU_VOICES: {
+    id: string;
+    label: string;
+}[];

package/dist/withJoi/admin/src/constants/volc.d.ts

@@ -0,0 +1,135 @@
+import { AudioFormat, VoiceLanguage, VoiceStatus } from '../types/voice';
+
+export declare const VOICE_STATUS_OPTIONS: readonly [{
+    readonly value: VoiceStatus;
+    readonly label: "等待中";
+    readonly color: "gray";
+    readonly description: "等待开始训练";
+}, {
+    readonly value: VoiceStatus;
+    readonly label: "训练中";
+    readonly color: "blue";
+    readonly description: "正在进行声音训练";
+}, {
+    readonly value: VoiceStatus;
+    readonly label: "已完成";
+    readonly color: "green";
+    readonly description: "训练完成，可以使用";
+}, {
+    readonly value: VoiceStatus;
+    readonly label: "失败";
+    readonly color: "red";
+    readonly description: "训练失败";
+}];
+
+export declare const VOICE_LANGUAGE_OPTIONS: readonly [{
+    readonly value: VoiceLanguage;
+    readonly label: "中文（简体）";
+    readonly code: "zh-CN";
+}, {
+    readonly value: VoiceLanguage;
+    readonly label: "English (US)";
+    readonly code: "en-US";
+}, {
+    readonly value: VoiceLanguage;
+    readonly label: "日本語";
+    readonly code: "ja-JP";
+}];
+
+export declare const AUDIO_FORMAT_OPTIONS: readonly [{
+    readonly value: AudioFormat;
+    readonly label: "WAV";
+    readonly mimeType: "audio/wav";
+    readonly extension: ".wav";
+}, {
+    readonly value: AudioFormat;
+    readonly label: "MP3";
+    readonly mimeType: "audio/mpeg";
+    readonly extension: ".mp3";
+}, {
+    readonly value: AudioFormat;
+    readonly label: "FLAC";
+    readonly mimeType: "audio/flac";
+    readonly extension: ".flac";
+}, {
+    readonly value: AudioFormat;
+    readonly label: "M4A";
+    readonly mimeType: "audio/mp4";
+    readonly extension: ".m4a";
+}];
+
+export declare const AUDIO_FILE_CONSTRAINTS: {
+    readonly maxSize: number;
+    readonly minDuration: 5;
+    readonly maxDuration: 300;
+    readonly acceptedTypes: readonly ["audio/wav", "audio/mpeg", "audio/mp3", "audio/flac", "audio/mp4", "audio/m4a", "audio/x-m4a"];
+};
+
+export declare const TRAINING_TEXT_CONSTRAINTS: {
+    readonly minLength: 5;
+    readonly maxLength: 1000;
+    readonly recommendedLength: 200;
+};
+
+export declare function getVoiceStatusOption(status: VoiceStatus): {
+    readonly value: VoiceStatus;
+    readonly label: "等待中";
+    readonly color: "gray";
+    readonly description: "等待开始训练";
+} | {
+    readonly value: VoiceStatus;
+    readonly label: "训练中";
+    readonly color: "blue";
+    readonly description: "正在进行声音训练";
+} | {
+    readonly value: VoiceStatus;
+    readonly label: "已完成";
+    readonly color: "green";
+    readonly description: "训练完成，可以使用";
+} | {
+    readonly value: VoiceStatus;
+    readonly label: "失败";
+    readonly color: "red";
+    readonly description: "训练失败";
+} | undefined;
+
+export declare function getVoiceLanguageOption(language: VoiceLanguage): {
+    readonly value: VoiceLanguage;
+    readonly label: "中文（简体）";
+    readonly code: "zh-CN";
+} | {
+    readonly value: VoiceLanguage;
+    readonly label: "English (US)";
+    readonly code: "en-US";
+} | {
+    readonly value: VoiceLanguage;
+    readonly label: "日本語";
+    readonly code: "ja-JP";
+} | undefined;
+
+export declare function getAudioFormatOption(format: AudioFormat): {
+    readonly value: AudioFormat;
+    readonly label: "WAV";
+    readonly mimeType: "audio/wav";
+    readonly extension: ".wav";
+} | {
+    readonly value: AudioFormat;
+    readonly label: "MP3";
+    readonly mimeType: "audio/mpeg";
+    readonly extension: ".mp3";
+} | {
+    readonly value: AudioFormat;
+    readonly label: "FLAC";
+    readonly mimeType: "audio/flac";
+    readonly extension: ".flac";
+} | {
+    readonly value: AudioFormat;
+    readonly label: "M4A";
+    readonly mimeType: "audio/mp4";
+    readonly extension: ".m4a";
+} | undefined;
+
+export declare function validateAudioFile(file: File): {
+    isValid: boolean;
+    errorMessage?: string;
+};

package/dist/withJoi/admin/src/lib/cos/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const STS_DURATION_CONSTANTS: {
+
+    readonly MIN_DURATION_SECONDS: 900;
+    readonly MAX_DURATION_SECONDS: 7200;
+    readonly DEFAULT_DURATION_SECONDS: 1800;
+};

package/dist/withJoi/admin/src/lib/cos/useCosDownload.d.ts

@@ -0,0 +1,39 @@
+import { formatFileSize, formatRemainingTime, formatSpeed } from '../utils';
+
+export type DownloadStatus = 'idle' | 'downloading' | 'completed' | 'error';
+
+export interface DownloadProgress {
+    progress: number;
+    downloadedSize: number;
+    totalSize: number;
+    speed: number;
+    remainingTime: number;
+}
+
+export declare function useCosDownload(): {
+    status: Readonly<import('vue').Ref<DownloadStatus, DownloadStatus>>;
+    progress: Readonly<import('vue').Ref<{
+        readonly progress: number;
+        readonly downloadedSize: number;
+        readonly totalSize: number;
+        readonly speed: number;
+        readonly remainingTime: number;
+    }, {
+        readonly progress: number;
+        readonly downloadedSize: number;
+        readonly totalSize: number;
+        readonly speed: number;
+        readonly remainingTime: number;
+    }>>;
+    error: Readonly<import('vue').Ref<string | null, string | null>>;
+    isDownloading: import('vue').ComputedRef<boolean>;
+    isCompleted: import('vue').ComputedRef<boolean>;
+    hasError: import('vue').ComputedRef<boolean>;
+    downloadFileFromCOS: (key: string, filename?: string, onProgress?: (progress: DownloadProgress) => void) => Promise<Blob>;
+    downloadAndSaveFile: (key: string, filename?: string, _onProgress?: (progress: DownloadProgress) => void) => Promise<void>;
+    downloadFileDirectly: (key: string, filename?: string) => Promise<void>;
+    resetDownload: () => void;
+    formatFileSize: typeof formatFileSize;
+    formatSpeed: typeof formatSpeed;
+    formatRemainingTime: typeof formatRemainingTime;
+};

package/dist/withJoi/admin/src/lib/cos/useCosUpload.d.ts

@@ -0,0 +1,47 @@
+import { formatFileSize, formatRemainingTime, formatSpeed } from '../utils';
+
+export type UploadStatus = 'idle' | 'uploading' | 'paused' | 'completed' | 'error';
+
+export interface UploadProgress {
+    progress: number;
+    uploadedSize: number;
+    totalSize: number;
+    speed: number;
+    remainingTime: number;
+}
+
+export interface UploadResult {
+    key: string;
+    url: string;
+    etag: string;
+}
+
+export declare function useCosUpload(): {
+    status: Readonly<import('vue').Ref<UploadStatus, UploadStatus>>;
+    progress: Readonly<import('vue').Ref<{
+        readonly progress: number;
+        readonly uploadedSize: number;
+        readonly totalSize: number;
+        readonly speed: number;
+        readonly remainingTime: number;
+    }, {
+        readonly progress: number;
+        readonly uploadedSize: number;
+        readonly totalSize: number;
+        readonly speed: number;
+        readonly remainingTime: number;
+    }>>;
+    error: Readonly<import('vue').Ref<string | null, string | null>>;
+    isUploading: import('vue').ComputedRef<boolean>;
+    isPaused: import('vue').ComputedRef<boolean>;
+    isCompleted: import('vue').ComputedRef<boolean>;
+    hasError: import('vue').ComputedRef<boolean>;
+    uploadFile: (file: File, onProgress?: (progress: UploadProgress) => void) => Promise<UploadResult>;
+    uploadFileSimple: (file: File) => Promise<UploadResult>;
+    pauseUpload: () => void;
+    cancelUpload: () => void;
+    resetUpload: () => void;
+    formatFileSize: typeof formatFileSize;
+    formatSpeed: typeof formatSpeed;
+    formatRemainingTime: typeof formatRemainingTime;
+};

package/dist/withJoi/admin/src/lib/cos/useVideoInfoExtractor.d.ts

@@ -0,0 +1,12 @@
+export interface VideoInfo {
+    duration: number;
+    resolution: string;
+    fileSize: number;
+    thumbnailUrl?: string;
+}
+
+export declare function useVideoInfoExtractor(): {
+    getVideoInfo: (videoUrl: string, r2Key?: string) => Promise<VideoInfo>;
+    clearCache: () => void;
+    clearVideoCache: (videoUrl: string, r2Key?: string) => void;
+};

package/dist/withJoi/admin/src/lib/cos/utils.d.ts

@@ -0,0 +1,4 @@
+import { OSSCredentials } from '../../apis/useOssApi';
+import { default as COS } from 'cos-js-sdk-v5';
+
+export declare function initCOS(credentials: OSSCredentials): Promise<COS>;

package/dist/withJoi/admin/src/lib/utils.d.ts

@@ -0,0 +1,49 @@
+import { ClassValue } from 'clsx';
+export declare function cn(...inputs: ClassValue[]): string;
+
+export declare function formatFileSize(bytes: number): string;
+
+export declare function formatDuration(seconds: number): string;
+
+export declare function formatDate(dateString?: string): string;
+
+export declare function formatDateTime(dateString?: string): string;
+
+export declare function formatTimestamp(timestamp?: {
+    seconds: string | number;
+    nanos?: number;
+} | string): string;
+
+export declare function getTimestamp(timestamp?: {
+    seconds: string | number;
+    nanos?: number;
+} | string): number;
+
+export declare function formatSpeed(bytesPerSecond: number): string;
+
+export declare function formatRemainingTime(seconds: number): string;
+
+export declare function formatJsonData(data?: Record<string, unknown>): string;
+
+export declare function formatDateForInput(dateString?: string): string;
+
+export declare function removeFileExtension(filename: string): string;
+export declare function getVideoThumbnail(videoUrl: string): string;
+
+export declare function getCharCount(str: string): number;
+
+export declare function exceedsCharLimit(str: string, maxCount: number): boolean;
+
+export declare function filterUsersByName(users: Array<{
+    id: string;
+    username: string;
+}>, searchTerm: string): Array<{
+    id: string;
+    username: string;
+}>;
+
+export declare function isUUID(str: string): boolean;
+
+export declare function formatUUID(uuid?: string | null): string;
+
+export declare function buildCollectionTaskShareUrl(shareToken: string, recordWebUrl: string, regionKey: string): string;

package/dist/withJoi/admin/src/renderSystem/animation/utils/eventEmitter.d.ts

@@ -0,0 +1,9 @@
+type EventHandler = (...args: any[]) => void;
+export declare class EventEmitter {
+    private events;
+    on(event: string, handler: EventHandler): void;
+    off(event: string, handler: EventHandler): void;
+    emit(event: string, ...args: any[]): void;
+    removeAllListeners(event?: string): void;
+}
+export {};

package/dist/withJoi/admin/src/renderSystem/animation/utils/flameConverter.d.ts

@@ -0,0 +1,18 @@
+import { Flame } from '../../generated/driveningress/v1/driveningress';
+export interface FlameParams {
+    shape_params?: number[];
+    expr_params?: number[];
+    rotation?: number[];
+    translation?: number[];
+    neck_pose?: number[];
+    jaw_pose?: number[];
+    eyes_pose?: number[];
+    eyelid?: number[];
+    has_eyelid?: boolean;
+}
+
+export declare function convertProtoFlameToWasmParams(protoFlame: Flame): FlameParams;
+
+export declare function convertWasmParamsToProtoFlame(wasmParams: FlameParams): Flame;
+
+export declare function createNeutralFlameProto(): Flame;

package/dist/withJoi/admin/src/renderSystem/audio/AnimationPlayer.d.ts

@@ -0,0 +1,29 @@
+import { StreamingAudioPlayer } from './StreamingAudioPlayer';
+export declare class AnimationPlayer {
+    private audio;
+    private streamingPlayer;
+    private _isPlaying;
+    private fps;
+    private onEndedCallback?;
+    private static audioUnlocked;
+    private useStreaming;
+    static unlockAudioContext(): Promise<void>;
+    initialize(audioUrl: string, onEnded?: () => void): Promise<void>;
+    initializeStreaming(streamingPlayer: StreamingAudioPlayer, onEnded?: () => void): Promise<void>;
+    isStreamingReady(): boolean;
+    getStreamingPlayer(): StreamingAudioPlayer | null;
+    createAndInitializeStreamingPlayer(): Promise<void>;
+    prepareStreamingPlayer(onEnded?: () => void): Promise<void>;
+    private setupEventListeners;
+    play(): Promise<void>;
+    stop(): void;
+    isPlaying(): boolean;
+    getCurrentFrameIndex(): number;
+    getCurrentTime(): number;
+    addAudioChunk(audio: Uint8Array, isLast?: boolean): void;
+    pause(): void;
+    resume(): Promise<void>;
+    setVolume(volume: number): void;
+    getVolume(): number;
+    dispose(): void;
+}