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

package/dist/playground/apps/web/src/config/region-config.d.ts

@@ -0,0 +1,13 @@
+export type Region = 'us' | 'cn' | 'test';
+export type I18nLocale = 'en' | 'zhCN';
+export interface RegionConfig {
+    name: string;
+    label: string;
+    sdkApiBaseUrl: string;
+    realtimeApiBaseUrl: string;
+    realtimeWsUrl: string;
+}
+export declare const REGION_LIST: Region[];
+export declare const REGION_CONFIGS: Partial<Record<Region, RegionConfig>>;
+export declare function getEnvironmentI18nKey(env: Region): string;
+export declare const REGION_KEYS: Region[];

package/dist/playground/apps/web/src/constants.d.ts

@@ -0,0 +1,14 @@
+import { Region } from './config/region-config';
+export declare const POSTHOG_HOST = "https://i.spatialwalk.ai";
+export declare const POSTHOG_API_KEY: any;
+export declare const POSTHOG_TRACK_EVENTS: boolean;
+export declare const POSTHOG_PROJECT_NAME: string;
+export declare const ENV_TEST: string | boolean;
+
+export declare function getRegionFromHostname(): Region;
+type WebListName = 'playground' | undefined;
+
+export declare function getWebListName(): WebListName;
+
+export declare function isDebugMode(): boolean;
+export {};

package/dist/playground/apps/web/src/libs/vad/manager.d.ts

@@ -0,0 +1,37 @@
+import { SimpleVAD } from './simpleVad';
+import { VAD, VADConfig } from './vad';
+export interface VADAudioOptions {
+    audioContextOptions?: AudioContextOptions;
+    minChunkSize?: number;
+    vadConfig?: Partial<VADConfig>;
+}
+
+export declare class VADAudioManager {
+    private audioContext;
+    private audioWorkletNode;
+    private mediaStream;
+    private sourceNode;
+    private highPassFilter;
+    private vad;
+    private workletInitialized;
+    private audioContextOptions;
+    private workletUrl;
+    constructor(vad: VAD | SimpleVAD, options?: VADAudioOptions);
+    private ensureAudioContext;
+    initialize(workletUrl: string): Promise<void>;
+    private initializeWorklet;
+    startMicrophone(requestVideo?: boolean): Promise<MediaStream | null>;
+    stopMicrophone(): Promise<void>;
+    pauseMicrophone(): Promise<void>;
+    resumeMicrophone(): Promise<void>;
+    stop(): void;
+    updateNoiseGateConfig(config: {
+        openThresholdDb?: number;
+        closeThresholdDb?: number;
+        attackMs?: number;
+        releaseMs?: number;
+        holdMs?: number;
+        highPassHz?: number;
+    }): void;
+    dispose(): void;
+}

package/dist/playground/apps/web/src/libs/vad/process.worklet.d.ts

@@ -0,0 +1,22 @@
+declare const MIN_CHUNK_SIZE = 512;
+
+declare let globalPointer: number;
+declare const globalBuffer: Float32Array<ArrayBuffer>;
+
+interface NoiseGateConfig {
+    enabled: boolean;
+    openThresholdDb: number;
+    closeThresholdDb: number;
+    attackMs: number;
+    releaseMs: number;
+    holdMs: number;
+}
+declare let noiseGateConfig: NoiseGateConfig;
+declare let gateEnvelope: number;
+declare let gateOpen: boolean;
+declare let holdCounter: number;
+
+declare class VADProcessor extends AudioWorkletProcessor {
+    constructor();
+    process(inputs: Float32Array[][], _outputs: Float32Array[][], _parameters: Record<string, Float32Array>): boolean;
+}

package/dist/playground/apps/web/src/libs/vad/simpleVad.d.ts

@@ -0,0 +1,35 @@
+import { VADEvents } from './vad';
+export interface SimpleVADConfig {
+    sampleRate: number;
+    speechThreshold: number;
+    exitThreshold: number;
+    minSilenceDurationMs: number;
+    speechPadMs: number;
+    minSpeechDurationMs: number;
+    maxBufferDuration: number;
+    newBufferSize: number;
+}
+
+export declare class SimpleVAD {
+    private config;
+    private buffer;
+    private bufferPointer;
+    private isRecording;
+    private prevBuffers;
+    private eventListeners;
+    private silenceStartTime;
+    private speechStartTime;
+    private isReady;
+    constructor(userConfig?: Partial<SimpleVADConfig>);
+    initialize(): Promise<void>;
+    private calculateRMS;
+    processAudio(buffer: Float32Array): Promise<void>;
+    private processSpeechSegment;
+    private reset;
+    on<K extends keyof VADEvents>(event: K, callback: (event: VADEvents[K]) => void): void;
+    off<K extends keyof VADEvents>(event: K, callback: (event: VADEvents[K]) => void): void;
+    emit<K extends keyof VADEvents>(event: K, data: VADEvents[K]): void;
+    updateConfig(newConfig: Partial<SimpleVADConfig>): void;
+}
+
+export declare function createSimpleVAD(config?: Partial<SimpleVADConfig>): Promise<SimpleVAD>;

package/dist/playground/apps/web/src/libs/vad/vad.d.ts

@@ -0,0 +1,56 @@
+export interface VADConfig {
+    sampleRate: number;
+    speechThreshold: number;
+    exitThreshold: number;
+    minSilenceDurationMs: number;
+    speechPadMs: number;
+    minSpeechDurationMs: number;
+    maxBufferDuration: number;
+    newBufferSize: number;
+    modelBaseUrl?: string;
+    modelName?: string;
+}
+export interface VADEvents {
+    'speech-start': void;
+    'speech-end': void;
+    'speech-ready': {
+        buffer: Float32Array;
+        duration: number;
+    };
+    'status': {
+        type: string;
+        message: string;
+    };
+    'debug': {
+        message: string;
+        data?: unknown;
+    };
+}
+export type VADEventCallback<K extends keyof VADEvents> = (event: VADEvents[K]) => void;
+
+export declare class VAD {
+    private config;
+    private model;
+    private state;
+    private sampleRateTensor;
+    private buffer;
+    private bufferPointer;
+    private isRecording;
+    private postSpeechSamples;
+    private prevBuffers;
+    private inferenceChain;
+    private eventListeners;
+    private isReady;
+    constructor(userConfig?: Partial<VADConfig>);
+    initialize(): Promise<void>;
+    on<K extends keyof VADEvents>(event: K, callback: VADEventCallback<K>): void;
+    off<K extends keyof VADEvents>(event: K, callback: VADEventCallback<K>): void;
+    emit<K extends keyof VADEvents>(event: K, data: VADEvents[K]): void;
+    processAudio(inputBuffer: Float32Array): Promise<void>;
+    private detectSpeech;
+    private processSpeechSegment;
+    private reset;
+    updateConfig(newConfig: Partial<VADConfig>): void;
+}
+
+export declare function createVAD(config?: Partial<VADConfig>): Promise<VAD>;

package/dist/playground/apps/web/src/libs/vad/wav.d.ts

@@ -0,0 +1 @@
+export declare function toWav(buffer: Float32Array, sampleRate: number): ArrayBuffer;

package/dist/playground/apps/web/src/locales/index.d.ts

@@ -0,0 +1,2 @@
+export { default as en } from './en.json';
+export { default as zhCN } from './zh-CN.json';

package/dist/playground/apps/web/src/modules/i18n.d.ts

@@ -0,0 +1,3 @@
+import { I18n } from 'vue-i18n';
+export declare const i18n: I18n;
+export declare function getGlobalT(): (key: string, params?: Record<string, unknown>) => string;

package/dist/playground/apps/web/src/modules/pwa.d.ts

@@ -0,0 +1 @@
+export { registerSW } from 'virtual:pwa-register';

package/dist/playground/apps/web/src/realtime/RealtimeWebSocketClient.d.ts

@@ -0,0 +1,18 @@
+export interface RealtimeWebSocketOptions {
+    wsUrl: string;
+    heartbeatInterval?: number;
+    debug?: boolean;
+    jwtToken?: string;
+}
+export declare function useRealtimeWebsocket(options: RealtimeWebSocketOptions): {
+    isConnected: import('vue').ComputedRef<boolean>;
+    connect: (characterId: string) => Promise<void>;
+    disconnect: () => void;
+    sendSessionStart: (reqId: string, characterId: string) => void;
+    sendAudio: (reqId: string, audio: Uint8Array) => void;
+    sendTextInput: (reqId: string, text: string) => void;
+    sendSpeechStart: (reqId: string) => void;
+    generateReqId: () => string;
+    on: (event: string, handler: (...args: any[]) => void) => void;
+    off: (event: string, handler: (...args: any[]) => void) => void;
+};

package/dist/playground/apps/web/src/realtime/index.d.ts

@@ -0,0 +1 @@
+export { useRealtimeWebsocket } from './RealtimeWebSocketClient';

package/dist/playground/apps/web/src/realtime/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: unknown[]): void;
+    removeAllListeners(event?: string): void;
+}
+export {};

package/dist/playground/apps/web/src/stores/call.d.ts

@@ -0,0 +1,173 @@
+import { SubtitleState } from '../composables/useSubtitle';
+export interface CallMessage {
+    role: 'user' | 'assistant';
+    text: string;
+    timestamp: number;
+}
+export type CallStatus = 'idle' | 'connecting' | 'connected' | 'disconnected';
+export declare const useCallStore: import('pinia').StoreDefinition<"call", Pick<{
+    currentIdleFrameIndex: import('vue').Ref<number, number>;
+    setCurrentIdleFrameIndex: (index: number) => void;
+    callStatus: import('vue').Ref<CallStatus, CallStatus>;
+    isConnecting: import('vue').ComputedRef<boolean>;
+    isConnected: import('vue').ComputedRef<boolean>;
+    startCall: () => void;
+    connectCall: () => void;
+    endCall: () => void;
+    isMuted: import('vue').Ref<boolean, boolean>;
+    isPlaying: import('vue').Ref<boolean, boolean>;
+    playbackProgress: import('vue').Ref<number, number>;
+    toggleMute: () => void;
+    vadActive: import('vue').Ref<boolean, boolean>;
+    isSpeaking: import('vue').Ref<boolean, boolean>;
+    vadInitializing: import('vue').Ref<boolean, boolean>;
+    messages: import('vue').Ref<{
+        role: "user" | "assistant";
+        text: string;
+        timestamp: number;
+    }[], CallMessage[] | {
+        role: "user" | "assistant";
+        text: string;
+        timestamp: number;
+    }[]>;
+    subtitle: import('vue').Ref<{
+        source: import('../composables/useSubtitle').SubtitleSource;
+        text: string;
+        isStreaming: boolean;
+    }, SubtitleState | {
+        source: import('../composables/useSubtitle').SubtitleSource;
+        text: string;
+        isStreaming: boolean;
+    }>;
+    currentReqId: import('vue').Ref<string | null, string | null>;
+    addMessage: (role: "user" | "assistant", text: string) => void;
+    clearMessages: () => void;
+    callDuration: import('vue').Ref<number, number>;
+    formatCallDuration: () => string;
+    stats: import('vue').Ref<{
+        fps: number;
+        wasmTime: number;
+        renderTime: number;
+        sortTime: number;
+    }, {
+        fps: number;
+        wasmTime: number;
+        renderTime: number;
+        sortTime: number;
+    } | {
+        fps: number;
+        wasmTime: number;
+        renderTime: number;
+        sortTime: number;
+    }>;
+}, "messages" | "currentIdleFrameIndex" | "callStatus" | "isMuted" | "isPlaying" | "playbackProgress" | "vadActive" | "isSpeaking" | "vadInitializing" | "subtitle" | "currentReqId" | "callDuration" | "stats">, Pick<{
+    currentIdleFrameIndex: import('vue').Ref<number, number>;
+    setCurrentIdleFrameIndex: (index: number) => void;
+    callStatus: import('vue').Ref<CallStatus, CallStatus>;
+    isConnecting: import('vue').ComputedRef<boolean>;
+    isConnected: import('vue').ComputedRef<boolean>;
+    startCall: () => void;
+    connectCall: () => void;
+    endCall: () => void;
+    isMuted: import('vue').Ref<boolean, boolean>;
+    isPlaying: import('vue').Ref<boolean, boolean>;
+    playbackProgress: import('vue').Ref<number, number>;
+    toggleMute: () => void;
+    vadActive: import('vue').Ref<boolean, boolean>;
+    isSpeaking: import('vue').Ref<boolean, boolean>;
+    vadInitializing: import('vue').Ref<boolean, boolean>;
+    messages: import('vue').Ref<{
+        role: "user" | "assistant";
+        text: string;
+        timestamp: number;
+    }[], CallMessage[] | {
+        role: "user" | "assistant";
+        text: string;
+        timestamp: number;
+    }[]>;
+    subtitle: import('vue').Ref<{
+        source: import('../composables/useSubtitle').SubtitleSource;
+        text: string;
+        isStreaming: boolean;
+    }, SubtitleState | {
+        source: import('../composables/useSubtitle').SubtitleSource;
+        text: string;
+        isStreaming: boolean;
+    }>;
+    currentReqId: import('vue').Ref<string | null, string | null>;
+    addMessage: (role: "user" | "assistant", text: string) => void;
+    clearMessages: () => void;
+    callDuration: import('vue').Ref<number, number>;
+    formatCallDuration: () => string;
+    stats: import('vue').Ref<{
+        fps: number;
+        wasmTime: number;
+        renderTime: number;
+        sortTime: number;
+    }, {
+        fps: number;
+        wasmTime: number;
+        renderTime: number;
+        sortTime: number;
+    } | {
+        fps: number;
+        wasmTime: number;
+        renderTime: number;
+        sortTime: number;
+    }>;
+}, "isConnected" | "isConnecting">, Pick<{
+    currentIdleFrameIndex: import('vue').Ref<number, number>;
+    setCurrentIdleFrameIndex: (index: number) => void;
+    callStatus: import('vue').Ref<CallStatus, CallStatus>;
+    isConnecting: import('vue').ComputedRef<boolean>;
+    isConnected: import('vue').ComputedRef<boolean>;
+    startCall: () => void;
+    connectCall: () => void;
+    endCall: () => void;
+    isMuted: import('vue').Ref<boolean, boolean>;
+    isPlaying: import('vue').Ref<boolean, boolean>;
+    playbackProgress: import('vue').Ref<number, number>;
+    toggleMute: () => void;
+    vadActive: import('vue').Ref<boolean, boolean>;
+    isSpeaking: import('vue').Ref<boolean, boolean>;
+    vadInitializing: import('vue').Ref<boolean, boolean>;
+    messages: import('vue').Ref<{
+        role: "user" | "assistant";
+        text: string;
+        timestamp: number;
+    }[], CallMessage[] | {
+        role: "user" | "assistant";
+        text: string;
+        timestamp: number;
+    }[]>;
+    subtitle: import('vue').Ref<{
+        source: import('../composables/useSubtitle').SubtitleSource;
+        text: string;
+        isStreaming: boolean;
+    }, SubtitleState | {
+        source: import('../composables/useSubtitle').SubtitleSource;
+        text: string;
+        isStreaming: boolean;
+    }>;
+    currentReqId: import('vue').Ref<string | null, string | null>;
+    addMessage: (role: "user" | "assistant", text: string) => void;
+    clearMessages: () => void;
+    callDuration: import('vue').Ref<number, number>;
+    formatCallDuration: () => string;
+    stats: import('vue').Ref<{
+        fps: number;
+        wasmTime: number;
+        renderTime: number;
+        sortTime: number;
+    }, {
+        fps: number;
+        wasmTime: number;
+        renderTime: number;
+        sortTime: number;
+    } | {
+        fps: number;
+        wasmTime: number;
+        renderTime: number;
+        sortTime: number;
+    }>;
+}, "setCurrentIdleFrameIndex" | "startCall" | "connectCall" | "endCall" | "toggleMute" | "addMessage" | "clearMessages" | "formatCallDuration">>;

package/dist/playground/apps/web/src/stores/character.d.ts

@@ -0,0 +1,188 @@
+import { RealtimeCharacter } from '../../../../generated/realtime/v2/realtime';
+export declare const useCharacterStore: import('pinia').StoreDefinition<"character", Pick<{
+    characters: import('vue').Ref<Map<string, {
+        id: string;
+        scene: string[];
+        name: string;
+        description: string;
+        status: string;
+        modelInfo: string;
+        coverUrl: string;
+        updatedAt?: {
+            seconds: string;
+            nanos: number;
+        } | undefined;
+    }> & Omit<Map<string, RealtimeCharacter>, keyof Map<any, any>>, Map<string, RealtimeCharacter> | (Map<string, {
+        id: string;
+        scene: string[];
+        name: string;
+        description: string;
+        status: string;
+        modelInfo: string;
+        coverUrl: string;
+        updatedAt?: {
+            seconds: string;
+            nanos: number;
+        } | undefined;
+    }> & Omit<Map<string, RealtimeCharacter>, keyof Map<any, any>>)>;
+    cacheCharacters: (characterList: RealtimeCharacter[]) => void;
+    cacheCharacter: (character: RealtimeCharacter) => void;
+    getCharacter: (characterId: string) => RealtimeCharacter | undefined;
+    clearCache: () => void;
+    characterList: import('vue').Ref<{
+        id: string;
+        scene: string[];
+        name: string;
+        description: string;
+        status: string;
+        modelInfo: string;
+        coverUrl: string;
+        updatedAt?: {
+            seconds: string;
+            nanos: number;
+        } | undefined;
+    }[], RealtimeCharacter[] | {
+        id: string;
+        scene: string[];
+        name: string;
+        description: string;
+        status: string;
+        modelInfo: string;
+        coverUrl: string;
+        updatedAt?: {
+            seconds: string;
+            nanos: number;
+        } | undefined;
+    }[]>;
+    loading: import('vue').Ref<boolean, boolean>;
+    error: import('vue').Ref<string | null, string | null>;
+    nextPageToken: import('vue').Ref<string, string>;
+    hasMore: import('vue').Ref<boolean, boolean>;
+    loadCharacters: (pageToken?: string) => Promise<void>;
+    loadMore: () => Promise<void>;
+    clearList: () => void;
+}, "error" | "nextPageToken" | "characters" | "loading" | "characterList" | "hasMore">, Pick<{
+    characters: import('vue').Ref<Map<string, {
+        id: string;
+        scene: string[];
+        name: string;
+        description: string;
+        status: string;
+        modelInfo: string;
+        coverUrl: string;
+        updatedAt?: {
+            seconds: string;
+            nanos: number;
+        } | undefined;
+    }> & Omit<Map<string, RealtimeCharacter>, keyof Map<any, any>>, Map<string, RealtimeCharacter> | (Map<string, {
+        id: string;
+        scene: string[];
+        name: string;
+        description: string;
+        status: string;
+        modelInfo: string;
+        coverUrl: string;
+        updatedAt?: {
+            seconds: string;
+            nanos: number;
+        } | undefined;
+    }> & Omit<Map<string, RealtimeCharacter>, keyof Map<any, any>>)>;
+    cacheCharacters: (characterList: RealtimeCharacter[]) => void;
+    cacheCharacter: (character: RealtimeCharacter) => void;
+    getCharacter: (characterId: string) => RealtimeCharacter | undefined;
+    clearCache: () => void;
+    characterList: import('vue').Ref<{
+        id: string;
+        scene: string[];
+        name: string;
+        description: string;
+        status: string;
+        modelInfo: string;
+        coverUrl: string;
+        updatedAt?: {
+            seconds: string;
+            nanos: number;
+        } | undefined;
+    }[], RealtimeCharacter[] | {
+        id: string;
+        scene: string[];
+        name: string;
+        description: string;
+        status: string;
+        modelInfo: string;
+        coverUrl: string;
+        updatedAt?: {
+            seconds: string;
+            nanos: number;
+        } | undefined;
+    }[]>;
+    loading: import('vue').Ref<boolean, boolean>;
+    error: import('vue').Ref<string | null, string | null>;
+    nextPageToken: import('vue').Ref<string, string>;
+    hasMore: import('vue').Ref<boolean, boolean>;
+    loadCharacters: (pageToken?: string) => Promise<void>;
+    loadMore: () => Promise<void>;
+    clearList: () => void;
+}, never>, Pick<{
+    characters: import('vue').Ref<Map<string, {
+        id: string;
+        scene: string[];
+        name: string;
+        description: string;
+        status: string;
+        modelInfo: string;
+        coverUrl: string;
+        updatedAt?: {
+            seconds: string;
+            nanos: number;
+        } | undefined;
+    }> & Omit<Map<string, RealtimeCharacter>, keyof Map<any, any>>, Map<string, RealtimeCharacter> | (Map<string, {
+        id: string;
+        scene: string[];
+        name: string;
+        description: string;
+        status: string;
+        modelInfo: string;
+        coverUrl: string;
+        updatedAt?: {
+            seconds: string;
+            nanos: number;
+        } | undefined;
+    }> & Omit<Map<string, RealtimeCharacter>, keyof Map<any, any>>)>;
+    cacheCharacters: (characterList: RealtimeCharacter[]) => void;
+    cacheCharacter: (character: RealtimeCharacter) => void;
+    getCharacter: (characterId: string) => RealtimeCharacter | undefined;
+    clearCache: () => void;
+    characterList: import('vue').Ref<{
+        id: string;
+        scene: string[];
+        name: string;
+        description: string;
+        status: string;
+        modelInfo: string;
+        coverUrl: string;
+        updatedAt?: {
+            seconds: string;
+            nanos: number;
+        } | undefined;
+    }[], RealtimeCharacter[] | {
+        id: string;
+        scene: string[];
+        name: string;
+        description: string;
+        status: string;
+        modelInfo: string;
+        coverUrl: string;
+        updatedAt?: {
+            seconds: string;
+            nanos: number;
+        } | undefined;
+    }[]>;
+    loading: import('vue').Ref<boolean, boolean>;
+    error: import('vue').Ref<string | null, string | null>;
+    nextPageToken: import('vue').Ref<string, string>;
+    hasMore: import('vue').Ref<boolean, boolean>;
+    loadCharacters: (pageToken?: string) => Promise<void>;
+    loadMore: () => Promise<void>;
+    clearList: () => void;
+}, "cacheCharacters" | "cacheCharacter" | "getCharacter" | "clearCache" | "loadCharacters" | "loadMore" | "clearList">>;

package/dist/playground/apps/web/src/stores/pwa.d.ts

@@ -0,0 +1,7 @@
+export declare const usePWAStore: import('pinia').StoreDefinition<"pwa", Pick<{
+    init: () => Promise<void>;
+}, never>, Pick<{
+    init: () => Promise<void>;
+}, never>, Pick<{
+    init: () => Promise<void>;
+}, "init">>;

package/dist/playground/apps/web/src/stores/region.d.ts

@@ -0,0 +1,14 @@
+import { Region, RegionConfig } from '../config/region-config';
+export declare const useRegionStore: import('pinia').StoreDefinition<"region", Pick<{
+    currentRegion: import('vue').Ref<Region, Region>;
+    currentConfig: import('vue').ComputedRef<RegionConfig>;
+    initializeRegion: () => void;
+}, "currentRegion">, Pick<{
+    currentRegion: import('vue').Ref<Region, Region>;
+    currentConfig: import('vue').ComputedRef<RegionConfig>;
+    initializeRegion: () => void;
+}, "currentConfig">, Pick<{
+    currentRegion: import('vue').Ref<Region, Region>;
+    currentConfig: import('vue').ComputedRef<RegionConfig>;
+    initializeRegion: () => void;
+}, "initializeRegion">>;

package/dist/playground/apps/web/src/stores/user.d.ts

@@ -0,0 +1,22 @@
+export declare const useUserStore: import('pinia').StoreDefinition<"user", Pick<{
+    userName: import('@vueuse/core').RemovableRef<string>;
+    jwtToken: import('@vueuse/core').RemovableRef<string>;
+    isAuthenticated: import('vue').ComputedRef<boolean>;
+    ensureAuthenticated: () => Promise<void>;
+    setToken: (token: string) => void;
+    clearToken: () => void;
+}, "userName" | "jwtToken">, Pick<{
+    userName: import('@vueuse/core').RemovableRef<string>;
+    jwtToken: import('@vueuse/core').RemovableRef<string>;
+    isAuthenticated: import('vue').ComputedRef<boolean>;
+    ensureAuthenticated: () => Promise<void>;
+    setToken: (token: string) => void;
+    clearToken: () => void;
+}, "isAuthenticated">, Pick<{
+    userName: import('@vueuse/core').RemovableRef<string>;
+    jwtToken: import('@vueuse/core').RemovableRef<string>;
+    isAuthenticated: import('vue').ComputedRef<boolean>;
+    ensureAuthenticated: () => Promise<void>;
+    setToken: (token: string) => void;
+    clearToken: () => void;
+}, "ensureAuthenticated" | "setToken" | "clearToken">>;