@lilaquadrat/chat 0.1.12 → 0.1.14

package/dist/types/src/helpers/participants.d.ts

@@ -15,11 +15,36 @@ export interface ParticipantUser {
     lastSeen?: string;
     /** presence: derived server-side from lastSeen freshness, pushed live via user:presence */
     online?: boolean;
+    /**
+     * the participant's role in the conversation. `'agent'` for a member of the support team.
+     *
+     * `null`, not absent, for everyone else: the backend collapses two different absences with an
+     * `$ifNull` (no participant doc at all vs. a doc carrying no role) so that both the REST row
+     * and the `conversation:new` frame carry the key on every participant. Never test for
+     * `undefined` or `'role' in participant` — that would hold on one path and not the other.
+     * Optional here only because a local draft's participants are built client-side.
+     */
+    role?: 'agent' | null;
 }
 export type Participant = string | ParticipantUser;
 /** the user id of a participant, whether it's a bare id or an object */
 export declare function participantId(participant: Participant): string;
 /** map a participant list to its ids (e.g. before sending to the backend) */
 export declare function participantIds(participants?: Participant[]): string[];
+/**
+ * the person being helped in a support conversation: the participant NOT marked
+ * `role: 'agent'`. There is no separate customer entity — a support conversation is a
+ * conversation whose participants carry roles, and this reads the counterpart back out.
+ *
+ * Matched by inequality against `'agent'`, deliberately: the counterpart's role arrives as
+ * `null` from the server and is absent on a client-built draft, so anything testing for
+ * `undefined` specifically would hold on one path and not the other.
+ *
+ * undefined when nothing in the list distinguishes anyone. That is the legacy case
+ * (conversations from before roles were stamped mark nobody): with no agent marked, every
+ * participant looks alike, and guessing would name an agent as the person being helped.
+ * Callers show an unknown counterpart instead.
+ */
+export declare function customerParticipant(participants?: Participant[]): ParticipantUser | undefined;
 /** human-readable name: "lastname, prename", else host name, else the raw id */
 export declare function participantName(participant: Participant): string;

package/dist/types/src/helpers/supportStatus.d.ts

@@ -0,0 +1,15 @@
+import type { ConversationSla } from '@/interfaces/ConversationSla';
+export declare const SUPPORT_STATUSES: readonly ["awaiting_agent", "awaiting_customer", "resolved"];
+export type SupportStatus = typeof SUPPORT_STATUSES[number];
+export type SupportStatusFilter = SupportStatus | 'all';
+export interface SupportStatusResponse {
+    conversation: string;
+    status: SupportStatus;
+    updatedAt: string;
+    version: number;
+    sla: ConversationSla | null;
+    serverTime: string;
+}
+export declare const DEFAULT_SUPPORT_STATUS: SupportStatus;
+export declare function isSupportStatus(value: unknown): value is SupportStatus;
+export declare function normalizeSupportStatus(value: unknown): SupportStatus;

package/dist/types/src/interfaces/Conversation.d.ts

@@ -0,0 +1,44 @@
+import type { Participant } from '@/helpers/participants';
+import type { SupportStatus } from '@/helpers/supportStatus';
+import type { Message } from '@/interfaces/Message';
+import type { ParticipantDocument } from '@/interfaces/ParticipantDocument';
+import type { ConversationSla } from '@/interfaces/ConversationSla';
+export type ConversationOperationMode = 'chat' | 'support';
+export interface Conversation {
+    _id?: string;
+    id?: string;
+    name?: string;
+    participants: Participant[];
+    blocked?: string[];
+    messagesCount?: number;
+    messagesCountSystem?: number;
+    createdAt?: string;
+    lastActivity?: string;
+    operationMode: ConversationOperationMode;
+    supportStatus?: SupportStatus;
+    supportStatusUpdatedAt?: string;
+    supportStatusVersion?: number;
+    sla?: ConversationSla | null;
+    participant?: ParticipantDocument;
+    participantDocs?: ParticipantDocument[];
+    lastMessage?: Message;
+    oldestMessageId?: number | null;
+    messages?: Message[];
+    messagesLoaded?: boolean;
+    unreadCount?: number;
+    unread?: boolean;
+    isMember?: boolean;
+    isNew?: boolean;
+    isTemp?: boolean;
+    creator?: string;
+}
+export type ConversationPayload = Omit<Conversation, '_id' | 'operationMode' | 'participants'> & {
+    _id: string;
+    operationMode?: 'default' | ConversationOperationMode;
+    participants?: Participant[];
+};
+export type SupportConversationPage = {
+    data: ConversationPayload[];
+    hasMore: boolean;
+    serverTime?: string;
+};

package/dist/types/src/interfaces/ConversationSla.d.ts

@@ -0,0 +1,9 @@
+import type { SupportStatus } from '@/helpers/supportStatus';
+export interface ConversationSla {
+    conversation: string;
+    status: SupportStatus;
+    statusVersion: number;
+    startedAt: string;
+    endAt: string;
+    stoppedAt?: string;
+}

package/dist/types/src/interfaces/IncomingFrame.d.ts

@@ -0,0 +1,71 @@
+import type { Participant } from '@/helpers/participants';
+import type { SupportStatus } from '@/helpers/supportStatus';
+import type { ConversationPayload } from '@/interfaces/Conversation';
+import type { Message } from '@/interfaces/Message';
+import type { ConversationSla } from '@/interfaces/ConversationSla';
+export type ConversationNewFrame = ConversationPayload & {
+    type: 'conversation:new';
+};
+export type ConversationRenamedFrame = {
+    type: 'conversation:renamed';
+    conversation: string;
+    names: {
+        to: string;
+    };
+};
+export type ConversationParticipantsFrame = {
+    type: 'conversation:participants';
+    conversation: string;
+    participants: Participant[];
+};
+export type ConversationUserFrame = {
+    type: 'conversation:left';
+    conversation: string;
+    user: string;
+};
+export type ConversationRemovedFrame = {
+    type: 'conversation:removed';
+    conversation: string;
+};
+export type ConversationMutedFrame = {
+    type: 'conversation:muted';
+    conversation: string;
+    muted: boolean;
+};
+export type ConversationStatusFrame = {
+    type: 'conversation:status';
+    conversation: string;
+    status: SupportStatus;
+    version: number;
+    updatedAt: string;
+    sla: ConversationSla | null;
+    serverTime: string;
+};
+export type ConversationRightsFrame = {
+    type: 'conversation:rights';
+    conversation: string;
+    user: string;
+    rights: string[];
+};
+export type ConversationTypingFrame = {
+    type: 'conversation:typing';
+    conversation: string;
+    user: string;
+    typing: boolean;
+};
+export type UserPresenceFrame = {
+    type: 'user:presence';
+    user: string;
+    online: boolean;
+    lastSeen?: string;
+};
+export type ErrorFrame = {
+    type: 'error';
+    error?: unknown;
+    messageType?: string;
+};
+export type MessageFrame = Message & {
+    type: 'message';
+};
+export type IncomingFrame = ConversationNewFrame | ConversationRenamedFrame | ConversationParticipantsFrame | ConversationUserFrame | ConversationRemovedFrame | ConversationMutedFrame | ConversationStatusFrame | ConversationRightsFrame | ConversationTypingFrame | UserPresenceFrame | ErrorFrame | MessageFrame;
+export declare function isIncomingFrame(value: unknown): value is IncomingFrame;

package/dist/types/src/interfaces/Message.d.ts

@@ -0,0 +1,16 @@
+export type MessageHistory = {
+    created: string;
+    updated?: string;
+};
+export interface Message {
+    _id?: string;
+    id: number;
+    conversation: string;
+    user?: string;
+    message?: string;
+    origin: 'user' | 'system';
+    history: MessageHistory;
+    action?: string;
+    actionData?: Record<string, unknown>;
+    isUser?: boolean;
+}

package/dist/types/src/interfaces/ParticipantDocument.d.ts

@@ -0,0 +1,13 @@
+export type ParticipantState = 'active' | 'left' | 'removed' | 'blocked' | 'deleted';
+export interface ParticipantDocument {
+    _id?: string;
+    conversation: string;
+    user: string;
+    state: ParticipantState;
+    rights: string[];
+    lastReadId?: number;
+    latestMessageId?: number;
+    muted?: boolean;
+    role?: 'agent';
+    joinedAt?: string;
+}

package/dist/types/src/libs/StudioSDK.d.ts

@@ -1,4 +1,9 @@
 import { type AxiosResponse, type AxiosRequestConfig } from 'axios';
+import type { SupportStatus, SupportStatusResponse } from '@/helpers/supportStatus';
+import type { ConversationPayload, SupportConversationPage } from '@/interfaces/Conversation';
+import type { Message } from '@/interfaces/Message';
+import type { ParticipantDocument } from '@/interfaces/ParticipantDocument';
+import type { ChatUser } from '@/config/users';
 type HttpStatusCode = number;
 export type SDKResponse<T> = {
     data: T;
@@ -74,9 +79,9 @@ export default class StudioSDK {
     private getHeaders;
     static getCacheKeyMock(url: string): string;
     static getCacheKey(url: string): string;
-    static getCache(): Record<string, SDKResponse<any> & SDKCache>;
-    static handleCall<T, D = any>(call: AxiosRequestConfig<D>, options?: SDKCallOptions): Promise<SDKResponse<T>>;
-    static cache<T>(url: string, response?: AxiosResponse<T>, options?: SDKCallOptions): SDKResponse<any> & SDKCache;
+    static getCache(): Record<string, SDKResponse<unknown> & SDKCache>;
+    static handleCall<T, D = unknown>(call: AxiosRequestConfig<D>, options?: SDKCallOptions): Promise<SDKResponse<T>>;
+    static cache<T>(url: string, response?: AxiosResponse<T>, options?: SDKCallOptions): SDKResponse<T> & SDKCache;
     static flushCache(group?: string, action?: string): void;
     /**
     * one id can hold several entries (one per query string, e.g. every `beforeId` page of a
@@ -85,36 +90,56 @@ export default class StudioSDK {
     */
     static flushId(id: string): void;
     conversations: {
-        list: () => Promise<SDKResponse<any>>;
-        activate: () => Promise<SDKResponse<any>>;
+        list: () => Promise<SDKResponse<ConversationPayload[]>>;
+        activate: () => Promise<SDKResponse<unknown>>;
         create: (data: {
             participants: string[];
-        }) => Promise<SDKResponse<any>>;
-        rename: (conversationId: string, name: string) => Promise<SDKResponse<any>>;
-        participants: (conversationId: string, add: string[], remove: string[]) => Promise<SDKResponse<any>>;
-        leave: (conversationId: string) => Promise<SDKResponse<any>>;
+        }) => Promise<SDKResponse<unknown>>;
+        rename: (conversationId: string, name: string) => Promise<SDKResponse<unknown>>;
+        participants: (conversationId: string, add: string[], remove: string[]) => Promise<SDKResponse<unknown>>;
+        leave: (conversationId: string) => Promise<SDKResponse<unknown>>;
         /**
         * POST, not DELETE: this removes the conversation for the CALLER only (their participant
         * state goes to 'deleted' server-side), it does not delete the resource for everyone.
         */
-        delete: (conversationId: string) => Promise<SDKResponse<any>>;
-        listParticipants: (conversationId: string) => Promise<SDKResponse<any>>;
-        rights: (conversationId: string, user: string, rights: string[]) => Promise<SDKResponse<any>>;
+        delete: (conversationId: string) => Promise<SDKResponse<unknown>>;
+        listParticipants: (conversationId: string) => Promise<SDKResponse<ParticipantDocument[]>>;
+        rights: (conversationId: string, user: string, rights: string[]) => Promise<SDKResponse<unknown>>;
         /**
         * silence the conversation for the CALLER only. Stored on their participant doc and never
         * broadcast to the other members — muting is private.
         */
-        mute: (conversationId: string, muted: boolean) => Promise<SDKResponse<any>>;
-        block: (conversationId: string, user: string, block: boolean) => Promise<SDKResponse<any>>;
+        mute: (conversationId: string, muted: boolean) => Promise<SDKResponse<unknown>>;
+        block: (conversationId: string, user: string, block: boolean) => Promise<SDKResponse<unknown>>;
     };
     contacts: {
-        list: (search?: string) => Promise<SDKResponse<any>>;
-        single: (contactId: string) => Promise<SDKResponse<any>>;
-        block: (contactId: string) => Promise<SDKResponse<any>>;
-        unblock: (contactId: string) => Promise<SDKResponse<any>>;
+        list: (search?: string) => Promise<SDKResponse<ChatUser[]>>;
+        single: (contactId: string) => Promise<SDKResponse<ChatUser>>;
+        block: (contactId: string) => Promise<SDKResponse<unknown>>;
+        unblock: (contactId: string) => Promise<SDKResponse<unknown>>;
     };
     messages: {
-        list: (conversation: string, beforeId?: number) => Promise<SDKResponse<any>>;
+        list: (conversation: string, beforeId?: number) => Promise<SDKResponse<Message[]>>;
+    };
+    support: {
+        /**
+        * every support conversation the staff can see, newest activity first. Mirrors
+        * conversations.list() for the agent side. Keyset pagination — pass the last row's
+        * `lastActivity` as `before` and its `_id` as `beforeId`.
+        *
+        * Its own cache GROUP on purpose, even though the action is now also called 'list'.
+        * deleteConversation() and setMuted() flush ('conversations','list') to drop a stale
+        * customer list; if this shared that group a flush would take it with it — and, worse, this
+        * loader's own reload() flushing 'conversations' would throw away a list the agent console
+        * never even loads.
+        */
+        list: (options?: {
+            limit?: number;
+            before?: string;
+            beforeId?: string;
+            status?: SupportStatus;
+        }) => Promise<SDKResponse<SupportConversationPage>>;
+        setStatus: (conversationId: string, status: SupportStatus, version: number) => Promise<SDKResponse<SupportStatusResponse>>;
     };
     health: {
         health: () => Promise<SDKResponse<void>>;

package/dist/types/src/libs/chatSession.d.ts

@@ -1,4 +1,5 @@
 import type { UseWebSocketOptions } from '@/libs/websocketManager';
+import { type IncomingFrame } from '@/interfaces/IncomingFrame';
 /**
  * Session layer on top of the raw websocket transport.
  *
@@ -32,7 +33,7 @@ export interface ChatSessionOptions {
     /** the current user id — used to recognize server echoes of own messages */
     ownUserId?: () => string | undefined;
     /** domain frames (messages, conversation events) — session frames are filtered out */
-    onMessage?: (_frame: Record<string, any>) => void;
+    onMessage?: (_frame: IncomingFrame) => void;
     onStateChange?: (_state: SessionState) => void;
     /** the session became ready again after a loss — the moment to resync missed data */
     onSessionRestored?: () => void;

package/dist/types/src/locales/de.d.ts

@@ -6,8 +6,25 @@ declare const _default: {
     retry: string;
     'new chat': string;
     conversations: string;
+    'no conversations yet': string;
     'contact support': string;
     support: string;
+    customer: string;
+    customers: string;
+    agents: string;
+    'load more': string;
+    supportStatus: {
+        label: string;
+        filter: string;
+        all: string;
+        awaiting_agent: string;
+        awaiting_customer: string;
+        resolved: string;
+    };
+    sla: {
+        due: string;
+        overdue: string;
+    };
     options: string;
     actions: string;
     mute: string;
@@ -25,6 +42,14 @@ declare const _default: {
     close: string;
     rights: string;
     members: string;
+    'user details': string;
+    'first name': string;
+    'last name': string;
+    email: string;
+    online: string;
+    offline: string;
+    'last seen': string;
+    back: string;
     'update members': string;
     read: string;
     write: string;
@@ -64,6 +89,7 @@ declare const _default: {
         CONVERSATION_NOT_FOUND: string;
         CONVERSATION_ALREADY_EXISTS: string;
         MIN_PARTICIPANTS: string;
+        SUPPORT_UNAVAILABLE: string;
         CONTACT_NOT_FOUND: string;
         CANNOT_BLOCK_SELF: string;
         UNKNOWN_MESSAGE_TYPE: string;

package/dist/types/src/locales/en.d.ts

@@ -6,8 +6,25 @@ declare const _default: {
     retry: string;
     'new chat': string;
     conversations: string;
+    'no conversations yet': string;
     'contact support': string;
     support: string;
+    customer: string;
+    customers: string;
+    agents: string;
+    'load more': string;
+    supportStatus: {
+        label: string;
+        filter: string;
+        all: string;
+        awaiting_agent: string;
+        awaiting_customer: string;
+        resolved: string;
+    };
+    sla: {
+        due: string;
+        overdue: string;
+    };
     options: string;
     actions: string;
     mute: string;
@@ -25,6 +42,14 @@ declare const _default: {
     close: string;
     rights: string;
     members: string;
+    'user details': string;
+    'first name': string;
+    'last name': string;
+    email: string;
+    online: string;
+    offline: string;
+    'last seen': string;
+    back: string;
     'update members': string;
     read: string;
     write: string;
@@ -64,6 +89,7 @@ declare const _default: {
         CONVERSATION_NOT_FOUND: string;
         CONVERSATION_ALREADY_EXISTS: string;
         MIN_PARTICIPANTS: string;
+        SUPPORT_UNAVAILABLE: string;
         CONTACT_NOT_FOUND: string;
         CANNOT_BLOCK_SELF: string;
         UNKNOWN_MESSAGE_TYPE: string;

package/dist/types/src/mixins/groupMessages.d.ts

@@ -1 +1,14 @@
-export default function groupMessages(messages: any, user: string): unknown[];
+import type { Message } from '@/interfaces/Message';
+type MessageGroup = {
+    user?: string;
+    origin: Message['origin'];
+    time: string;
+    isUser: boolean;
+    messages: Message[];
+};
+type MessageDateGroup = {
+    date: string;
+    userTimeGroups: MessageGroup[];
+};
+export default function groupMessages(messages: Message[], user: string | undefined): MessageDateGroup[];
+export {};

package/dist/types/src/plugins/i18n.d.ts

@@ -10,8 +10,25 @@ declare const i18n: import("vue-i18n").I18n<{
         retry: string;
         'new chat': string;
         conversations: string;
+        'no conversations yet': string;
         'contact support': string;
         support: string;
+        customer: string;
+        customers: string;
+        agents: string;
+        'load more': string;
+        supportStatus: {
+            label: string;
+            filter: string;
+            all: string;
+            awaiting_agent: string;
+            awaiting_customer: string;
+            resolved: string;
+        };
+        sla: {
+            due: string;
+            overdue: string;
+        };
         options: string;
         actions: string;
         mute: string;
@@ -29,6 +46,14 @@ declare const i18n: import("vue-i18n").I18n<{
         close: string;
         rights: string;
         members: string;
+        'user details': string;
+        'first name': string;
+        'last name': string;
+        email: string;
+        online: string;
+        offline: string;
+        'last seen': string;
+        back: string;
         'update members': string;
         read: string;
         write: string;
@@ -68,6 +93,7 @@ declare const i18n: import("vue-i18n").I18n<{
             CONVERSATION_NOT_FOUND: string;
             CONVERSATION_ALREADY_EXISTS: string;
             MIN_PARTICIPANTS: string;
+            SUPPORT_UNAVAILABLE: string;
             CONTACT_NOT_FOUND: string;
             CANNOT_BLOCK_SELF: string;
             UNKNOWN_MESSAGE_TYPE: string;

package/dist/types/src/standalone/auth.d.ts

@@ -1,38 +1,21 @@
 import type { ParticipantUser } from '@/helpers/participants';
 import type { StandaloneSettings } from './settings';
+/** Keep post-login navigation on this deployment's origin. */
+export declare function resolveDestination(target?: string): string;
 export declare class StandaloneAuth {
     private client?;
     private dev;
     private devToken?;
     private profile?;
     private get origin();
-    /** the Auth0 client, guaranteed to exist. Every caller runs after a non-dev init(). */
-    private get auth0();
-    /**
-     * Bring the page into an authenticated state.
-     *
-     * Handles the redirect callback, then either resolves (authenticated) or navigates away to
-     * Auth0 (not authenticated). Resolves `false` when the browser is being redirected, so the
-     * caller knows not to mount anything.
-     */
+    private get keycloak();
+    /** Bring the page into an authenticated Keycloak session. */
     init(settings: StandaloneSettings): Promise<boolean>;
-    /**
-     * Complete the Auth0 redirect: exchange the code, then rewrite the URL back to wherever the
-     * user came from. A single pathname check replaces a router — the shell has no other routes.
-     */
-    private handleCallback;
-    /**
-     * A currently-valid access token. Handed to the chat as `getToken`, so every WS (re)auth and
-     * every HTTP call resolves a fresh one; auth0-spa-js owns the cache and the refresh.
-     */
+    /** Resolve a valid access token; Keycloak refreshes it when it expires within 30 seconds. */
     getToken(): Promise<string>;
-    /**
-     * The current user's own profile. The backend enriches other participants but not the
-     * requesting user, so the chat needs this to render our own name. Taken from the id-token
-     * claims — no /me endpoint required.
-     */
     getProfile(): ParticipantUser | undefined;
     private loadProfile;
+    private restoreLoginTarget;
     logout(): void;
 }
 declare const _default: StandaloneAuth;

package/dist/types/src/standalone/settings.d.ts

@@ -1,9 +1,10 @@
 import type { Feature } from '@/stores/main.store';
-/** Auth0 SPA client settings. Mirrors the `auth0` key of studio-app's settings.json. */
-export interface StandaloneAuth0Settings {
-    domain: string;
+import type { SupportAgentConfig } from '@/config/bootstrap.agent';
+/** Keycloak SPA client settings. Mirrors the `keycloak` key of studio-app's settings.json. */
+export interface StandaloneKeycloakSettings {
+    url: string;
+    realm: string;
     clientId: string;
-    audience?: string;
 }
 /**
  * Runtime configuration of a standalone deployment, served as a plain file next to the
@@ -11,18 +12,19 @@ export interface StandaloneAuth0Settings {
  * configured per domain. Same file path and shape as studio-app so ops handling is identical.
  */
 export interface StandaloneSettings {
-    /** dev bypass: skip Auth0 entirely and use `devToken`. Mirrors studio-app's `settings.dev`. */
+    /** dev bypass: skip Keycloak entirely and use `devToken`. Mirrors studio-app's `settings.dev`. */
     dev?: boolean;
     /** the token handed to the chat when `dev` is set. Pair with the backend's ENV=dev / DEV_USER. */
     devToken?: string;
-    /** Auth0 client. Omitted → the built-in lilaquadrat defaults are used. */
-    auth0?: StandaloneAuth0Settings;
+    /** Keycloak public client. Required outside dev mode. */
+    keycloak?: StandaloneKeycloakSettings;
     /** passed straight into the chat element's config */
     chat: {
         features?: Feature[];
         wsUrl?: string;
         apiUrl?: string;
         mediaUrl?: string;
+        /** @deprecated ignored — the backend owns the support team, see ChatModuleConfig.support */
         support?: {
             participants: string[];
         };
@@ -37,6 +39,25 @@ export interface StandaloneSettings {
 export declare const SETTINGS_URL = "/settings/settings.json";
 /**
  * Load the deployment settings. Always uncached — the file is edited in place on the
- * server and a stale copy would point the app at the wrong backend or Auth0 client.
+ * server and a stale copy would point the app at the wrong backend or Keycloak client.
  */
 export default function loadSettings(): Promise<StandaloneSettings>;
+/** the endpoint-ish fields of `chat` the support-agent element accepts. */
+export type SupportAgentEndpoints = Pick<SupportAgentConfig, 'wsUrl' | 'apiUrl' | 'mediaUrl' | 'sound'>;
+/**
+ * Narrow the settings' `chat` section to what <lilaquadrat-studio-support> accepts.
+ *
+ * The same settings.json shape serves both deployments, so the agent shell reads a `chat` section
+ * that may legitimately carry customer-only keys. This picks fields EXPLICITLY rather than
+ * spreading, and the two it drops are dropped on purpose:
+ *
+ * - `features`: the agent bundle decides its own mode — applySupportAgentConfig forces
+ *   ['support']. A host-supplied `features` reaching the console is exactly the confusion
+ *   `appRole` exists to prevent (a support console rendering the customer's chat header).
+ * - `support: { participants }`: already deprecated and ignored — the backend owns the support
+ *   team (everyone holding the `support:member` scope), so a client-side list can only drift.
+ *
+ * A spread would smuggle both past SupportAgentConfig's excess-property check, since the check
+ * only fires on object literals, not on spread-in values.
+ */
+export declare function supportAgentEndpoints(settings: StandaloneSettings): SupportAgentEndpoints;

package/dist/types/src/standalone-support/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/stores/calls.store.d.ts

@@ -1,13 +1,13 @@
 export declare const useCallStore: import("pinia").StoreDefinition<"calls", Pick<{
-    calls: import("vue").Ref<Record<string, "rejected" | "pending" | "resolved">, Record<string, "rejected" | "pending" | "resolved">>;
+    calls: import("vue").Ref<Record<string, "resolved" | "rejected" | "pending">, Record<string, "resolved" | "rejected" | "pending">>;
     addCall: () => string;
     updateCall: (id: string, state: "pending" | "resolved" | "rejected") => void;
 }, "calls">, Pick<{
-    calls: import("vue").Ref<Record<string, "rejected" | "pending" | "resolved">, Record<string, "rejected" | "pending" | "resolved">>;
+    calls: import("vue").Ref<Record<string, "resolved" | "rejected" | "pending">, Record<string, "resolved" | "rejected" | "pending">>;
     addCall: () => string;
     updateCall: (id: string, state: "pending" | "resolved" | "rejected") => void;
 }, never>, Pick<{
-    calls: import("vue").Ref<Record<string, "rejected" | "pending" | "resolved">, Record<string, "rejected" | "pending" | "resolved">>;
+    calls: import("vue").Ref<Record<string, "resolved" | "rejected" | "pending">, Record<string, "resolved" | "rejected" | "pending">>;
     addCall: () => string;
     updateCall: (id: string, state: "pending" | "resolved" | "rejected") => void;
 }, "addCall" | "updateCall">>;