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

package/dist/withJoi/src/components/ui/avatar/index.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from 'class-variance-authority';
+export { default as Avatar } from './Avatar.vue';
+export { default as AvatarFallback } from './AvatarFallback.vue';
+export { default as AvatarImage } from './AvatarImage.vue';
+export declare const avatarVariant: (props?: ({
+    size?: "base" | "sm" | "lg" | null | undefined;
+    shape?: "circle" | "square" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type AvatarVariants = VariantProps<typeof avatarVariant>;

package/dist/withJoi/src/components/ui/badge/index.d.ts

@@ -0,0 +1,6 @@
+import { VariantProps } from 'class-variance-authority';
+export { default as Badge } from './Badge.vue';
+export declare const badgeVariants: (props?: ({
+    variant?: "default" | "destructive" | "secondary" | "outline" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type BadgeVariants = VariantProps<typeof badgeVariants>;

package/dist/withJoi/src/components/ui/button/index.d.ts

@@ -0,0 +1,7 @@
+import { VariantProps } from 'class-variance-authority';
+export { default as Button } from './Button.vue';
+export declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "destructive" | "secondary" | "outline" | "ghost" | "gradient" | null | undefined;
+    size?: "default" | "icon" | "sm" | "lg" | "xs" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type ButtonVariants = VariantProps<typeof buttonVariants>;

package/dist/withJoi/src/components/ui/popover/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Popover } from './Popover.vue';
+export { default as PopoverContent } from './PopoverContent.vue';
+export { default as PopoverTrigger } from './PopoverTrigger.vue';
+export { PopoverAnchor } from 'reka-ui';

package/dist/withJoi/src/components/ui/select/index.d.ts

@@ -0,0 +1,11 @@
+export { default as Select } from './Select.vue';
+export { default as SelectContent } from './SelectContent.vue';
+export { default as SelectGroup } from './SelectGroup.vue';
+export { default as SelectItem } from './SelectItem.vue';
+export { default as SelectItemText } from './SelectItemText.vue';
+export { default as SelectLabel } from './SelectLabel.vue';
+export { default as SelectScrollDownButton } from './SelectScrollDownButton.vue';
+export { default as SelectScrollUpButton } from './SelectScrollUpButton.vue';
+export { default as SelectSeparator } from './SelectSeparator.vue';
+export { default as SelectTrigger } from './SelectTrigger.vue';
+export { default as SelectValue } from './SelectValue.vue';

package/dist/withJoi/src/composables/useCameraConfig.d.ts

@@ -0,0 +1,48 @@
+import { Ref } from 'vue';
+import { CameraConfig } from '../types/avatar';
+import { AvatarView } from '@spatialwalk/avatarkit';
+
+export declare const CAMERA_RANGE_OFFSETS: {
+    readonly translationX: 0.2;
+    readonly translationY: 0.2;
+    readonly translationZ: 0.5;
+};
+export interface CameraSnapshot {
+    camera: {
+        fovYRadians: number;
+        translationX: number;
+        translationY: number;
+        translationZ: number;
+    };
+}
+
+export declare function useCameraConfig(postprocess: Ref<{
+    camera: {
+        fovYRadians: number;
+        translationX: number;
+        translationY: number;
+        translationZ: number;
+    };
+}>, avatarView: Ref<AvatarView | null>, isInitialized: Ref<boolean>, initialSnapshot?: Ref<CameraSnapshot | null>): {
+    cameraRanges: import('vue').ComputedRef<{
+        fovYRadians: {
+            min: number;
+            max: number;
+        };
+        translationX: {
+            min: number;
+            max: number;
+        };
+        translationY: {
+            min: number;
+            max: number;
+        };
+        translationZ: {
+            min: number;
+            max: number;
+        };
+    }>;
+    setBaseCameraConfig: (config: CameraConfig) => void;
+    applyCameraConfig: () => void;
+    resetCameraConfig: () => void;
+};

package/dist/withJoi/src/composables/useDebugDataCollector.d.ts

@@ -0,0 +1,377 @@
+import { Flame } from '../../generated/realtime/v1/messages';
+export interface DebugData {
+    reqId: string;
+    audioChunks: Array<{
+        data: Uint8Array;
+        isLast: boolean;
+    }>;
+    flameKeyframes: Flame[];
+    startTime: number;
+    endTime?: number;
+}
+
+export declare function useDebugDataCollector(): {
+    currentRoundData: import('vue').Ref<{
+        reqId: string;
+        audioChunks: {
+            data: {
+                [x: number]: number;
+                readonly BYTES_PER_ELEMENT: number;
+                readonly buffer: {
+                    readonly byteLength: number;
+                    slice: (begin?: number, end?: number) => ArrayBuffer;
+                    readonly maxByteLength: number;
+                    readonly resizable: boolean;
+                    resize: (newByteLength?: number) => void;
+                    readonly detached: boolean;
+                    transfer: (newByteLength?: number) => ArrayBuffer;
+                    transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                    readonly [Symbol.toStringTag]: "ArrayBuffer";
+                } | {
+                    readonly byteLength: number;
+                    slice: (begin?: number, end?: number) => SharedArrayBuffer;
+                    readonly growable: boolean;
+                    readonly maxByteLength: number;
+                    grow: (newByteLength?: number) => void;
+                    readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                };
+                readonly byteLength: number;
+                readonly byteOffset: number;
+                copyWithin: (target: number, start: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                every: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+                fill: (value: number, start?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                filter: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => any, thisArg?: any) => Uint8Array<ArrayBuffer>;
+                find: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number | undefined;
+                findIndex: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number;
+                forEach: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => void, thisArg?: any) => void;
+                indexOf: (searchElement: number, fromIndex?: number) => number;
+                join: (separator?: string) => string;
+                lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                readonly length: number;
+                map: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => number, thisArg?: any) => Uint8Array<ArrayBuffer>;
+                reduce: {
+                    (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                    (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                    <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+                };
+                reduceRight: {
+                    (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                    (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                    <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+                };
+                reverse: () => Uint8Array<ArrayBufferLike>;
+                set: (array: ArrayLike<number>, offset?: number) => void;
+                slice: (start?: number, end?: number) => Uint8Array<ArrayBuffer>;
+                some: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+                sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBufferLike>;
+                subarray: (begin?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                toLocaleString: {
+                    (): string;
+                    (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                };
+                toString: () => string;
+                valueOf: () => Uint8Array<ArrayBufferLike>;
+                entries: () => ArrayIterator<[number, number]>;
+                keys: () => ArrayIterator<number>;
+                values: () => ArrayIterator<number>;
+                includes: (searchElement: number, fromIndex?: number) => boolean;
+                at: (index: number) => number | undefined;
+                findLast: {
+                    <S extends number>(predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => value is S, thisArg?: any): S | undefined;
+                    (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any): number | undefined;
+                };
+                findLastIndex: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => number;
+                toReversed: () => Uint8Array<ArrayBuffer>;
+                toSorted: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBuffer>;
+                with: (index: number, value: number) => Uint8Array<ArrayBuffer>;
+                [Symbol.iterator]: () => ArrayIterator<number>;
+                readonly [Symbol.toStringTag]: "Uint8Array";
+            };
+            isLast: boolean;
+        }[];
+        flameKeyframes: {
+            translation: number[];
+            rotation: number[];
+            neckPose: number[];
+            jawPose: number[];
+            eyePose: number[];
+            eyeLid: number[];
+            expression: number[];
+        }[];
+        startTime: number;
+        endTime?: number | undefined;
+    } | null, DebugData | {
+        reqId: string;
+        audioChunks: {
+            data: {
+                [x: number]: number;
+                readonly BYTES_PER_ELEMENT: number;
+                readonly buffer: {
+                    readonly byteLength: number;
+                    slice: (begin?: number, end?: number) => ArrayBuffer;
+                    readonly maxByteLength: number;
+                    readonly resizable: boolean;
+                    resize: (newByteLength?: number) => void;
+                    readonly detached: boolean;
+                    transfer: (newByteLength?: number) => ArrayBuffer;
+                    transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                    readonly [Symbol.toStringTag]: "ArrayBuffer";
+                } | {
+                    readonly byteLength: number;
+                    slice: (begin?: number, end?: number) => SharedArrayBuffer;
+                    readonly growable: boolean;
+                    readonly maxByteLength: number;
+                    grow: (newByteLength?: number) => void;
+                    readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                };
+                readonly byteLength: number;
+                readonly byteOffset: number;
+                copyWithin: (target: number, start: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                every: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+                fill: (value: number, start?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                filter: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => any, thisArg?: any) => Uint8Array<ArrayBuffer>;
+                find: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number | undefined;
+                findIndex: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number;
+                forEach: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => void, thisArg?: any) => void;
+                indexOf: (searchElement: number, fromIndex?: number) => number;
+                join: (separator?: string) => string;
+                lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                readonly length: number;
+                map: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => number, thisArg?: any) => Uint8Array<ArrayBuffer>;
+                reduce: {
+                    (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                    (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                    <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+                };
+                reduceRight: {
+                    (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                    (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                    <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+                };
+                reverse: () => Uint8Array<ArrayBufferLike>;
+                set: (array: ArrayLike<number>, offset?: number) => void;
+                slice: (start?: number, end?: number) => Uint8Array<ArrayBuffer>;
+                some: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+                sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBufferLike>;
+                subarray: (begin?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                toLocaleString: {
+                    (): string;
+                    (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                };
+                toString: () => string;
+                valueOf: () => Uint8Array<ArrayBufferLike>;
+                entries: () => ArrayIterator<[number, number]>;
+                keys: () => ArrayIterator<number>;
+                values: () => ArrayIterator<number>;
+                includes: (searchElement: number, fromIndex?: number) => boolean;
+                at: (index: number) => number | undefined;
+                findLast: {
+                    <S extends number>(predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => value is S, thisArg?: any): S | undefined;
+                    (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any): number | undefined;
+                };
+                findLastIndex: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => number;
+                toReversed: () => Uint8Array<ArrayBuffer>;
+                toSorted: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBuffer>;
+                with: (index: number, value: number) => Uint8Array<ArrayBuffer>;
+                [Symbol.iterator]: () => ArrayIterator<number>;
+                readonly [Symbol.toStringTag]: "Uint8Array";
+            };
+            isLast: boolean;
+        }[];
+        flameKeyframes: {
+            translation: number[];
+            rotation: number[];
+            neckPose: number[];
+            jawPose: number[];
+            eyePose: number[];
+            eyeLid: number[];
+            expression: number[];
+        }[];
+        startTime: number;
+        endTime?: number | undefined;
+    } | null>;
+    allRoundsData: import('vue').Ref<{
+        reqId: string;
+        audioChunks: {
+            data: {
+                [x: number]: number;
+                readonly BYTES_PER_ELEMENT: number;
+                readonly buffer: {
+                    readonly byteLength: number;
+                    slice: (begin?: number, end?: number) => ArrayBuffer;
+                    readonly maxByteLength: number;
+                    readonly resizable: boolean;
+                    resize: (newByteLength?: number) => void;
+                    readonly detached: boolean;
+                    transfer: (newByteLength?: number) => ArrayBuffer;
+                    transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                    readonly [Symbol.toStringTag]: "ArrayBuffer";
+                } | {
+                    readonly byteLength: number;
+                    slice: (begin?: number, end?: number) => SharedArrayBuffer;
+                    readonly growable: boolean;
+                    readonly maxByteLength: number;
+                    grow: (newByteLength?: number) => void;
+                    readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                };
+                readonly byteLength: number;
+                readonly byteOffset: number;
+                copyWithin: (target: number, start: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                every: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+                fill: (value: number, start?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                filter: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => any, thisArg?: any) => Uint8Array<ArrayBuffer>;
+                find: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number | undefined;
+                findIndex: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number;
+                forEach: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => void, thisArg?: any) => void;
+                indexOf: (searchElement: number, fromIndex?: number) => number;
+                join: (separator?: string) => string;
+                lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                readonly length: number;
+                map: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => number, thisArg?: any) => Uint8Array<ArrayBuffer>;
+                reduce: {
+                    (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                    (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                    <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+                };
+                reduceRight: {
+                    (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                    (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                    <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+                };
+                reverse: () => Uint8Array<ArrayBufferLike>;
+                set: (array: ArrayLike<number>, offset?: number) => void;
+                slice: (start?: number, end?: number) => Uint8Array<ArrayBuffer>;
+                some: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+                sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBufferLike>;
+                subarray: (begin?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                toLocaleString: {
+                    (): string;
+                    (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                };
+                toString: () => string;
+                valueOf: () => Uint8Array<ArrayBufferLike>;
+                entries: () => ArrayIterator<[number, number]>;
+                keys: () => ArrayIterator<number>;
+                values: () => ArrayIterator<number>;
+                includes: (searchElement: number, fromIndex?: number) => boolean;
+                at: (index: number) => number | undefined;
+                findLast: {
+                    <S extends number>(predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => value is S, thisArg?: any): S | undefined;
+                    (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any): number | undefined;
+                };
+                findLastIndex: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => number;
+                toReversed: () => Uint8Array<ArrayBuffer>;
+                toSorted: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBuffer>;
+                with: (index: number, value: number) => Uint8Array<ArrayBuffer>;
+                [Symbol.iterator]: () => ArrayIterator<number>;
+                readonly [Symbol.toStringTag]: "Uint8Array";
+            };
+            isLast: boolean;
+        }[];
+        flameKeyframes: {
+            translation: number[];
+            rotation: number[];
+            neckPose: number[];
+            jawPose: number[];
+            eyePose: number[];
+            eyeLid: number[];
+            expression: number[];
+        }[];
+        startTime: number;
+        endTime?: number | undefined;
+    }[], DebugData[] | {
+        reqId: string;
+        audioChunks: {
+            data: {
+                [x: number]: number;
+                readonly BYTES_PER_ELEMENT: number;
+                readonly buffer: {
+                    readonly byteLength: number;
+                    slice: (begin?: number, end?: number) => ArrayBuffer;
+                    readonly maxByteLength: number;
+                    readonly resizable: boolean;
+                    resize: (newByteLength?: number) => void;
+                    readonly detached: boolean;
+                    transfer: (newByteLength?: number) => ArrayBuffer;
+                    transferToFixedLength: (newByteLength?: number) => ArrayBuffer;
+                    readonly [Symbol.toStringTag]: "ArrayBuffer";
+                } | {
+                    readonly byteLength: number;
+                    slice: (begin?: number, end?: number) => SharedArrayBuffer;
+                    readonly growable: boolean;
+                    readonly maxByteLength: number;
+                    grow: (newByteLength?: number) => void;
+                    readonly [Symbol.toStringTag]: "SharedArrayBuffer";
+                };
+                readonly byteLength: number;
+                readonly byteOffset: number;
+                copyWithin: (target: number, start: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                every: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+                fill: (value: number, start?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                filter: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => any, thisArg?: any) => Uint8Array<ArrayBuffer>;
+                find: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number | undefined;
+                findIndex: (predicate: (value: number, index: number, obj: Uint8Array<ArrayBufferLike>) => boolean, thisArg?: any) => number;
+                forEach: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => void, thisArg?: any) => void;
+                indexOf: (searchElement: number, fromIndex?: number) => number;
+                join: (separator?: string) => string;
+                lastIndexOf: (searchElement: number, fromIndex?: number) => number;
+                readonly length: number;
+                map: (callbackfn: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => number, thisArg?: any) => Uint8Array<ArrayBuffer>;
+                reduce: {
+                    (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                    (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                    <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+                };
+                reduceRight: {
+                    (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number): number;
+                    (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => number, initialValue: number): number;
+                    <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: Uint8Array<ArrayBufferLike>) => U, initialValue: U): U;
+                };
+                reverse: () => Uint8Array<ArrayBufferLike>;
+                set: (array: ArrayLike<number>, offset?: number) => void;
+                slice: (start?: number, end?: number) => Uint8Array<ArrayBuffer>;
+                some: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => boolean;
+                sort: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBufferLike>;
+                subarray: (begin?: number, end?: number) => Uint8Array<ArrayBufferLike>;
+                toLocaleString: {
+                    (): string;
+                    (locales: string | string[], options?: Intl.NumberFormatOptions): string;
+                };
+                toString: () => string;
+                valueOf: () => Uint8Array<ArrayBufferLike>;
+                entries: () => ArrayIterator<[number, number]>;
+                keys: () => ArrayIterator<number>;
+                values: () => ArrayIterator<number>;
+                includes: (searchElement: number, fromIndex?: number) => boolean;
+                at: (index: number) => number | undefined;
+                findLast: {
+                    <S extends number>(predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => value is S, thisArg?: any): S | undefined;
+                    (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any): number | undefined;
+                };
+                findLastIndex: (predicate: (value: number, index: number, array: Uint8Array<ArrayBufferLike>) => unknown, thisArg?: any) => number;
+                toReversed: () => Uint8Array<ArrayBuffer>;
+                toSorted: (compareFn?: ((a: number, b: number) => number) | undefined) => Uint8Array<ArrayBuffer>;
+                with: (index: number, value: number) => Uint8Array<ArrayBuffer>;
+                [Symbol.iterator]: () => ArrayIterator<number>;
+                readonly [Symbol.toStringTag]: "Uint8Array";
+            };
+            isLast: boolean;
+        }[];
+        flameKeyframes: {
+            translation: number[];
+            rotation: number[];
+            neckPose: number[];
+            jawPose: number[];
+            eyePose: number[];
+            eyeLid: number[];
+            expression: number[];
+        }[];
+        startTime: number;
+        endTime?: number | undefined;
+    }[]>;
+    startNewRound: (reqId: string) => void;
+    addAudioChunk: (audio: Uint8Array, isLast?: boolean) => void;
+    addFlameKeyframes: (keyframes: Flame[]) => void;
+    endCurrentRound: () => void;
+    reset: () => void;
+};

package/dist/withJoi/src/composables/usePreviewWebSocketManager.d.ts

@@ -0,0 +1,25 @@
+import { Ref } from 'vue';
+import { PostprocessConfig } from '../utils/postprocess-transform';
+import { AvatarController } from '@spatialwalk/avatarkit';
+
+export declare function usePreviewWebSocketManager(options: {
+
+    getCharacterId: () => string | Promise<string | undefined>;
+    getSpeaker: () => string | undefined;
+    getDrivenServerUrl?: () => string | undefined;
+    loadingAvatar?: Ref<boolean>;
+    avatarController?: Ref<AvatarController | null>;
+    postprocessConfig?: Ref<PostprocessConfig>;
+}): {
+    previewTextInput: Ref<string, string>;
+    isPreviewPlaying: Ref<boolean, boolean>;
+    isPreviewPaused: Ref<boolean, boolean>;
+    previewWsConnected: Ref<boolean, boolean>;
+    previewWsConnecting: Ref<boolean, boolean>;
+    isSending: import('vue').ComputedRef<boolean>;
+    connect: () => Promise<void>;
+    reconnect: () => Promise<void>;
+    handleSendText: (textToSend?: string) => Promise<void>;
+    handlePause: () => void;
+    handleInterrupt: () => Promise<void>;
+};